2:\n ignore_mask_color = (255, 255, 255)\n else:\n ignore_mask_color = 255\n\n # 식별된 구간 제외 전부 검은색칠\n cv2.fillPoly(mask, np.int32([shaper]), ignore_mask_color)\n\n # bitwise_and 연산\n masked_image = cv2.bitwise_and(img, mask)\n # cv2.imshow('ROI', masked_image)\n # cv2.waitKey()\n\n return masked_image","def target_intersection(self, runid):\n\n def targeting(shuffledict, seg_copy_array, cell_name):\n bedstring = \"\"\n seg_counts_dict = defaultdict(int)\n breakpoint_counts = 0\n sum_counts = 0\n for cell in shuffledict:\n with suppress(IndexError):\n i = len(cell_name)\n cell_label = cell[:i]\n\n if not cell_name == cell_label:\n continue\n\n shuffled_list = shuffledict[cell]\n scipy.random.shuffle(shuffled_list)\n sum_counts += sum(shuffled_list)\n\n for i in range(len(shuffled_list)):\n if shuffled_list[i] == 0:\n continue\n\n breakpoint_counts += 1\n segment_index = i\n if i == 0:\n segment_index = 1\n\n chrm = seg_copy_array[seg_copy_array[:, 0] == segment_index][0, 1].decode()\n chrom_slice = seg_copy_array[seg_copy_array[:, 1] == chrm.encode()]\n chrom_seg_count = chrom_slice.shape[0]\n start_seg = segment_index\n stop_seg = segment_index+1\n\n # Prevents us from running past the end of the chromosome\n if segment_index+1 > chrom_seg_count:\n stop_seg = segment_index\n start_seg = segment_index-1\n\n coord_start = int(seg_copy_array[seg_copy_array[:, 0] == start_seg][0, 2])\n coord_stop = int(seg_copy_array[seg_copy_array[:, 0] == stop_seg][0, 3])\n\n segkey = \"{}.{}\".format(chrm, coord_start)\n seg_counts_dict[segkey] += 1\n bedstring += \"{0} {1} {2} {3} {0}|{1}|{2}|{3}\\n\".format(chrm, coord_start, coord_stop, \"x\")\n\n if eval(self.args.PairedBreakpoints):\n segment_index = shuffled_list[i]+i\n\n # Since segments are paired we can run past the end of the list.\n if segment_index > len(shuffled_list):\n segment_index = len(shuffled_list)-1\n\n # If the shuffle results in a segment overlap, skip it.\n if not shuffled_list[segment_index] == 0:\n continue\n\n start_seg = segment_index\n stop_seg = segment_index+1\n\n # Prevents us from running past the end of the chromosome by flipping direction of region\n if segment_index + 1 > chrom_seg_count:\n start_seg = shuffled_list[i] - i\n stop_seg = start_seg-1\n\n coor_start = int(seg_copy_array[seg_copy_array[:, 0] == start_seg][0, 2])\n coor_stop = int(seg_copy_array[seg_copy_array[:, 0] == stop_seg][0, 3])\n breakpoint_counts += 1\n segkey = \"{}.{}\".format(chrm, coord_start)\n seg_counts_dict[segkey] += 1\n bedstring += \"{0} {1} {2} {3} {0}|{1}|{2}|{3}\\n\".format(chrm, coor_start, coor_stop, \"x\")\n\n return bedstring, seg_counts_dict, breakpoint_counts\n\n encoded_cell_name = self.args.Cell_Name\n shuffle_dict = self.shuffle_dict_unpaired\n if eval(self.args.PairedBreakpoints):\n shuffle_dict = self.shuffle_dict_pairs\n output_data_dict = defaultdict(lambda: defaultdict(str))\n\n iteration_limit = int(self.args.Iteration_Count)/int(self.args.Spawn)\n iteration_count = 0\n while iteration_count < iteration_limit:\n if iteration_count % int(self.args.Prog_Check) == 0:\n self.log.info(\"Iteration: {} of {} for job {}\".format(iteration_count, iteration_limit, runid))\n\n bed_string, segment_count_dict, total_breakpoints = \\\n targeting(shuffle_dict, self.seg_analyzer.seg_copy_array, encoded_cell_name)\n\n # Bedtool Section.\n breakpoint_bedtool = pybedtools.BedTool(bed_string, from_string=True)\n target_bedtool = pybedtools.BedTool(self.args.Target_File, from_string=False)\n\n # Find target intersects for printing.\n breakpoint_target_intersect = breakpoint_bedtool.intersect(target_bedtool, wb=True, stream=True)\n\n \"\"\"\n The breakpoint target intersect pybedtools object is expected to have this structure;\n l[0] = Breakpoint chrom; l[1] = Breakpoint start coord; l[2] = Breakpoint end coord; \n l[3] = aberration copy type; l[4] = segment ID for internal tracking. The next items are from the target BED \n file. Make sure column 5 in that file is the target name.\n \"\"\"\n\n # Processing Breakpoint Intersects.\n intersect_dict = defaultdict(list)\n total_targeted_breakpoints = 0\n unique_targeted_breakpoints = 0\n\n for l in breakpoint_target_intersect:\n chrom = l[4].split(\"|\")[0]\n start = l[4].split(\"|\")[1]\n segment_key = \"{}.{}\".format(chrom, start)\n intersect_dict[segment_key].append(l[9])\n\n for k in intersect_dict:\n total_targeted_breakpoints += segment_count_dict[k]\n if segment_count_dict[k] > 0:\n unique_targeted_breakpoints += 1\n\n output_data_dict[iteration_count] = \"{}\\t{}\\t{}\\t{}\\n\"\\\n .format(total_breakpoints, total_targeted_breakpoints, len(segment_count_dict), len(intersect_dict))\n\n iteration_count += 1\n\n # Process data for output and write file.\n outstring = \"\"\n\n for k in output_data_dict:\n outstring += output_data_dict[k]\n\n permuted_shuffle_file_name = \\\n \"{}{}{}{}\".format(self.args.Working_Folder, self.args.Cell_Name, self.args.Job_Name, runid)\n permuted_shuffle_file = open(permuted_shuffle_file_name, 'w')\n permuted_shuffle_file.write(outstring)\n permuted_shuffle_file.close()\n\n return","def new_tile(self):\r\n # replace with your code\r\n # complete search ....\r\n non_zero_count = 0;\r\n for row in range(self._grid_height):\r\n for col in range(self._grid_width):\r\n if self._grid_tile[row][col] == 0:\r\n non_zero_count += 1\r\n random_choice = random.randrange(0, non_zero_count)\r\n count = 0\r\n # another search ....\r\n generated_new_tile = False\r\n for row in range(self._grid_height):\r\n for col in range(self._grid_width):\r\n if generated_new_tile == False and self._grid_tile[row][col] == 0:\r\n if count != random_choice:\r\n count += 1 \r\n else:\r\n if random.randrange(0,100) < 10:\r\n self.set_tile(row, col ,4)\r\n else:\r\n self.set_tile(row, col ,2)\r\n generated_new_tile = True","def closed_regions(self, image, test):\n pixel = image.load()\n xs, ys = map(xrange, image.size)\n todo = set(xy for xy in product(xs, ys) if test(pixel[xy]))\n while todo:\n region = set()\n edge = set([todo.pop()])\n while edge:\n region |= edge\n todo -= edge\n edge = todo.intersection(\n flatten(((x - 1, y), (x, y - 1), (x + 1, y), (x, y + 1)) for x, y in edge))\n yield region","def step(self):\n # amt_selected = \\\n # int(self.population_size * self.part_selected) \n\n # spawning_pool = [] # list of dna selected for reproduction\n new_data =[]\n \n sorted_dna = sorted(self.data, \n key=lambda dna: dna.fitness_function(dna),\n reverse=True)\n \n \n \n\n # mutation\n for dna in sorted_dna:\n dna.mute(self.mutation_probability)\n\n # crossover\n while len(new_data) < \\\n self.population_size - (self.population_size % 2):\n\n d1 = copy.copy(self.pick())\n d2 = copy.copy(self.pick())\n times = 2\n for i in range(times):\n d1.crossover(d2)\n\n new_data += [d1, d2]\n\n\n\n\n\n if (self.population_size % 2) == 1:\n new_data.append(copy.deepcopy(self.pick()))\n\n assert(len(self.data) == len(new_data))\n\n for i in range(len(new_data)):\n self.data[i].data = new_data[i]","def set_sample_region(self):\n\n theta_delta = self.wrap(self.start[0:3], self.goal[0:3])\n\n delta_signs = np.sign(self.goal[0:3] - self.start[0:3])\n\n self.smart_region_min = self.start\n\n self.smart_region_max = self.start + delta_signs * theta_delta\n\n velocity_min = np.zeros(3,1)\n\n \n for i in range(3):","def set_sample_region(self):\n\n theta_delta = self.wrap(self.start[0:3], self.goal[0:3])\n\n delta_signs = np.sign(self.goal[0:3] - self.start[0:3])\n\n self.smart_region_min = self.start\n\n self.smart_region_max = self.start + delta_signs * theta_delta\n\n velocity_min = np.zeros(3,1)\n\n \n for i in range(3):","def _simulate_until_stable(\n grid: List[List[str]],\n count_occupied: Callable[[List[List[str]], int, int], int],\n min_occupied_to_free=4) -> int:\n while True:\n next_grid = _simulate(grid, count_occupied, min_occupied_to_free)\n if _are_equal(next_grid, grid):\n return _count_occupied_seats(grid)\n grid = next_grid","def setDefensiveArea(self ,gameState): \n mazeCentreX = (gameState.data.layout.width - 2) / 2\n if not self.red:\n mazeCentreX += 1\n mazeCentreY = (gameState.data.layout.height - 2) / 2\n\n self.defenceRegion = []\n for i in range(1, gameState.data.layout.height - 1):\n if gameState.hasWall(mazeCentreX, i):\n a = 0\n \n else:\n self.defenceRegion.append((mazeCentreX, i))\n\n expectedSize = mazeCentreY\n actualSize = len(self.defenceRegion)\n\n\n for i in range(len(self .defenceRegion)):\n if expectedSize > actualSize:\n break\n else:\n self.defenceRegion.remove(self.defenceRegion[0])\n self.defenceRegion.remove(self.defenceRegion[-1])\n actualSize = len(self.defenceRegion)\n\n for i in range(len(self.defenceRegion)):\n if len(self.defenceRegion) > 2:\n self.defenceRegion.remove(self.defenceRegion[0])\n self.defenceRegion.remove(self.defenceRegion[-1])\n else:\n break","def find_instances_in_features(self, features, region):\n for current_window in self.hogger.hog_scan(self.box_size, self.box_size):\n if self.classifier.classify_features(current_window[\"features\"])==1.0:\n off_x = current_window[\"x\"]\n off_y = current_window[\"y\"]\n trans_off_x = int(off_x * self.scaling) + region[0]\n trans_off_y = int(off_y * self.scaling) + region[1]\n\n cv2.rectangle(self.resized_image, (off_x, off_y), (off_x + self.box_size, off_y + self.box_size),\n color=(255, 255, 255), thickness=2)\n cv2.rectangle(self.image, (trans_off_x, trans_off_y), (trans_off_x + self.eff_box_size, trans_off_y + self.eff_box_size),\n color=(255, 255, 255), thickness=2)\n self.boundings.append(((trans_off_x, trans_off_y), (trans_off_x + self.eff_box_size, trans_off_y + self.eff_box_size)))","def _sample_regions(region_rois, gt_regions, voc_sign):\n # overlaps: (rois x gt_regions)\n overlaps_gt = bbox_overlaps(\n np.ascontiguousarray(region_rois[:, 1:5], dtype=np.float),\n np.ascontiguousarray(gt_regions[:, :4], dtype=np.float))\n # gt_assignment = overlaps_gt.argmax(axis=1)\n max_overlaps_gt = overlaps_gt.max(axis=1)\n # labels = gt_regions[gt_assignment, 4:]\n fg_inds = np.where(max_overlaps_gt >= cfg.TRAIN.FG_THRESH_REGION)[0]\n bg_inds = np.where(\n (max_overlaps_gt < cfg.TRAIN.BG_THRESH_HI_REGION) & (max_overlaps_gt >= cfg.TRAIN.BG_THRESH_LO_REGION))[0]\n\n # ## Debug Codes\n # print('fg: {} v.s. bg:{}'.format(len(fg_inds), len(bg_inds)))\n # gt_hit_overlap = overlaps_gt.max(axis=0)\n # hit_ids = np.unique(np.where(gt_hit_overlap >= cfg.TRAIN.FG_THRESH_REGION)[0])\n # print('Recall: {} ({}/{})'.format(\n # float(len(hit_ids)) / len(gt_regions), len(hit_ids), len(gt_regions)))\n # The indices that we're selecting (both fg and bg)\n keep_inds = np.append(fg_inds, bg_inds)\n # Select sampled values from various arrays:\n labels = np.ones((len(keep_inds), gt_regions.shape[1] - 4), dtype=np.int64) * voc_sign['end']\n # Here we randomly select regions overlapped with proposed ROI more than 0.7\n gt_assignment = np.zeros(len(fg_inds), dtype=np.int64)\n for i in range(len(fg_inds)):\n gt_assignment[i] = npr.choice(np.where(overlaps_gt[fg_inds[i]] > cfg.TRAIN.FG_THRESH_REGION)[0], size=1)\n labels[i] = gt_regions[gt_assignment[i], 4:]\n\n # add start label to background and padding them with <end> sign\n labels[len(fg_inds):, 0] = voc_sign['start']\n rois = region_rois[keep_inds]\n\n targets_fg = bbox_transform(rois[:len(fg_inds), 1:5], gt_regions[gt_assignment, :4])\n bbox_inside_weights_fg = np.ones(targets_fg.shape, dtype=np.float32) * cfg.TRAIN.BBOX_INSIDE_WEIGHTS\n targets_bg = np.zeros((bg_inds.size, targets_fg.shape[1]), dtype=np.float32)\n bbox_inside_weight_bg = np.zeros(targets_bg.shape, dtype=np.float32)\n bbox_targets = np.vstack([targets_fg, targets_bg])\n bbox_inside_weight = np.vstack([bbox_inside_weights_fg, bbox_inside_weight_bg])\n\n return labels, bbox_targets, bbox_inside_weight, keep_inds","def __test_region(self, bk):\n for arg in self.args['region']:\n ds = ArgoDataFetcher(backend=bk).region(arg).to_xarray()\n assert isinstance(ds, xr.Dataset) == True","def find_instances(self, image, region, overlap):\n self.image = np.copy(image)\n\n self.eff_step_size = int((1.0-overlap)*self.eff_box_size)\n\n y_steps = (region[3]-region[1])//self.eff_step_size\n x_steps = (region[2]-region[0])//self.eff_step_size\n\n if region[0]+(x_steps-1)*self.eff_step_size+self.eff_box_size>region[2]:\n x_steps -= 1\n if region[1]+(y_steps-1)*self.eff_step_size+self.eff_box_size>region[3]:\n y_steps -= 1\n\n if self.single_hog:\n self.resized_image = image[region[1]:region[3],region[0]:region[2],:]\n self.resized_image = cv2.resize(self.resized_image, (int(self.resized_image.shape[1]/self.scaling), int(self.resized_image.shape[0]/self.scaling)))\n features, img = self.hogger.hog_image(self.resized_image, visualize=False, feature_vector=False)\n features = np.array(features)\n self.find_instances_in_features(features, region)\n return self.image, self.resized_image\n else:\n for row in range(y_steps):\n off_y = region[1] + row * self.eff_step_size\n for col in range(x_steps):\n off_x = region[0]+col * self.eff_step_size\n sub_sample = self.get_resized_sub_sample(off_x, off_y)\n pred = self.classifier.classify(sub_sample)\n if(pred==1.0):\n cv2.rectangle(self.image, (off_x, off_y), (off_x+self.eff_box_size, off_y+self.eff_box_size), color=(255,255,255), thickness=2)\n self.boundings.append(((off_x, off_y), (off_x+self.eff_box_size, off_y+self.eff_box_size)))\n\n return self.image, None","def test_bkg_regions(i07_nexus: I07Nexus, regions):\n for i, _ in enumerate(regions):\n assert i07_nexus.background_regions[i] == regions[i]","def find_pins_and_blockages(self, pin_list):\n # This finds the pin shapes and sorts them into \"groups\" that are connected\n # This must come before the blockages, so we can not count the pins themselves\n # as blockages.\n start_time = datetime.now()\n for pin_name in pin_list:\n self.retrieve_pins(pin_name)\n print_time(\"Retrieving pins\",datetime.now(), start_time, 4)\n \n start_time = datetime.now()\n for pin_name in pin_list:\n self.analyze_pins(pin_name)\n print_time(\"Analyzing pins\",datetime.now(), start_time, 4)\n\n # This will get all shapes as blockages and convert to grid units\n # This ignores shapes that were pins\n start_time = datetime.now()\n self.find_blockages()\n print_time(\"Finding blockages\",datetime.now(), start_time, 4)\n\n # Convert the blockages to grid units\n start_time = datetime.now()\n self.convert_blockages()\n print_time(\"Converting blockages\",datetime.now(), start_time, 4)\n \n # This will convert the pins to grid units\n # It must be done after blockages to ensure no DRCs between expanded pins and blocked grids\n start_time = datetime.now()\n for pin in pin_list:\n self.convert_pins(pin)\n print_time(\"Converting pins\",datetime.now(), start_time, 4)\n\n # Combine adjacent pins into pin groups to reduce run-time\n # by reducing the number of maze routes.\n # This algorithm is > O(n^2) so remove it for now\n # start_time = datetime.now()\n # for pin in pin_list:\n # self.combine_adjacent_pins(pin)\n # print_time(\"Combining adjacent pins\",datetime.now(), start_time, 4)\n\n\n # Separate any adjacent grids of differing net names that overlap\n # Must be done before enclosing pins\n start_time = datetime.now()\n self.separate_adjacent_pins(0)\n print_time(\"Separating adjacent pins\",datetime.now(), start_time, 4)\n \n # Enclose the continguous grid units in a metal rectangle to fix some DRCs\n start_time = datetime.now()\n self.enclose_pins()\n print_time(\"Enclosing pins\",datetime.now(), start_time, 4)","def generate_grains(self, cells):\n\t\tfor cell_num in range(cells):\n\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\tsample_cell = sample_cell[0]\n\t\t\twhile sample_cell.state != 0:\n\t\t\t\trandom_row = random.randrange(0,self.space.shape[0],1)\n\t\t\t\tsample_cell = np.random.choice(self.space[random_row],1)\n\t\t\t\tsample_cell = sample_cell[0]\n\t\t\tsample_cell.change_state(self.init_time ,cell_num)","def lower_covers(self, x):","def find_objects_in_image(self, image, visualize):\n self.select(image)\n\n for scan_region in self.scan_regions:\n self.set_scaling(scan_region[0])\n full, small = self.find_instances(image, scan_region[1], 0.5)\n if (visualize):\n fig = plt.figure(figsize=(30, 20))\n plt.imshow(small)\n plt.title(\"Scan region {} using scaling {}\".format(scan_region[1], scan_region[0]))\n plt.show()","def region_graph(t0, t1, t2, t3):\r\n medians0 = sorted(sub_saharan_africa_countries())\r\n t0.goto(-250, ((medians0[0])-50))\r\n t0.rt(90)\r\n for idx in range(1, len(medians0)):\r\n t0.pencolor(\"blue\")\r\n t0.pd()\r\n t0.setpos((-250+(idx*10.5)), ((medians0[idx])))\r\n\r\n medians1 = sorted(south_asia_countries())\r\n t1.goto(-250, ((medians1[0]) - 60))\r\n t1.rt(90)\r\n for idx in range(1, len(medians1)):\r\n t1.pencolor(\"red\")\r\n t1.pd()\r\n t1.setpos((-250 + (idx * 68.5)), (2*(medians1[idx])+10))\r\n\r\n medians2 = sorted(europe_central_asia_countries())\r\n t2.goto(-250, (medians2[0])+60)\r\n t2.rt(90)\r\n for idx in range(1, len(medians2)):\r\n t2.pencolor(\"green\")\r\n t2.pd()\r\n t2.setpos((-250 + (idx*10.19)), (2 * (medians2[idx]) + 10))\r\n\r\n medians3 = sorted(latin_america_countries())\r\n t3.goto(-250, (medians3[0]) + 20)\r\n t3.rt(90)\r\n for idx in range(1, len(medians3)):\r\n t3.pencolor(\"gold\")\r\n t3.pd()\r\n t3.setpos((-250 + (idx * 14.39)), (2 * (medians3[idx]) + 10))\r\n\r\n t0.pu()\r\n t0.goto(initialCoordinates())\r\n t1.pu()\r\n t1.goto(initialCoordinates())\r\n t2.pu()\r\n t2.goto(initialCoordinates())\r\n t3.pu()\r\n t3.goto(initialCoordinates())\r\n\r\n medians4 = sorted(middle_east_countries())\r\n t0.goto(-250, (medians4[0])-40)\r\n t0.rt(90)\r\n for idx in range(1, len(medians4)):\r\n t0.pencolor(\"BLACK\")\r\n t0.pd()\r\n t0.setpos((-250 + (idx * 26.3)), (2 * (medians4[idx]) + 10))\r\n t0.rt(180)\r\n\r\n medians5 = sorted(north_america_countries())\r\n t1.goto(-250, (medians5[0])+60)\r\n t1.rt(90)\r\n for idx in range(1, len(medians5)):\r\n t1.pencolor(\"YELLOW\")\r\n t1.pd()\r\n t1.setpos((-250 + (idx * 485.3)), (2 * (medians5[idx]) + 10))\r\n t1.rt(180)\r\n\r\n medians6 = sorted(east_asia_pacific_countries())\r\n t2.goto(-250, (medians6[0]))\r\n t2.rt(90)\r\n for idx in range(1, len(medians6)):\r\n t2.pencolor(\"purple\")\r\n t2.pd()\r\n t2.setpos((-250 + (idx * 16)), (2 * (medians6[idx]) + 10))\r\n t0.pu()\r\n t0.goto(initialCoordinates())\r\n t1.pu()\r\n t1.goto(initialCoordinates())\r\n t2.pu()\r\n t2.goto(initialCoordinates())","def test_guider_start_ffsClosed(self):\n self._guider_start(6, 20, 0, 0)","def activatePinReading(self):\n\n for pin in self.pinsToMeasure:\n arduino.samplePinDuringCapture(self.f, self.pinMap[pin], self.wallClock)","def computePValues(options,whole_mapped_data,mapped_data_per_size_per_register,phase,cycle):\n min_reads_mapped_to_a_phased_register=3\n min_reads_in_a_window=10\n chromosome_hits=[]\n for chromosome in sorted(mapped_data_per_size_per_register):\n chromosome_hits.append(chromosome)\n fhr=open(options.output_directory_per_run+\"/\"+options.input_filename+\"_\"+str(phase)+\"_\"+str(cycle)+\"_\"+chromosome+\".regionsOfInterest\",\"r\")\n fhw=open(options.output_directory_per_run+\"/\"+options.input_filename+\"_\"+str(phase)+\"_\"+str(cycle)+\"_\"+chromosome+\".regionsOfInterest.concentrated\",\"w\")\n for line in fhr:\n register,start,end=line.strip().split()\n register=int(register)\n start=int(start)\n end=int(end)\n \n begin=start\n #print(chromosome,register,start,end)\n sys.stdout.flush()\n while begin+(phase*min_reads_mapped_to_a_phased_register) <= end+1:\n finish=begin+(phase*cycle)-1\n \n k=0\n for i in range(begin,finish+1):\n #print(chromosome,register,i,phase,start,end)\n try:\n k+=mapped_data_per_size_per_register[chromosome][register][i]\n except KeyError:\n pass\n #print(\"Next\")\n if k<min_reads_mapped_to_a_phased_register: \n begin+=phase\n continue\n \n num_all_reads=0\n for i in range(begin,finish+1):\n try:\n num_all_reads+=whole_mapped_data[chromosome][i]\n except KeyError:\n pass\n if num_all_reads<min_reads_in_a_window:\n begin+=phase\n continue\n \n n=0\n \"\"\"print(\"reached here\")\n sys.stdout.flush()\"\"\"\n # register_i is an iterator different from register\n for register_i in sorted(mapped_data_per_size_per_register[chromosome]):\n for i in range(begin,finish+1):\n try:\n n+=mapped_data_per_size_per_register[chromosome][register_i][i]\n except KeyError:\n pass\n \"\"\"if chromosome==\"Chr1\":\n print(str(n)+\" \"+str(num_all_reads)+\"\\n\")\"\"\"\n if n/num_all_reads<0.3:\n begin+=phase\n continue\n m=cycle*2\n pvalue=0\n for x in range(k,m+1):\n numerator=nCr((phase-1)*m,n-x)*nCr(m,x)\n pvalue+=numerator\n denominator=nCr(phase*m,n)\n pvalue=pvalue/denominator\n #print(chromosome,begin,finish,k,n,m,num_all_reads,pvalue,n/num_all_reads)\n if pvalue>=options.pvalue_cutoff:\n begin+=phase\n continue\n stuffs_to_be_printed_to_file=[register,begin,finish,k,n,m,num_all_reads,n/num_all_reads,pvalue]\n fhw.write(\"\\t\".join(map(str,stuffs_to_be_printed_to_file))+\"\\n\")\n sys.stdout.flush()\n begin+=phase","def add_river_greedy(me, lm, material_dict, imgs, rounded_river,\n min_length):\n print(\" Building random river...\")\n cell_source = get_river_source(material_dict)\n if not(cell_source):\n print(\"no cell source\")\n return\n xi,yi = cell_source\n cell_source = lm.cells[xi][yi]\n path = [cell_source]\n cell_xy = cell_source\n maxn = 1000\n it = 0\n should_finish = False\n margin = 0.01\n lake_probability = 0.5\n while True:\n if it > maxn:\n break\n elif \"water\" in cell_xy.material.name.lower():\n break\n elif should_finish:\n break\n it += 1\n section_length = random.randint(2,10)\n if random.random() < 0.5:\n sign = 1\n else:\n sign = -1\n if random.random() < 0.5:\n dx, dy = sign, 0\n else:\n dx, dy = 0, sign\n## print(dx,dy,section_length)\n ################################################\n for i in range(section_length):\n if should_finish:\n break\n x = cell_xy.coord[0] + dx\n y = cell_xy.coord[1] + dy\n new_cell = lm.get_cell_at(x,y)\n if new_cell is None:\n break\n elif new_cell.h - margin > cell_xy.h:\n if cell_xy.material.name != new_cell.material.name:\n break\n elif new_cell in path:\n break\n elif new_cell.name != \"river\":\n is_valid = True\n for neigh in new_cell.get_neighbors_von_neuman():\n if neigh:\n if not(neigh is cell_xy):\n if neigh.name == \"river\":\n is_valid = False\n break\n elif \"water\" in neigh.material.name.lower():\n should_finish = True\n elif neigh in path:\n is_valid = False\n break\n if is_valid:\n cell_xy = new_cell\n path.append(new_cell)\n## print(\"OK\",dx,dy,section_length)\n else:\n break\n else:\n break\n #4) change the end to first shallow shore cell\n actual_path = []\n for cell in path:\n if cell.name == \"river\":\n break\n actual_path.append(cell)\n if \"water\" in cell.material.name.lower():\n break\n else: #LAKE ?\n next_to_water = False\n for neigh in cell.get_neighbors_von_neuman():\n if neigh:\n if \"water\" in neigh.material.name.lower():\n next_to_water = True\n break\n if next_to_water:\n break\n if len(actual_path) < min_length:\n return\n if actual_path[0].material.name == actual_path[-1].material.name:\n return\n elif not(\"water\" in actual_path[-1].material.name.lower()):\n if random.random() < lake_probability:\n pass\n else:\n return\n #build images of river\n objs = {}\n for delta in imgs: #imgs[(dx,dy)][zoom]\n river_obj = MapObject(me, imgs[delta][0], \"river\", 1.)\n river_obj.is_ground = True\n river_obj.lm = lm\n objs[delta] = river_obj\n #5) add river cells to map and layer\n for i,cell in enumerate(actual_path):\n prepare_cell_for_river(lm, cell)\n dx,dy,corner = get_path_orientation(i, cell, actual_path)\n if rounded_river:\n c = objs.get((dx,dy,corner))\n else:\n c = objs.get((dx,dy,None))\n if not c:\n raise Exception(\"No river object for delta\", dx, dy, corner)\n assert cell.name != \"river\"\n c = c.add_copy_on_cell(cell)\n cell.name = \"river\"\n lm.static_objects.append(c)\n\n if actual_path:\n## print(\"RIVER BUILT:\", [cell.coord for cell in actual_path])\n if not(\"water\" in actual_path[-1].material.name.lower()):\n for neigh in actual_path[-1].get_neighbors_moore():\n if neigh and neigh.name != \"river\":\n prepare_cell_for_river(lm, neigh)\n river_obj = MapObject(me, imgs[(0,0,None)][0], \"river\", 1.)\n river_obj.is_ground = True\n river_obj.lm = lm\n river_obj = river_obj.add_copy_on_cell(neigh)\n neigh.name = \"river\"\n lm.static_objects.append(river_obj)\n return objs","def scan(self, cut_off, r0 = 4, dr = 2, rmax = 80, bg_global = 3419, sigma = 3.5 * 13.8):\r\n \r\n start_time = time.time()\r\n for trial in range(self.dimension):\r\n \r\n max_count, max_rank = self.pick_largest(cut_off = cut_off)\r\n fitted = 0 # galaxy not fitted to a circle\r\n point = [] # \r\n circle_number = 0\r\n \r\n if max_count == -1:\r\n print(\"Scan completed, number of galaxies found is \", len(self.galaxies), \"run time is\", time.time() - start_time)\r\n break\r\n \r\n if max_count >= 0: # That means a value that is larger than cut_off exists\r\n ypos,xpos = self.rank_yx(max_rank)\r\n # print(\"max_count, y, x\", max_count, ypos, xpos) \r\n \r\n \r\n for r in range(r0, rmax, dr): # r = radius, we know the largest radius can't be >80 by inspecting the pic.\r\n print(\"locating the galaxy position at\", ypos, xpos, \"at a radius r =\", r) \r\n if fitted == 1 or r == 80:\r\n # print(\"max_count, yx\",max_count, ypos, xpos, \"cut =\", no_cut, len(new_point)/2)\r\n \r\n self.mask_region(ypos, xpos, r - dr)\r\n # print(bg_local, no_bg)\r\n if r - dr > r0: # it must be a galaxy\r\n \r\n # getting the local bg\r\n if no_bg > 3: # check if enough data to deduce bg\r\n bg = bg_local / no_bg \r\n else:\r\n bg = bg_global\r\n \r\n if circle_number >= np.pi* 2* (r - dr)**2:\r\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\r\n\r\n else:\r\n if no_cut < circle_number/2 and circle_number*2 >= np.pi * (r0**2):\r\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\r\n\r\n print(\"\\ngalaxy scan completed,radius =\", r - dr, \"position =\", ypos, xpos, \"max count =\", max_count, \"time = \", time.time() - start_time)\r\n\r\n break\r\n \r\n ##### Resetting parameters ####\r\n no_bg = 0 # number 0f background pixels\r\n bg_local = 0 # sum of local background noises\r\n no_cut = 0 # number of counts below cut off\r\n new_point = [] # pending pixels to be added\r\n ###############################\r\n \r\n if fitted == 0:\r\n \r\n if r == r0:\r\n \r\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\r\n \r\n # Check if it is within the circle radius = 2\r\n if int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\r\n \r\n i,j =[int(i), int(j)]\r\n if self.raw_image_data[j,i] == self.raw_image_data[j,i] *self.masked[j,i]: # Append the ppoint if not masked (masked = 1)\r\n\r\n if self.raw_image_data[j,i] <= cut_off:\r\n no_cut += 1\r\n\r\n if self.raw_image_data[j,i] > cut_off:\r\n point.append(self.raw_image_data[j, i])\r\n circle_number += 1\r\n\r\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\r\n bg_local += self.raw_image_data[j,i]\r\n no_bg += 1\r\n \r\n if no_cut >= len(point)/2 or 2*circle_number < np.pi * r0**2:\r\n fitted = 1\r\n else:\r\n pass\r\n \r\n#######################################################################################################\r\n if r > r0:\r\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): \r\n \r\n # Check if data are in between the previous and the new circle\r\n if (r - dr)**2 < int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\r\n i,j =[int(i), int(j)] # just incase \r\n \r\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]:\r\n\r\n if self.raw_image_data[j,i] <= cut_off:\r\n no_cut += 1\r\n if self.raw_image_data[j,i] > cut_off:\r\n new_point.append(self.raw_image_data[j, i]) # points are pending to be added in\r\n circle_number += 1\r\n\r\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\r\n bg_local += self.raw_image_data[j,i]\r\n no_bg += 1\r\n \r\n # Check if half of the new data points are inside cut off region\r\n if no_cut <= int(len(new_point)/2) or circle_number*2 < np.pi * r**2:\r\n for rannk in range(len(new_point)):\r\n point.append(new_point[rannk])\r\n\r\n else:\r\n fitted = 1","def region_growing_from_input(self, color, bone_from_scan=None):\n collect()\n # initilize\n if not bone_from_scan:\n self.load_original_data()\n else:\n self.copy_original_from_bone(bone_from_scan)\n checked = zeros(self._original_img_data.shape)\n seg = zeros(self._original_img_data.shape)\n need_to_check = []\n # Color the seeds and check for neighbors\n for seed in self._seeds_points:\n seg[seed] = color\n checked[seed] = 1\n neighbors = self._get_neighbors(seed, checked, self.\n _original_img_data.shape)\n for neighbor in neighbors:\n if self._get_threshold(self._original_img_data[neighbor],\n VOID_VALUES[0],\n VOID_VALUES[1]):\n need_to_check.append(neighbor)\n # Region Growing - while there's a neighbor, color it and keep going\n bone_to_check = []\n while need_to_check:\n pt = need_to_check.pop()\n if checked[pt] == 1:\n continue\n else:\n checked[pt] = 1\n neighbors = self._get_neighbors(pt, checked, self.\n _original_img_data.shape)\n for neighbor in neighbors:\n if self._get_threshold(\n self._original_img_data[neighbor],\n VOID_VALUES[0], VOID_VALUES[1]):\n need_to_check.append(neighbor)\n if self._get_threshold(\n self._original_img_data[neighbor],\n BONE_BOUND_VALUES[0], BONE_BOUND_VALUES[1]):\n bone_to_check.append(neighbor)\n seg[pt] = color\n # Closing holes\n del need_to_check\n # check for Bone value - edge of the radius\n while bone_to_check:\n pt = bone_to_check.pop()\n if checked[pt] == 1:\n continue\n else:\n checked[pt] = 1\n neighbors = self._get_neighbors(pt, checked, self.\n _original_img_data.shape)\n for neighbor in neighbors:\n if self._get_threshold(\n self._original_img_data[neighbor],\n RADIUS_VALUES[0], RADIUS_VALUES[1]):\n bone_to_check.append(neighbor)\n seg[pt] = color\n del checked, bone_to_check\n for i in range(self._dilation):\n seg = dilation(seg, cube(3, uint8))\n for i in range(self._dilation - 1):\n seg = erosion(seg, cube(3, uint8))\n self._segmentation_data = seg\n del seg\n collect()","def test_avalanche_warning_by_region_obs(self):\n pass","def fillIn(self):\n\n # Grabs first point (which is a shore) and prefills in hashes\n toBeAnalyzed = [self.points[0]]\n islandHash = defaultdict(list)\n islandHash[toBeAnalyzed[0].x].append(toBeAnalyzed[0].x)\n islandGridPoints = toBeAnalyzed[:]\n\n # Find all points not at pond-level.\n while toBeAnalyzed:\n gridPoint = toBeAnalyzed.pop()\n neighbors = self.analyzeData.iterateDiagonal(gridPoint.x,\n gridPoint.y)\n for _x, _y, elevation in neighbors:\n\n if elevation != self.pondElevation and _y not in\\\n islandHash[_x]:\n branch = GridPoint(_x, _y, elevation)\n islandHash[_x].append(_y)\n toBeAnalyzed.append(branch)\n islandGridPoints.append(branch)\n self.points = islandGridPoints","def grid(iant,xgrid=[0],ygrid=[0],sleep=4):\n d=Carma(iant).drive()\n d.setOffset(xgrid[0],ygrid[0])\n time.sleep(sleep)\n time.sleep(sleep)\n for y in ygrid:\n for x in xgrid:\n print x,y\n d.setOffset(x,y)\n time.sleep(sleep)","def auto(self):\n self.set_thermostat = 1 if self.desired_values[0] > self.data[0] else 0\n self.set_humidifier = 1 if self.desired_values[1] > self.data[1] else 0\n self.set_sprinklers = 1 if self.desired_values[2] > self.data[2] else 0\n self.set_ventilation = 1 if (self.desired_values[3] > self.data[3] or self.desired_values[4] < self.data[4]) else 0","def mainSelection():\n\timport time\n\tc1 = Content(1,4,20)\n\tc2 = Content(2,6,30)\n\tc3 = Content(3,5,25)\n\tc1_ = Content(1,1,20)\n\tc5 = Content(5,3,29)\n\tc6 = Content(6,11,50)\n\tc7 = Content(7,7,34)\n\tc1__ = Content(1,3,20)\n\tc8 = Content(8,6,10)\n\ta1 = Area('a1',1.0)\n\ta1.addContent(0,0,c1)\n\ta1.addContent(0,6,c2)\n\ta1.addContent(0,12,c3)\n\ta1.addContent(0,18,c1_)\n\ta1.addContent(1,2,c5)\n\ta1.addContent(1,9,c6)\n\ta1.addContent(2,0,c7)\n\ta1.addContent(2,9,c1__)\n\ta1.addContent(2,14,c8)\n\ta1.printSchedule()\n\tprint \"\\n\"\n\ta2 = Area('a2',0.5)\n\ta2.addContent(0,0,c6)\n\ta2.addContent(0,11,c7)\n\ta2.addContent(1,0,c1)\n\ta2.addContent(1,6,c8)\n\ta2.addContent(1,15,c3)\n\ta2.addContent(2,0,c3)\n\ta2.addContent(2,7,c5)\n\ta2.addContent(2,13,c2)\n\ta2.addContent(2,19,c1_)\n\ta2.printSchedule()\n\ta3 = Area('a3',1.0)\n\ta4 = Area('a4',0.9)\n\ta3.addContent(0,0,c2)\n\ta3.addContent(1,0,c5)\n\ta4.addContent(0,0,c2)\n\tsol_select = Selection_solution()\n\ttime_b = time.time()\n\tsol_select.select_bruteforce(time=12,a1=a1,a2=a2)\n\tprint \"running time: \",time.time()-time_b\n\ttime_g = time.time()\n\tsol_select.select_greedy(time=12,a1=a1,a2=a2)\n\tprint \"running time: \",time.time()-time_g\n\ttime_b = time.time()\n\tsol_select.select_bruteforce(time=0,a1=a3,a2=a4)\n\tprint \"running time: \",time.time()-time_b\n\ttime_g = time.time()\n\tsol_select.select_greedy(time=0,a1=a3,a2=a4)\n\tprint \"running time: \",time.time()-time_g","def setValues(\n self,\n checkSelfIntersection: Boolean = ON,\n autoCaching: Boolean = ON,\n maxCachedStates: int = 5,\n ):\n pass","def slicewhere(condition):\n regions = ndimage.find_objects(ndimage.label(condition)[0])\n return [region[0] for region in regions]","def _cons_traj(self,lon,lat,period):\n\t\tgroup = self['%g_sec'%( period )]\n\t\tlonArr = group['lonArr'].value\n\t\tlatArr = group['latArr'].value\n\t\tageArr = group['age_Arr'].value\n\t\tage_drv_lon = group['age_deriv_lon_Arr']\n\t\tage_drv_lat = group['age_deriv_lat_Arr']\n\t\tage_drv_msk = group['age_deriv_msk_Arr']\n\t\ttomo_data_msk = group['tomo_data_msk'].value\n\t\tmask_init = np.logical_or(tomo_data_msk, age_drv_msk)\n\t\tmask = np.array(np.ones(lonArr.shape),dtype=bool)\n\t\ti_s, j_s = self._find_nearest_grid(lon,lat,period) # find the 1st and 2nd index of the start point on grid\n\t\tif mask_init[i_s,j_s]:\n\t\t\traise ValueError(\"The starting point is out bounds of the resulting map\")\n\t\tmask[i_s,j_s] = False\n\t\t# go along increasing age direction\n\t\ti,j = _walk(age_drv_lon,age_drv_lat,i_s,j_s,1)\n\t\twhile (0<i<lonArr.shape[0] and 0<j<lonArr.shape[1]):\n\t\t\tif mask_init[i,j]:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tmask[i,j] = False\n\t\t\ti,j = _walk(age_drv_lon,age_drv_lat,i,j,1)\n\t\t\t\n\t\t# go along descending age direction\n\t\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_s,j_s,-1)\n\t\tmask[i_2,j_2] = False\n\t\twhile (0<i_2<lonArr.shape[0] and 0<j_2<lonArr.shape[1]):\n\t\t\tif mask_init[i_2,j_2]:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tmask[i_2,j_2] = False\n\t\t\tage_b = ageArr[i_2,j_2]\n\t\t\ti_b,j_b = i_2,j_2\n\t\t\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_2,j_2,-1)\n\t\t\tif ageArr[i_2,j_2] > age_b: # find the youngest age\n\t\t\t\ti_3,j_3 = i_b,j_b\n\t\t\t\tbreak\n\t\ttry:\n\t\t\ti_3\n\t\texcept NameError:\n\t\t\treturn mask\n\t\t\n\t\t# go along increasing age from the found youngest age\n\t\twhile (0<i_3<lonArr.shape[0] and 0<j_3<lonArr.shape[1]):\n\t\t\tif mask_init[i_3,j_3]:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tmask[i_3,j_3] = False\n\t\t\ti_3,j_3 = _walk(age_drv_lon,age_drv_lat,i_3,j_3,1)\n\t\treturn mask","def _check_fleet_edges(self):\n\t\tfor auto in self.autos.sprites():\n\t\t\tif auto.check_edges():\n\t\t\t\tself._change_fleet_direction()\n\t\t\t\tbreak","def step():\n x_rand = sample()\n x_nearest = new_nearest_neighbour(x_rand)\n x_new = steer(x_nearest, x_rand)\n if obstacle_free(x_nearest, x_new):\n X_near = new_neighbourhood(x_new)\n x_min = x_nearest\n c_min = x_nearest.cost + x_nearest.dist_to(x_new)\n for x_near in X_near:\n if obstacle_free(x_near, x_new) and (x_near.cost + x_near.dist_to(x_new) < c_min):\n x_min = x_near\n c_min = (x_near.cost + x_near.dist_to(x_new) < c_min)\n x_new_node = add_node(x_new, x_min, True)\n for x_near in X_near:\n if obstacle_free(x_near, x_new) and (x_new_node.cost + x_near.dist_to(x_new) < x_near.cost):\n x_near.change_parent(x_new_node)\n # Here I check for goal paths and draw the circle\n updated = False\n if shared.root_path:\n updated = goal_path_resolve(shared.root_path[0])\n updated = updated or goal_path_resolve(shared.nodes[-1])\n if updated:\n diameter = shared.root_path_length\n center = ((shared.root_path[0].x + shared.root_path[-1].x) / 2,\n (shared.root_path[0].y + shared.root_path[-1].y) / 2)\n if shared.region:\n shared.region.remove_from_batch()\n shared.region = ellipse.Ellipse(center[0], center[1], diameter)\n shared.region.add_to_batch()","async def test_sampling_boundaries_given(hass: HomeAssistant) -> None:\n assert await async_setup_component(\n hass,\n \"sensor\",\n {\n \"sensor\": [\n {\n \"platform\": \"statistics\",\n \"name\": \"test_boundaries_none\",\n \"entity_id\": \"sensor.test_monitored\",\n \"state_characteristic\": \"mean\",\n },\n {\n \"platform\": \"statistics\",\n \"name\": \"test_boundaries_size\",\n \"entity_id\": \"sensor.test_monitored\",\n \"state_characteristic\": \"mean\",\n \"sampling_size\": 20,\n },\n {\n \"platform\": \"statistics\",\n \"name\": \"test_boundaries_age\",\n \"entity_id\": \"sensor.test_monitored\",\n \"state_characteristic\": \"mean\",\n \"max_age\": {\"minutes\": 4},\n },\n {\n \"platform\": \"statistics\",\n \"name\": \"test_boundaries_both\",\n \"entity_id\": \"sensor.test_monitored\",\n \"state_characteristic\": \"mean\",\n \"sampling_size\": 20,\n \"max_age\": {\"minutes\": 4},\n },\n ]\n },\n )\n await hass.async_block_till_done()\n\n hass.states.async_set(\n \"sensor.test_monitored\",\n str(VALUES_NUMERIC[0]),\n {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},\n )\n await hass.async_block_till_done()\n\n state = hass.states.get(\"sensor.test_boundaries_none\")\n assert state is None\n state = hass.states.get(\"sensor.test_boundaries_size\")\n assert state is not None\n state = hass.states.get(\"sensor.test_boundaries_age\")\n assert state is not None\n state = hass.states.get(\"sensor.test_boundaries_both\")\n assert state is not None","def shifter(self):\n #self.BA_shift = self.timeshift_latitude(self.latB, self.latA)\n #self.BC_shift = self.timeshift_latitude(self.latB, self.latC)\n\n\n self.shifted = True #changing boolean to True when function is called.\n\n secondsA = self.secondsA\n secondsB = self.secondsB\n secondsC = self.secondsC\n\n NeA = self.holefill(self.NeA, secondsA)\n NeB = self.holefill(self.NeB, secondsB)\n NeC = self.holefill(self.NeC, secondsC)\n\n start = 0\n stop = len(NeA) - np.max(np.array([self.BA_shift, self.BC_shift]))\n\n startA = start + self.BA_shift\n stopA = stop + self.BA_shift\n\n startC = start + self.BC_shift\n stopC = stop + self.BC_shift\n\n NeA = NeA[startA:stopA]\n NeB = NeB[start:stop]\n NeC = NeC[startC:stopC]\n\n longA = self.holefill(self.longA, secondsA)\n longB = self.holefill(self.longB, secondsB)\n longC = self.holefill(self.longC, secondsC)\n longA = longA[startA:stopA]\n longB = longB[start:stop]\n longC = longC[startC:stopC]\n\n latA = self.holefill(self.latA, secondsA)\n latB = self.holefill(self.latB, secondsB)\n latC = self.holefill(self.latC, secondsC)\n latA = latA[startA:stopA]\n latB = latB[start:stop]\n latC = latC[startC:stopC]\n\n radA = self.holefill(self.radA, secondsA)\n radB = self.holefill(self.radB, secondsB)\n radC = self.holefill(self.radC, secondsC)\n radA = radA[startA:stopA]\n radB = radB[start:stop]\n radC = radC[startC:stopC]\n\n velA = self.holefill(self.velA, secondsA)\n velB = self.holefill(self.velB, secondsB)\n velC = self.holefill(self.velC, secondsC)\n velA = velA[startA:stopA]\n velB = velB[start:stop]\n velC = velC[start:stop]\n\n altA = self.holefill(self.altA, secondsA)\n altB = self.holefill(self.altB, secondsB)\n altC = self.holefill(self.altC, secondsC)\n altA = altA[startA:stopA]\n altB = altB[start:stop]\n altC = altC[startC:stopC]\n\n\n mlatA = self.holefill(self.mlatA, secondsA)\n mlatB = self.holefill(self.mlatB, secondsB)\n mlatC = self.holefill(self.mlatC, secondsC)\n mlatA = mlatA[startA:stopA]\n mlatB = mlatB[start:stop]\n mlatC = mlatC[startC:stopC]\n\n mlongA = self.holefill(self.mlongA, secondsA)\n mlongB = self.holefill(self.mlongB, secondsB)\n mlongC = self.holefill(self.mlongC, secondsC)\n mlongA = mlongA[startA:stopA]\n mlongB = mlongB[start:stop]\n mlongC = mlongC[startC:stopC]\n\n mltA = self.holefill(self.mltA, secondsA)\n mltB = self.holefill(self.mltB, secondsB)\n mltC = self.holefill(self.mltC, secondsC)\n mltA = mltA[startA:stopA]\n mltB = mltB[start:stop]\n mltC = mltC[startC:stopC]\n\n secondsA = self.holefill(secondsA, secondsA)\n secondsB = self.holefill(secondsB, secondsB)\n secondsC = self.holefill(secondsC, secondsC)\n secondsA = secondsA[startA:stopA]\n secondsB = secondsB[start:stop]\n secondsC = secondsC[startC:stopC]\n\n indsA = np.nonzero(secondsA)[0]\n indsB = np.nonzero(secondsB)[0]\n indsC = np.nonzero(secondsC)[0]\n\n inds = np.intersect1d(indsA, indsB)\n inds = np.intersect1d(inds, indsC)\n\n self.NeA = NeA[inds]\n self.NeB = NeB[inds]\n self.NeC = NeC[inds]\n\n self.longA = longA[inds]\n self.longB = longB[inds]\n self.longC = longC[inds]\n\n self.latA = latA[inds]\n self.latB = latB[inds]\n self.latC = latC[inds]\n\n self.radA = radA[inds]\n self.radB = radB[inds]\n self.radC = radC[inds]\n\n self.velA = velA[inds]\n self.velB = velB[inds]\n self.velC = velC[inds]\n\n self.altA = altA[inds]\n self.altB = altB[inds]\n self.altC = altC[inds]\n\n self.mlatA = mlatA[inds]\n self.mlatB = mlatB[inds]\n self.mlatC = mlatC[inds]\n\n self.mlongA = mlongA[inds]\n self.mlongB = mlongB[inds]\n self.mlongC = mlongC[inds]\n\n self.mltA = mltA[inds]\n self.mltB = mltB[inds]\n self.mltC = mltC[inds]\n\n self.secondsA = secondsA[inds]\n self.secondsB = secondsB[inds]\n self.secondsC = secondsC[inds]","def mask_the_images(working_path,set_name):\n\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41cf2fb1198e.npy')\n out_images = [] #final set of images for all patients\n for fname in file_list:\n out_images_per_patient = []\n print (\"working on file \", fname)\n imgs_to_process = np.load(fname.replace(\"lungmask\",\"images\")) # images of one patient\n masks = np.load(fname)\n for i in range(len(imgs_to_process)):\n mask = masks[i]\n img = imgs_to_process[i]\n new_size = [512,512] # we're scaling back up to the original size of the image\n img= mask*img # apply lung mask\n #\n # renormalizing the masked image (in the mask region)\n #\n new_mean = np.mean(img[mask>0])\n new_std = np.std(img[mask>0])\n #\n # Pulling the background color up to the lower end\n # of the pixel range for the lungs\n #\n old_min = np.min(img) # background color\n img[img==old_min] = new_mean-1.2*new_std # resetting backgound color\n img = img-new_mean\n img = img/new_std\n #make image bounding box (min row, min col, max row, max col)\n labels = measure.label(mask)\n regions = measure.regionprops(labels)\n #\n # Finding the global min and max row over all regions\n #\n min_row = 512\n max_row = 0\n min_col = 512\n max_col = 0\n for prop in regions:\n B = prop.bbox\n if min_row > B[0]:\n min_row = B[0]\n if min_col > B[1]:\n min_col = B[1]\n if max_row < B[2]:\n max_row = B[2]\n if max_col < B[3]:\n max_col = B[3]\n width = max_col-min_col\n height = max_row - min_row\n if width > height:\n max_row=min_row+width\n else:\n max_col = min_col+height\n #\n # cropping the image down to the bounding box for all regions\n # (there's probably an skimage command that can do this in one line)\n #\n img = img[min_row:max_row,min_col:max_col]\n mask = mask[min_row:max_row,min_col:max_col]\n if max_row-min_row <5 or max_col-min_col<5: # skipping all images with no god regions\n pass\n else:\n # moving range to -1 to 1 to accomodate the resize function\n mean = np.mean(img)\n img = img - mean\n min = np.min(img)\n max = np.max(img)\n img = img/(max-min)\n new_img = resize(img,[512,512], mode='constant')\n out_images_per_patient.append(new_img)\n\n id = re.sub(r'.*_images_(.*)\\.npy',r'\\1',fname)\n patient_images_and_id = (out_images_per_patient,id)\n out_images.append(patient_images_and_id)\n print (\"Delete files: {} \\n\\t {} \".format(fname,re.sub(\"lungmask\",\"images\",fname)))\n os.remove(fname)\n os.remove(fname.replace(\"images\",\"lungmask\")) # images of one patient\n\n\n np.save(working_path+\"{}Images.npy\".format(set_name),out_images)","async def _run(self):\n while True:\n for count in range(self._nSamples):\n if self._currentValue == self._pin.value():\n break\n else:\n await asyncio.sleep_ms(self._interval)\n if count == self._nSamples - 1:\n # Edge detected\n self._currentValue = not self._currentValue\n if self._currentValue:\n # Raising edge\n self._count += 1\n\n await asyncio.sleep_ms(self._interval)","def sample_pin_position_range():\n #Create a sample goniometer\n g = TopazInHouseGoniometer()\n\n #Initialize the leg limits\n g.relative_sample_position = column([0.0, 0.0, 0.0])\n g.getplatepos(0.0, 0.0, 0.0)\n g.calculate_leg_xy_limits(visualize=True)\n\n# if True:\n# pylab.show()\n# return\n\n n = 17\n positions = np.linspace(-8, 8, n) #Range calculated in mm\n allowed = np.zeros( (n,n,n) )\n for (ix, x) in enumerate(positions):\n print \"Calculating x\", x\n for (iy, y) in enumerate(positions):\n for (iz, z) in enumerate(positions):\n #Set up\n g.relative_sample_position = column([x, y, z])\n allowed[ix,iy,iz] = g.are_angles_allowed([0., 0., 0.], return_reason=False)\n\n #Do a plot\n\n pylab.figure(1, figsize=[15,15])\n pylab.title(\"Allowable XZ sample positions\")\n for (iy, y) in enumerate(positions):\n print \"At y of\", y, \", # of points = \", np.sum( allowed[:, iy,:])\n if iy < 16:\n pylab.subplot(4,4,iy+1)\n pylab.pcolor(positions, positions, allowed[:, iy, :].transpose(), norm=pylab.Normalize(0, 1))\n pylab.xlabel(\"x\")\n pylab.ylabel(\"z\")\n pylab.title(\"y = %.3f mm\" % y)\n pylab.draw()\n pylab.axis('equal')\n pylab.show()\n #pylab.","def separation_crawler(mode: bool) -> bool:\r\n for x in range(shape):\r\n for y in range(shape):\r\n if mode:\r\n if conflict_space[x, y] != 0 and safeboard[x, y] == 1:\r\n if walled_in(x, y):\r\n safeboard[x, y] = 0\r\n print(\"Cell will create separation if marked. Marked safe:\", x, \",\", y)\r\n progress_handler(False, True)\r\n else:\r\n if example[x, y] == 0:\r\n if walled_in(x, y):\r\n print(\"Solution Rejected, separated areas\")\r\n return True","def test_absolute_areas(self):\n\n assert len(self.test_shape.areas) == 4\n assert len(set([round(i) for i in self.test_shape.areas])) == 3\n assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1000)) == 2\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 970)) == 1\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1030)) == 1","def dealing_covers(high_series,low_series):\n #dealing k\n #initialize\n pre_calculated=0\n rates_total=len(high_series)\n valid_high=high_series.copy()\n valid_low=low_series.copy()\n valid_k_line_mark=np.zeros(rates_total)\n \"\"\"\n start point use up contains dealing\n \"\"\"\n start_index=0\n pre_high=valid_high[start_index]\n pre_low=valid_low[start_index]\n pre_idx=start_index\n cur_idx=pre_idx\n is_found=False\n while(not is_found):\n cur_idx=cur_idx+1\n cur_high=valid_high[cur_idx]\n cur_low=valid_low[cur_idx]\n if (cur_high>pre_high and cur_low>pre_low)or (cur_high<pre_high and cur_low<pre_low):\n is_found=True\n valid_high[pre_idx]=pre_high\n valid_low[pre_idx]=pre_low\n valid_k_line_mark[pre_idx]=1\n else:\n if pre_high>cur_high:\n # first k cover second k\n pre_low=cur_low\n elif pre_high<cur_high:\n\n # first k be convered by second k\n pre_high=cur_high\n pre_idx=cur_idx\n else:\n # high value is equal\n pre_low=cur_low\n pre_idx=cur_idx\n\n # no start point dealing\n begin_idx=cur_idx+1\n for i in range(begin_idx,rates_total):\n post_high=valid_high[i]\n post_low=valid_low[i]\n post_idx=i\n #first classification: no contains\n if (cur_high>post_high and cur_low>post_low)or (cur_high<post_high and cur_low<post_low):\n valid_high[cur_idx]=cur_high\n valid_low[cur_idx]=cur_low\n valid_k_line_mark[cur_idx]=1\n pre_high=cur_high\n pre_low=cur_low\n pre_idx=cur_idx\n cur_high=post_high\n cur_low=post_low\n cur_idx=post_idx\n else:\n if pre_high<cur_high:#up contains\n if cur_high>post_high:\n #post be coverd by cur\n cur_low=post_low\n elif cur_high<post_high:\n #post cover cur\n cur_high=post_high\n cur_idx=post_idx\n else:\n #high be equal\n if cur_low>post_low:\n #cur be covered by post\n cur_idx=post_idx\n else:\n #cur covers post\n cur_low=post_low\n else:#down contains\n if cur_low>post_low:\n #cur be covered by post\n cur_low=post_low\n cur_idx=post_idx\n elif cur_low<post_low:\n #cur covers post\n cur_high=post_high\n else:\n # two low is equal\n if cur_high>post_high:\n cur_high=post_high\n else:\n cur_idx=post_idx\n cur_high=post_high#I think the words can be deleted\n return valid_k_line_mark,valid_high,valid_low","def occupied_cells(self):\n\n for lm in self.landmarks:\n if self.cell_size < 1:\n # expand the range the landmark exists\n lm_x_range = np.arange(lm[0]-self.R, lm[0]+self.R, self.cell_size)\n lm_y_range = np.arange(lm[1]-self.R, lm[1]+self.R, self.cell_size)\n\n # loop through expanded ranges and compute grid positions\n for lm_x in lm_x_range:\n for lm_y in lm_y_range:\n\n row, col = self.cell_index([lm_x, lm_y])\n\n # apply cost of occupied cell\n try:\n self.world[row][col] = 1000\n except IndexError:\n pass\n\n else:\n # apply cost of occupied cell\n row, col = self.cell_index(lm)\n try:\n self.world[row][col] = 1000\n except IndexError:\n pass"],"string":"[\n \"def test_assign_to_regions(self):\\n \\n tool = pybedtools.BedTool(clipper.test_file(\\\"FOX2Brain-05.15.09.polyATrim.adapterTrim.rmRep.sorted.rmDup.peaks.bed\\\"))\\n \\n assign_to_regions(tool=tool, \\n clusters=\\\"test\\\", \\n speciesFA= clipper.test_file(\\\"mm9.fa\\\"), \\n regions_dir=os.path.join(clipper.test_dir(), \\\"regions\\\"), \\n regions={\\\"exons\\\" : \\\"Exon\\\", \\\"utr3\\\" : \\\"3' UTR\\\", \\n \\\"utr5\\\" : \\\"5' UTR\\\", \\\"proxintron500\\\" : \\\"Proximal Intron\\\", \\n \\\"distintron500\\\" : \\\"Distal Intron\\\"} ,\\n assigned_dir = clipper.test_dir(),\\n fasta_dir = clipper.test_dir(),\\n species=\\\"mm9\\\", \\n nrand = 3, \\n getseq=False)\",\n \"def check_setpoints(self):\\n # TODO: Can possibly put this in the CCBC Brains\\n for heater in self.ard_data['heaters'].keys():\\n current_temp = float(self.ard_data['tempsensors'][self.ard_data['heaters'][heater]['tsensor_name']]['value'])\\n\\n # Assign the pin_status the previous value from the previous iteration\\n pin_status = self.ard_data['heaters'][heater]['status']\\n\\n if current_temp > self.ard_data['heaters'][heater]['upper limit']:\\n pin_status = 'OFF'\\n\\n if current_temp < self.ard_data['heaters'][heater]['lower limit']:\\n pin_status = 'ON'\\n\\n if current_temp >= self.ard_data['heaters'][heater]['maxtemp']:\\n pin_status = 'OFF'\\n\\n self.ard_data['heaters'][heater]['status'] = pin_status\\n\\n for pump in self.ard_data['pumps'].keys():\\n pressure = float(self.ard_data['presssensors'][self.ard_data['pumps'][pump]['psensor_name']]['pressure'])\\n gallons = float(pressure * self.ard_data['pumps'][pump]['psi_to_gal_slope'] +\\n self.ard_data['pumps'][pump]['psi_to_gal_intercept'])\\n self.ard_data['pumps'][pump]['gallons'] = gallons\\n\\n # Assign the pin status the previous value from the previous cycle\\n pin_status = self.ard_data['pumps'][pump]['status']\\n\\n if gallons > self.ard_data['pumps'][pump]['upper limit']:\\n # Turn the pump off when the setpoint is above the setpoint\\n pin_status = 'OFF'\\n # TODO: Account for solenoid valve control when available\\n\\n if gallons < self.ard_data['pumps'][pump]['lower limit']:\\n pin_status = 'ON'\\n\\n self.ard_data['pumps'][pump]['status'] = pin_status\",\n \"def Check(self):\\n cleared = False\\n while not cleared:\\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\\n x1 = i[0][0]\\n y1 = i[0][1]\\n r1 = i[0][2] / 2\\n idx1 = i[0][3]\\n x2 = i[1][0]\\n y2 = i[1][1]\\n r2 = i[1][2] / 2\\n idx1 = i[0][3]\\n idx2 = i[1][3]\\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\\n radii = (r1 + r2) * (r1 + r2)\\n if distance == radii:\\n cleared = True\\n elif distance > radii:\\n cleared = True\\n else:\\n if x1 > x2 and y1 > y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n elif x1 > x2 and y1 < y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n elif x1 < x2 and y1 > y2:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n else:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n _logger.debug(\\n f\\\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\\\"\\n )\\n cleared = False\\n return\",\n \"def assign(self):\\n\\n for s in self.spots:\\n if self.cells[s[:2]] == 0:\\n label = find_nearest_region(self.cells, *s[:2])\\n else:\\n label = self.cells[s[:2]]\\n\\n s.region = label\",\n \"def test_guider_start_arcsOn(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['arcs'])\\n self._guider_start(8, 20, 0, 0)\",\n \"def wait(self):\\n self.set_vals(spin=.2)\\n nearest_deg = 0\\n nearest_deg_dist = self.perim_dist + 1\\n for i, x in enumerate(self.ranges):\\n if (x != 0) and (x < nearest_deg_dist):\\n nearest_deg = i\\n nearest_deg_dist = x\\n if nearest_deg_dist < self.perim_dist:\\n nearest_deg = ((nearest_deg + 180) % 360) - 180\\n self.center(degree=nearest_deg)\\n self.current_state = \\\"follow\\\"\",\n \"def __iteratively_retain(\\n self,\\n orf_regions: List[Tuple[int, int]]) -> List[Tuple[int, int]]:\\n\\n ret = []\\n\\n arr = np.zeros((len(self.seq), ))\\n\\n for start, end in orf_regions:\\n ret.append((start, end))\\n arr[start-1:end] = 1\\n orf_coverage = np.sum(arr) / len(arr)\\n if orf_coverage > self.min_orf_coverage:\\n break\\n\\n return ret\",\n \"def nearest_test_pulse(self):\",\n \"def upper_covers(self, x):\",\n \"def nextRange(self):\\r\\n if (self.selectedmap < len(self.maplevels)-1):\\r\\n self.pickMap(self.selectedmap+1)\",\n \"def pick_area(data ,total_process, interval ,list_of_vars, list_of_areas, init_time=0, pr_height=None, ):\\n \\n \\n \\n #trying if the longitude values change from 0 to 360 or -180 to 180?\\n \\n if data['lon'].values[0] < 0:\\n \\n p_d = {'europe' : [0, 48, 30, 65],\\n 'northamerica' : [-142,-42,0,60],\\n 'australia' : [80,180,-50,10],\\n 'gulfofmexico' : [-100,-75,18,31],\\n 'carribeans' : [-85,-60,12,38], \\n 'indianocean' : [30, 130,-35,35],\\n 'NH' : [-180, 180 ,0,90]}\\n \\n # -180 to 180 change the values given in the dictionary to relevant\\n else:\\n \\n p_d = {'europe' : [0, 48, 30, 65],\\n 'northamerica' : [218,318,-10,70],\\n 'australia' : [80,180,-50,10],\\n 'gulfofmexico' : [260,285,14,37],\\n 'carribeans' : [275,300,12,38], \\n 'indianocean' : [30, 130,-35,35],\\n 'NH' : [0, 360 ,0,90]}\\n \\n \\n \\n places_dict = {}\\n #looping in the list of areas\\n say_pl = 1\\n for pl in list_of_areas:\\n variables_l = {}\\n #looping in the list of variables\\n say_var =1\\n for var in list_of_vars:\\n #check if data contains 'lev' coords.\\n try:\\n \\n #wrap the data\\n single = data[var].sel(lon=slice(p_d[pl][0],p_d[pl][1]), \\n lat=slice(p_d[pl][2],p_d[pl][3]), \\n lev=pr_height).isel(time=slice(init_time, total_process, interval))\\n \\n #if no 'lev' coords exist.\\n except:\\n single = data[var].sel(lon=slice(p_d[pl][0],p_d[pl][1]), \\n lat=slice(p_d[pl][2],p_d[pl][3]),).isel(time=slice(init_time, total_process, interval))\\n \\n #append a single variable given by the user\\n variables_l[var] = single\\n \\n \\n #append all the variables with respect to their area of interest.\\n places_dict[pl] = variables_l\\n \\n #return\\n return places_dict\",\n \"def occupied(self):\\n self.is_occupied = 1\\n for hex in self.fon:\\n hex.add_neighbor()\\n hex.set_quality()\",\n \"def make_binning(img, skip=5):\\n table = Table.read(\\\"ellipse.txt\\\", format=\\\"ascii\\\")\\n table = table[table[\\\"sma\\\"]>10]\\n table = table[::skip]\\n data, norm = make_masked_img(img)\\n ydim, xdim = data.shape\\n x, y = np.meshgrid(np.arange(xdim)+1, np.arange(ydim)+1)\\n ##########################################################################\\n # Set the value of the geometric parameters for the inner region to\\n # ignore the dust lane.\\n sma_inn = 20\\n idxinn = np.where(table[\\\"sma\\\"]<=sma_inn)[0]\\n e_inn = table[idxinn][\\\"ellipticity\\\"][-1]\\n pa_inn = table[idxinn][\\\"pa\\\"][-1]\\n ###########################################################################\\n bintable = []\\n for i, isophote in enumerate(table):\\n ellip = e_inn if isophote[\\\"sma\\\"] <= sma_inn else isophote[\\\"ellipticity\\\"]\\n pa = pa_inn if isophote[\\\"sma\\\"] <= sma_inn else isophote[\\\"pa\\\"]\\n bintable.append([isophote[\\\"sma\\\"], ellip, pa])\\n e = Ellipse2D(amplitude=1., x_0=213, y_0=235, a=isophote[\\\"sma\\\"],\\n b=isophote[\\\"sma\\\"] * (1 - ellip),\\n theta=np.deg2rad(pa))\\n if i==0:\\n binning = e(x,y)\\n continue\\n outer = e(x,y)\\n ring = np.where((outer>0) & (binning==0))\\n binning[ring] = i+1\\n binning[binning==0] = np.nan\\n bintable = np.array(bintable)\\n table = Table(bintable, names=[\\\"sma\\\", \\\"ellipticity\\\", \\\"pa\\\"])\\n binning[data.mask] = np.nan\\n hdu0 = fits.PrimaryHDU(binning)\\n hdu1 = fits.BinTableHDU(table)\\n hdulist = fits.HDUList([hdu0, hdu1])\\n hdulist.writeto(\\\"ellipse_binning_v0.fits\\\", overwrite=True)\",\n \"def start_region(self, x, y):\\n if x>0 and x<100 and y>0 and y<100:\\n return 1\\n elif x>700 and x<800 and y>0 and y<100:\\n return 2\\n elif x>0 and x<100 and y>400 and y<500:\\n return 3\\n elif x>700 and x<800 and y>400 and y<500:\\n return 4\\n return 0\",\n \"def ROOMSELECTION_LOOP():\\n pass\",\n \"def make_partioned_regions(shape, alpha=1.0, max_regions=5, min_regions=2):\\n ring = np.array([[1,1,1],[1,0,1],[1,1,1]], dtype=np.int16)\\n adjacent = np.array([ # Diagonals don't count as adjacent\\n [-1,0,0,1],\\n [0,-1,1,0]], dtype=np.int16).T\\n nearby = np.meshgrid([-2,-1,0,1,2], [-2,-1,0,1,2])\\n\\n board = np.zeros(shape, dtype=np.int16)\\n perimeters = [{\\n (i, j) for i, j in zip(*np.nonzero(board == 0))\\n }]\\n exclusions = [set()]\\n while sum(len(p) for p in perimeters) > 0:\\n weights = np.array([len(p) for p in perimeters], dtype=float)\\n weights[0] = min(alpha, weights[0]) if len(weights) <= max_regions else 1e-10\\n if len(weights) <= min_regions:\\n weights[1:] = 1e-10\\n weights /= np.sum(weights)\\n k = get_rng().choice(len(perimeters), p=weights)\\n plist = list(perimeters[k])\\n i, j = plist[get_rng().choice(len(plist))]\\n perimeters[0].discard((i, j))\\n perimeters[k].discard((i, j))\\n if (i, j) in exclusions[k]:\\n continue\\n exclusions[0].add((i,j))\\n exclusions[k].add((i,j))\\n b = board[(i+nearby[0]) % shape[0], (j+nearby[1]) % shape[1]]\\n b[2,2] = k or -1\\n num_neighbors = signal.convolve2d(b != 0, ring, mode='valid')\\n num_foreign = signal.convolve2d((b > 0) & (b != k), ring, mode='valid')\\n if ((num_foreign > 0) & (num_neighbors > 2)).any() or num_foreign[1,1] > 0:\\n continue\\n # Add to the board\\n if k == 0:\\n k = len(perimeters)\\n perimeters.append(set())\\n exclusions.append(set())\\n board[i, j] = k\\n for i2, j2 in (adjacent + (i, j)) % shape:\\n if board[i2, j2] == 0:\\n perimeters[k].add((i2, j2))\\n return board\",\n \"def check_powerups(self):\\n for powerup in self.pjs.powerups:\\n block = powerup.rects[0]\\n if block.overlap(self.rects[0]):\\n self.eat(powerup)\",\n \"def test_bad_region():\\n ref_file = pkg_resources.resource_filename('m260b.test_data', 'ref_practice_W_1_chr_1.fasta')\\n read_file = pkg_resources.resource_filename('m260b.test_data', 'practice_w_1.std.bad_region1.bam')\\n ref_hdr, reference = read_basic_fasta(ref_file) \\n read_iter = pysam.Samfile(read_file)\\n chr = ref_hdr[1:].strip()\\n areg = list(active_regions(read_iter, reference, chr, start_offset=0, flank=30, dfrac=1.0))\\n found = False\\n for region, reads in areg:\\n found |= region.start <= 5769 <= region.stop\\n if not found:\\n raise ValueError('Window did not open around variant')\",\n \"def forehead_region_growing(img, seed,forehead_inf_limit, threshold=1):\\n\\n dims = img.shape\\n reg = np.zeros(dims, np.uint8)\\n\\n #parameters\\n mean_reg = float(img[seed[1], seed[0]])\\n size = 1\\n pix_area = dims[0]*dims[1]\\n\\n contour = [] # will be [ [[x1, y1], val1],..., [[xn, yn], valn] ]\\n contour_val = []\\n dist = 0\\n # TODO: may be enhanced later with 8th connectivity\\n orient = [(1, 0), (0, 1), (-1, 0), (0, -1)] # 4 connectivity\\n cur_pix = [seed[0], seed[1]]\\n\\n #Spreading\\n while(dist<threshold and size<pix_area):\\n #adding pixels\\n for j in range(4):\\n #select new candidate\\n temp_pix = [cur_pix[0] +orient[j][0], cur_pix[1] +orient[j][1]]\\n\\n #check if it belongs to the image\\n is_in_img = dims[0]>temp_pix[0]>0 and dims[1]>temp_pix[1]>=forehead_inf_limit #returns boolean\\n #candidate is taken if not already selected before\\n if (is_in_img and (reg[temp_pix[1], temp_pix[0]]==0)):\\n contour.append(temp_pix)\\n contour_val.append(img[temp_pix[1], temp_pix[0]] )\\n reg[temp_pix[1], temp_pix[0]] = 150\\n #add the nearest pixel of the contour in it\\n dist = abs(int(np.mean(contour_val)) - mean_reg)\\n\\n dist_list = [abs(i - mean_reg) for i in contour_val ]\\n dist = min(dist_list) #get min distance\\n index = dist_list.index(min(dist_list)) #mean distance index\\n size += 1 # updating region size\\n reg[cur_pix[1], cur_pix[0]] = 255\\n\\n #updating mean MUST BE FLOAT\\n mean_reg = (mean_reg*size + float(contour_val[index]))/(size+1)\\n #updating seed\\n cur_pix = contour[index]\\n\\n #removing pixel from neigborhood\\n del contour[index]\\n del contour_val[index]\\n\\n return reg\",\n \"def test_areas_locked_ok(self):\",\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 reset(self, **kwargs):\\n coverage_filter = np.zeros((self.region, self.region))\\n coverage_filter[np.random.uniform(0, 1, (self.region, self.region)) < self.coverage] = 1.\\n self.resources = np.multiply(\\n np.random.uniform(self.min_value, self.max_value, (self.region, self.region)),\\n coverage_filter\\n )\",\n \"def __call__(self, results):\\n h, w, c = results['img'].shape\\n n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)\\n for _ in range(n_holes):\\n x1 = np.random.randint(0, w)\\n y1 = np.random.randint(0, h)\\n index = np.random.randint(0, len(self.candidates))\\n if not self.with_ratio:\\n cutout_w, cutout_h = self.candidates[index]\\n else:\\n cutout_w = int(self.candidates[index][0] * w)\\n cutout_h = int(self.candidates[index][1] * h)\\n\\n x2 = np.clip(x1 + cutout_w, 0, w)\\n y2 = np.clip(y1 + cutout_h, 0, h)\\n results['img'][y1:y2, x1:x2, :] = self.fill_in\\n\\n return results\",\n \"def test_build_genomic_regions(self):\\n\\n CDS = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t7700\\\\t7900\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t7999\\\\t8500\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n UTR5 = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t7499\\\\t7700\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n UTR3 = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t8500\\\\t9000\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n proxintron = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t100\\\\t300\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t798\\\\t998\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t2000\\\\t2200\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t2798\\\\t2998\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t6000\\\\t6200\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t6798\\\\t6998\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t7900\\\\t7998\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True\\n )\\n distintron = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t301\\\\t797\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t2201\\\\t2797\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t6201\\\\t6797\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n \\n regions = build_genomic_regions(pybedtools.BedTool(clipper.test_file(\\\"test.gtf\\\")), prox_distance=200) \\n \\n #print UTR3\\n\\n #print regions['UTR3']\\n print proxintron\\n print regions['proxintron']\\n #print regions['distintron']\\n \\n self.assertEqual(len(CDS.intersect(regions['CDS'], f= 1.0, r = True)), 2)\\n self.assertEqual(len(UTR5.intersect(regions['UTR5'], f= 1.0, r = True)), 1)\\n self.assertEqual(len(UTR3.intersect(regions['UTR3'], f= 1.0, r = True)), 1)\\n self.assertEqual(len(proxintron.intersect(regions['proxintron'], f= 1.0, r = True)), 7)\\n self.assertEqual(len(distintron.intersect(regions['distintron'], f= 1.0, r = True)), 3)\",\n \"def split():\\n flag = 0\\n for chromosome in region:\\n for inf in region[chromosome]:\\n if flag == 0:\\n if chromosome not in test_set:\\n test_set[chromosome] = [inf]\\n else:\\n test_set[chromosome].append(inf)\\n else:\\n if chromosome not in train_set:\\n train_set[chromosome] = [inf]\\n else:\\n train_set[chromosome].append(inf)\\n\\n flag += 1\\n flag %= 10\",\n \"def _pickFull(self, context):\\n rayObject = context.getPickingSegment(frame=self._getScenePrimitive())\\n if rayObject is None:\\n return None\\n rayObject = rayObject[:, :3]\\n\\n data = self.getData(copy=False)\\n bins = utils.segmentVolumeIntersect(\\n rayObject, numpy.array(data.shape) - 1)\\n if bins is None:\\n return None\\n\\n # gather bin data\\n offsets = [(i, j, k) for i in (0, 1) for j in (0, 1) for k in (0, 1)]\\n indices = bins[:, numpy.newaxis, :] + offsets\\n binsData = data[indices[:, :, 0], indices[:, :, 1], indices[:, :, 2]]\\n # binsData.shape = nbins, 8\\n # TODO up-to this point everything can be done once for all isosurfaces\\n\\n # check bin candidates\\n level = self.getLevel()\\n mask = numpy.logical_and(numpy.nanmin(binsData, axis=1) <= level,\\n level <= numpy.nanmax(binsData, axis=1))\\n bins = bins[mask]\\n binsData = binsData[mask]\\n\\n if len(bins) == 0:\\n return None # No bin candidate\\n\\n # do picking on candidates\\n intersections = []\\n depths = []\\n for currentBin, data in zip(bins, binsData):\\n mc = MarchingCubes(data.reshape(2, 2, 2), isolevel=level)\\n points = mc.get_vertices() + currentBin\\n triangles = points[mc.get_indices()]\\n t = glu.segmentTrianglesIntersection(rayObject, triangles)[1]\\n t = numpy.unique(t) # Duplicates happen on triangle edges\\n if len(t) != 0:\\n # Compute intersection points and get closest data point\\n points = t.reshape(-1, 1) * (rayObject[1] - rayObject[0]) + rayObject[0]\\n # Get closest data points by rounding to int\\n intersections.extend(points)\\n depths.extend(t)\\n\\n if len(intersections) == 0:\\n return None # No intersected triangles\\n\\n intersections = numpy.array(intersections)[numpy.argsort(depths)]\\n indices = numpy.transpose(numpy.round(intersections).astype(numpy.int64))\\n return PickingResult(self, positions=intersections, indices=indices)\",\n \"def test_WIMP_cut_region_on_true_data(bolo_name, mass, analysis):\\n\\t\\n\\n\\t#Load 2D PDF\\n\\tfWIMP2D, f = PyRPl.open_ROOT_object(\\\"./ROOT_files/WIMP_PDF2D_\\\" + analysis + \\\".root\\\", \\\"WIMP_\\\" + mass + \\\"_GeV\\\")\\n\\n\\t#Load cut value on PDF for 95% WIMP box\\n\\tcut_val_90, cut_val_99 = 0,0\\n\\twith open (\\\"./Text_files/WIMP_PDF_90_and_99_cut_value_\\\" + analysis + \\\".txt\\\", \\\"r\\\") as fcut:\\n\\t\\tstuff = [elem.rstrip().split(\\\",\\\") for elem in fcut.readlines()]\\n\\t\\tfor elem in stuff:\\n\\t\\t\\tmass_val = elem[0]\\n\\t\\t\\tif int(mass)==int(mass_val):\\n\\t\\t\\t\\tcut_val_90 = float(elem[1])\\n\\t\\t\\t\\tcut_val_99 = float(elem[2])\\n\\t\\n\\n\\tdata_path = \\\"/home/irfulx204/mnt/tmain/Desktop/Run308_Analyse_ERA/Fond_ERA_merged/\\\"\\n\\tfilou = TFile(data_path + bolo_name + \\\"_\\\" + analysis + \\\"_fond.root\\\", \\\"read\\\")\\n\\ttree = filou.Get(\\\"data\\\")\\n\\tnum_pass_cut =0\\n\\n\\thpass = TH2F(\\\"hpass\\\", \\\"hpass\\\", 100, 0, 15, 100, 0, 15)\\n\\n\\t# #T Check that the events are found where expected\\n\\t# arr1 = np.random.uniform(0,15,size=(200000,2))\\n\\t# for i in range(arr1.shape[0]):\\n\\t# \\tPDF_val = fWIMP2D.Eval(arr1[i][0], arr1[i][1])\\n\\t# \\tif (cut_val_99<PDF_val<cut_val_90):\\n\\t# \\t# if (cut_val_99<PDF_val<cut_val_90):\\n\\t# \\t\\tnum_pass_cut+=1\\n\\t# \\t\\thpass.Fill(arr1[i][0], arr1[i][1])\\t\\t\\n\\n\\t# hpass.Draw()\\n\\t# raw_input()\\n\\n\\tfor k in range(tree.GetEntries()):\\n\\t\\ttree.GetEntry(k)\\n\\t\\tER=(1+8./3)*0.5*(tree.EC1+tree.EC2)-0.33*(1.5*tree.EIA+4*tree.EIB+1.5*tree.EIC+4*tree.EID)\\n\\t\\tPDF_val = fWIMP2D.Eval(ER, 0.5*(tree.EIB+tree.EID))\\n\\t\\tif (cut_val_99<PDF_val<cut_val_90 and 0.5*(tree.EIB+tree.EID)>0.7):\\n\\t\\t# if (cut_val_99<PDF_val<cut_val_90):\\n\\t\\t\\tnum_pass_cut+=1\\n\\t\\t\\thpass.Fill(0.5*(tree.EC1+tree.EC2), 0.5*(tree.EIB+tree.EID))\\n\\n\\tprint num_pass_cut\\n\\thpass.Draw()\\n\\traw_input()\",\n \"def region_growing(im: np.ndarray, seed_points: list, T: int) -> np.ndarray:\\n ### START YOUR CODE HERE ### (You can change anything inside this block)\\n # You can also define other helper functions\\n segmented = np.zeros_like(im).astype(bool)\\n\\n (H, W) = im.shape\\n\\n for seed_row, seed_col in seed_points:\\n region = []\\n region.append([seed_row, seed_col])\\n for row, col in region:\\n for rows in range((row-1),(row+2)): # Check neighbouring pixels\\n for cols in range((col-1),(col+2)):\\n if rows < H and rows >= 0 and cols < W and cols >= 0: # Is pixel inside image?\\n if (np.abs(im[seed_row, seed_col] - im[rows, cols]) <= T) and not segmented[row, col]:\\n region.append([rows, cols])\\n segmented[row, col] = True\\n return segmented\\n ### END YOUR CODE HERE ### \",\n \"def mark_check() -> None:\\r\\n for i in range(shape):\\r\\n y = i\\r\\n can_mark = False\\r\\n conflict_counter = 0\\r\\n\\r\\n # Horizontal Check\\r\\n for j in range(shape):\\r\\n x = j\\r\\n for z in range(shape):\\r\\n if conflict_space[x, y] == conflict_space[z, y] and x != z and conflict_space[x, y] != 0:\\r\\n if safeboard[z, y] == 0:\\r\\n can_mark = True\\r\\n conflict_counter += 1\\r\\n else:\\r\\n conflict_counter += 1\\r\\n if can_mark and conflict_counter < 2 and safeboard[x, y] != 0 and no_neighbour(x, y):\\r\\n print(\\\"Horizontal: conflict_counter at\\\", conflict_counter, \\\"so it is going to mark \\\", x, \\\",\\\", y)\\r\\n example[x, y] = 0\\r\\n conflict_space[x, y] = 0\\r\\n shade_neighbours(x, y)\\r\\n conflict_check()\\r\\n progress_handler(False, True)\\r\\n conflict_counter = 0\\r\\n can_mark = False\\r\\n\\r\\n # Vertical Check\\r\\n x = i\\r\\n for j in range(shape):\\r\\n y = j\\r\\n for z in range(shape):\\r\\n if conflict_space[x, y] == conflict_space[x, z] and y != z and conflict_space[x, y] != 0:\\r\\n if safeboard[x, z] == 0:\\r\\n can_mark = True\\r\\n conflict_counter += 1\\r\\n else:\\r\\n conflict_counter += 1\\r\\n if can_mark and conflict_counter < 2 and safeboard[x, y] != 0 and no_neighbour(x, y):\\r\\n print(\\\"Vertical: conflict_counter at\\\", conflict_counter, \\\"so it is going to mark \\\", x, \\\",\\\", y)\\r\\n example[x, y] = 0\\r\\n conflict_space[x, y] = 0\\r\\n shade_neighbours(x, y)\\r\\n conflict_check()\\r\\n progress_handler(False, True)\\r\\n conflict_counter = 0\\r\\n can_mark = False\",\n \"def needleDetection(self):\\n #research #obsolete\\n profbox(whoami())\\n # Apply Island Effect\\n editUtil = EditorLib.EditUtil.EditUtil()\\n parameterNode = editUtil.getParameterNode()\\n sliceLogic = editUtil.getSliceLogic()\\n lm = slicer.app.layoutManager()\\n sliceWidget = lm.sliceWidget('Red')\\n islandsEffect = EditorLib.IdentifyIslandsEffectOptions()\\n islandsEffect.setMRMLDefaults()\\n islandsEffect.__del__()\\n islandTool = EditorLib.IdentifyIslandsEffectLogic(sliceLogic)\\n parameterNode.SetParameter(\\\"IslandEffect,minimumSize\\\",'0')\\n islandTool.removeIslands()\\n # select the image node from the Red slice viewer\\n m=vtk.vtkMatrix4x4()\\n volumeNode = slicer.app.layoutManager().sliceWidget(\\\"Red\\\").sliceLogic().GetBackgroundLayer().GetVolumeNode()\\n volumeNode.GetIJKToRASMatrix(m)\\n imageData = volumeNode.GetImageData()\\n spacing = volumeNode.GetSpacing()\\n # chrono starts\\n self.t0 = time.clock()\\n # get the coordinates from the label map\\n label=self.array2()\\n for I in xrange(len(label)):\\n A=label[I]\\n colorVar = I/(len(label))\\n self.needleDetectionThread(A, imageData, colorVar,spacing)\\n if slicer.modules.NeedleFinderWidget.autoStopTip.isChecked():\\n self.needleDetectionUPThread(A, imageData, colorVar,spacing)\",\n \"def getmissedoutregions(peakfile,treatment_bamfile, min_size, min_coverage_gain_over_average,window_size):\\n total_read_count=getmappedreadcount(treatment_bamfile)\\n chrsizedict=getchrsizes(treatment_bamfile)\\n total_chr_size=sum([chrsizedict[chrnm] for chrnm in chrsizedict])\\n avg_reads=1.0*total_read_count/total_chr_size\\n indexed_bamfile=ChipSeqIndex.ChipSeqIndex(treatment_bamfile)\\n tempmissedoutregionslist=[]\\n prev_chrinterval=['chr1',0,0]\\n lncnt=0\\n for lntxt in open(peakfile):\\n lncnt+=1\\n ln=lntxt.rstrip('\\\\n').split('\\\\t')\\n chrinterval=[ln[0],int(ln[1]),int(ln[2])]\\n cadidategaplist=[]\\n if prev_chrinterval[0]==chrinterval[0]:\\n if (chrinterval[1]-prev_chrinterval[2]-1)>min_size:\\n cadidategaplist.append([chrinterval[0],prev_chrinterval[2]+1,chrinterval[1]-1])\\n else:\\n if (chrsizedict[prev_chrinterval[0]]-prev_chrinterval[2])>min_size:\\n cadidategaplist.append([prev_chrinterval[0],prev_chrinterval[2]+1,chrsizedict[prev_chrinterval[0]]])\\n if (chrinterval[1]-1)>min_size:\\n cadidategaplist.append([chrinterval[0],1,chrinterval[1]-1])\\n for cadidatelargegap in cadidategaplist:\\n for i in range((cadidatelargegap[2]-cadidatelargegap[1])/window_size+1):\\n cadidategap=[cadidatelargegap[0],cadidatelargegap[1]+i*window_size,min(cadidatelargegap[1]+(i+1)*window_size,cadidatelargegap[2])]\\n chrrange='%s:%d-%d'%tuple(cadidategap)\\n readcounts=indexed_bamfile.countreadsinrange(chrrange)\\n if readcounts*1.0/(chrinterval[1]-prev_chrinterval[2])> min_coverage_gain_over_average*avg_reads:\\n tempmissedoutregionslist.append(cadidategap)\\n prev_chrinterval=chrinterval[0:]\\n\\n #join adjacent regions\\n missedoutregionslist=[]\\n if len(tempmissedoutregionslist)!=0:\\n prev_region=tempmissedoutregionslist[0]\\n for region in tempmissedoutregionslist[1:]:\\n if region[0]==prev_region[0] and (region[1]-prev_region[2])<=1:\\n prev_region[2]=region[2]\\n else:\\n missedoutregionslist.append(prev_region)\\n prev_region=region[0:]\\n missedoutregionslist.append(prev_region)\\n \\n return missedoutregionslist\",\n \"def setUpBombs(self, event):\\n pos = (event.widget.row * self.cols) + event.widget.col\\n size = self.rows * self.cols\\n \\n #get a list random indexes in range to be mines\\n mines = random.sample(range(size), self.numMines)\\n if pos in mines:\\n mines.remove(pos)\\n temp = random.sample(range(size), 1)[0]\\n while (temp == pos): temp = random.sample(range(size), 1)[0]\\n mines.append(temp)\\n \\n #mark all mine squares as mines\\n for mine in mines:\\n targetRow = int(mine/self.cols)\\n targetCol = mine % self.cols\\n self.tiles[targetRow][targetCol].setMine()\\n\\n #calculate the number in each Square of the current game\\n for row in self.tiles:\\n for tile in row:\\n if not tile.isMine():\\n counter = 0\\n for adjTile in self.getAdjacentTiles(tile.row,tile.col):\\n if adjTile.isMine(): counter += 1\\n tile.setCount(counter)\\n \\n self.minesArmed = True\\n self.startTime = time.time()\\n return 1\",\n \"def range(self, event):\\r\\n \\r\\n p = (event.x, self.toCartesian(event.y))\\r\\n \\r\\n if self.selectedRegion is None:\\r\\n self.selectedStart = Region(p[X],p[Y], p[X],p[Y])\\r\\n self.selectedRegion = self.selectedStart.unionPoint(p)\\r\\n \\r\\n self.paint()\\r\\n \\r\\n # return (node,sub-tree) where sub-tree is True if draining entire tree\\r\\n # rooted at node. Draw these as shaded red rectangle to identify whole\\r\\n # sub-tree is selected.\\r\\n for pair in self.tree.range(self.selectedRegion):\\r\\n p = pair[0].point\\r\\n \\r\\n if pair[1]:\\r\\n self.canvas.create_rectangle(pair[0].region.x_min, self.toTk(pair[0].region.y_min), \\r\\n pair[0].region.x_max, self.toTk(pair[0].region.y_max),\\r\\n fill='Red', stipple='gray12')\\r\\n else:\\r\\n self.canvas.create_rectangle(p[X] - BoxSize, self.toTk(p[Y]) - BoxSize, \\r\\n p[X] + BoxSize, self.toTk(p[Y]) + BoxSize, fill='Red')\\r\\n\\r\\n self.queryRect = self.canvas.create_rectangle(self.selectedRegion.x_min, self.toTk(self.selectedRegion.y_min), \\r\\n self.selectedRegion.x_max, self.toTk(self.selectedRegion.y_max), \\r\\n outline='Red', dash=(2, 4))\",\n \"def test_multi_area(self):\\n pass\",\n \"def FillupArea(self):\\r\\n\\r\\n drillsize = self.FromUserUnit(float(self.m_txtViaDrillSize.GetValue()))\\r\\n viasize = self.FromUserUnit(float(self.m_txtViaSize.GetValue()))\\r\\n step_x = self.FromUserUnit(float(self.m_txtHSpacing.GetValue()))\\r\\n step_y = self.FromUserUnit(float(self.m_txtVSpacing.GetValue()))\\r\\n clearance = self.FromUserUnit(float(self.m_txtClearance.GetValue()))\\r\\n self.randomize = self.m_chkRandomize.GetValue()\\r\\n self.clearance = clearance\\r\\n bbox = self.area.GetBoundingBox()\\r\\n top = bbox.GetTop()\\r\\n bottom = bbox.GetBottom()\\r\\n right = bbox.GetRight()\\r\\n left = bbox.GetLeft()\\r\\n netname = self.m_cbNet.GetStringSelection()\\r\\n netcode = self.board.GetNetcodeFromNetname(netname)\\r\\n # commit = pcbnew.COMMIT()\\r\\n viacount = 0\\r\\n x = left\\r\\n\\r\\n # Cycle trough area bounding box checking and implanting vias\\r\\n layer = self.area.GetLayer()\\r\\n\\r\\n while x <= right:\\r\\n y = top\\r\\n while y <= bottom:\\r\\n if self.randomize:\\r\\n xp = x + random.uniform(-1, 1) * step_x / 5\\r\\n yp = y + random.uniform(-1, 1) * step_y / 5\\r\\n else:\\r\\n xp = x\\r\\n yp = y\\r\\n\\r\\n if hasattr(pcbnew, 'VECTOR2I'):\\r\\n p = pcbnew.VECTOR2I(xp, yp)\\r\\n else:\\r\\n if(hasattr(pcbnew, 'wxPoint')):\\r\\n p = pcbnew.wxPoint(xp, yp)\\r\\n\\r\\n if self.area.HitTestFilledArea(layer, p, 0):\\r\\n via = pcbnew.PCB_VIA(self.board)\\r\\n via.SetPosition(p)\\r\\n via.SetLayer(layer)\\r\\n via.SetNetCode(netcode)\\r\\n # Set up via with clearance added to its size-> bounding box check will be OK in worst case, may be too conservative, but additional checks are possible if needed\\r\\n # TODO: possibly take the clearance from the PCB settings instead of the dialog\\r\\n # Clearance is all around -> *2\\r\\n via.SetDrill(drillsize + 2 * clearance)\\r\\n via.SetWidth(viasize + 2 * clearance)\\r\\n # via.SetTimeStamp(__timecode__)\\r\\n if not self.CheckOverlap(via):\\r\\n # Check clearance only if clearance value differs from 0 (disabled)\\r\\n if (clearance == 0) or self.CheckClearance(via, self.area, clearance):\\r\\n via.SetWidth(viasize)\\r\\n via.SetDrill(drillsize)\\r\\n self.board.Add(via)\\r\\n # commit.Add(via)\\r\\n self.pcb_group.AddItem(via)\\r\\n viacount += 1\\r\\n y += step_y\\r\\n x += step_x\\r\\n\\r\\n if viacount > 0:\\r\\n wx.MessageBox(_(u\\\"Implanted: %d vias!\\\") % viacount)\\r\\n # commit.Push()\\r\\n pcbnew.Refresh()\\r\\n else:\\r\\n wx.MessageBox(_(u\\\"No vias implanted!\\\"))\",\n \"def random_points_ascending_hillclimber(house, all_houses, waters, total_value_map):\\n total_value_map_NEW = total_value_map\\n\\n # check in welke range het huis geplaats kan worden, niet kijkend naar water of andere \\n rangex = MAXIMUM_WIDTH - house.width\\n rangey = MAXIMUM_HEIGHT - house.length\\n\\n for x in range(100):\\n # maak random x en y coördinaat\\n randomizex = rangex * random()\\n randomizey = rangey * random()\\n\\n # bewaar oude locaties\\n tempx = house.bottom_left[0]\\n tempy = house.bottom_left[1]\\n \\n # verander locatie\\n bottom_left = (randomizex,randomizey)\\n house.location(bottom_left)\\n\\n # als je je huis op nieuwe locatie kan plaatsen\\n if place_house(house, all_houses, waters) == True:\\n # bereken nieuw waarde map, waarin huis is verplaatst\\n total_value_map_temp = 0\\n for item in all_houses.values():\\n for house in item:\\n house.extra_meters()\\n total_value_map_temp += house.totalprice()\\n\\n # als waarde met nieuwe locatie hoger is, verander deze\\n if total_value_map_NEW < total_value_map_temp:\\n total_value_map_NEW = total_value_map_temp\\n # als waarde niet hoger is verander naar oude locatie en bereken weer totale waarde map\\n else:\\n bottom_left = (tempx,tempy)\\n house.location(bottom_left)\\n if place_house(house, all_houses, waters) == True:\\n for item in all_houses.values():\\n for houses in item:\\n houses.extra_meters()\\n houses.totalprice()\\n # als huis niet geplaats kan worden, verander naar oude locatie en bereken weer totale waarde map\\n else:\\n bottom_left = (tempx,tempy)\\n house.location(bottom_left)\\n if place_house(house, all_houses, waters) == True:\\n for item in all_houses.values():\\n for houses in item:\\n houses.extra_meters()\\n houses.totalprice()\\n\\n return all_houses, total_value_map_NEW\",\n \"def inregionCut(self,l,r,g,Nb):\\n A1 = np.random.randint(l+1-self.keepCL, r-1-(Nb-1)*(g+1)-(1-self.keepCL))\\n return A1 + np.arange(Nb)*(1+g)\",\n \"def fetchCooler(c, regions, coolerFetch = lambda coo, ext:coo.matrix(balance=True, sparse=True).fetch(ext),\\n mask=True, force=False, ):\\n regions = [list(i) for i in regions]\\n resolution = c.binsize\\n\\n for i in regions:\\n if i[1] == None:\\n i[1] = 0 \\n if i[2] == None:\\n i[2] = c.chromsizes[i[0]]\\n\\n \\n for a in regions: \\n if str(a[0]) not in c.chromnames:\\n raise ValueError(\\\"Chromosome {0} from regions not found in cooler\\\".format(a))\\n if (a[1] % resolution) != 0:\\n raise ValueError(\\\"Start of an region should be a multiple fo resolution\\\")\\n \\n# bins = c.bins()[:]\\n \\n# # managing masks \\n# if mask is False: \\n# bins[\\\"mask\\\"] = 1 \\n# elif mask is None:\\n# assert \\\"mask\\\" in bins.columns\\n# elif mask is True: \\n# pass \\n# elif callable(mask):\\n# pass \\n# else:\\n# bins[\\\"mask\\\"] = mask \\n \\n \\n for region in regions:\\n matrix = coolerFetch(c, region)\\n try: # setting matrix nans to zeros.\\n matrix.data = np.nan_to_num(matrix.data, copy=False)\\n except TypeError: #workaround for old numpy versions\\n matrix.data = np.nan_to_num(matrix.data)\\n# st,end = c.extent(region)\\n# subbins = bins[st:end].copy()\\n if mask is True: \\n newmask = np.array((matrix.sum(axis=0) > 0 ))[0]\\n# if callable(mask):\\n# new_mask = mask(matrix)\\n# subbins[\\\"mask\\\"] = newmask \\n\\n assert len(newmask) == matrix.shape[0]\\n\\n yield matrix, newmask\",\n \"def select_cells_in_trenches(props_all, trenchLocs = TrenchLocs.MIDDLE, below_trench_quantile = 90, above_trench_quantile = 100, mother_cell_y_offset=10,inversion_mult = 1):\\n def indcs_in_trenches(centy,cell_indcs, invert):\\n \\n cy = centy[cell_indcs]\\n above_trench_cut = np.percentile(invert*cy,100 - above_trench_quantile)\\n below_trench_cut = np.percentile(invert*cy,below_trench_quantile)\\n idx_above = (invert*centy) > above_trench_cut - mother_cell_y_offset\\n idx_below = (invert*centy) < below_trench_cut\\n idx_select = np.all(np.vstack((cell_indcs,idx_above,idx_below)),axis=0)\\n return idx_select\\n \\n \\n img_height = props_all.img_height\\n centy = np.array(props_all.centy)\\n props_all['trench_inversion_mult'] = 1*inversion_mult\\n ### Note that the y-indx is flipped in image compared to matrix coords\\n if trenchLocs == TrenchLocs.MIDDLE:\\n idx_select = np.zeros(centy.shape,dtype=bool)\\n for pos in np.unique(props_all.pos_num):\\n idx_pos = np.array(props_all.pos_num == pos)\\n idx_cell_pos = indcs_in_trenches(centy,idx_pos, 1*inversion_mult)\\n idx_select = np.any(np.vstack((idx_select,idx_cell_pos)),axis=0)\\n \\n props_clean = props_all[idx_select]\\n else:\\n # top position in actual picture (smallest y value in matrix)\\n idx_top = centy < (img_height/2) \\n idx_bottom = centy > (img_height/2)\\n props_all.loc[idx_bottom,'trench_inversion_mult'] = -1*inversion_mult\\n \\n idx_select_top = np.zeros(idx_top.shape,dtype=bool)\\n idx_select_bottom = np.zeros(idx_bottom.shape,dtype=bool)\\n\\n for pos in np.unique(props_all.pos_num): \\n idx_pos = (props_all.pos_num == pos)\\n idx_top_pos = np.all(np.vstack((idx_top,idx_pos)),axis=0)\\n idx_bottom_pos = np.all(np.vstack((idx_bottom,idx_pos)),axis=0)\\n\\n idx_select_top_pos = indcs_in_trenches(centy,idx_top_pos, 1*inversion_mult)\\n idx_select_bottom_pos = indcs_in_trenches(centy,idx_bottom_pos, -1*inversion_mult)\\n idx_select_top = np.any(np.vstack((idx_select_top,idx_select_top_pos)),axis=0)\\n idx_select_bottom = np.any(np.vstack((idx_select_bottom,idx_select_bottom_pos)),axis=0)\\n\\n \\n if trenchLocs == TrenchLocs.TOP:\\n idx_reasonable_cells = idx_select_top\\n elif trenchLocs == TrenchLocs.BOTTOM:\\n idx_reasonable_cells = idx_select_bottom\\n elif trenchLocs == TrenchLocs.TOP_AND_BOTTOM:\\n idx_reasonable_cells = np.any(np.vstack((idx_select_top,idx_select_bottom)),axis=0) \\n \\n props_clean = props_all.loc[idx_reasonable_cells,:]\\n\\n return props_clean\",\n \"def generateBounds(regionFilename, latitudeRange, longitudeRange): \\n rastData = Dataset(regionFilename)\\n\\n #setting up values for raster data\\n latsRast = np.array(rastData[\\\"lat\\\"][:])\\n lonsRast = np.array(rastData[\\\"lon\\\"][:])\\n regionOfInterest = np.array(rastData[\\\"Band1\\\"][:][:])\\n\\n\\n regionArray = np.zeros((len(longitudeRange),len(latitudeRange)))\\n\\n\\n for lat in latitudeRange:\\n closestLatIndex = np.where( np.abs(latsRast-lat) == np.abs(latsRast-lat).min())[0][0]\\n for lon in longitudeRange:\\n closestLonIndex = np.where( np.abs(lonsRast-lon) == np.abs(lonsRast-lon).min())[0][0]\\n\\n #If lat long of MERRA data box is offshore or in region (values 1 in raster) set them equal to 1 for master Array, else they are left as zeros\\n if (regionOfInterest[closestLatIndex][closestLonIndex] == 1):\\n latIndex = np.where(latitudeRange == lat)[0][0]\\n lonIndex = np.where(longitudeRange == lon)[0][0]\\n regionArray[lonIndex][latIndex] = 1\\n\\n\\n #for debugging\\n ''' \\n ax = sns.heatmap(regionArray)\\n plt.show()\\n '''\\n return regionArray\",\n \"def needleDetection(self):\\r\\n # research #obsolete\\r\\n profbox(whoami())\\r\\n # Apply Island Effect\\r\\n editUtil = EditorLib.EditUtil.EditUtil()\\r\\n parameterNode = editUtil.getParameterNode()\\r\\n sliceLogic = editUtil.getSliceLogic()\\r\\n lm = slicer.app.layoutManager()\\r\\n sliceWidget = lm.sliceWidget('Red')\\r\\n islandsEffect = EditorLib.IdentifyIslandsEffectOptions()\\r\\n islandsEffect.setMRMLDefaults()\\r\\n islandsEffect.__del__()\\r\\n islandTool = EditorLib.IdentifyIslandsEffectLogic(sliceLogic)\\r\\n parameterNode.SetParameter(\\\"IslandEffect,minimumSize\\\", '0')\\r\\n islandTool.removeIslands()\\r\\n # select the image node from the Red slice viewer\\r\\n m = vtk.vtkMatrix4x4()\\r\\n volumeNode = slicer.app.layoutManager().sliceWidget(\\\"Red\\\").sliceLogic().GetBackgroundLayer().GetVolumeNode()\\r\\n volumeNode.GetIJKToRASMatrix(m)\\r\\n imageData = volumeNode.GetImageData()\\r\\n spacing = volumeNode.GetSpacing()\\r\\n # chrono starts\\r\\n self.t0 = time.clock()\\r\\n # get the coordinates from the label map\\r\\n label = self.array2()\\r\\n for I in xrange(len(label)):\\r\\n A = label[I]\\r\\n colorVar = I # ??? /(len(label))\\r\\n self.needleDetectionThread(A, imageData, colorVar, spacing)\\r\\n if slicer.modules.NeedleFinderWidget.autoStopTip.isChecked():\\r\\n self.needleDetectionUPThread(A, imageData, colorVar, spacing)\",\n \"def separate_frontier(self):\\n\\t#print self.frontier\\n region = [] # a list of tuples\\n region_list = [] # a list of regions\\n in_list = False\\n region_size = 7\\n num_regions = 25\\n n = 0\\n h = 0\\n print \\\"separate frontier\\\"\\n while(region_size>0):\\n for i in range(len(self.frontier)):\\n if (h < num_regions):\\n region = []\\n self.find_region(self.frontier[i], region)\\n\\t\\t #rospy.loginfo(region)\\n in_list = region in region_list\\n if (len(region) > region_size) and (not in_list):\\n region_list.append(region)\\n h += 1\\n self.regions = region_list\\n region_size -= 1\\n\\t#print self.regions\",\n \"def propogate(self):\\r\\n X = len(grid[0])\\r\\n Y = len(grid)\\r\\n for DIR in [[1,0], [-1,0], [0,1], [0,-1]]:\\r\\n target_x, target_y = self.block_loc[0]+DIR[0], self.block_loc[1]+DIR[1]\\r\\n if 0 <= target_x < X and 0 <= target_y < Y: #if inbounds:\\r\\n target_block = grid[target_y][target_x]\\r\\n if not target_block.collapsed: #only ping uncollapsed blocks\\r\\n self.send_update(target_block,DIR)\\r\\n return\",\n \"def _pick_visible_ids(self, xmin, ymin, xmax, ymax):\\n #vtk.vtkSelectVisiblePoints()\\n #vcs = vtk.vtkVisibleCellSelector()\\n area_picker = vtk.vtkRenderedAreaPicker()\\n area_picker.AreaPick(xmin, ymin, xmax, ymax, self.parent.rend)\\n #area_picker.Pick()\",\n \"def tryout_new_location(self):\\n try_location = [0, 0]\\n \\n # try locations until a not-occupied location is found and not all folds are checked\\n while try_location in self.occupied:\\n\\n # folds north everytime\\n current_type = 2\\n \\n # check if location is possible \\n try_location = self.assign_location(current_type)\\n\\n # if location is not possible, try next fold\\n if try_location in self.occupied:\\n continue\\n # if location is possible, use location\\n else:\\n self.next_location = try_location\\n return\",\n \"def sea_execution(board, position, role):\\n quitt = False\\n if position == 'comp':\\n #print(1)\\n #temporary for dumb AI\\n #create and print a list of coastal, friendly regions where norse is not the ONLY one\\n \\n possible_region_list = []\\n \\n #loops through list of friendly, coastal, not just Norse regions to append to a possible_region_list\\n for region in board.get_controlled_regions(role):\\n #print(2)\\n coastal = False\\n just_norse = False\\n if region.coast:\\n coastal = True\\n if len(region.blocks_present) == 1 and region.blocks_present[0].name.upper() == 'NORSE':\\n just_norse = True\\n \\n if coastal and not just_norse:\\n possible_region_list.append(region)\\n \\n \\n #loops through list of friendly, coastal regions to append to a possible_final_region_list\\n possible_final_region_list = []\\n for region in board.get_controlled_regions(role): \\n #print(3) \\n if region.coast:\\n possible_final_region_list.append(region)\\n \\n \\n \\n if len(possible_final_region_list) >= 2:\\n #if you want to add in last-min strategy, do it here\\n #random region from possible list\\n england = board.regions[22]\\n if england in possible_region_list:\\n original_region = england\\n else:\\n original_region = possible_region_list[random.randint(0, len(possible_region_list) - 1)]\\n #remove the original region from the possible end regions\\n possible_final_region_list.remove(original_region)\\n \\n #possible_block_list\\n #list of possible blocks to move (present in region) and not norse\\n possible_block_list = []\\n for block in original_region.blocks_present:\\n if block.name != 'NORSE':\\n possible_block_list.append(block)\\n \\n move_block_list = []\\n blocks_moved = 0\\n #print(4)\\n\\n while blocks_moved < 2:\\n #print(5)\\n block = possible_block_list[random.randint(0, len(possible_block_list)-1)]\\n #if it's not already on the list,append to move_block_list\\n if block not in move_block_list:\\n move_block_list.append(block)\\n blocks_moved+=1\\n elif block in move_block_list and len(possible_block_list) == 1:\\n blocks_moved+=1\\n else:\\n print('neither condition was met so this is an infinite loop')\\n \\n \\n #print(6) \\n new_region = possible_final_region_list[random.randint(0, len(possible_final_region_list) - 1)]\\n \\n for block in move_block_list:\\n \\n board.add_to_location(block, new_region)\\n print(block.name + ' moved from ' + original_region.name + ' to ' + new_region.name)\\n \\n else:\\n print('There are not enough friendly regions with which to play this card.')\\n \\n \\n #add in if it's not possible\\n elif position == 'opp':\\n \\n \\n possible_region_list = []\\n \\n #loops through list of friendly, coastal, not just Norse regions to append to a possible_region_list\\n for region in board.get_controlled_regions(role):\\n coastal = False\\n just_norse = False\\n if region.coast:\\n coastal = True\\n if len(region.blocks_present) == 1 and region.blocks_present[0].name.upper() == 'NORSE':\\n just_norse = True\\n \\n if coastal and not just_norse:\\n possible_region_list.append(region)\\n \\n \\n #loops through list of friendly, coastal regions to append to a possible_final_region_list\\n possible_final_region_list = []\\n for region in board.get_controlled_regions(role): \\n if region.coast:\\n possible_final_region_list.append(region)\\n \\n \\n \\n if len(possible_final_region_list) >= 2:\\n \\n print('Possible origin regions:')\\n for region in possible_region_list:\\n print(region.name)\\n \\n #user input region, check if in possible list\\n valid_region = False\\n while not valid_region:\\n \\n original_region_name = input('What region would you like to move block(s) from? Enter a name or \\\\'none\\\\'.\\\\n>').upper()\\n \\n if original_region_name != 'NONE':\\n \\n original_region = search.region_name_to_object(board, original_region_name)\\n \\n if original_region and original_region in possible_region_list:\\n valid_region = True\\n else:\\n print('Invalid region.')\\n else:\\n quitt = True\\n \\n if not quitt:\\n #remove the original region from the possible end regions\\n possible_final_region_list.remove(original_region)\\n \\n #possible_block_list\\n #list of possible blocks to move (present in region) and not norse\\n possible_block_list = []\\n for block in original_region.blocks_present:\\n if block.name != 'NORSE':\\n possible_block_list.append(block)\\n \\n print('Possible blocks:')\\n for block in possible_block_list:\\n print(block.name)\\n \\n \\n move_block_list = []\\n blocks_moved = 0\\n quittt = False\\n block_name = ''\\n while blocks_moved < 2 and not quittt:\\n if block_name != 'NONE':\\n valid_block = False\\n while not valid_block:\\n \\n \\n block_name = input('Which block would you like to move? Enter a name or \\\\'none\\\\'.\\\\n>').upper()\\n \\n if block_name != 'NONE':\\n \\n block_to_move = search.block_name_to_object(possible_block_list, block_name)\\n \\n if block_to_move and block_to_move not in move_block_list:\\n valid_block = True\\n move_block_list.append(block_to_move)\\n blocks_moved+=1\\n \\n elif block in move_block_list and len(possible_block_list) == 1:\\n blocks_moved=1\\n \\n else:\\n print('Invalid block.')\\n continue\\n else:\\n valid_block = True\\n if len(move_block_list) == 1:\\n quittt = True\\n quitt = False\\n if len(move_block_list) > 0: \\n print('Possible final regions:')\\n for region in possible_final_region_list:\\n print(region.name)\\n \\n #user input region, check if in possible list\\n valid_region = False\\n while not valid_region:\\n \\n new_region_name = input('What region would you like to move block(s) to? Enter a name or \\\\'none\\\\'.\\\\n>').upper()\\n \\n if new_region_name != 'NONE':\\n \\n new_region = search.region_name_to_object(board, new_region_name)\\n \\n if new_region and new_region in possible_final_region_list:\\n valid_region = True\\n else:\\n print('Invalid region.')\\n continue\\n else:\\n valid_region = True\\n quitt = True\\n \\n if not quitt:\\n \\n for block in move_block_list:\\n \\n board.add_to_location(block, new_region)\\n print(block.name + ' moved from ' + original_region.name + ' to ' + new_region.name)\\n \\n else:\\n print('There are not enough friendly coastal regions with which to play this card.')\",\n \"def warm_region_cal(audio_samples, fs):\\n #window the audio\\n windowed_samples = timbral_util.window_audio(audio_samples)\\n\\n # need to define a function for the roughness stimuli, emphasising the 20 - 40 region (of the bark scale)\\n min_bark_band = 10\\n max_bark_band = 40\\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\\n array = np.arange(min_bark_band, max_bark_band)\\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\\n x -= np.min(x)\\n x /= np.max(x)\\n\\n wr_array = np.zeros(240)\\n wr_array[min_bark_band:max_bark_band] = x\\n\\n # need to define a second array emphasising the 20 - 40 region (of the bark scale)\\n min_bark_band = 80\\n max_bark_band = 240\\n mean_bark_band = (min_bark_band + max_bark_band) / 2.0\\n array = np.arange(min_bark_band, max_bark_band)\\n x = timbral_util.normal_dist(array, theta=0.01, mean=mean_bark_band)\\n x -= np.min(x)\\n x /= np.max(x)\\n\\n hf_array = np.zeros(240)\\n hf_array[min_bark_band:max_bark_band] = x\\n\\n windowed_loud_spec = []\\n windowed_rms = []\\n\\n wr_vals = []\\n hf_vals = []\\n\\n for i in range(windowed_samples.shape[0]):\\n samples = windowed_samples[i, :]\\n N_entire, N_single = timbral_util.specific_loudness(samples, Pref=100.0, fs=fs, Mod=0)\\n\\n # append the loudness spec\\n windowed_loud_spec.append(N_single)\\n windowed_rms.append(np.sqrt(np.mean(samples * samples)))\\n\\n wr_vals.append(np.sum(wr_array * N_single))\\n hf_vals.append(np.sum(hf_array * N_single))\\n\\n mean_wr = np.mean(wr_vals)\\n mean_hf = np.mean(hf_vals)\\n weighted_wr = np.average(wr_vals, weights=windowed_rms)\\n weighted_hf = np.average(hf_vals, weights=windowed_rms)\\n\\n return mean_wr, weighted_wr, mean_hf, weighted_hf\",\n \"def mutate_point_rect(mutated_genome):\\n seed = random.randint(0,1)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if seed == 0:\\n move_point_rect(mutated_genome,index)\\n else: #seed == 1:\\n shift_point_rect(mutated_genome,index)\",\n \"def process_regions(mask, t1, ignore_vals=[0]):\\n regions = np.unique(mask)\\n regions = [i for i in regions if i not in ignore_vals]\\n colors = map_label_colors(regions)\\n images = [process_region(mask, t1, colors, region) for region in regions]\\n montage = create_montage(images, direction='v')\\n return(montage)\",\n \"def build_grains(self):\\n\\t\\ttime = datetime.datetime.now()\\n\\t\\tif self.probability == 0:\\n\\t\\t\\tfor cell in self.space.flat:\\n\\t\\t\\t\\tif cell.state != 0 :\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.check_empty_neighbours(cell):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\t\\n\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\tgrains = [0 for i in range(self.grains)]\\n\\t\\t\\t\\t\\tfor i in range(1,self.grains+1):\\n\\t\\t\\t\\t\\t\\tfor neighbour in neighbours:\\n\\t\\t\\t\\t\\t\\t\\tif neighbour.state == i and neighbour.timestamp < time:\\n\\t\\t\\t\\t\\t\\t\\t\\tgrains[i] = grains[i] + 1\\n\\t\\t\\t\\t\\tif grains == [0 for i in range(self.grains)]:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tnew_grain = 0\\n\\t\\t\\t\\t\\tfor i in range(self.grains):\\n\\t\\t\\t\\t\\t\\tif grains[i] >= new_grain:\\n\\t\\t\\t\\t\\t\\t\\tnew_grain = i\\n\\t\\t\\t\\t\\tcell.change_state(time, new_grain)\\n\\t\\t\\t\\t\\tself.empty_cells = self.empty_cells - 1\\n\\t\\telse:\\n\\t\\t\\tfor cell in self.space.flat:\\n\\t\\t\\t\\tif cell.state != 0 :\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telif self.check_empty_neighbours(cell):\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,5, time):\\n\\t\\t\\t\\t\\t\\tneighbours = self.get_nearest_neighbours(cell)\\n\\t\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,3, time):\\n\\t\\t\\t\\t\\t\\t\\tneighbours = self.get_further_neighbours(cell)\\n\\t\\t\\t\\t\\t\\t\\tif self.decide_changing(cell,neighbours,3, time):\\n\\t\\t\\t\\t\\t\\t\\t\\tneighbours = self.get_neighbours(cell)\\n\\t\\t\\t\\t\\t\\t\\t\\tgrains = [0 for i in range(self.grains)]\\n\\t\\t\\t\\t\\t\\t\\t\\tfor i in range(1,self.grains+1):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tfor neighbour in neighbours:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif neighbour.state == i and neighbour.timestamp < time:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tgrains[i] = grains[i] + 1\\n\\t\\t\\t\\t\\t\\t\\t\\tif grains == [0 for i in range(self.grains)]:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\t\\t\\tnew_grain = 0\\n\\t\\t\\t\\t\\t\\t\\t\\tfor i in range(self.grains):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif grains[i] >= new_grain:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tnew_grain = i\\n\\t\\t\\t\\t\\t\\t\\t\\trandom_number = random.random() * 100\\n\\t\\t\\t\\t\\t\\t\\t\\tif random_number <= self.probability:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcell.change_state(time, new_grain)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.empty_cells = self.empty_cells - 1\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcontinue\",\n \"def fillingrid(self):\\n\\n if self.imagearray is None:\\n if self.gs.isfixed:\\n for n in range(0, self.numcols):\\n self.vspins[n].setValue(self.currentvalues[n])\\n elif self.gs.isperc:\\n for n in range(0, self.numcols):\\n self.fillinpercent(n)\\n else:\\n for n in range(0, self.numcols):\\n self.nsspins[n].setValue(self.currentnsigs[n])\\n else:\\n for n in range(0, self.numcols):\\n self.vspins[n].setValue(self.currentvalues[n])\\n self.nsspins[n].setValue(self.currentnsigs[n])\\n self.fillinpercent(n)\",\n \"def onpick(cls, event):\\n event_len = len(event.ind)\\n if not event_len:\\n return True\\n value = event.ind[-1] + FigureControl.minPossibleGenNumber\\n vis_now = FigureControl.isVisible(value)\\n FigureControl.makeGenVisible(value, not vis_now, \\\"dist\\\")\",\n \"def supply_region(self, x, y):\\n if x>350 and x<450 and y>0 and y<100:\\n return 1\\n elif x>350 and x<450 and y>400 and y<500:\\n return 2\\n return 0\",\n \"def test_overFill(self):\\r\\n high = 15\\r\\n for _ in range(high):\\r\\n self.nb.add(_)\\r\\n\\r\\n self.assertFalse(self.nb.isEmpty())\\r\\n self.assertTrue(self.nb.isFull())\\r\\n self.assertEqual(5, len(self.nb))\\r\\n\\r\\n # check all are still present\\r\\n for _ in range(high-1, high - SIZE-1, -1):\\r\\n self.assertTrue(_ in self.nb)\",\n \"def region_growing(imOr,reg,area,prof,conn,precision):\\n\\tif prof:\\n\\t\\tif area > 0.085:\\n\\t\\t\\treg1 = morph('erode',reg,25)\\n\\t\\t\\tif reg1.max() == 1.0:\\n\\t\\t\\t\\treg = reg1\\n\\t\\t\\telse:\\n\\t\\t\\t\\treg1 = morph('erode',reg,15)\\n\\t\\t\\t\\tif reg1.max() == 1.0:\\n\\t\\t\\t\\t\\treg = reg1\\n\\telse:\\n\\t\\tif area > 0.15:\\n\\t\\t\\treg1 = morph('erode',reg,15)\\n\\t\\t\\tif reg1.max() == 1.0:\\n\\t\\t\\t\\treg = reg1\\n\\n\\telementos = contar (reg,1)\\n\\tseguir = True\\n\\twhile seguir:\\n\\t\\treg = cv2.convertScaleAbs(reg)\\n\\t\\t_,contours, h = cv2.findContours(reg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n\\t\\treg[reg != 0] = 1\\n\\t\\tmedia_region = sum(imOr[reg==1])/max(cv2.contourArea(contours[0]),0.001)\\n\\n\\t\\tfor elemento in contours[0]:\\n\\t\\t\\tif prof:\\n\\t\\t\\t\\treg = expand(elemento,reg,imOr,media_region,precision/2,conn)\\n\\t\\t\\telse:\\n\\t\\t\\t\\treg = expand(elemento,reg,imOr,media_region,precision,conn)\\n\\t\\telementos_nuevo = contar (reg,1)\\n\\t\\tif elementos == elementos_nuevo:\\n\\t\\t\\tseguir = False\\n\\t\\telementos = elementos_nuevo\\n\\tse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))\\n\\treg = cv2.dilate(reg.astype(np.float32),se,iterations = 3)\\n\\tse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))\\n\\treg = cv2.erode(reg.astype(np.float32),se,iterations = 2)\\n\\n\\treturn reg\",\n \"def region_region_checkerboard(self, **_):\\n outputs: dict = {}\\n\\n if self.AGG_BY == \\\"zone\\\":\\n agg = \\\"zone\\\"\\n else:\\n agg = \\\"region\\\"\\n\\n # List of properties needed by the plot, properties are a set of tuples and\\n # contain 3 parts: required True/False, property name and scenarios required,\\n # scenarios must be a list.\\n properties = [(True, f\\\"{agg}_{agg}s_Net_Interchange\\\", self.Scenarios)]\\n\\n # Runs get_formatted_data within PlotDataStoreAndProcessor to populate PlotDataStoreAndProcessor dictionary\\n # with all required properties, returns a 1 if required data is missing\\n check_input_data = self.get_formatted_data(properties)\\n\\n if 1 in check_input_data:\\n return MissingInputData()\\n\\n ncols, nrows = set_x_y_dimension(len(self.Scenarios))\\n grid_size = ncols * nrows\\n excess_axs = grid_size - len(self.Scenarios)\\n\\n mplt = PlotLibrary(nrows, ncols, squeeze=False, ravel_axs=True)\\n fig, axs = mplt.get_figure()\\n plt.subplots_adjust(wspace=0.02, hspace=0.4)\\n max_flow_group = []\\n Data_Out = []\\n n = 0\\n for scenario in self.Scenarios:\\n rr_int = self[f\\\"{agg}_{agg}s_Net_Interchange\\\"].get(scenario)\\n if shift_leapday:\\n rr_int = adjust_for_leapday(rr_int)\\n\\n if self.AGG_BY != \\\"region\\\" and self.AGG_BY != \\\"zone\\\":\\n agg_region_mapping = (\\n self.region_mapping[[\\\"region\\\", self.AGG_BY]]\\n .set_index(\\\"region\\\")\\n .to_dict()[self.AGG_BY]\\n )\\n # Checks if keys all aggregate to a single value, this plot requires multiple values to work\\n if len(set(agg_region_mapping.values())) == 1:\\n return UnsupportedAggregation()\\n rr_int = rr_int.reset_index()\\n rr_int[\\\"parent\\\"] = rr_int[\\\"parent\\\"].map(agg_region_mapping)\\n rr_int[\\\"child\\\"] = rr_int[\\\"child\\\"].map(agg_region_mapping)\\n rr_int_agg = rr_int.groupby([\\\"parent\\\", \\\"child\\\"], as_index=True).sum()\\n rr_int_agg.rename(columns={\\\"values\\\": \\\"flow (MW)\\\"}, inplace=True)\\n rr_int_agg = rr_int_agg.loc[\\n rr_int_agg[\\\"flow (MW)\\\"] > 0.01\\n ] # Keep only positive flows\\n rr_int_agg.sort_values(ascending=False, by=\\\"flow (MW)\\\")\\n rr_int_agg = rr_int_agg / 1000 # MWh -> GWh\\n\\n data_out = rr_int_agg.copy()\\n data_out.rename(\\n columns={\\\"flow (MW)\\\": \\\"{} flow (GWh)\\\".format(scenario)}, inplace=True\\n )\\n\\n max_flow = max(rr_int_agg[\\\"flow (MW)\\\"])\\n rr_int_agg = rr_int_agg.unstack(\\\"child\\\")\\n rr_int_agg = rr_int_agg.droplevel(level=0, axis=1)\\n\\n current_cmap = plt.cm.get_cmap()\\n current_cmap.set_bad(color=\\\"grey\\\")\\n\\n axs[n].imshow(rr_int_agg)\\n axs[n].set_xticks(np.arange(rr_int_agg.shape[1]))\\n axs[n].set_yticks(np.arange(rr_int_agg.shape[0]))\\n axs[n].set_xticklabels(rr_int_agg.columns)\\n axs[n].set_yticklabels(rr_int_agg.index)\\n axs[n].set_title(scenario.replace(\\\"_\\\", \\\" \\\"), fontweight=\\\"bold\\\")\\n\\n # Rotate the tick labels and set their alignment.\\n plt.setp(\\n axs[n].get_xticklabels(),\\n rotation=90,\\n ha=\\\"right\\\",\\n rotation_mode=\\\"anchor\\\",\\n )\\n\\n # Delineate the boxes and make room at top and bottom\\n axs[n].set_xticks(np.arange(rr_int_agg.shape[1] + 1) - 0.5, minor=True)\\n axs[n].set_yticks(np.arange(rr_int_agg.shape[0] + 1) - 0.5, minor=True)\\n axs[n].grid(which=\\\"minor\\\", color=\\\"k\\\", linestyle=\\\"-\\\", linewidth=1)\\n axs[n].tick_params(which=\\\"minor\\\", bottom=False, left=False)\\n\\n max_flow_group.append(max_flow)\\n Data_Out.append(data_out)\\n n += 1\\n\\n # Remove extra axes\\n mplt.remove_excess_axs(excess_axs, grid_size)\\n\\n cmap = cm.inferno\\n norm = mcolors.Normalize(vmin=0, vmax=max(max_flow_group))\\n cax = plt.axes([0.90, 0.1, 0.035, 0.8])\\n fig.colorbar(\\n cm.ScalarMappable(norm=norm, cmap=cmap),\\n cax=cax,\\n label=\\\"Total Net Interchange [GWh]\\\",\\n )\\n plt.xlabel(\\\"To Region\\\", color=\\\"black\\\", rotation=\\\"horizontal\\\", labelpad=40)\\n plt.ylabel(\\\"From Region\\\", color=\\\"black\\\", rotation=\\\"vertical\\\", labelpad=40)\\n\\n data_table_out = pd.concat(Data_Out, axis=1)\\n save_figures = self.figure_folder.joinpath(f\\\"{self.AGG_BY}_transmission\\\")\\n fig.savefig(\\n save_figures.joinpath(\\\"region_region_checkerboard.svg\\\"),\\n dpi=600,\\n bbox_inches=\\\"tight\\\",\\n )\\n data_table_out.to_csv(save_figures.joinpath(\\\"region_region_checkerboard.csv\\\"))\\n\\n outputs = DataSavedInModule()\\n return outputs\",\n \"def cross_detect2(self):\\n for agent_idx in range(self.agent_num):\\n\\n agent = self.agent_list[agent_idx]\\n for object_idx in range(len(self.map['objects'])):\\n object = self.map['objects'][object_idx]\\n\\n if not object.can_pass():\\n continue\\n else:\\n #print('object = ', object.type)\\n if object.color == 'red' and object.check_cross(self.agent_pos[agent_idx], agent.r):\\n\\n agent.color = 'red'\\n agent.finished = True #when agent has crossed the finished line\\n agent.alive = False #kill the agent when finishing the task\",\n \"def region_of_interest(img):\\n # defining a blank mask to start with\\n y, x = img.shape[:2]\\n # print(\\\"roi_width : {}, roi_height : {}\\\".format(x, y))\\n\\n # 왼쪽과 오른쪽 roi를 동시 설정; 영역의 범위에 따라 보이는 영역이 바뀜\\n left1 = [int(0.1*x), int(y)]\\n left2 = [int(0.1*x), int(0.1*y)]\\n left3 = [int(0.4*x), int(0.1*y)]\\n left4 = [int(0.4*x), int(y)]\\n\\n right1 = [int(0.7*x), int(y)]\\n right2 = [int(0.7*x), int(0.1*y)]\\n right3 = [int(0.9*x), int(0.1*y)]\\n right4 = [int(0.9*x), int(y)]\\n\\n middle = [int(0.2*x), int(y)]\\n\\n shaper = np.array([left1, left2, left3, left4, right1, right2, right3, right4, middle])\\n\\n mask = np.zeros_like(img)\\n\\n # 흑백, 컬러 구분 없이 흑백으로 채움\\n if len(img.shape) > 2:\\n ignore_mask_color = (255, 255, 255)\\n else:\\n ignore_mask_color = 255\\n\\n # 식별된 구간 제외 전부 검은색칠\\n cv2.fillPoly(mask, np.int32([shaper]), ignore_mask_color)\\n\\n # bitwise_and 연산\\n masked_image = cv2.bitwise_and(img, mask)\\n # cv2.imshow('ROI', masked_image)\\n # cv2.waitKey()\\n\\n return masked_image\",\n \"def target_intersection(self, runid):\\n\\n def targeting(shuffledict, seg_copy_array, cell_name):\\n bedstring = \\\"\\\"\\n seg_counts_dict = defaultdict(int)\\n breakpoint_counts = 0\\n sum_counts = 0\\n for cell in shuffledict:\\n with suppress(IndexError):\\n i = len(cell_name)\\n cell_label = cell[:i]\\n\\n if not cell_name == cell_label:\\n continue\\n\\n shuffled_list = shuffledict[cell]\\n scipy.random.shuffle(shuffled_list)\\n sum_counts += sum(shuffled_list)\\n\\n for i in range(len(shuffled_list)):\\n if shuffled_list[i] == 0:\\n continue\\n\\n breakpoint_counts += 1\\n segment_index = i\\n if i == 0:\\n segment_index = 1\\n\\n chrm = seg_copy_array[seg_copy_array[:, 0] == segment_index][0, 1].decode()\\n chrom_slice = seg_copy_array[seg_copy_array[:, 1] == chrm.encode()]\\n chrom_seg_count = chrom_slice.shape[0]\\n start_seg = segment_index\\n stop_seg = segment_index+1\\n\\n # Prevents us from running past the end of the chromosome\\n if segment_index+1 > chrom_seg_count:\\n stop_seg = segment_index\\n start_seg = segment_index-1\\n\\n coord_start = int(seg_copy_array[seg_copy_array[:, 0] == start_seg][0, 2])\\n coord_stop = int(seg_copy_array[seg_copy_array[:, 0] == stop_seg][0, 3])\\n\\n segkey = \\\"{}.{}\\\".format(chrm, coord_start)\\n seg_counts_dict[segkey] += 1\\n bedstring += \\\"{0} {1} {2} {3} {0}|{1}|{2}|{3}\\\\n\\\".format(chrm, coord_start, coord_stop, \\\"x\\\")\\n\\n if eval(self.args.PairedBreakpoints):\\n segment_index = shuffled_list[i]+i\\n\\n # Since segments are paired we can run past the end of the list.\\n if segment_index > len(shuffled_list):\\n segment_index = len(shuffled_list)-1\\n\\n # If the shuffle results in a segment overlap, skip it.\\n if not shuffled_list[segment_index] == 0:\\n continue\\n\\n start_seg = segment_index\\n stop_seg = segment_index+1\\n\\n # Prevents us from running past the end of the chromosome by flipping direction of region\\n if segment_index + 1 > chrom_seg_count:\\n start_seg = shuffled_list[i] - i\\n stop_seg = start_seg-1\\n\\n coor_start = int(seg_copy_array[seg_copy_array[:, 0] == start_seg][0, 2])\\n coor_stop = int(seg_copy_array[seg_copy_array[:, 0] == stop_seg][0, 3])\\n breakpoint_counts += 1\\n segkey = \\\"{}.{}\\\".format(chrm, coord_start)\\n seg_counts_dict[segkey] += 1\\n bedstring += \\\"{0} {1} {2} {3} {0}|{1}|{2}|{3}\\\\n\\\".format(chrm, coor_start, coor_stop, \\\"x\\\")\\n\\n return bedstring, seg_counts_dict, breakpoint_counts\\n\\n encoded_cell_name = self.args.Cell_Name\\n shuffle_dict = self.shuffle_dict_unpaired\\n if eval(self.args.PairedBreakpoints):\\n shuffle_dict = self.shuffle_dict_pairs\\n output_data_dict = defaultdict(lambda: defaultdict(str))\\n\\n iteration_limit = int(self.args.Iteration_Count)/int(self.args.Spawn)\\n iteration_count = 0\\n while iteration_count < iteration_limit:\\n if iteration_count % int(self.args.Prog_Check) == 0:\\n self.log.info(\\\"Iteration: {} of {} for job {}\\\".format(iteration_count, iteration_limit, runid))\\n\\n bed_string, segment_count_dict, total_breakpoints = \\\\\\n targeting(shuffle_dict, self.seg_analyzer.seg_copy_array, encoded_cell_name)\\n\\n # Bedtool Section.\\n breakpoint_bedtool = pybedtools.BedTool(bed_string, from_string=True)\\n target_bedtool = pybedtools.BedTool(self.args.Target_File, from_string=False)\\n\\n # Find target intersects for printing.\\n breakpoint_target_intersect = breakpoint_bedtool.intersect(target_bedtool, wb=True, stream=True)\\n\\n \\\"\\\"\\\"\\n The breakpoint target intersect pybedtools object is expected to have this structure;\\n l[0] = Breakpoint chrom; l[1] = Breakpoint start coord; l[2] = Breakpoint end coord; \\n l[3] = aberration copy type; l[4] = segment ID for internal tracking. The next items are from the target BED \\n file. Make sure column 5 in that file is the target name.\\n \\\"\\\"\\\"\\n\\n # Processing Breakpoint Intersects.\\n intersect_dict = defaultdict(list)\\n total_targeted_breakpoints = 0\\n unique_targeted_breakpoints = 0\\n\\n for l in breakpoint_target_intersect:\\n chrom = l[4].split(\\\"|\\\")[0]\\n start = l[4].split(\\\"|\\\")[1]\\n segment_key = \\\"{}.{}\\\".format(chrom, start)\\n intersect_dict[segment_key].append(l[9])\\n\\n for k in intersect_dict:\\n total_targeted_breakpoints += segment_count_dict[k]\\n if segment_count_dict[k] > 0:\\n unique_targeted_breakpoints += 1\\n\\n output_data_dict[iteration_count] = \\\"{}\\\\t{}\\\\t{}\\\\t{}\\\\n\\\"\\\\\\n .format(total_breakpoints, total_targeted_breakpoints, len(segment_count_dict), len(intersect_dict))\\n\\n iteration_count += 1\\n\\n # Process data for output and write file.\\n outstring = \\\"\\\"\\n\\n for k in output_data_dict:\\n outstring += output_data_dict[k]\\n\\n permuted_shuffle_file_name = \\\\\\n \\\"{}{}{}{}\\\".format(self.args.Working_Folder, self.args.Cell_Name, self.args.Job_Name, runid)\\n permuted_shuffle_file = open(permuted_shuffle_file_name, 'w')\\n permuted_shuffle_file.write(outstring)\\n permuted_shuffle_file.close()\\n\\n return\",\n \"def new_tile(self):\\r\\n # replace with your code\\r\\n # complete search ....\\r\\n non_zero_count = 0;\\r\\n for row in range(self._grid_height):\\r\\n for col in range(self._grid_width):\\r\\n if self._grid_tile[row][col] == 0:\\r\\n non_zero_count += 1\\r\\n random_choice = random.randrange(0, non_zero_count)\\r\\n count = 0\\r\\n # another search ....\\r\\n generated_new_tile = False\\r\\n for row in range(self._grid_height):\\r\\n for col in range(self._grid_width):\\r\\n if generated_new_tile == False and self._grid_tile[row][col] == 0:\\r\\n if count != random_choice:\\r\\n count += 1 \\r\\n else:\\r\\n if random.randrange(0,100) < 10:\\r\\n self.set_tile(row, col ,4)\\r\\n else:\\r\\n self.set_tile(row, col ,2)\\r\\n generated_new_tile = True\",\n \"def closed_regions(self, image, test):\\n pixel = image.load()\\n xs, ys = map(xrange, image.size)\\n todo = set(xy for xy in product(xs, ys) if test(pixel[xy]))\\n while todo:\\n region = set()\\n edge = set([todo.pop()])\\n while edge:\\n region |= edge\\n todo -= edge\\n edge = todo.intersection(\\n flatten(((x - 1, y), (x, y - 1), (x + 1, y), (x, y + 1)) for x, y in edge))\\n yield region\",\n \"def step(self):\\n # amt_selected = \\\\\\n # int(self.population_size * self.part_selected) \\n\\n # spawning_pool = [] # list of dna selected for reproduction\\n new_data =[]\\n \\n sorted_dna = sorted(self.data, \\n key=lambda dna: dna.fitness_function(dna),\\n reverse=True)\\n \\n \\n \\n\\n # mutation\\n for dna in sorted_dna:\\n dna.mute(self.mutation_probability)\\n\\n # crossover\\n while len(new_data) < \\\\\\n self.population_size - (self.population_size % 2):\\n\\n d1 = copy.copy(self.pick())\\n d2 = copy.copy(self.pick())\\n times = 2\\n for i in range(times):\\n d1.crossover(d2)\\n\\n new_data += [d1, d2]\\n\\n\\n\\n\\n\\n if (self.population_size % 2) == 1:\\n new_data.append(copy.deepcopy(self.pick()))\\n\\n assert(len(self.data) == len(new_data))\\n\\n for i in range(len(new_data)):\\n self.data[i].data = new_data[i]\",\n \"def set_sample_region(self):\\n\\n theta_delta = self.wrap(self.start[0:3], self.goal[0:3])\\n\\n delta_signs = np.sign(self.goal[0:3] - self.start[0:3])\\n\\n self.smart_region_min = self.start\\n\\n self.smart_region_max = self.start + delta_signs * theta_delta\\n\\n velocity_min = np.zeros(3,1)\\n\\n \\n for i in range(3):\",\n \"def set_sample_region(self):\\n\\n theta_delta = self.wrap(self.start[0:3], self.goal[0:3])\\n\\n delta_signs = np.sign(self.goal[0:3] - self.start[0:3])\\n\\n self.smart_region_min = self.start\\n\\n self.smart_region_max = self.start + delta_signs * theta_delta\\n\\n velocity_min = np.zeros(3,1)\\n\\n \\n for i in range(3):\",\n \"def _simulate_until_stable(\\n grid: List[List[str]],\\n count_occupied: Callable[[List[List[str]], int, int], int],\\n min_occupied_to_free=4) -> int:\\n while True:\\n next_grid = _simulate(grid, count_occupied, min_occupied_to_free)\\n if _are_equal(next_grid, grid):\\n return _count_occupied_seats(grid)\\n grid = next_grid\",\n \"def setDefensiveArea(self ,gameState): \\n mazeCentreX = (gameState.data.layout.width - 2) / 2\\n if not self.red:\\n mazeCentreX += 1\\n mazeCentreY = (gameState.data.layout.height - 2) / 2\\n\\n self.defenceRegion = []\\n for i in range(1, gameState.data.layout.height - 1):\\n if gameState.hasWall(mazeCentreX, i):\\n a = 0\\n \\n else:\\n self.defenceRegion.append((mazeCentreX, i))\\n\\n expectedSize = mazeCentreY\\n actualSize = len(self.defenceRegion)\\n\\n\\n for i in range(len(self .defenceRegion)):\\n if expectedSize > actualSize:\\n break\\n else:\\n self.defenceRegion.remove(self.defenceRegion[0])\\n self.defenceRegion.remove(self.defenceRegion[-1])\\n actualSize = len(self.defenceRegion)\\n\\n for i in range(len(self.defenceRegion)):\\n if len(self.defenceRegion) > 2:\\n self.defenceRegion.remove(self.defenceRegion[0])\\n self.defenceRegion.remove(self.defenceRegion[-1])\\n else:\\n break\",\n \"def find_instances_in_features(self, features, region):\\n for current_window in self.hogger.hog_scan(self.box_size, self.box_size):\\n if self.classifier.classify_features(current_window[\\\"features\\\"])==1.0:\\n off_x = current_window[\\\"x\\\"]\\n off_y = current_window[\\\"y\\\"]\\n trans_off_x = int(off_x * self.scaling) + region[0]\\n trans_off_y = int(off_y * self.scaling) + region[1]\\n\\n cv2.rectangle(self.resized_image, (off_x, off_y), (off_x + self.box_size, off_y + self.box_size),\\n color=(255, 255, 255), thickness=2)\\n cv2.rectangle(self.image, (trans_off_x, trans_off_y), (trans_off_x + self.eff_box_size, trans_off_y + self.eff_box_size),\\n color=(255, 255, 255), thickness=2)\\n self.boundings.append(((trans_off_x, trans_off_y), (trans_off_x + self.eff_box_size, trans_off_y + self.eff_box_size)))\",\n \"def _sample_regions(region_rois, gt_regions, voc_sign):\\n # overlaps: (rois x gt_regions)\\n overlaps_gt = bbox_overlaps(\\n np.ascontiguousarray(region_rois[:, 1:5], dtype=np.float),\\n np.ascontiguousarray(gt_regions[:, :4], dtype=np.float))\\n # gt_assignment = overlaps_gt.argmax(axis=1)\\n max_overlaps_gt = overlaps_gt.max(axis=1)\\n # labels = gt_regions[gt_assignment, 4:]\\n fg_inds = np.where(max_overlaps_gt >= cfg.TRAIN.FG_THRESH_REGION)[0]\\n bg_inds = np.where(\\n (max_overlaps_gt < cfg.TRAIN.BG_THRESH_HI_REGION) & (max_overlaps_gt >= cfg.TRAIN.BG_THRESH_LO_REGION))[0]\\n\\n # ## Debug Codes\\n # print('fg: {} v.s. bg:{}'.format(len(fg_inds), len(bg_inds)))\\n # gt_hit_overlap = overlaps_gt.max(axis=0)\\n # hit_ids = np.unique(np.where(gt_hit_overlap >= cfg.TRAIN.FG_THRESH_REGION)[0])\\n # print('Recall: {} ({}/{})'.format(\\n # float(len(hit_ids)) / len(gt_regions), len(hit_ids), len(gt_regions)))\\n # The indices that we're selecting (both fg and bg)\\n keep_inds = np.append(fg_inds, bg_inds)\\n # Select sampled values from various arrays:\\n labels = np.ones((len(keep_inds), gt_regions.shape[1] - 4), dtype=np.int64) * voc_sign['end']\\n # Here we randomly select regions overlapped with proposed ROI more than 0.7\\n gt_assignment = np.zeros(len(fg_inds), dtype=np.int64)\\n for i in range(len(fg_inds)):\\n gt_assignment[i] = npr.choice(np.where(overlaps_gt[fg_inds[i]] > cfg.TRAIN.FG_THRESH_REGION)[0], size=1)\\n labels[i] = gt_regions[gt_assignment[i], 4:]\\n\\n # add start label to background and padding them with <end> sign\\n labels[len(fg_inds):, 0] = voc_sign['start']\\n rois = region_rois[keep_inds]\\n\\n targets_fg = bbox_transform(rois[:len(fg_inds), 1:5], gt_regions[gt_assignment, :4])\\n bbox_inside_weights_fg = np.ones(targets_fg.shape, dtype=np.float32) * cfg.TRAIN.BBOX_INSIDE_WEIGHTS\\n targets_bg = np.zeros((bg_inds.size, targets_fg.shape[1]), dtype=np.float32)\\n bbox_inside_weight_bg = np.zeros(targets_bg.shape, dtype=np.float32)\\n bbox_targets = np.vstack([targets_fg, targets_bg])\\n bbox_inside_weight = np.vstack([bbox_inside_weights_fg, bbox_inside_weight_bg])\\n\\n return labels, bbox_targets, bbox_inside_weight, keep_inds\",\n \"def __test_region(self, bk):\\n for arg in self.args['region']:\\n ds = ArgoDataFetcher(backend=bk).region(arg).to_xarray()\\n assert isinstance(ds, xr.Dataset) == True\",\n \"def find_instances(self, image, region, overlap):\\n self.image = np.copy(image)\\n\\n self.eff_step_size = int((1.0-overlap)*self.eff_box_size)\\n\\n y_steps = (region[3]-region[1])//self.eff_step_size\\n x_steps = (region[2]-region[0])//self.eff_step_size\\n\\n if region[0]+(x_steps-1)*self.eff_step_size+self.eff_box_size>region[2]:\\n x_steps -= 1\\n if region[1]+(y_steps-1)*self.eff_step_size+self.eff_box_size>region[3]:\\n y_steps -= 1\\n\\n if self.single_hog:\\n self.resized_image = image[region[1]:region[3],region[0]:region[2],:]\\n self.resized_image = cv2.resize(self.resized_image, (int(self.resized_image.shape[1]/self.scaling), int(self.resized_image.shape[0]/self.scaling)))\\n features, img = self.hogger.hog_image(self.resized_image, visualize=False, feature_vector=False)\\n features = np.array(features)\\n self.find_instances_in_features(features, region)\\n return self.image, self.resized_image\\n else:\\n for row in range(y_steps):\\n off_y = region[1] + row * self.eff_step_size\\n for col in range(x_steps):\\n off_x = region[0]+col * self.eff_step_size\\n sub_sample = self.get_resized_sub_sample(off_x, off_y)\\n pred = self.classifier.classify(sub_sample)\\n if(pred==1.0):\\n cv2.rectangle(self.image, (off_x, off_y), (off_x+self.eff_box_size, off_y+self.eff_box_size), color=(255,255,255), thickness=2)\\n self.boundings.append(((off_x, off_y), (off_x+self.eff_box_size, off_y+self.eff_box_size)))\\n\\n return self.image, None\",\n \"def test_bkg_regions(i07_nexus: I07Nexus, regions):\\n for i, _ in enumerate(regions):\\n assert i07_nexus.background_regions[i] == regions[i]\",\n \"def find_pins_and_blockages(self, pin_list):\\n # This finds the pin shapes and sorts them into \\\"groups\\\" that are connected\\n # This must come before the blockages, so we can not count the pins themselves\\n # as blockages.\\n start_time = datetime.now()\\n for pin_name in pin_list:\\n self.retrieve_pins(pin_name)\\n print_time(\\\"Retrieving pins\\\",datetime.now(), start_time, 4)\\n \\n start_time = datetime.now()\\n for pin_name in pin_list:\\n self.analyze_pins(pin_name)\\n print_time(\\\"Analyzing pins\\\",datetime.now(), start_time, 4)\\n\\n # This will get all shapes as blockages and convert to grid units\\n # This ignores shapes that were pins\\n start_time = datetime.now()\\n self.find_blockages()\\n print_time(\\\"Finding blockages\\\",datetime.now(), start_time, 4)\\n\\n # Convert the blockages to grid units\\n start_time = datetime.now()\\n self.convert_blockages()\\n print_time(\\\"Converting blockages\\\",datetime.now(), start_time, 4)\\n \\n # This will convert the pins to grid units\\n # It must be done after blockages to ensure no DRCs between expanded pins and blocked grids\\n start_time = datetime.now()\\n for pin in pin_list:\\n self.convert_pins(pin)\\n print_time(\\\"Converting pins\\\",datetime.now(), start_time, 4)\\n\\n # Combine adjacent pins into pin groups to reduce run-time\\n # by reducing the number of maze routes.\\n # This algorithm is > O(n^2) so remove it for now\\n # start_time = datetime.now()\\n # for pin in pin_list:\\n # self.combine_adjacent_pins(pin)\\n # print_time(\\\"Combining adjacent pins\\\",datetime.now(), start_time, 4)\\n\\n\\n # Separate any adjacent grids of differing net names that overlap\\n # Must be done before enclosing pins\\n start_time = datetime.now()\\n self.separate_adjacent_pins(0)\\n print_time(\\\"Separating adjacent pins\\\",datetime.now(), start_time, 4)\\n \\n # Enclose the continguous grid units in a metal rectangle to fix some DRCs\\n start_time = datetime.now()\\n self.enclose_pins()\\n print_time(\\\"Enclosing pins\\\",datetime.now(), start_time, 4)\",\n \"def generate_grains(self, cells):\\n\\t\\tfor cell_num in range(cells):\\n\\t\\t\\trandom_row = random.randrange(0,self.space.shape[0],1)\\n\\t\\t\\tsample_cell = np.random.choice(self.space[random_row],1)\\n\\t\\t\\tsample_cell = sample_cell[0]\\n\\t\\t\\twhile sample_cell.state != 0:\\n\\t\\t\\t\\trandom_row = random.randrange(0,self.space.shape[0],1)\\n\\t\\t\\t\\tsample_cell = np.random.choice(self.space[random_row],1)\\n\\t\\t\\t\\tsample_cell = sample_cell[0]\\n\\t\\t\\tsample_cell.change_state(self.init_time ,cell_num)\",\n \"def lower_covers(self, x):\",\n \"def find_objects_in_image(self, image, visualize):\\n self.select(image)\\n\\n for scan_region in self.scan_regions:\\n self.set_scaling(scan_region[0])\\n full, small = self.find_instances(image, scan_region[1], 0.5)\\n if (visualize):\\n fig = plt.figure(figsize=(30, 20))\\n plt.imshow(small)\\n plt.title(\\\"Scan region {} using scaling {}\\\".format(scan_region[1], scan_region[0]))\\n plt.show()\",\n \"def region_graph(t0, t1, t2, t3):\\r\\n medians0 = sorted(sub_saharan_africa_countries())\\r\\n t0.goto(-250, ((medians0[0])-50))\\r\\n t0.rt(90)\\r\\n for idx in range(1, len(medians0)):\\r\\n t0.pencolor(\\\"blue\\\")\\r\\n t0.pd()\\r\\n t0.setpos((-250+(idx*10.5)), ((medians0[idx])))\\r\\n\\r\\n medians1 = sorted(south_asia_countries())\\r\\n t1.goto(-250, ((medians1[0]) - 60))\\r\\n t1.rt(90)\\r\\n for idx in range(1, len(medians1)):\\r\\n t1.pencolor(\\\"red\\\")\\r\\n t1.pd()\\r\\n t1.setpos((-250 + (idx * 68.5)), (2*(medians1[idx])+10))\\r\\n\\r\\n medians2 = sorted(europe_central_asia_countries())\\r\\n t2.goto(-250, (medians2[0])+60)\\r\\n t2.rt(90)\\r\\n for idx in range(1, len(medians2)):\\r\\n t2.pencolor(\\\"green\\\")\\r\\n t2.pd()\\r\\n t2.setpos((-250 + (idx*10.19)), (2 * (medians2[idx]) + 10))\\r\\n\\r\\n medians3 = sorted(latin_america_countries())\\r\\n t3.goto(-250, (medians3[0]) + 20)\\r\\n t3.rt(90)\\r\\n for idx in range(1, len(medians3)):\\r\\n t3.pencolor(\\\"gold\\\")\\r\\n t3.pd()\\r\\n t3.setpos((-250 + (idx * 14.39)), (2 * (medians3[idx]) + 10))\\r\\n\\r\\n t0.pu()\\r\\n t0.goto(initialCoordinates())\\r\\n t1.pu()\\r\\n t1.goto(initialCoordinates())\\r\\n t2.pu()\\r\\n t2.goto(initialCoordinates())\\r\\n t3.pu()\\r\\n t3.goto(initialCoordinates())\\r\\n\\r\\n medians4 = sorted(middle_east_countries())\\r\\n t0.goto(-250, (medians4[0])-40)\\r\\n t0.rt(90)\\r\\n for idx in range(1, len(medians4)):\\r\\n t0.pencolor(\\\"BLACK\\\")\\r\\n t0.pd()\\r\\n t0.setpos((-250 + (idx * 26.3)), (2 * (medians4[idx]) + 10))\\r\\n t0.rt(180)\\r\\n\\r\\n medians5 = sorted(north_america_countries())\\r\\n t1.goto(-250, (medians5[0])+60)\\r\\n t1.rt(90)\\r\\n for idx in range(1, len(medians5)):\\r\\n t1.pencolor(\\\"YELLOW\\\")\\r\\n t1.pd()\\r\\n t1.setpos((-250 + (idx * 485.3)), (2 * (medians5[idx]) + 10))\\r\\n t1.rt(180)\\r\\n\\r\\n medians6 = sorted(east_asia_pacific_countries())\\r\\n t2.goto(-250, (medians6[0]))\\r\\n t2.rt(90)\\r\\n for idx in range(1, len(medians6)):\\r\\n t2.pencolor(\\\"purple\\\")\\r\\n t2.pd()\\r\\n t2.setpos((-250 + (idx * 16)), (2 * (medians6[idx]) + 10))\\r\\n t0.pu()\\r\\n t0.goto(initialCoordinates())\\r\\n t1.pu()\\r\\n t1.goto(initialCoordinates())\\r\\n t2.pu()\\r\\n t2.goto(initialCoordinates())\",\n \"def test_guider_start_ffsClosed(self):\\n self._guider_start(6, 20, 0, 0)\",\n \"def activatePinReading(self):\\n\\n for pin in self.pinsToMeasure:\\n arduino.samplePinDuringCapture(self.f, self.pinMap[pin], self.wallClock)\",\n \"def computePValues(options,whole_mapped_data,mapped_data_per_size_per_register,phase,cycle):\\n min_reads_mapped_to_a_phased_register=3\\n min_reads_in_a_window=10\\n chromosome_hits=[]\\n for chromosome in sorted(mapped_data_per_size_per_register):\\n chromosome_hits.append(chromosome)\\n fhr=open(options.output_directory_per_run+\\\"/\\\"+options.input_filename+\\\"_\\\"+str(phase)+\\\"_\\\"+str(cycle)+\\\"_\\\"+chromosome+\\\".regionsOfInterest\\\",\\\"r\\\")\\n fhw=open(options.output_directory_per_run+\\\"/\\\"+options.input_filename+\\\"_\\\"+str(phase)+\\\"_\\\"+str(cycle)+\\\"_\\\"+chromosome+\\\".regionsOfInterest.concentrated\\\",\\\"w\\\")\\n for line in fhr:\\n register,start,end=line.strip().split()\\n register=int(register)\\n start=int(start)\\n end=int(end)\\n \\n begin=start\\n #print(chromosome,register,start,end)\\n sys.stdout.flush()\\n while begin+(phase*min_reads_mapped_to_a_phased_register) <= end+1:\\n finish=begin+(phase*cycle)-1\\n \\n k=0\\n for i in range(begin,finish+1):\\n #print(chromosome,register,i,phase,start,end)\\n try:\\n k+=mapped_data_per_size_per_register[chromosome][register][i]\\n except KeyError:\\n pass\\n #print(\\\"Next\\\")\\n if k<min_reads_mapped_to_a_phased_register: \\n begin+=phase\\n continue\\n \\n num_all_reads=0\\n for i in range(begin,finish+1):\\n try:\\n num_all_reads+=whole_mapped_data[chromosome][i]\\n except KeyError:\\n pass\\n if num_all_reads<min_reads_in_a_window:\\n begin+=phase\\n continue\\n \\n n=0\\n \\\"\\\"\\\"print(\\\"reached here\\\")\\n sys.stdout.flush()\\\"\\\"\\\"\\n # register_i is an iterator different from register\\n for register_i in sorted(mapped_data_per_size_per_register[chromosome]):\\n for i in range(begin,finish+1):\\n try:\\n n+=mapped_data_per_size_per_register[chromosome][register_i][i]\\n except KeyError:\\n pass\\n \\\"\\\"\\\"if chromosome==\\\"Chr1\\\":\\n print(str(n)+\\\" \\\"+str(num_all_reads)+\\\"\\\\n\\\")\\\"\\\"\\\"\\n if n/num_all_reads<0.3:\\n begin+=phase\\n continue\\n m=cycle*2\\n pvalue=0\\n for x in range(k,m+1):\\n numerator=nCr((phase-1)*m,n-x)*nCr(m,x)\\n pvalue+=numerator\\n denominator=nCr(phase*m,n)\\n pvalue=pvalue/denominator\\n #print(chromosome,begin,finish,k,n,m,num_all_reads,pvalue,n/num_all_reads)\\n if pvalue>=options.pvalue_cutoff:\\n begin+=phase\\n continue\\n stuffs_to_be_printed_to_file=[register,begin,finish,k,n,m,num_all_reads,n/num_all_reads,pvalue]\\n fhw.write(\\\"\\\\t\\\".join(map(str,stuffs_to_be_printed_to_file))+\\\"\\\\n\\\")\\n sys.stdout.flush()\\n begin+=phase\",\n \"def add_river_greedy(me, lm, material_dict, imgs, rounded_river,\\n min_length):\\n print(\\\" Building random river...\\\")\\n cell_source = get_river_source(material_dict)\\n if not(cell_source):\\n print(\\\"no cell source\\\")\\n return\\n xi,yi = cell_source\\n cell_source = lm.cells[xi][yi]\\n path = [cell_source]\\n cell_xy = cell_source\\n maxn = 1000\\n it = 0\\n should_finish = False\\n margin = 0.01\\n lake_probability = 0.5\\n while True:\\n if it > maxn:\\n break\\n elif \\\"water\\\" in cell_xy.material.name.lower():\\n break\\n elif should_finish:\\n break\\n it += 1\\n section_length = random.randint(2,10)\\n if random.random() < 0.5:\\n sign = 1\\n else:\\n sign = -1\\n if random.random() < 0.5:\\n dx, dy = sign, 0\\n else:\\n dx, dy = 0, sign\\n## print(dx,dy,section_length)\\n ################################################\\n for i in range(section_length):\\n if should_finish:\\n break\\n x = cell_xy.coord[0] + dx\\n y = cell_xy.coord[1] + dy\\n new_cell = lm.get_cell_at(x,y)\\n if new_cell is None:\\n break\\n elif new_cell.h - margin > cell_xy.h:\\n if cell_xy.material.name != new_cell.material.name:\\n break\\n elif new_cell in path:\\n break\\n elif new_cell.name != \\\"river\\\":\\n is_valid = True\\n for neigh in new_cell.get_neighbors_von_neuman():\\n if neigh:\\n if not(neigh is cell_xy):\\n if neigh.name == \\\"river\\\":\\n is_valid = False\\n break\\n elif \\\"water\\\" in neigh.material.name.lower():\\n should_finish = True\\n elif neigh in path:\\n is_valid = False\\n break\\n if is_valid:\\n cell_xy = new_cell\\n path.append(new_cell)\\n## print(\\\"OK\\\",dx,dy,section_length)\\n else:\\n break\\n else:\\n break\\n #4) change the end to first shallow shore cell\\n actual_path = []\\n for cell in path:\\n if cell.name == \\\"river\\\":\\n break\\n actual_path.append(cell)\\n if \\\"water\\\" in cell.material.name.lower():\\n break\\n else: #LAKE ?\\n next_to_water = False\\n for neigh in cell.get_neighbors_von_neuman():\\n if neigh:\\n if \\\"water\\\" in neigh.material.name.lower():\\n next_to_water = True\\n break\\n if next_to_water:\\n break\\n if len(actual_path) < min_length:\\n return\\n if actual_path[0].material.name == actual_path[-1].material.name:\\n return\\n elif not(\\\"water\\\" in actual_path[-1].material.name.lower()):\\n if random.random() < lake_probability:\\n pass\\n else:\\n return\\n #build images of river\\n objs = {}\\n for delta in imgs: #imgs[(dx,dy)][zoom]\\n river_obj = MapObject(me, imgs[delta][0], \\\"river\\\", 1.)\\n river_obj.is_ground = True\\n river_obj.lm = lm\\n objs[delta] = river_obj\\n #5) add river cells to map and layer\\n for i,cell in enumerate(actual_path):\\n prepare_cell_for_river(lm, cell)\\n dx,dy,corner = get_path_orientation(i, cell, actual_path)\\n if rounded_river:\\n c = objs.get((dx,dy,corner))\\n else:\\n c = objs.get((dx,dy,None))\\n if not c:\\n raise Exception(\\\"No river object for delta\\\", dx, dy, corner)\\n assert cell.name != \\\"river\\\"\\n c = c.add_copy_on_cell(cell)\\n cell.name = \\\"river\\\"\\n lm.static_objects.append(c)\\n\\n if actual_path:\\n## print(\\\"RIVER BUILT:\\\", [cell.coord for cell in actual_path])\\n if not(\\\"water\\\" in actual_path[-1].material.name.lower()):\\n for neigh in actual_path[-1].get_neighbors_moore():\\n if neigh and neigh.name != \\\"river\\\":\\n prepare_cell_for_river(lm, neigh)\\n river_obj = MapObject(me, imgs[(0,0,None)][0], \\\"river\\\", 1.)\\n river_obj.is_ground = True\\n river_obj.lm = lm\\n river_obj = river_obj.add_copy_on_cell(neigh)\\n neigh.name = \\\"river\\\"\\n lm.static_objects.append(river_obj)\\n return objs\",\n \"def scan(self, cut_off, r0 = 4, dr = 2, rmax = 80, bg_global = 3419, sigma = 3.5 * 13.8):\\r\\n \\r\\n start_time = time.time()\\r\\n for trial in range(self.dimension):\\r\\n \\r\\n max_count, max_rank = self.pick_largest(cut_off = cut_off)\\r\\n fitted = 0 # galaxy not fitted to a circle\\r\\n point = [] # \\r\\n circle_number = 0\\r\\n \\r\\n if max_count == -1:\\r\\n print(\\\"Scan completed, number of galaxies found is \\\", len(self.galaxies), \\\"run time is\\\", time.time() - start_time)\\r\\n break\\r\\n \\r\\n if max_count >= 0: # That means a value that is larger than cut_off exists\\r\\n ypos,xpos = self.rank_yx(max_rank)\\r\\n # print(\\\"max_count, y, x\\\", max_count, ypos, xpos) \\r\\n \\r\\n \\r\\n for r in range(r0, rmax, dr): # r = radius, we know the largest radius can't be >80 by inspecting the pic.\\r\\n print(\\\"locating the galaxy position at\\\", ypos, xpos, \\\"at a radius r =\\\", r) \\r\\n if fitted == 1 or r == 80:\\r\\n # print(\\\"max_count, yx\\\",max_count, ypos, xpos, \\\"cut =\\\", no_cut, len(new_point)/2)\\r\\n \\r\\n self.mask_region(ypos, xpos, r - dr)\\r\\n # print(bg_local, no_bg)\\r\\n if r - dr > r0: # it must be a galaxy\\r\\n \\r\\n # getting the local bg\\r\\n if no_bg > 3: # check if enough data to deduce bg\\r\\n bg = bg_local / no_bg \\r\\n else:\\r\\n bg = bg_global\\r\\n \\r\\n if circle_number >= np.pi* 2* (r - dr)**2:\\r\\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\\r\\n\\r\\n else:\\r\\n if no_cut < circle_number/2 and circle_number*2 >= np.pi * (r0**2):\\r\\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\\r\\n\\r\\n print(\\\"\\\\ngalaxy scan completed,radius =\\\", r - dr, \\\"position =\\\", ypos, xpos, \\\"max count =\\\", max_count, \\\"time = \\\", time.time() - start_time)\\r\\n\\r\\n break\\r\\n \\r\\n ##### Resetting parameters ####\\r\\n no_bg = 0 # number 0f background pixels\\r\\n bg_local = 0 # sum of local background noises\\r\\n no_cut = 0 # number of counts below cut off\\r\\n new_point = [] # pending pixels to be added\\r\\n ###############################\\r\\n \\r\\n if fitted == 0:\\r\\n \\r\\n if r == r0:\\r\\n \\r\\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\\r\\n \\r\\n # Check if it is within the circle radius = 2\\r\\n if int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\\r\\n \\r\\n i,j =[int(i), int(j)]\\r\\n if self.raw_image_data[j,i] == self.raw_image_data[j,i] *self.masked[j,i]: # Append the ppoint if not masked (masked = 1)\\r\\n\\r\\n if self.raw_image_data[j,i] <= cut_off:\\r\\n no_cut += 1\\r\\n\\r\\n if self.raw_image_data[j,i] > cut_off:\\r\\n point.append(self.raw_image_data[j, i])\\r\\n circle_number += 1\\r\\n\\r\\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\\r\\n bg_local += self.raw_image_data[j,i]\\r\\n no_bg += 1\\r\\n \\r\\n if no_cut >= len(point)/2 or 2*circle_number < np.pi * r0**2:\\r\\n fitted = 1\\r\\n else:\\r\\n pass\\r\\n \\r\\n#######################################################################################################\\r\\n if r > r0:\\r\\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): \\r\\n \\r\\n # Check if data are in between the previous and the new circle\\r\\n if (r - dr)**2 < int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\\r\\n i,j =[int(i), int(j)] # just incase \\r\\n \\r\\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]:\\r\\n\\r\\n if self.raw_image_data[j,i] <= cut_off:\\r\\n no_cut += 1\\r\\n if self.raw_image_data[j,i] > cut_off:\\r\\n new_point.append(self.raw_image_data[j, i]) # points are pending to be added in\\r\\n circle_number += 1\\r\\n\\r\\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\\r\\n bg_local += self.raw_image_data[j,i]\\r\\n no_bg += 1\\r\\n \\r\\n # Check if half of the new data points are inside cut off region\\r\\n if no_cut <= int(len(new_point)/2) or circle_number*2 < np.pi * r**2:\\r\\n for rannk in range(len(new_point)):\\r\\n point.append(new_point[rannk])\\r\\n\\r\\n else:\\r\\n fitted = 1\",\n \"def region_growing_from_input(self, color, bone_from_scan=None):\\n collect()\\n # initilize\\n if not bone_from_scan:\\n self.load_original_data()\\n else:\\n self.copy_original_from_bone(bone_from_scan)\\n checked = zeros(self._original_img_data.shape)\\n seg = zeros(self._original_img_data.shape)\\n need_to_check = []\\n # Color the seeds and check for neighbors\\n for seed in self._seeds_points:\\n seg[seed] = color\\n checked[seed] = 1\\n neighbors = self._get_neighbors(seed, checked, self.\\n _original_img_data.shape)\\n for neighbor in neighbors:\\n if self._get_threshold(self._original_img_data[neighbor],\\n VOID_VALUES[0],\\n VOID_VALUES[1]):\\n need_to_check.append(neighbor)\\n # Region Growing - while there's a neighbor, color it and keep going\\n bone_to_check = []\\n while need_to_check:\\n pt = need_to_check.pop()\\n if checked[pt] == 1:\\n continue\\n else:\\n checked[pt] = 1\\n neighbors = self._get_neighbors(pt, checked, self.\\n _original_img_data.shape)\\n for neighbor in neighbors:\\n if self._get_threshold(\\n self._original_img_data[neighbor],\\n VOID_VALUES[0], VOID_VALUES[1]):\\n need_to_check.append(neighbor)\\n if self._get_threshold(\\n self._original_img_data[neighbor],\\n BONE_BOUND_VALUES[0], BONE_BOUND_VALUES[1]):\\n bone_to_check.append(neighbor)\\n seg[pt] = color\\n # Closing holes\\n del need_to_check\\n # check for Bone value - edge of the radius\\n while bone_to_check:\\n pt = bone_to_check.pop()\\n if checked[pt] == 1:\\n continue\\n else:\\n checked[pt] = 1\\n neighbors = self._get_neighbors(pt, checked, self.\\n _original_img_data.shape)\\n for neighbor in neighbors:\\n if self._get_threshold(\\n self._original_img_data[neighbor],\\n RADIUS_VALUES[0], RADIUS_VALUES[1]):\\n bone_to_check.append(neighbor)\\n seg[pt] = color\\n del checked, bone_to_check\\n for i in range(self._dilation):\\n seg = dilation(seg, cube(3, uint8))\\n for i in range(self._dilation - 1):\\n seg = erosion(seg, cube(3, uint8))\\n self._segmentation_data = seg\\n del seg\\n collect()\",\n \"def test_avalanche_warning_by_region_obs(self):\\n pass\",\n \"def fillIn(self):\\n\\n # Grabs first point (which is a shore) and prefills in hashes\\n toBeAnalyzed = [self.points[0]]\\n islandHash = defaultdict(list)\\n islandHash[toBeAnalyzed[0].x].append(toBeAnalyzed[0].x)\\n islandGridPoints = toBeAnalyzed[:]\\n\\n # Find all points not at pond-level.\\n while toBeAnalyzed:\\n gridPoint = toBeAnalyzed.pop()\\n neighbors = self.analyzeData.iterateDiagonal(gridPoint.x,\\n gridPoint.y)\\n for _x, _y, elevation in neighbors:\\n\\n if elevation != self.pondElevation and _y not in\\\\\\n islandHash[_x]:\\n branch = GridPoint(_x, _y, elevation)\\n islandHash[_x].append(_y)\\n toBeAnalyzed.append(branch)\\n islandGridPoints.append(branch)\\n self.points = islandGridPoints\",\n \"def grid(iant,xgrid=[0],ygrid=[0],sleep=4):\\n d=Carma(iant).drive()\\n d.setOffset(xgrid[0],ygrid[0])\\n time.sleep(sleep)\\n time.sleep(sleep)\\n for y in ygrid:\\n for x in xgrid:\\n print x,y\\n d.setOffset(x,y)\\n time.sleep(sleep)\",\n \"def auto(self):\\n self.set_thermostat = 1 if self.desired_values[0] > self.data[0] else 0\\n self.set_humidifier = 1 if self.desired_values[1] > self.data[1] else 0\\n self.set_sprinklers = 1 if self.desired_values[2] > self.data[2] else 0\\n self.set_ventilation = 1 if (self.desired_values[3] > self.data[3] or self.desired_values[4] < self.data[4]) else 0\",\n \"def mainSelection():\\n\\timport time\\n\\tc1 = Content(1,4,20)\\n\\tc2 = Content(2,6,30)\\n\\tc3 = Content(3,5,25)\\n\\tc1_ = Content(1,1,20)\\n\\tc5 = Content(5,3,29)\\n\\tc6 = Content(6,11,50)\\n\\tc7 = Content(7,7,34)\\n\\tc1__ = Content(1,3,20)\\n\\tc8 = Content(8,6,10)\\n\\ta1 = Area('a1',1.0)\\n\\ta1.addContent(0,0,c1)\\n\\ta1.addContent(0,6,c2)\\n\\ta1.addContent(0,12,c3)\\n\\ta1.addContent(0,18,c1_)\\n\\ta1.addContent(1,2,c5)\\n\\ta1.addContent(1,9,c6)\\n\\ta1.addContent(2,0,c7)\\n\\ta1.addContent(2,9,c1__)\\n\\ta1.addContent(2,14,c8)\\n\\ta1.printSchedule()\\n\\tprint \\\"\\\\n\\\"\\n\\ta2 = Area('a2',0.5)\\n\\ta2.addContent(0,0,c6)\\n\\ta2.addContent(0,11,c7)\\n\\ta2.addContent(1,0,c1)\\n\\ta2.addContent(1,6,c8)\\n\\ta2.addContent(1,15,c3)\\n\\ta2.addContent(2,0,c3)\\n\\ta2.addContent(2,7,c5)\\n\\ta2.addContent(2,13,c2)\\n\\ta2.addContent(2,19,c1_)\\n\\ta2.printSchedule()\\n\\ta3 = Area('a3',1.0)\\n\\ta4 = Area('a4',0.9)\\n\\ta3.addContent(0,0,c2)\\n\\ta3.addContent(1,0,c5)\\n\\ta4.addContent(0,0,c2)\\n\\tsol_select = Selection_solution()\\n\\ttime_b = time.time()\\n\\tsol_select.select_bruteforce(time=12,a1=a1,a2=a2)\\n\\tprint \\\"running time: \\\",time.time()-time_b\\n\\ttime_g = time.time()\\n\\tsol_select.select_greedy(time=12,a1=a1,a2=a2)\\n\\tprint \\\"running time: \\\",time.time()-time_g\\n\\ttime_b = time.time()\\n\\tsol_select.select_bruteforce(time=0,a1=a3,a2=a4)\\n\\tprint \\\"running time: \\\",time.time()-time_b\\n\\ttime_g = time.time()\\n\\tsol_select.select_greedy(time=0,a1=a3,a2=a4)\\n\\tprint \\\"running time: \\\",time.time()-time_g\",\n \"def setValues(\\n self,\\n checkSelfIntersection: Boolean = ON,\\n autoCaching: Boolean = ON,\\n maxCachedStates: int = 5,\\n ):\\n pass\",\n \"def slicewhere(condition):\\n regions = ndimage.find_objects(ndimage.label(condition)[0])\\n return [region[0] for region in regions]\",\n \"def _cons_traj(self,lon,lat,period):\\n\\t\\tgroup = self['%g_sec'%( period )]\\n\\t\\tlonArr = group['lonArr'].value\\n\\t\\tlatArr = group['latArr'].value\\n\\t\\tageArr = group['age_Arr'].value\\n\\t\\tage_drv_lon = group['age_deriv_lon_Arr']\\n\\t\\tage_drv_lat = group['age_deriv_lat_Arr']\\n\\t\\tage_drv_msk = group['age_deriv_msk_Arr']\\n\\t\\ttomo_data_msk = group['tomo_data_msk'].value\\n\\t\\tmask_init = np.logical_or(tomo_data_msk, age_drv_msk)\\n\\t\\tmask = np.array(np.ones(lonArr.shape),dtype=bool)\\n\\t\\ti_s, j_s = self._find_nearest_grid(lon,lat,period) # find the 1st and 2nd index of the start point on grid\\n\\t\\tif mask_init[i_s,j_s]:\\n\\t\\t\\traise ValueError(\\\"The starting point is out bounds of the resulting map\\\")\\n\\t\\tmask[i_s,j_s] = False\\n\\t\\t# go along increasing age direction\\n\\t\\ti,j = _walk(age_drv_lon,age_drv_lat,i_s,j_s,1)\\n\\t\\twhile (0<i<lonArr.shape[0] and 0<j<lonArr.shape[1]):\\n\\t\\t\\tif mask_init[i,j]:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmask[i,j] = False\\n\\t\\t\\ti,j = _walk(age_drv_lon,age_drv_lat,i,j,1)\\n\\t\\t\\t\\n\\t\\t# go along descending age direction\\n\\t\\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_s,j_s,-1)\\n\\t\\tmask[i_2,j_2] = False\\n\\t\\twhile (0<i_2<lonArr.shape[0] and 0<j_2<lonArr.shape[1]):\\n\\t\\t\\tif mask_init[i_2,j_2]:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmask[i_2,j_2] = False\\n\\t\\t\\tage_b = ageArr[i_2,j_2]\\n\\t\\t\\ti_b,j_b = i_2,j_2\\n\\t\\t\\ti_2,j_2 = _walk(age_drv_lon,age_drv_lat,i_2,j_2,-1)\\n\\t\\t\\tif ageArr[i_2,j_2] > age_b: # find the youngest age\\n\\t\\t\\t\\ti_3,j_3 = i_b,j_b\\n\\t\\t\\t\\tbreak\\n\\t\\ttry:\\n\\t\\t\\ti_3\\n\\t\\texcept NameError:\\n\\t\\t\\treturn mask\\n\\t\\t\\n\\t\\t# go along increasing age from the found youngest age\\n\\t\\twhile (0<i_3<lonArr.shape[0] and 0<j_3<lonArr.shape[1]):\\n\\t\\t\\tif mask_init[i_3,j_3]:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmask[i_3,j_3] = False\\n\\t\\t\\ti_3,j_3 = _walk(age_drv_lon,age_drv_lat,i_3,j_3,1)\\n\\t\\treturn mask\",\n \"def _check_fleet_edges(self):\\n\\t\\tfor auto in self.autos.sprites():\\n\\t\\t\\tif auto.check_edges():\\n\\t\\t\\t\\tself._change_fleet_direction()\\n\\t\\t\\t\\tbreak\",\n \"def step():\\n x_rand = sample()\\n x_nearest = new_nearest_neighbour(x_rand)\\n x_new = steer(x_nearest, x_rand)\\n if obstacle_free(x_nearest, x_new):\\n X_near = new_neighbourhood(x_new)\\n x_min = x_nearest\\n c_min = x_nearest.cost + x_nearest.dist_to(x_new)\\n for x_near in X_near:\\n if obstacle_free(x_near, x_new) and (x_near.cost + x_near.dist_to(x_new) < c_min):\\n x_min = x_near\\n c_min = (x_near.cost + x_near.dist_to(x_new) < c_min)\\n x_new_node = add_node(x_new, x_min, True)\\n for x_near in X_near:\\n if obstacle_free(x_near, x_new) and (x_new_node.cost + x_near.dist_to(x_new) < x_near.cost):\\n x_near.change_parent(x_new_node)\\n # Here I check for goal paths and draw the circle\\n updated = False\\n if shared.root_path:\\n updated = goal_path_resolve(shared.root_path[0])\\n updated = updated or goal_path_resolve(shared.nodes[-1])\\n if updated:\\n diameter = shared.root_path_length\\n center = ((shared.root_path[0].x + shared.root_path[-1].x) / 2,\\n (shared.root_path[0].y + shared.root_path[-1].y) / 2)\\n if shared.region:\\n shared.region.remove_from_batch()\\n shared.region = ellipse.Ellipse(center[0], center[1], diameter)\\n shared.region.add_to_batch()\",\n \"async def test_sampling_boundaries_given(hass: HomeAssistant) -> None:\\n assert await async_setup_component(\\n hass,\\n \\\"sensor\\\",\\n {\\n \\\"sensor\\\": [\\n {\\n \\\"platform\\\": \\\"statistics\\\",\\n \\\"name\\\": \\\"test_boundaries_none\\\",\\n \\\"entity_id\\\": \\\"sensor.test_monitored\\\",\\n \\\"state_characteristic\\\": \\\"mean\\\",\\n },\\n {\\n \\\"platform\\\": \\\"statistics\\\",\\n \\\"name\\\": \\\"test_boundaries_size\\\",\\n \\\"entity_id\\\": \\\"sensor.test_monitored\\\",\\n \\\"state_characteristic\\\": \\\"mean\\\",\\n \\\"sampling_size\\\": 20,\\n },\\n {\\n \\\"platform\\\": \\\"statistics\\\",\\n \\\"name\\\": \\\"test_boundaries_age\\\",\\n \\\"entity_id\\\": \\\"sensor.test_monitored\\\",\\n \\\"state_characteristic\\\": \\\"mean\\\",\\n \\\"max_age\\\": {\\\"minutes\\\": 4},\\n },\\n {\\n \\\"platform\\\": \\\"statistics\\\",\\n \\\"name\\\": \\\"test_boundaries_both\\\",\\n \\\"entity_id\\\": \\\"sensor.test_monitored\\\",\\n \\\"state_characteristic\\\": \\\"mean\\\",\\n \\\"sampling_size\\\": 20,\\n \\\"max_age\\\": {\\\"minutes\\\": 4},\\n },\\n ]\\n },\\n )\\n await hass.async_block_till_done()\\n\\n hass.states.async_set(\\n \\\"sensor.test_monitored\\\",\\n str(VALUES_NUMERIC[0]),\\n {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},\\n )\\n await hass.async_block_till_done()\\n\\n state = hass.states.get(\\\"sensor.test_boundaries_none\\\")\\n assert state is None\\n state = hass.states.get(\\\"sensor.test_boundaries_size\\\")\\n assert state is not None\\n state = hass.states.get(\\\"sensor.test_boundaries_age\\\")\\n assert state is not None\\n state = hass.states.get(\\\"sensor.test_boundaries_both\\\")\\n assert state is not None\",\n \"def shifter(self):\\n #self.BA_shift = self.timeshift_latitude(self.latB, self.latA)\\n #self.BC_shift = self.timeshift_latitude(self.latB, self.latC)\\n\\n\\n self.shifted = True #changing boolean to True when function is called.\\n\\n secondsA = self.secondsA\\n secondsB = self.secondsB\\n secondsC = self.secondsC\\n\\n NeA = self.holefill(self.NeA, secondsA)\\n NeB = self.holefill(self.NeB, secondsB)\\n NeC = self.holefill(self.NeC, secondsC)\\n\\n start = 0\\n stop = len(NeA) - np.max(np.array([self.BA_shift, self.BC_shift]))\\n\\n startA = start + self.BA_shift\\n stopA = stop + self.BA_shift\\n\\n startC = start + self.BC_shift\\n stopC = stop + self.BC_shift\\n\\n NeA = NeA[startA:stopA]\\n NeB = NeB[start:stop]\\n NeC = NeC[startC:stopC]\\n\\n longA = self.holefill(self.longA, secondsA)\\n longB = self.holefill(self.longB, secondsB)\\n longC = self.holefill(self.longC, secondsC)\\n longA = longA[startA:stopA]\\n longB = longB[start:stop]\\n longC = longC[startC:stopC]\\n\\n latA = self.holefill(self.latA, secondsA)\\n latB = self.holefill(self.latB, secondsB)\\n latC = self.holefill(self.latC, secondsC)\\n latA = latA[startA:stopA]\\n latB = latB[start:stop]\\n latC = latC[startC:stopC]\\n\\n radA = self.holefill(self.radA, secondsA)\\n radB = self.holefill(self.radB, secondsB)\\n radC = self.holefill(self.radC, secondsC)\\n radA = radA[startA:stopA]\\n radB = radB[start:stop]\\n radC = radC[startC:stopC]\\n\\n velA = self.holefill(self.velA, secondsA)\\n velB = self.holefill(self.velB, secondsB)\\n velC = self.holefill(self.velC, secondsC)\\n velA = velA[startA:stopA]\\n velB = velB[start:stop]\\n velC = velC[start:stop]\\n\\n altA = self.holefill(self.altA, secondsA)\\n altB = self.holefill(self.altB, secondsB)\\n altC = self.holefill(self.altC, secondsC)\\n altA = altA[startA:stopA]\\n altB = altB[start:stop]\\n altC = altC[startC:stopC]\\n\\n\\n mlatA = self.holefill(self.mlatA, secondsA)\\n mlatB = self.holefill(self.mlatB, secondsB)\\n mlatC = self.holefill(self.mlatC, secondsC)\\n mlatA = mlatA[startA:stopA]\\n mlatB = mlatB[start:stop]\\n mlatC = mlatC[startC:stopC]\\n\\n mlongA = self.holefill(self.mlongA, secondsA)\\n mlongB = self.holefill(self.mlongB, secondsB)\\n mlongC = self.holefill(self.mlongC, secondsC)\\n mlongA = mlongA[startA:stopA]\\n mlongB = mlongB[start:stop]\\n mlongC = mlongC[startC:stopC]\\n\\n mltA = self.holefill(self.mltA, secondsA)\\n mltB = self.holefill(self.mltB, secondsB)\\n mltC = self.holefill(self.mltC, secondsC)\\n mltA = mltA[startA:stopA]\\n mltB = mltB[start:stop]\\n mltC = mltC[startC:stopC]\\n\\n secondsA = self.holefill(secondsA, secondsA)\\n secondsB = self.holefill(secondsB, secondsB)\\n secondsC = self.holefill(secondsC, secondsC)\\n secondsA = secondsA[startA:stopA]\\n secondsB = secondsB[start:stop]\\n secondsC = secondsC[startC:stopC]\\n\\n indsA = np.nonzero(secondsA)[0]\\n indsB = np.nonzero(secondsB)[0]\\n indsC = np.nonzero(secondsC)[0]\\n\\n inds = np.intersect1d(indsA, indsB)\\n inds = np.intersect1d(inds, indsC)\\n\\n self.NeA = NeA[inds]\\n self.NeB = NeB[inds]\\n self.NeC = NeC[inds]\\n\\n self.longA = longA[inds]\\n self.longB = longB[inds]\\n self.longC = longC[inds]\\n\\n self.latA = latA[inds]\\n self.latB = latB[inds]\\n self.latC = latC[inds]\\n\\n self.radA = radA[inds]\\n self.radB = radB[inds]\\n self.radC = radC[inds]\\n\\n self.velA = velA[inds]\\n self.velB = velB[inds]\\n self.velC = velC[inds]\\n\\n self.altA = altA[inds]\\n self.altB = altB[inds]\\n self.altC = altC[inds]\\n\\n self.mlatA = mlatA[inds]\\n self.mlatB = mlatB[inds]\\n self.mlatC = mlatC[inds]\\n\\n self.mlongA = mlongA[inds]\\n self.mlongB = mlongB[inds]\\n self.mlongC = mlongC[inds]\\n\\n self.mltA = mltA[inds]\\n self.mltB = mltB[inds]\\n self.mltC = mltC[inds]\\n\\n self.secondsA = secondsA[inds]\\n self.secondsB = secondsB[inds]\\n self.secondsC = secondsC[inds]\",\n \"def mask_the_images(working_path,set_name):\\n\\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41cf2fb1198e.npy')\\n out_images = [] #final set of images for all patients\\n for fname in file_list:\\n out_images_per_patient = []\\n print (\\\"working on file \\\", fname)\\n imgs_to_process = np.load(fname.replace(\\\"lungmask\\\",\\\"images\\\")) # images of one patient\\n masks = np.load(fname)\\n for i in range(len(imgs_to_process)):\\n mask = masks[i]\\n img = imgs_to_process[i]\\n new_size = [512,512] # we're scaling back up to the original size of the image\\n img= mask*img # apply lung mask\\n #\\n # renormalizing the masked image (in the mask region)\\n #\\n new_mean = np.mean(img[mask>0])\\n new_std = np.std(img[mask>0])\\n #\\n # Pulling the background color up to the lower end\\n # of the pixel range for the lungs\\n #\\n old_min = np.min(img) # background color\\n img[img==old_min] = new_mean-1.2*new_std # resetting backgound color\\n img = img-new_mean\\n img = img/new_std\\n #make image bounding box (min row, min col, max row, max col)\\n labels = measure.label(mask)\\n regions = measure.regionprops(labels)\\n #\\n # Finding the global min and max row over all regions\\n #\\n min_row = 512\\n max_row = 0\\n min_col = 512\\n max_col = 0\\n for prop in regions:\\n B = prop.bbox\\n if min_row > B[0]:\\n min_row = B[0]\\n if min_col > B[1]:\\n min_col = B[1]\\n if max_row < B[2]:\\n max_row = B[2]\\n if max_col < B[3]:\\n max_col = B[3]\\n width = max_col-min_col\\n height = max_row - min_row\\n if width > height:\\n max_row=min_row+width\\n else:\\n max_col = min_col+height\\n #\\n # cropping the image down to the bounding box for all regions\\n # (there's probably an skimage command that can do this in one line)\\n #\\n img = img[min_row:max_row,min_col:max_col]\\n mask = mask[min_row:max_row,min_col:max_col]\\n if max_row-min_row <5 or max_col-min_col<5: # skipping all images with no god regions\\n pass\\n else:\\n # moving range to -1 to 1 to accomodate the resize function\\n mean = np.mean(img)\\n img = img - mean\\n min = np.min(img)\\n max = np.max(img)\\n img = img/(max-min)\\n new_img = resize(img,[512,512], mode='constant')\\n out_images_per_patient.append(new_img)\\n\\n id = re.sub(r'.*_images_(.*)\\\\.npy',r'\\\\1',fname)\\n patient_images_and_id = (out_images_per_patient,id)\\n out_images.append(patient_images_and_id)\\n print (\\\"Delete files: {} \\\\n\\\\t {} \\\".format(fname,re.sub(\\\"lungmask\\\",\\\"images\\\",fname)))\\n os.remove(fname)\\n os.remove(fname.replace(\\\"images\\\",\\\"lungmask\\\")) # images of one patient\\n\\n\\n np.save(working_path+\\\"{}Images.npy\\\".format(set_name),out_images)\",\n \"async def _run(self):\\n while True:\\n for count in range(self._nSamples):\\n if self._currentValue == self._pin.value():\\n break\\n else:\\n await asyncio.sleep_ms(self._interval)\\n if count == self._nSamples - 1:\\n # Edge detected\\n self._currentValue = not self._currentValue\\n if self._currentValue:\\n # Raising edge\\n self._count += 1\\n\\n await asyncio.sleep_ms(self._interval)\",\n \"def sample_pin_position_range():\\n #Create a sample goniometer\\n g = TopazInHouseGoniometer()\\n\\n #Initialize the leg limits\\n g.relative_sample_position = column([0.0, 0.0, 0.0])\\n g.getplatepos(0.0, 0.0, 0.0)\\n g.calculate_leg_xy_limits(visualize=True)\\n\\n# if True:\\n# pylab.show()\\n# return\\n\\n n = 17\\n positions = np.linspace(-8, 8, n) #Range calculated in mm\\n allowed = np.zeros( (n,n,n) )\\n for (ix, x) in enumerate(positions):\\n print \\\"Calculating x\\\", x\\n for (iy, y) in enumerate(positions):\\n for (iz, z) in enumerate(positions):\\n #Set up\\n g.relative_sample_position = column([x, y, z])\\n allowed[ix,iy,iz] = g.are_angles_allowed([0., 0., 0.], return_reason=False)\\n\\n #Do a plot\\n\\n pylab.figure(1, figsize=[15,15])\\n pylab.title(\\\"Allowable XZ sample positions\\\")\\n for (iy, y) in enumerate(positions):\\n print \\\"At y of\\\", y, \\\", # of points = \\\", np.sum( allowed[:, iy,:])\\n if iy < 16:\\n pylab.subplot(4,4,iy+1)\\n pylab.pcolor(positions, positions, allowed[:, iy, :].transpose(), norm=pylab.Normalize(0, 1))\\n pylab.xlabel(\\\"x\\\")\\n pylab.ylabel(\\\"z\\\")\\n pylab.title(\\\"y = %.3f mm\\\" % y)\\n pylab.draw()\\n pylab.axis('equal')\\n pylab.show()\\n #pylab.\",\n \"def separation_crawler(mode: bool) -> bool:\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n if mode:\\r\\n if conflict_space[x, y] != 0 and safeboard[x, y] == 1:\\r\\n if walled_in(x, y):\\r\\n safeboard[x, y] = 0\\r\\n print(\\\"Cell will create separation if marked. Marked safe:\\\", x, \\\",\\\", y)\\r\\n progress_handler(False, True)\\r\\n else:\\r\\n if example[x, y] == 0:\\r\\n if walled_in(x, y):\\r\\n print(\\\"Solution Rejected, separated areas\\\")\\r\\n return True\",\n \"def test_absolute_areas(self):\\n\\n assert len(self.test_shape.areas) == 4\\n assert len(set([round(i) for i in self.test_shape.areas])) == 3\\n assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1000)) == 2\\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 970)) == 1\\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1030)) == 1\",\n \"def dealing_covers(high_series,low_series):\\n #dealing k\\n #initialize\\n pre_calculated=0\\n rates_total=len(high_series)\\n valid_high=high_series.copy()\\n valid_low=low_series.copy()\\n valid_k_line_mark=np.zeros(rates_total)\\n \\\"\\\"\\\"\\n start point use up contains dealing\\n \\\"\\\"\\\"\\n start_index=0\\n pre_high=valid_high[start_index]\\n pre_low=valid_low[start_index]\\n pre_idx=start_index\\n cur_idx=pre_idx\\n is_found=False\\n while(not is_found):\\n cur_idx=cur_idx+1\\n cur_high=valid_high[cur_idx]\\n cur_low=valid_low[cur_idx]\\n if (cur_high>pre_high and cur_low>pre_low)or (cur_high<pre_high and cur_low<pre_low):\\n is_found=True\\n valid_high[pre_idx]=pre_high\\n valid_low[pre_idx]=pre_low\\n valid_k_line_mark[pre_idx]=1\\n else:\\n if pre_high>cur_high:\\n # first k cover second k\\n pre_low=cur_low\\n elif pre_high<cur_high:\\n\\n # first k be convered by second k\\n pre_high=cur_high\\n pre_idx=cur_idx\\n else:\\n # high value is equal\\n pre_low=cur_low\\n pre_idx=cur_idx\\n\\n # no start point dealing\\n begin_idx=cur_idx+1\\n for i in range(begin_idx,rates_total):\\n post_high=valid_high[i]\\n post_low=valid_low[i]\\n post_idx=i\\n #first classification: no contains\\n if (cur_high>post_high and cur_low>post_low)or (cur_high<post_high and cur_low<post_low):\\n valid_high[cur_idx]=cur_high\\n valid_low[cur_idx]=cur_low\\n valid_k_line_mark[cur_idx]=1\\n pre_high=cur_high\\n pre_low=cur_low\\n pre_idx=cur_idx\\n cur_high=post_high\\n cur_low=post_low\\n cur_idx=post_idx\\n else:\\n if pre_high<cur_high:#up contains\\n if cur_high>post_high:\\n #post be coverd by cur\\n cur_low=post_low\\n elif cur_high<post_high:\\n #post cover cur\\n cur_high=post_high\\n cur_idx=post_idx\\n else:\\n #high be equal\\n if cur_low>post_low:\\n #cur be covered by post\\n cur_idx=post_idx\\n else:\\n #cur covers post\\n cur_low=post_low\\n else:#down contains\\n if cur_low>post_low:\\n #cur be covered by post\\n cur_low=post_low\\n cur_idx=post_idx\\n elif cur_low<post_low:\\n #cur covers post\\n cur_high=post_high\\n else:\\n # two low is equal\\n if cur_high>post_high:\\n cur_high=post_high\\n else:\\n cur_idx=post_idx\\n cur_high=post_high#I think the words can be deleted\\n return valid_k_line_mark,valid_high,valid_low\",\n \"def occupied_cells(self):\\n\\n for lm in self.landmarks:\\n if self.cell_size < 1:\\n # expand the range the landmark exists\\n lm_x_range = np.arange(lm[0]-self.R, lm[0]+self.R, self.cell_size)\\n lm_y_range = np.arange(lm[1]-self.R, lm[1]+self.R, self.cell_size)\\n\\n # loop through expanded ranges and compute grid positions\\n for lm_x in lm_x_range:\\n for lm_y in lm_y_range:\\n\\n row, col = self.cell_index([lm_x, lm_y])\\n\\n # apply cost of occupied cell\\n try:\\n self.world[row][col] = 1000\\n except IndexError:\\n pass\\n\\n else:\\n # apply cost of occupied cell\\n row, col = self.cell_index(lm)\\n try:\\n self.world[row][col] = 1000\\n except IndexError:\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5690144","0.56761265","0.56038886","0.5585656","0.5530814","0.5513189","0.54393256","0.5427754","0.5368495","0.5355389","0.53465384","0.53144586","0.5309058","0.5297361","0.5285404","0.5273793","0.5240959","0.52374387","0.5226939","0.52219576","0.5216464","0.51996493","0.5190396","0.5171101","0.51653266","0.5152892","0.5150748","0.5148904","0.5141409","0.51222503","0.5120164","0.51166666","0.5111002","0.5107005","0.510681","0.5104367","0.5103986","0.5099151","0.50956106","0.508896","0.5082235","0.50792825","0.50771123","0.50735617","0.50727224","0.5070202","0.5069293","0.5058274","0.5057407","0.505732","0.5048925","0.5045895","0.5045456","0.504265","0.5036817","0.50340575","0.5029906","0.5028394","0.5028362","0.502493","0.5024129","0.5018102","0.50179076","0.50179076","0.50107205","0.5005215","0.5004272","0.500103","0.5000182","0.49954525","0.49917737","0.4989098","0.49881682","0.49880552","0.4986841","0.49849644","0.49843907","0.4983087","0.49812177","0.49792647","0.4976653","0.49720833","0.4969047","0.49688607","0.4968802","0.4967961","0.49669692","0.49667498","0.49627993","0.49620137","0.4961842","0.49615088","0.49585846","0.49580222","0.4941344","0.49382126","0.49377114","0.49352664","0.4931125","0.49277678","0.49230778"],"string":"[\n \"0.5690144\",\n \"0.56761265\",\n \"0.56038886\",\n \"0.5585656\",\n \"0.5530814\",\n \"0.5513189\",\n \"0.54393256\",\n \"0.5427754\",\n \"0.5368495\",\n \"0.5355389\",\n \"0.53465384\",\n \"0.53144586\",\n \"0.5309058\",\n \"0.5297361\",\n \"0.5285404\",\n \"0.5273793\",\n \"0.5240959\",\n \"0.52374387\",\n \"0.5226939\",\n \"0.52219576\",\n \"0.5216464\",\n \"0.51996493\",\n \"0.5190396\",\n \"0.5171101\",\n \"0.51653266\",\n \"0.5152892\",\n \"0.5150748\",\n \"0.5148904\",\n \"0.5141409\",\n \"0.51222503\",\n \"0.5120164\",\n \"0.51166666\",\n \"0.5111002\",\n \"0.5107005\",\n \"0.510681\",\n \"0.5104367\",\n \"0.5103986\",\n \"0.5099151\",\n \"0.50956106\",\n \"0.508896\",\n \"0.5082235\",\n \"0.50792825\",\n \"0.50771123\",\n \"0.50735617\",\n \"0.50727224\",\n \"0.5070202\",\n \"0.5069293\",\n \"0.5058274\",\n \"0.5057407\",\n \"0.505732\",\n \"0.5048925\",\n \"0.5045895\",\n \"0.5045456\",\n \"0.504265\",\n \"0.5036817\",\n \"0.50340575\",\n \"0.5029906\",\n \"0.5028394\",\n \"0.5028362\",\n \"0.502493\",\n \"0.5024129\",\n \"0.5018102\",\n \"0.50179076\",\n \"0.50179076\",\n \"0.50107205\",\n \"0.5005215\",\n \"0.5004272\",\n \"0.500103\",\n \"0.5000182\",\n \"0.49954525\",\n \"0.49917737\",\n \"0.4989098\",\n \"0.49881682\",\n \"0.49880552\",\n \"0.4986841\",\n \"0.49849644\",\n \"0.49843907\",\n \"0.4983087\",\n \"0.49812177\",\n \"0.49792647\",\n \"0.4976653\",\n \"0.49720833\",\n \"0.4969047\",\n \"0.49688607\",\n \"0.4968802\",\n \"0.4967961\",\n \"0.49669692\",\n \"0.49667498\",\n \"0.49627993\",\n \"0.49620137\",\n \"0.4961842\",\n \"0.49615088\",\n \"0.49585846\",\n \"0.49580222\",\n \"0.4941344\",\n \"0.49382126\",\n \"0.49377114\",\n \"0.49352664\",\n \"0.4931125\",\n \"0.49277678\",\n \"0.49230778\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76567,"cells":{"query":{"kind":"string","value":"Plot the grid generated by a flow. The displacement can be too small, so we add a scale factor"},"document":{"kind":"string","value":"def plot_grid(ax, flow, factor=10):\n grid = factor * flow[:, ::8, ::8]\n lin_range = np.linspace(0, 512, 64)\n x, y = np.meshgrid(lin_range, lin_range)\n x = x + grid[0, ...]\n y = y + grid[1, ...]\n y = y\n\n segs1 = np.stack((x, y), axis=2)\n segs2 = segs1.transpose(1, 0, 2)\n ax.add_collection(LineCollection(segs1, color='black', linewidths=0.8))\n ax.add_collection(LineCollection(segs2, color='black', linewidths=0.8))\n ax.autoscale()"},"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 show_grid(frame, episode_nr):\n plt.grid('on')\n ax = plt.gca()\n ax.set_xticks(np.arange(0.5, 10, 1))\n ax.set_yticks(np.arange(0.5, 10, 1))\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n ax.imshow(frame, cmap='binary')\n ax.set_title(\"Episode {}\".format(episode_nr))\n plt.pause(0.01)\n plt.clf()","def plot_flow(x, y, u, v, ax, flow_type, units, regrid_shape=40,\n thin_quivers=None, quiver_length=1.0, palette='YlGnBu', colour='0.8', \n plot_magnitude=False, colour_bounds=None):\n\n if type(u) == numpy.ma.core.MaskedArray:\n u = u.filled(numpy.nan)\n v = v.filled(numpy.nan)\n\n assert flow_type in ['streamlines', 'quivers']\n\n if colour_bounds:\n vmin, vmax = colour_bounds\n norm = matplotlib.colors.Normalize(vmin=0, vmax=30)\n else:\n norm = None\n\n if flow_type == 'streamlines' and plot_magnitude:\n magnitude = (u ** 2 + v ** 2) ** 0.5\n cmap = get_palette(palette)\n ax.streamplot(x, y, u, v, transform=ccrs.PlateCarree(),\n color=magnitude, cmap=cmap, norm=norm) #linewidth=2, density=2\n elif flow_type == 'streamlines':\n ax.streamplot(x, y, u, v, transform=ccrs.PlateCarree(), color=colour)\n elif flow_type == 'quivers':\n if thin_quivers:\n qplot = ax.quiver(x[::thin_quivers], y[::thin_quivers],\n u[::thin_quivers, ::thin_quivers], v[::thin_quivers, ::thin_quivers],\n transform=ccrs.PlateCarree()) \n else: \n qplot = ax.quiver(x, y, u, v, transform=ccrs.PlateCarree(), regrid_shape=regrid_shape, color=colour)\n #regrid_shape seems to problematic for a simple PlateCarree plot (i.e. no transform) \n\n label = str(quiver_length) + ' ' + str(units)\n ax.quiverkey(qplot, 0.95, 1.02, quiver_length, label, labelpos='W')","def draw_grid(self):\n plt.imshow(py.array(\n map(lambda x: map(lambda y: mplc.colorConverter.to_rgb(colord[y]), x), self.create_grid(self.graph))),\n interpolation='nearest')\n plt.show()","def plot_outputgrid(self, scalefactor=1, **kwargs):\n\n if not (type(scalefactor) == 'int'):\n scalefactor = round(scalefactor)\n\n xx = np.arange(self.xori, self.xend, scalefactor * self.dx)\n yy = np.arange(self.yori, self.yend, scalefactor * self.dy)\n plt.hlines(yy, self.xori, self.xend, linewidth=0.2, **kwargs)\n plt.vlines(xx, self.yori, self.yend, linewidth=0.2, **kwargs)\n\n logger.debug('Adding output grid to plot')","def show_grid(self):\n for ax in (self.time_velocity, self.time_power, self.power_velocity):\n ax.grid(True)","def SimpleFlowMapPlotHelper(self,filename,grid_type,log_max=4):\n flowmap_object = iodriver.load_field(filename,\n file_type=iodriver.get_file_extension(filename),\n field_type='Generic',\n grid_type=grid_type)\n flowmap = flowmap_object.get_data()\n plt.figure()\n plt.subplot(111)\n if log_max == 0:\n log_max = math.log(np.amax(flowmap))\n levels = np.logspace(0,log_max,num=50)\n #ctrs = plt.contourf(flowmap,levels=levels,norm=colors.LogNorm())\n #plt.contourf(flowmap,levels=levels,norm=colors.LogNorm())\n plt.contourf(flowmap,levels=levels)\n #cbar = plt.colorbar(ctrs)\n cbar = plt.colorbar()\n cbar.ax.set_ylabel('Number of cells flowing to cell')\n pts.set_ticks_to_zero()\n if self.save:\n #plt.savefig('')\n pass","def plotgrid(data,d=10,shape=(30,30)):\n ion()\n gray()\n clf()\n for i in range(min(d*d,len(data))):\n subplot(d,d,i+1)\n row = data[i]\n if shape is not None: row = row.reshape(shape)\n imshow(row)\n ginput(1,timeout=0.1)","def render(self, mode = 'human'):\n if mode == 'human':\n\n if self.is_2d:\n fig = plt.figure()\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n plt.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n plt.scatter(*index, c='blue', s=1000, alpha=0.2)\n plt.xlim(-1, self.dim[0])\n plt.ylim(-1, self.dim[1])\n plt.xticks([])\n plt.yticks([])\n plt.grid(True)\n\n if self.is_3d:\n fig = plt.figure()\n ax = Axes3D(fig)\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\n ax.set_xlim(0, self.dim[0] - 1)\n ax.set_ylim(0, self.dim[1] - 1)\n ax.set_zlim(0, self.dim[2] - 1)\n\n else:\n fig = plt.figure()\n ax = Axes3D(fig)\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\n\n ax.set_xlim(0, self.dim[0] - 1)\n ax.set_ylim(0, self.dim[1] - 1)\n ax.set_zlim(0, self.dim[2] - 1)\n ax.set_title('Nr of steps: ' + str(self.steps))\n\n plt.show()\n return fig","def plot(self):\n R = self.length\n\n plt.figure()\n for ii, car in enumerate(self.cars):\n theta = self.positions[ii] + car.position\n x = R * np.cos(theta)\n y = R * np.sin(theta)\n if ii == 0:\n plt.scatter(x, y, marker='x')\n else:\n plt.scatter(x, y)\n\n plt.axis('scaled')\n lim = (-1.2 * R, 1.2 * R)\n plt.ylim(lim)\n plt.xlim(lim)\n plt.savefig('traffic_{:d}.png'.format(self.time))\n plt.close()","def drawGrid(self):\n for div in range(NBCELL):\n sec = SSIZE*div\n self.can.create_line(0, sec, GSIZE, sec, width=3, fill=GFILL)\n self.can.create_line(sec, 0, sec, GSIZE, width=3, fill=GFILL)","def plot_graph(self) -> None:","def coordPlt(grid, buffer=10, step=5):\n plt.cla()\n\n plt.plot(grid[1][0::step, 0::step],\n grid[0][0::step, 0::step],\n '.-b' )\n\n plt.plot(grid[1][0::step, 0::step].T,\n grid[0][0::step, 0::step].T,\n '.-b' )\n\n plt.axis( [ grid[1].max() + buffer,\n grid[1].min() - buffer,\n grid[0].max() + buffer,\n grid[0].min() - buffer],\n )\n plt.axis('off')\n plt.grid()","def scree_plot(self, ev):\n plt.scatter(range(1,len(ev)+1), ev)\n plt.plot(range(1,len(ev)+1), ev)\n plt.title(\"Scree Plot\")\n plt.xlabel(\"Factors\")\n plt.ylabel(\"Eigenvalue\")\n plt.grid()\n plt.show()","def grid_frame(self, steps, figure_size=(12, 12)):\r\n\r\n x = self.seed\r\n counts = []\r\n for n in np.arange(0, steps):\r\n x, stats = self.update_grid(x)\r\n counts.append(stats)\r\n\r\n counts = np.array(counts)\r\n\r\n fig, ax = plt.subplots(figsize=figure_size)\r\n ax.get_xaxis().set_visible(False)\r\n ax.get_yaxis().set_visible(False)\r\n color_map = matplotlib.colors.ListedColormap(['white', 'black'])\r\n img = plt.imshow(x, interpolation='nearest', cmap=color_map)\r\n img.axes.grid(False)\r\n plt.title(self.title + ' | Step ' + str(steps))\r\n plt.show()\r\n\r\n return x, counts","def plot(self):\n pass","def _plot_grid(frames: Figure, ncols: int = 3) -> Figure:\n for frame in frames:\n frame.plot_height = frame.plot_height // ncols\n frame.plot_width = frame.plot_width // ncols\n return gridplot(frames, ncols=ncols)","def show_plot() :\n logger.info(\"Show plot\")\n pylab.axis('equal')\n pylab.xlabel(\"Longitud\")\n pylab.ylabel(\"Latitud\")\n pylab.grid(True)\n pylab.title(\"Product tiles and product source\")\n pylab.show()","def plot_plasma(self):\n x = self.geom.x\n fig, axes = plt.subplots(1, 2, figsize=(8, 3),\n constrained_layout=True)\n # plot densities\n ax = axes[0]\n ax.plot(x, self.ne, 'b-')\n ax.plot(x, self.ni, 'r-')\n ax.legend(['E', 'Ion'])\n ax.set_xlabel('Position (m)')\n ax.set_ylabel('Density (m^-3)')\n # plot temperature\n ax = axes[1]\n ax.plot(x, self.Te, 'b-')\n ax.plot(x, self.Ti, 'r-')\n ax.legend(['Te', 'Ti'])\n ax.set_xlabel('Position (m)')\n ax.set_ylabel('Temperature (eV)')\n plt.show()","def display_game(self):\n display = plt.figure()\n\n # Plots dots.\n for dot in self.dots:\n plt.scatter(dot.x + .5, dot.y + .5, color=dot.color, s=1000)\n\n # Makes a uniform grid,\n axes = display.gca()\n axes.set_aspect('equal', adjustable='box')\n axes.set_xticks(np.arange(0, self.dimension + 1, 1))\n axes.set_yticks(np.arange(0, self.dimension + 1, 1))\n plt.grid(True, color=\"black\", linestyle=\"-\")\n axes.set_xticklabels([])\n axes.set_yticklabels([])\n for tic in axes.xaxis.get_major_ticks():\n tic.tick1On = tic.tick2On = False\n for tic in axes.yaxis.get_major_ticks():\n tic.tick1On = tic.tick2On = False\n plt.show()","def plot_slice(self,res):\n x = np.linspace(0,1,res)\n y = np.linspace(0,1,res)\n X,Y = np.meshgrid(x,y)\n plt.figure()\n ax = plt.axes(projection = '3d')\n ax.plot_surface(X,Y,abs(self.psi)[:,:,math.floor(res/2)])\n plt.show()","def plot_price_evolution_for_nr_run(nr_log):\n plt.figure(figsize=(10, 5))\n\n plt.plot(nr_log['time'], nr_log['virtual_price'], '.', label='NR')\n\n plt.legend()\n\n plt.grid()\n\n plt.title('Network Relaxation run - Grid price evolution')\n\n plt.xlabel('time [s]')\n\n plt.ylabel('price [$]')\n\n plt.show()","def plot(self):\n\t\tself.plotOfTF().plot()","def plot_graphon(graphon, resolution=1000):\n labels = _np.linspace(0, 1, resolution)\n heights = evaluate(graphon, labels)\n _plt.matshow(heights, cmap=_plt.cm.gray_r, vmin=0, vmax=1)\n ax = _plt.gca()\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)","def make_grid(self):\n length = self.size / 8\n # draw horizontal lines\n for y in range(0, self.size, length):\n self.window.create_line(0, y, self.size, y, fill = \"blue\")\n \n # draw vertical lines\n for x in range(0, self.size, length):\n self.window.create_line(x, 0, x, self.size, fill = \"blue\")\n\n # draw the axes red\n self.window.create_line(\n 0,\n self.size / 2,\n self.size, \n self.size / 2, \n fill = \"red\"\n )\n self.window.create_line(\n self.size / 2, 0,\n self.size / 2, \n self.size, \n fill = \"red\"\n )\n print(\"Grid Made.\")","def plot_cost(self):\n steps = np.arange(len(self.cost_values))\n plt.plot(steps, self.cost_values, '-o')\n plt.xlabel(\"Steps\")\n plt.ylabel(\"Cost value\")\n plt.title(\"Cost value per step using Gradient Descent\")\n plt.show()","def plot_grid(filename, title, names, x):\n fig = plt.figure(figsize=(10,6))\n ax = fig.add_subplot(111)\n ax.set_title(title)\n plt.imshow(x, interpolation=\"nearest\", cmap=plt.get_cmap(\"hot\"))\n ax.set_aspect('equal')\n plt.xticks(range(6), names, rotation='vertical')\n plt.yticks(range(6), names)\n plt.subplots_adjust(bottom=0.25)\n # ax.set_xticklabels(('',) + names)\n # ax.set_yticklabels(('',) + names)\n cax = fig.add_axes([0.12, 0.1, 0.78, 0.8])\n cax.get_xaxis().set_visible(False)\n cax.get_yaxis().set_visible(False)\n cax.patch.set_alpha(0)\n cax.set_frame_on(False)\n plt.colorbar(orientation='vertical')\n plt.savefig(filename+\".pdf\")\n fig.clear()","def draw_grid(self):\n for x in range(0, WIDTH, TILESIZE):\n pg.draw.line(self.screen, LIGHTGREY, (x, 0), (x, HEIGHT))\n \n for y in range(0, HEIGHT, TILESIZE):\n pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y))","def plot_phase_diagram(self):\n t_max = np.log(max(self.temperatures))\n d_min = np.log(min(self.distortions))\n y_axis = [np.log(i) - d_min for i in self.distortions]\n x_axis = [t_max - np.log(i) for i in self.temperatures]\n\n plt.figure(figsize=(12, 9))\n plt.plot(x_axis, y_axis)\n\n region = {}\n for i, c in list(enumerate(self.n_eff_clusters)):\n if c not in region:\n region[c] = {}\n region[c]['min'] = x_axis[i]\n region[c]['max'] = x_axis[i]\n for c in region:\n if c == 0:\n continue\n plt.text((region[c]['min'] + region[c]['max']) / 2, 0.2,\n 'K={}'.format(c), rotation=90)\n plt.axvspan(region[c]['min'], region[c]['max'], color='C' + str(c),\n alpha=0.2)\n plt.title('Phases diagram (log)')\n plt.xlabel('Temperature')\n plt.ylabel('Distortion')\n plt.show()","def plot(self, x_unit='ft', y_unit='psi'):\n\n #Find the grid centers (where the solution exists)\n x_pos = np.cumsum(self.dx_arr) - self.dx_arr[0] / 2.0\n\n #Loop over all stored solutions and plot stair-step line (because\n #pressure is constant over grid block). We skip the first stored values\n #because they are just the initialization values.\n plt.figure()\n for P in self.P_plot:\n plt.plot(x_pos, P)\n\n #Labels, etc.\n plt.xlabel('Reservoir position (' + x_unit + ')')\n plt.ylabel('Pressure (' + y_unit + ')')\n plt.xlim([0, self.res_length])\n plt.show()","def draw_plot(yscale='linear'):\n plt.yscale(yscale)\n plt.xticks(list(range(0, 101, 5)))\n plt.xlabel('percentile [%]')\n plt.grid(True)\n plt.ylabel('operation time [ns]')\n plt.legend()\n plt.show()","def fdplot(self, imx):\n fig = plt.figure()\n maxval = np.max(imx)\n ims = list(map(lambda im: [plt.imshow(np.fabs(im),norm=colors.Normalize(0.0,maxval))], imx))\n animation = anim.ArtistAnimation(fig,ims,interval=50)\n plt.show()","def plot(self):\n self.plotsite()\n self.plotbond()\n plt.show()","def visualize(self):\n\n check_is_fitted(self, \"sm_\")\n\n fig = plt.figure(figsize=(6, 4))\n inner = gridspec.GridSpec(2, 1, hspace=0.1, height_ratios=[6, 1])\n ax1_main = plt.Subplot(fig, inner[0]) \n xgrid = np.linspace(self.xmin, self.xmax, 100).reshape([-1, 1])\n ygrid = self.decision_function(xgrid)\n ax1_main.plot(xgrid, ygrid)\n ax1_main.set_xticklabels([])\n ax1_main.set_title(\"Shape Function\", fontsize=12)\n fig.add_subplot(ax1_main)\n \n ax1_density = plt.Subplot(fig, inner[1]) \n xint = ((np.array(self.bins_[1:]) + np.array(self.bins_[:-1])) / 2).reshape([-1, 1]).reshape([-1])\n ax1_density.bar(xint, self.density_, width=xint[1] - xint[0])\n ax1_main.get_shared_x_axes().join(ax1_main, ax1_density)\n ax1_density.set_yticklabels([])\n ax1_density.autoscale()\n fig.add_subplot(ax1_density)\n plt.show()","def vis_latent_space_abs(self):\n gen_input = self.init_vec.detach().numpy()\n\n grid_x, grid_y = np.mgrid[-2:2:200j, -2:2:200j]\n\n gen_input = torch.tensor(\n np.stack([grid_x.reshape(-1,), grid_y.reshape(-1,)], axis=1), requires_grad=False).float()\n gen_output = self.generator(gen_input).detach().numpy()\n\n grid_color = griddata(gen_input, np.abs(gen_output[:, 1])-np.abs(gen_output[:, 0]),\n (grid_x, grid_y), method='cubic')\n\n fig, ax = plt.subplots(figsize=(14, 12))\n col = ax.imshow(grid_color.T, extent=(-2, 2, -2, 2))\n plt.colorbar(col, label='|Y| - |X|')\n plt.title(\"Latent Space coloring (Cross)\")","def visualize_M_gridworld(self, state=0):\n\n\t\tplt.subplot(221); plt.imshow(self.M[12,0,:].reshape(5,5)), plt.colorbar()\n\t\tplt.subplot(222); plt.imshow(self.M[12,1,:].reshape(5,5)), plt.colorbar()\n\t\tplt.subplot(223); plt.imshow(self.M[12,2,:].reshape(5,5)), plt.colorbar()\n\t\tplt.subplot(224); plt.imshow(self.M[12,3,:].reshape(5,5)), plt.colorbar()\n\t\tplt.show()","def draw_grid(G: 'Graph') -> None:\n xgrid_precision = 5\n ygrid_precision = 12\n rounding = 3\n for i in range(G.grid_lines):\n pygame.draw.line(screen, black, (0, i * height//G.grid_lines),\n (width, i * height//G.grid_lines), 1)\n pygame.draw.line(screen, black, (i * width//G.grid_lines, 0),\n (i * width//G.grid_lines, height), 1)\n\n for i in range(xgrid_precision):\n x = G.dependant[round(i*len(G.dependant)/xgrid_precision)][0]\n x = grid_coord(str(round(x, rounding)))\n x_rec = x.get_rect()\n x_rec.center = (i*width/xgrid_precision, height//2 + 10)\n screen.blit(x, x_rec)\n pygame.draw.line(screen, gray, (i*width/xgrid_precision, 0),\n (i*width/xgrid_precision, height), 1)\n\n for i in range(ygrid_precision, 0, -1):\n y = i*(G.ymin - G.ymax)/ygrid_precision + G.ymax\n y = grid_coord(str(round(y, rounding)))\n y_rec = y.get_rect()\n y_rec.center = (width//2 + 8, i*height/ygrid_precision)\n screen.blit(y, y_rec)\n pygame.draw.line(screen, gray, (0, i*width/ygrid_precision),\n (width, i*width/ygrid_precision), 1)","def __init__(self, nx, ny, nxsize=5.4, nysize=6.2):\n self.nx = nx\n self.ny = ny\n self.n = 1\n plt.figure(figsize=(nysize*ny, nxsize*nx))\n plt.subplot(nx, ny, self.n)","def plotKinetic(self, phys, forces, step):\r\n self.plotQuantity(step, TopologyUtilities.kineticEnergy(phys.myTop, phys.velvec), 'kineticenergy')","def create_grid(self):\n\n # initial point of the path\n self.p0 = np.array([self.start_x, self.start_y])\n self.pf = np.array([self.end_x, self.end_y]) # final point of the path\n\n self.l1 = np.linalg.norm(np.subtract(self.pf, self.p0))\n self.l2 = 0.2 * self.l1\n\n # we define the 2 unit vectors self.d1 and self.d2 in which directions we are moving along\n # then we apply to them the size of the desired displacement\n self.d1 = np.subtract(self.pf, self.p0) / \\\n (np.linalg.norm(np.subtract(self.pf, self.p0)))\n\n self.d2 = np.array([-self.d1[1], self.d1[0]])\n self.d2 = self.d2/(np.linalg.norm(self.d2))\n\n # we create our grid moving with self.d1 and self.d2\n # each point of the grid has the following properties:\n # position, distance to self.d1, distance to self.pf, velocity\n n_displacements_2 = 0\n self.lines_list = []\n\n # variables for making easier the plotting afterwards\n self.x_list_grid = []\n self.y_list_grid = []\n time_n = 1\n\n while True:\n current_point = np.subtract(\n self.p0, self.d2*(n_displacements_2*self.displacement))\n current_length_2 = np.linalg.norm(\n np.subtract(current_point, self.p0))\n if current_length_2 > self.l2/2:\n if time_n == 2:\n break\n else:\n time_n += 1\n self.lines_list = list(reversed(self.lines_list))\n self.d2 = -1 * self.d2\n n_displacements_2 = 1\n current_point = np.subtract(\n self.p0, self.d2*(n_displacements_2*self.displacement))\n\n line_points = []\n self.x_list_grid.append(current_point[0])\n self.y_list_grid.append(current_point[1])\n\n # TODO: add fish real prediction\n line_points.append({\n \"position\": current_point.tolist(),\n \"distance_to_l1\": n_displacements_2*self.displacement,\n \"distance_to_pf\": np.linalg.norm(np.subtract(self.pf, current_point)),\n \"fish\": random.random()\n })\n\n initial_point_1 = current_point\n while True:\n current_point = np.sum(\n [current_point, self.d1 * self.displacement], axis=0)\n current_length_1 = np.linalg.norm(\n np.subtract(current_point, initial_point_1))\n if current_length_1 >= self.l1:\n current_point = self.pf - self.d2*n_displacements_2*self.displacement\n self.x_list_grid.append(current_point[0])\n self.y_list_grid.append(current_point[1])\n # TODO: add fish real prediction\n line_points.append({\n \"position\": current_point.tolist(),\n \"distance_to_l1\": n_displacements_2*self.displacement,\n \"distance_to_pf\": np.linalg.norm(np.subtract(self.pf, current_point)),\n \"fish\": random.random()\n })\n break\n\n self.x_list_grid.append(current_point[0])\n self.y_list_grid.append(current_point[1])\n\n # TODO: add fish real prediction\n line_points.append({\n \"position\": current_point.tolist(),\n \"distance_to_l1\": n_displacements_2*self.displacement,\n \"distance_to_pf\": np.linalg.norm(np.subtract(self.pf, current_point)),\n \"fish\": random.random()\n })\n\n self.lines_list.append(line_points)\n n_displacements_2 += 1","def plot(self):\n\t\tself.plotOfXray().plot()","def plot_final_grid(generated_images):\n\n fig = plt.figure(figsize=(8, 6))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\n\n for ind in range(GRID_IMGS):\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\n\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\n plt.savefig('/content/drive/My Drive/WGAN/results/DCGAN.png')\n plt.show()","def plot_dynamic_system(f, nb_sub=10, ax=None, xlim=[-1, 1], ylim=[-1, 1], scale=0.01,\n name=None, equal=False, **kwargs):\n\n Y, X = np.mgrid[ylim[0]:ylim[1]:complex(nb_sub), xlim[0]:xlim[\n 1]:complex(nb_sub)]\n mesh_data = np.vstack([X.ravel(), Y.ravel()])\n\n field = f(mesh_data.T).T\n\n U = field[0]\n V = field[1]\n U = U.reshape(nb_sub, nb_sub)\n V = V.reshape(nb_sub, nb_sub)\n speed = np.sqrt(U * U + V * V)\n\n if name is not None:\n plt.suptitle(name)\n\n if ax is not None:\n strm = ax.streamplot(X, Y, U, V, linewidth=scale * speed, **kwargs)\n ax.set_xlim(xlim)\n ax.set_ylim(ylim)\n\n if equal:\n ax.set_aspect('equal')\n\n else:\n strm = plt.streamplot(X, Y, U, V, linewidth=scale * speed, **kwargs)\n plt.xlim(xlim)\n plt.ylim(ylim)\n\n if equal:\n plt.axes().set_aspect('equal')\n\n return [strm]","def drawGrid(self,gridLines=True):\n if not self.changed: self.edit()\n cGrid = Fmap.GRID\n cBorder = Fmap.BORDER\n if gridLines: #--Some fools don't want the grid!\n #--Grid\n for uv in range(-25,26,5):\n xy = 512/2 - 9*uv + 4\n self.drawRect(cGrid,0,xy,512,xy+1)\n self.drawRect(cGrid,xy,0,xy+1,512)\n #--Grid axes\n xy = 512/2 + 4\n self.drawRect(cBorder,0,xy,512,xy+1)\n self.drawRect(cBorder,xy,0,xy+1,512)\n #--Border\n self.drawBorder(cBorder,0,0,512,512,4)","def plot(self):\n\t\tself.plotOfSpect().plot()","def plot_final_grid(generated_images):\n\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\n\n for ind in range(GRID_IMGS):\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\n\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\n plt.savefig('/content/drive/My Drive/WGAN/results/WGAN.png')\n plt.show()","def show_image_grid(imgs):\n grd = make_grid(imgs)\n npimg = grd.numpy()\n plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n plt.ion()\n plt.show()","def init_plot(self):\n self.dpi = 100\n self.fig = Figure((5.0, 5.0), dpi = self.dpi)\n\n self.main_plot = self.fig.add_subplot(111)\n self.main_plot.set_axis_bgcolor('black')\n self.main_plot.set_title('Dynamic venous flow view', size = 12)\n\n pylab.setp(self.main_plot.get_xticklabels(), fontsize = 8)\n pylab.setp(self.main_plot.get_yticklabels(), fontsize = 8)\n\n # Plot the data as a green line\n self.plot_data = self.main_plot.plot(\n self.daq.data0,\n linewidth = 1,\n color = (0, 1, 0),\n )[0]\n self.main_plot.grid(True, color='gray')","def cplot(self, figure, i, n):\n xx, yy = np.meshgrid(range(self.L), range(self.L))\n ax = figure.add_subplot(2,2,n)\n plt.setp(ax.get_yticklabels(), visible=False)\n plt.setp(ax.get_xticklabels(), visible=False) \n plt.pcolormesh(xx, yy, self.config, cmap=plt.cm.RdBu);\n plt.title('Time=%d'%i, fontsize=20)\n plt.xlabel('X', fontsize=12)\n plt.ylabel('Y',fontsize=12) \n plt.axis('tight') \n self.ax = ax","def plot(self, n_confs):\n \n import pandas as pd\n import numpy as np\n import matplotlib as mpl\n mpl.use('Agg')\n import matplotlib.pyplot as plt\n import csv\n \n n_iter = len(self.plot_data)\n \n data = np.ndarray((n_iter, n_confs+1))\n data[:,0] = [i[0] for i in self.plot_data]\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\n\n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n df.to_csv(f\"{self.plot_name}.tab\", sep=\"\\t\", quoting=csv.QUOTE_NONE) \n\n d = data[:,1:].reshape(-1)\n d = d[~np.isnan(d)]\n mine = d.min() - 0.01\n for i in range(n_confs): \n data[:,i+1] -= mine\n \n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n \n colors = (0,0,0)\n area = 10\n \n # Plot\n fig = plt.figure(figsize=(15, 15))\n ax = fig.add_subplot(1,1,1)\n for i in range(n_confs):\n ax.plot('iter', f'c{i+1}', data=df)\n ax.set_yscale('log')\n\n plt.xlabel('iter')\n plt.ylabel('loss')\n plt.savefig(f'{self.plot_name}.png')","def draw_grid(self, verbosity=0):\n log.debug(\"Drawing grid\")\n (x0, y0) = self.origin\n color = (191, 191, 191)\n\n (w, h) = self.surface.get_size()\n\n i = x0\n while True:\n (x, ignore) = self.map_to_screen((i, 0))\n if x > w:\n break\n pygame.draw.line(self.surface, color, (x, 0), (x, h), 1)\n i += 10\n\n j = y0\n while True:\n (ignore, y) = self.map_to_screen((0, j))\n if y > h:\n break\n pygame.draw.line(self.surface, color, (0, y), (w, y), 1)\n j -= 10","def draw_grid(plt):\n x0, x1, x2, x3 = 0, 3057, 6508, 9860\n y0, y1, y2, y3, y4, y5, y6, y7, y8 = 0, 1535, 2041, 2547, 3053, 3559, 4257, 5303, 6978\n alpha, linewidth = 0.3, 0.5\n\n # Vertical Lines\n plt.plot((x0, x0), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x1, x1), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x2, x2), (y0, y5), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x3, x3), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\n\n # Horizontal Lines\n plt.plot((x0, x3), (y0, y0), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y1, y1), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y2, y2), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y3, y3), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y4, y4), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y5, y5), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x1), (y6, y6), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x1, x3), (y7, y7), 'black', alpha=alpha, linewidth=linewidth)\n plt.plot((x0, x3), (y8, y8), 'black', alpha=alpha, linewidth=linewidth)","def test_sizergrid():\n regular_grid(8, 3)\n mpl.show()","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def visualize_network_samples_grid(net, start=5, stop=100, step=10,\n f_ext=\"pdf\"):\n save_dir = make_memnet_checkpoint_dir(\n Path(\"plots/vis_memnet_samples/grid/\"), net)\n if not save_dir.exists():\n save_dir.makedirs()\n inds = list(product(range(start, stop, step), range(start, stop, step)))\n grid_width = len(range(start, stop, step))\n print(\"Loading plants.\")\n inputs, stim_vals = load_plants(\n net.image_width,\n net.trainingset_dir,\n layer_type=net.layer_type,\n normalize=True)\n print(\"Finished.\")\n fig, axes = plt.subplots(grid_width, grid_width, figsize=(50, 50))\n preds = []\n print(\"Making plots...\")\n for i in range(len(stim_vals)):\n if tuple(stim_vals[i]) in inds:\n print(\"Making \", stim_vals[i])\n preds.append(\n net.predict(inputs[i:i + 1], keep_session=True).reshape(\n net.image_width, net.image_width))\n grid_coord = tuple(stim_vals[i] / step)\n ax = axes[int(grid_coord[1]), int(grid_coord[0])]\n # ax = axes[tuple(stim_vals[i] / step)]\n ax.imshow(preds[-1], cmap=\"gray_r\")\n ax.set_xticklabels(\"\")\n ax.set_xticks([])\n ax.set_xticklabels(\"\")\n ax.set_yticks([])\n ax.set_yticklabels(\"\")\n plt.savefig(save_dir.joinpath('grid.' + f_ext))\n print(\"Saved to \", save_dir.joinpath('grid.' + f_ext))\n return","def visualisation(self):\n plt.plot(self.x, self.y, 'o', label = 'Example data')\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\n plt.xlim([-1,1])\n plt.ylim([-1,1])","def show_grid(grid, edges, path1, path2):\n plt.imshow(grid, origin='lower', cmap='Greys')\n\n if edges is not None:\n for e in edges:\n p1 = e[0]\n p2 = e[1]\n plt.plot([p1[1], p2[1]], [p1[0], p2[0]], 'b-')\n\n # Stepping through each edge\n if path1 is not None:\n p1 = path1[0]\n for p in path1[1:]:\n p2 = p\n plt.plot([p1[1], p2[1]], [p1[0], p2[0]], 'ro')\n p1 = p2\n\n if path2 is not None:\n p1 = path2[0]\n for p in path2[1:]:\n p2 = p\n plt.plot([p1[1], p2[1]], [p1[0], p2[0]], 'g-', linewidth=3)\n p1 = p2\n\n plt.plot(start[1], start[0], 'rx')\n plt.plot(goal[1], goal[0], 'rx')\n plt.grid()\n plt.xlabel('EAST')\n plt.ylabel('NORTH')\n plt.xticks([x for x in range(0, 1000, 50)])\n plt.yticks([y for y in range(0, 1000, 50)])\n plt.show()","def Traffic_Perform_Plot(performance, hurricanes):\n fig = plt.figure(figsize = (8, 6))\n for i in range(len(performance)):\n temp1 = performance[i]\n temp2 = hurricanes[i]\n perform = sf.Normalize(temp1, Type = 'max')\n plt.plot(np.arange(0, len(perform), 1), perform, color = temp2.c, label = temp2.name, marker = 'o')\n plt.xlabel('Time Step')\n plt.xticks(np.arange(0, len(perform), 1))\n plt.ylabel('Performance')\n plt.legend(bbox_to_anchor=(1, 1), loc='upper left', ncol=1, frameon = 0)\n plt.grid(True)","def plot(self):\n\t\tself.plotOfSpect()","def plot_tessellation(self):\n\n if (self.ndim != 2):\n print(\"Only able to plot the tessellation in two dimensions.\")\n return\n\n # find bounds:\n xmin = np.nanmin(self.grid[:,0])\n xmax = np.nanmax(self.grid[:,0])\n ymin = np.nanmin(self.grid[:,1])\n ymax = np.nanmax(self.grid[:,1])\n dx = xmax-xmin\n dy = ymax-ymin\n xmin -= dx*0.03\n xmax += dx*0.03\n ymin -= dy*0.05\n ymax += dy*0.05\n\n #plt.semilogy(self.grid[:,0],self.grid[:,1],'o')\n plt.plot(self.grid[:,0],self.grid[:,1],'o')\n plt.triplot(self.grid[:,0],self.grid[:,1],self.tessellation.simplices.copy())\n plt.xlim((xmin,xmax))\n plt.ylim((ymin,ymax))\n plt.xlabel(string_to_latex(self.grid_params[0]))\n plt.ylabel(string_to_latex(self.grid_params[1]))\n plt.savefig(\"tessellation.eps\")","def plot_activity(opts, points, activity, labels, plot_state=False):\n sort_ix = sort_weights(opts)\n activity[:,opts.state_size:] = activity[:,opts.state_size+sort_ix]\n\n x = np.arange(0, opts.state_size)\n # x = np.linspace(np.amin(points[:, 0]), np.amax(points[:, 0]))\n scale = 2 * np.pi / opts.state_size\n x_rad = x * scale\n cos, sin = np.cos(x_rad), np.sin(x_rad)\n if opts.velocity:\n y = np.linspace(np.amin(points[:, 1]), np.amax(points[:, 1]))\n else:\n y = np.zeros(1)\n\n x_mesh, y_mesh = np.meshgrid(x, y)\n cos, _ = np.meshgrid(cos, y)\n sin, _ = np.meshgrid(sin, y)\n if plot_state:\n nc, nr = 5, 4\n neurons = np.arange(opts.state_size) # state neurons\n else:\n nc, nr = 5, 8\n neurons = np.arange(opts.state_size, opts.rnn_size) # extra neurons\n\n\n f_linear, ax_linear = plt.subplots(ncols=nc, nrows=nr)\n # plt.suptitle('Linear Interpolated Data')\n\n c, r = 0, 0\n for i, n in enumerate(neurons):\n z_lin = griddata(points[:, :2], activity[:, n], (x_mesh, y_mesh), method='linear')\n plt.sca(ax_linear[r, c])\n # plt.title('Neuron {}'.format(n))\n plt.contourf(x, y, z_lin, cmap='RdBu_r')\n plt.axis('off')\n\n # find the global centroid\n if np.nanmax(z_lin) <= 0:\n z_lin -= np.nanmean(z_lin) # center activations at the median\n\n z_lin[np.isnan(z_lin)] = 0\n z_lin[z_lin < 0] = 0\n norm = np.sum(z_lin)\n\n cos_mean = np.sum(cos * z_lin) / norm\n sin_mean = np.sum(sin * z_lin) / norm\n com_rad = np.arctan2(sin_mean, cos_mean)\n com_x = (com_rad / scale) % 20\n com_y = np.sum(y_mesh * z_lin) / norm\n # plt.scatter(com_x, com_y, c='k')\n\n c += 1\n if c == nc:\n c = 0\n r += 1\n if r == nr:\n break\n # plt.tight_layout()\n plt.show()","def makeGrid(self):\n self.h = self.step_x\n self.k = self.step_t\n self.t, self.x = np.meshgrid(np.arange(self.min_t, self.max_t, self.step_t), np.arange(self.min_x, self.max_x\n , self.step_x))","def draw_grid(self):\n if self.grid_center == True:\n (n, m) = (self.n, self.m)\n (dx, dy) = (self.dx // 2, self.dy // 2)\n else:\n (n, m) = (self.n + 1, self.m + 1)\n (dx, dy) = (0, 0)\n\n x0 = self.x0 + dx\n y0 = self.y0 + dy\n\n # vertical lines\n for j in range(m):\n p0 = (x0 + j * self.dx, y0)\n p1 = (x0 + j * self.dx, y0 + (n-1) * self.dy)\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d) \n # horizontal lines\n for i in range(n):\n p0 = (x0, y0 + i * self.dy)\n p1 = (x0 + (m-1) * self.dx, y0 + i * self.dy)\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d)","def plot_tiles(self):\n \n #TODO: adjust plot, border and text_box sizes\n \n ordered_projections = []\n flat_clusters = []\n colors_2D = []\n\n for cluster, nodes in clusters.items():\n for n in nodes:\n ordered_projections.append(projection_2D[n])\n\n for n in nodes:\n flat_clusters.append(n)\n\n for i, n in enumerate(G.nodes):\n if n in nodes:\n colors_2D.append(colors[i])\n\n grid_cols = int(np.ceil(np.sqrt(len(ordered_projections))))\n\n if len(ordered_projections) <= (grid_cols**2 - grid_cols):\n grid_rows = grid_cols - 1\n else:\n grid_rows = grid_cols\n\n #assuming images are same size, get shape\n l, w = ordered_projections[0].shape\n\n #add blank images to pack in grid\n while len(ordered_projections) < grid_rows*grid_cols:\n ordered_projections.append(np.zeros((l, w)))\n colors_2D.append((0., 0., 0.))\n flat_clusters.append('')\n\n f = Figure()\n\n grid = ImageGrid(f, 111, #similar to subplot(111)\n nrows_ncols=(grid_rows, grid_cols), #creates grid of axes\n axes_pad=0.05) #pad between axes in inch\n \n lw = 1.75\n text_box_size = 5 \n props = dict(boxstyle='round', facecolor='white')\n \n for i, (ax, im) in enumerate(zip(grid, ordered_projections)):\n ax.imshow(im, cmap='gray')\n\n for side, spine in ax.spines.items():\n spine.set_color(colors_2D[i])\n spine.set_linewidth(lw)\n\n ax.get_yaxis().set_ticks([])\n ax.get_xaxis().set_ticks([])\n\n text = str(flat_clusters[i])\n ax.text(1, 1, text, va='top', ha='left', bbox=props, size=text_box_size)\n \n newWindow = tk.Toplevel()\n newWindow.grid_rowconfigure(0, weight=1)\n newWindow.grid_columnconfigure(0, weight=1)\n \n #PLOT FRAME\n plotFrame = tk.Frame(newWindow, bg='lightgrey', width=600, height=400)\n plotFrame.grid(row=0, column=0, sticky='nsew')\n \n canvas = FigureCanvasTkAgg(f, plotFrame)\n canvas.draw()\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)\n canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)\n canvas.figure.tight_layout()\n \n\n #TOOLBAR FRAME\n toolbarFrame = ttk.Frame(newWindow, width=600, height=100)\n toolbarFrame.grid(row=1, column=0, sticky='nsew')\n toolbarFrame.grid_propagate(0)\n \n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)\n toolbar.update()","def grid(self):\n def startEndPoints(start, end, num):\n \"\"\"Generate num points between a start and stop point. Assumed to be (t,x) points.\n \"\"\"\n ll = np.linspace(0,1,num)\n xxs = start[0]*(1-ll)+end[0]*ll\n tts = start[1]*(1-ll)+end[1]*ll\n return( np.array([xxs, tts]) )\n \n fig, ax = plt.subplots( figsize=(10,8) )\n # The slope is beta.\n # x' axis, input points in (x,t) S points\n boost = self.boost()\n invboost = np.linalg.inv( boost )\n astart = np.dot(invboost, [0, 0] )\n aend = np.dot(invboost, [0,10] )\n aaxis = startEndPoints( astart, aend, 40 )\n\n ax.plot(aaxis[0], aaxis[1], 'b-')\n \n # t' axis\n astart = np.dot(invboost, [0, 0])\n aend = np.dot(invboost, [10, 0])\n aaxis = startEndPoints( astart, aend, 40 )\n\n ax.plot(aaxis[0], aaxis[1], 'b-')\n \n # light lines on all 45 degrees\n aaxis = startEndPoints( [-10, -10], [10, 10], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k--')\n aaxis = startEndPoints( [-10, 10], [10, -10], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k--')\n \n # t-hat and x-hat axes\n aaxis = startEndPoints( [0, 0], [10, 0], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k-')\n aaxis = startEndPoints( [0, 0], [0, 10], 40 )\n ax.plot(aaxis[0], aaxis[1], 'k-')\n ax.grid(True)\n \n return( (fig, ax) )","def _plot_camera_view(self):\n fig, axs = plt.subplots()\n fig.show()\n axs.cla()\n axs.axis([-0.003, 0.003, -0.003, 0.003])\n axs.grid()\n axs.plot([0], [0], 'r+')\n for t_step in range(0, int(self._t_sim / self._dt) + 1, 250):\n axs.plot(\n self._feat_vec[t_step, 0, 0],\n self._feat_vec[t_step, 1, 0], 'ro')\n axs.plot(\n self._feat_vec[t_step, 0, 1],\n self._feat_vec[t_step, 1, 1], 'bo')\n axs.plot(\n self._feat_vec[t_step, 0, 2],\n self._feat_vec[t_step, 1, 2], 'yo')\n axs.plot(\n self._feat_vec[t_step, 0, 3],\n self._feat_vec[t_step, 1, 3], 'go')\n axs.plot(\n self._feat_vec[t_step, 0, 4],\n self._feat_vec[t_step, 1, 4], 'ro')\n plt.pause(1 / self._plot_fps)","def SimpleMeasuredGrid(min_x,min_y,max_x,max_y,x_spacing,y_spacing,\n color=(0.5,1.0,0.5,1.0),xoff=-0.14,yoff=1.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 # Round to nearest integer space\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\n\n lxoff=(max_x-min_x)*xoff # horizontal label placement\n lyoff=(max_y-min_y)*yoff # vertical label placement\n\n for hval in numpy.arange(min_x,\n max_x+x_spacing/100.0,\n x_spacing):\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',\"%d\" % int(hval+0.5))\n shps.append(pshp)\n\n for vval in numpy.arange(min_y,\n max_y+y_spacing/100.0,\n y_spacing):\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',\"%d\" % int(vval+0.5))\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 plot(self):\n\t\tplot_chain(self.database_path, self.temp_folder)\n\t\tplot_density(self.database_path, self.temp_folder, self.cal_params)","def gen_grids(self):\n self.dx = self.grid_width / self.grid_resol\n self.dk = 2 * np.pi/self.grid_width\n self.grid_x_shifted = -self.grid_width/2 + self.dx * np.arange(0, self.grid_resol)\n self.grid_x = self.grid_x_shifted + self.grid_center\n self.grid_k = - (np.pi * self.grid_resol)/self.grid_width + self.dk * np.arange(0, self.grid_resol)\n self.grid_k = np.roll(self.grid_k, int((self.grid_resol)/2))\n self.grid_kin = np.square(self.h)/ (2*self.m) * np.square(self.grid_k)","def plot(self):\n\n fig, ax = plt.subplots()\n\n for run in self.runs:\n # Load datasets\n data_measure = run.get_dataset(\"stats-collect_link_congestion-raw-*.csv\")\n data_sp = run.get_dataset(\"stats-collect_link_congestion-sp-*.csv\")\n\n # Extract link congestion information\n data_measure = data_measure['msgs']\n data_sp = data_sp['msgs']\n\n # Compute ECDF and plot it\n ecdf_measure = sm.distributions.ECDF(data_measure)\n ecdf_sp = sm.distributions.ECDF(data_sp)\n\n variable_label = \"\"\n size = run.orig.settings.get('size', None)\n if size is not None:\n variable_label = \" (n=%d)\" % size\n\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\n label=\"U-Sphere%s\" % variable_label)\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\n label=u\"Klasični usmerjevalni protokol%s\" % variable_label)\n\n ax.set_xlabel('Obremenjenost povezave')\n ax.set_ylabel('Kumulativna verjetnost')\n ax.grid()\n ax.axis((28, None, 0.99, 1.0005))\n self.convert_axes_to_bw(ax)\n\n legend = ax.legend(loc='lower right')\n if self.settings.GRAPH_TRANSPARENCY:\n legend.get_frame().set_alpha(0.8)\n fig.savefig(self.get_figure_filename())","def continuous_plot(iterations, grn):\n width, height = size = (600,600)\n screen = pygame.display.set_mode(size)\n # order the colors for the TF andP proteins\n colors = []\n conc_list = []\n extra_up, extra_down = False, False\n\n for gene in grn.genes:\n \n if gene.gene_type == \"TF\":\n colors.append((0, 0, 255))\n elif gene.gene_type == \"P\":\n colors.append((0, 255, 0))\n elif gene.gene_type == \"EXTRA\":\n colors.append((255,0,0))\n prev_extra = 600-(gene.concentration * 600)\n\n conc_list.append(600-(gene.concentration * 600))\n\n # add variables for user input\n\n for i in range(iterations):\n #check for keypress\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n pygame.quit()\n sys.exit()\n elif event.type == pygame.KEYDOWN:\n if pygame.key.get_pressed()[pygame.K_UP]:\n extra_up = True\n if pygame.key.get_pressed()[pygame.K_DOWN]:\n extra_down = True\n elif event.type == pygame.KEYUP:\n extra_up, extra_down = False, False\n if extra_up: \n grn.change_extra(0.01)\n if extra_down: \n grn.change_extra(-0.01)\n #run grn and get protein concentration\n results = grn.regulate_matrix(2, False)\n scaled = [int(600-(x * 600)) for x in results]\n old_conc = conc_list\n conc_list = scaled\n \n for idx, conc in enumerate(conc_list):\n pygame.draw.line(screen, colors[idx], \n (width-3, old_conc[idx]), \n (width-2, conc))\n\n # if draw_extra:\n # pygame.draw.line(screen, colors[-1], \n # (width-3, 600-prev_extra-1), \n # (width-2, 600-extra))\n\n pygame.display.flip()\n #screen.blit(screen, (-1, 0))\n screen.scroll(-1,0)\n pygame.time.wait(5)","def plot_model(self):\n \n plt.figure(figsize=[10,5])\n \n plt.scatter(self.receivers['recxs'],self.receivers['reczs'],marker='v')\n if self.source['src_type']==4:\n from obspy.imaging.beachball import beach\n beach = beach(self.source['mt'], xy=(self.source['srcx'],self.source['srcz']), width=self.model_parameters['xmax']*0.05)\n ax = plt.gca()\n \n ax.add_collection(beach) \n ax.set_aspect(\"equal\")\n \n else:\n plt.scatter(self.source['srcx'],self.source['srcz'],marker='*',color='r',s=200)\n \n plt.axhline(y=0,c='0.5')\n plt.xlim(0,self.model_parameters['xmax'])\n plt.ylim(self.model_parameters['zmax'],-0.1*self.model_parameters['zmax'])\n \n plt.xlabel('Distance (km)')\n plt.ylabel('Depth (km)')\n plt.grid()\n plt.show()","def visualize_network_samples_grid_1D(net, start=5, stop=100, step=10,\n f_ext=\"pdf\"):\n save_dir = make_memnet_checkpoint_dir(\n Path(\"plots/vis_memnet_samples/grid/\"), net)\n if not save_dir.exists():\n save_dir.makedirs()\n relevant_vals = range(start, stop, step)\n grid_width = len(relevant_vals)\n print(\"Loading plants.\")\n inputs0, stim_vals0 = load_plants(\n net.image_width,\n net.trainingset_dir,\n layer_type=net.layer_type,\n normalize=True)\n inputs0 = inputs0 / 255. # Normalize\n print(\"Finished.\")\n irrelevant_dim = int(net.input_distribution_dim == 0)\n if irrelevant_dim == 0:\n inds = list(product([50], relevant_vals))\n else:\n inds = list(product(relevant_vals, [50]))\n inputs_valid = inputs0[stim_vals0[:, irrelevant_dim] == 50]\n stim_vals = stim_vals0[stim_vals0[:, irrelevant_dim] == 50]\n fig, axes = plt.subplots(\n 1, grid_width, figsize=(50, 50 / len(relevant_vals)))\n preds = []\n inputs = []\n print(\"Making plots...\")\n for i in range(len(stim_vals)):\n if tuple(stim_vals[i]) in inds:\n print(\"Making \", stim_vals[i])\n inputs.append(inputs_valid[i])\n preds = net.predict(inputs, keep_session=True)\n for i in range(len(preds)):\n ax = axes[i]\n ax.imshow(\n preds[i:i + 1].reshape(net.image_width, net.image_width),\n cmap=\"gray_r\")\n ax.set_xticklabels(\"\")\n ax.set_xticks([])\n ax.set_xticklabels(\"\")\n ax.set_yticks([])\n ax.set_yticklabels(\"\")\n plt.savefig(save_dir.joinpath('grid.' + f_ext))\n print(\"Saved to \", save_dir.joinpath('grid.' + f_ext))\n return","def visualize_scan(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n ax.scatter(self.p1_points[:, 0], self.p1_points[:, 1], self.p1_points[:, 2], c='r')\n ax.scatter(self.p2_points[:, 0], self.p2_points[:, 1], self.p2_points[:, 2], c='g')\n ax.scatter(self.p3_points[:, 0], self.p3_points[:, 1], self.p3_points[:, 2], c='b')\n ax.scatter(self.p4_points[:, 0], self.p4_points[:, 1], self.p4_points[:, 2])\n\n ax.set_xlabel('x')\n ax.set_ylabel('y')\n ax.set_zlabel('z')\n plt.show()","def visualize_flow(flow, mode='Y'):\n if mode == 'Y':\n # Ccbcr color wheel\n img = flow_to_image(flow)\n plt.imshow(img)\n plt.show()\n elif mode == 'RGB':\n (h, w) = flow.shape[0:2]\n du = flow[:, :, 0]\n dv = flow[:, :, 1]\n valid = flow[:, :, 2]\n max_flow = max(np.max(du), np.max(dv))\n img = np.zeros((h, w, 3), dtype=np.float64)\n # angle layer\n img[:, :, 0] = np.arctan2(dv, du) / (2 * np.pi)\n # magnitude layer, normalized to 1\n img[:, :, 1] = np.sqrt(du * du + dv * dv) * 8 / max_flow\n # phase layer\n img[:, :, 2] = 8 - img[:, :, 1]\n # clip to [0,1]\n small_idx = img[:, :, 0:3] < 0\n large_idx = img[:, :, 0:3] > 1\n img[small_idx] = 0\n img[large_idx] = 1\n # convert to rgb\n img = cl.hsv_to_rgb(img)\n # remove invalid point\n img[:, :, 0] = img[:, :, 0] * valid\n img[:, :, 1] = img[:, :, 1] * valid\n img[:, :, 2] = img[:, :, 2] * valid\n # show\n plt.imshow(img)\n plt.show()\n\n return None","def plot(self):\n\t\tself.plotOfLoopVoltage()","def _DoUpdatePlot( self, wd, ht ):\n self.ax.grid(\n True, 'both', 'both',\n\tcolor = '#c8c8c8', linestyle = ':', linewidth = 1\n\t)","def make_grid(self):\n for k in range(0, NUM + 1):\n self.create_line(k * UNIT, 0, k * UNIT, SIZE, width=THICKNESS)\n self.create_line(0, k * UNIT, SIZE, k * UNIT, width=THICKNESS)","def draw_grid(self) -> None:\n for x in range(0, WIDTH, TILE_SIZE):\n pg.draw.line(self.screen, LIGHT_GREY, (x, INFO_HEIGHT), (x, HEIGHT))\n for y in range(INFO_HEIGHT, INFO_HEIGHT + HEIGHT, TILE_SIZE):\n pg.draw.line(self.screen, LIGHT_GREY, (0, y), (WIDTH, y))","def show_flow(filename):\n flow = read_flow(filename)\n img = flow_to_image(flow)\n plt.imshow(img)\n plt.show()","def plot(self, x, fname=None):\n logger.debug('plotting inducing grid')\n assert np.all(self.grid_sub_dim == 1), \"only works when grid dims are 1d\"\n import matplotlib\n if fname is not None:\n matplotlib.use('Agg')\n from matplotlib.backends.backend_pdf import PdfPages\n matplotlib.rcParams.update({'font.size': 10})\n import matplotlib.pyplot as plt\n def plot1dim(i_dim):\n \"\"\" function for ploting one grid dimension\"\"\"\n freq = plt.hist(x=x[:,i_dim], bins=min(100,4*self.grid_shape[i_dim]))[0]\n plt.plot(self.xg[i_dim][:,0],np.zeros(self.grid_shape[i_dim]) + 0.5*np.max(freq),'ko',markersize=3)\n plt.xlabel(r'x_%d'%i_dim)\n plt.ylabel('Frequency')\n plt.title('Dim %d, m = %d' % (i_dim, self.grid_shape[i_dim]))\n\n # now loop through and plot\n if fname is None: # then plot to screen\n plt.figure(figsize=(4,4*self.grid_dim))\n for i in range(self.grid_dim):\n plt.subplot(self.grid_dim,1,i+1)\n plot1dim(i_dim=i)\n plt.suptitle('Inducing Grid and Train Point Dist.')\n plt.show(block=False)\n else: # save to file\n with PdfPages(fname) as pdf:\n for i in range(self.grid_dim):\n plt.figure(figsize=(4,4))\n plot1dim(i_dim=i)\n pdf.savefig()\n plt.close()","def debugplots(fig,data):\n grid = AxesGrid(fig, 111, # similar to subplot(142)\n nrows_ncols=(1, 6),\n axes_pad=0.0,\n share_all=True,\n label_mode=\"L\",\n cbar_location=\"right\",\n cbar_mode=\"none\",\n )\n\n Z0=data[0].real\n Z1=data[1].real\n Z2=data[2].real\n Z3=data[3].real\n Z4=data[4].real\n Z5=data[5].real\n \n Z=[Z0,Z1,Z2,Z3,Z4,Z5]\n \n for i in range(6):\n grid[i].set_title(r\"$t=%u\\Delta t$\"%(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\n im = grid[i].imshow(Z[i], extent=(-2, 2, -2, 2), interpolation=\"Nearest\",origin=\"lower\",cmap='seismic',vmin=-1,vmax=1)\n grid[i].set_aspect(ratio)\n grid[i].set_xlabel(\"$x/10$\",size=16)\n grid[0].set_ylabel(\"$y/10$\",size=16)\n pos2 = [0.905,0.25,0.01,0.5]\n position = fig.add_axes(pos2)\n fig.colorbar(im, ax=grid[2],cax=position,extend=\"both\")\n \n for cax in grid.cbar_axes:\n cax.toggle_label(True)\n \n # This affects all axes as share_all = True.\n grid.axes_llc.set_xticks([-2,-1, 0,1])\n #grid[0].set_xticks([-20,-10, 0,10, 20])\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])","def show_filters(self):\n w_mat = np.transpose(self.sess.run(self.W_fc1))\n\n plt.figure(figsize=(10,10), facecolor='w', edgecolor='w')\n plot_positions = [(0,0),(0,1),(1,0),(1,1)]\n for ch in range(self.n_input_channels):\n grid,_ = ia.image_grid_RGB( w_mat,\n n_channels=self.n_input_channels,\n image_size=(self.y_res,self.x_res), n_x=6, n_y=6,\n channel_order=(ch,ch,ch), amplitude_scaling=(1,1,1),\n line_color=1, auto_scale=True, return_borders=False )\n colormax = np.abs(grid).max()\n with sns.axes_style(\"white\"):\n ax = plt.subplot2grid( (2,2), plot_positions[ch] )\n ax.imshow( grid[:,:,0], interpolation='nearest',\n cmap=plt.get_cmap('seismic'),\n clim=(-1*colormax,colormax) )\n ax.set_title(\"Hidden units, channel {}\".format(ch))\n plt.axis('tight')\n plt.axis('off')\n plt.tight_layout()","def plot(self, transform=None, label=None, style='hull', autoscale=True,\n zorder=None, ax=None, figsize=None, fc='gray'):\n if style.lower() not in ['hull', 'scatter', 'cell']:\n raise ValueError(f'Unknown plotting style \"{style}\". Choose from: '\n f'\"hull\", \"scatter\", \"cell\"')\n if ax is None:\n ax = plt.gca()\n if figsize is not None:\n ax.figure.set_size_inches(figsize)\n ax.set_aspect('equal')\n if autoscale:\n ax.autoscale(True)\n if zorder is None:\n zorder = ZORDER['background']\n\n x, y = self.x, self.y\n try:\n # Step might be a tuple:\n x_step, y_step = self.step\n except TypeError:\n x_step = self.step\n y_step = self.step\n\n if style.lower() == 'cell':\n # Show a polygon for every grid cell that we are simulating:\n if self.type == 'hexagonal':\n raise NotImplementedError\n patches = []\n for xret, yret in zip(x.ravel(), y.ravel()):\n # Outlines of the cell are given by (x,y) and the step size:\n vertices = np.array([\n [xret - x_step / 2, yret - y_step / 2],\n [xret - x_step / 2, yret + y_step / 2],\n [xret + x_step / 2, yret + y_step / 2],\n [xret + x_step / 2, yret - y_step / 2],\n ])\n if transform is not None:\n vertices = np.array(transform(*vertices.T)).T\n patches.append(Polygon(vertices, alpha=0.3, ec='k', fc=fc,\n ls='--', zorder=zorder))\n ax.add_collection(PatchCollection(patches, match_original=True,\n zorder=zorder, label=label))\n else:\n # Show either the convex hull or a scatter plot:\n if transform is not None:\n x, y = transform(self.x, self.y)\n points = np.vstack((x.ravel(), y.ravel()))\n # Remove NaN values from the grid:\n points = points[:, ~np.logical_or(*np.isnan(points))]\n if style.lower() == 'hull':\n hull = ConvexHull(points.T)\n ax.add_patch(Polygon(points[:, hull.vertices].T, alpha=0.3, ec='k',\n fc=fc, ls='--', zorder=zorder, label=label))\n elif style.lower() == 'scatter':\n ax.scatter(*points, alpha=0.3, ec=fc, color=fc, marker='+',\n zorder=zorder, label=label)\n # This is needed in MPL 3.0.X to set the axis limit correctly:\n ax.autoscale_view()\n return ax","def tiled_plot(self, stims):\n nstim = stims.shape[0]\n plotrows = int(np.sqrt(nstim))\n plotcols = int(np.ceil(nstim/plotrows))\n f, axes = plt.subplots(plotrows, plotcols, sharex=True, sharey=True)\n for ii in range(nstim):\n axes.flatten()[ii].plot(stims[ii])\n f.subplots_adjust(hspace=0, wspace=0)\n plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)\n plt.setp([a.get_yticklabels() for a in f.axes[:-1]], visible=False)","def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()","def plot(self):\n # Find only unmasked data :\n # xyz, sData, sColor, _ = self._select_unmasked()\n xyz, sData, sColor = self.xyz, self.sData, self.sColor\n\n # Render as cloud points :\n self.mesh = visu.Markers(name='Sources')\n self.mesh.set_data(xyz, edge_color=self.edgecolor, face_color=sColor,\n size=sData, scaling=self.scaling,\n edge_width=self.edgewidth, symbol=self.symbol)\n self.mesh.set_gl_state('translucent')","def mesh_grid(self,width,height):\n # get\n \n x_linspace=tf.linspace(-self.cx_,1-self.cx_,width)\n y_linspace=tf.linspace(-self.cy_,1-self.cy_,height)\n \n# x_cord,y_cord=tf.meshgrid(x_linspace,y_linspace)\n y_cord,x_cord=tf.meshgrid(y_linspace,x_linspace)\n \n \n x_cord=tf.reshape(x_cord,[-1])\n y_cord=tf.reshape(y_cord,[-1])\n \n f_=tf.ones_like(x_cord)\n \n x_=tf.div(x_cord,self.cf)\n y_=tf.div(y_cord,self.cf)\n \n grid=tf.concat([x_,y_,f_],0)\n return grid","def plot(self):\n layout = self.graph.layout(\"kk\")\n bbox = igraph.BoundingBox(600, 600)\n figure = igraph.Plot(bbox=bbox, background=\"white\")\n bbox = bbox.contract(100)\n figure.add(self.graph, layout = layout, bbox=bbox)\n figure.show()","def plot_graph(self):\r\n A = self.a_grid ; V = self.V1 ; Pol = self.Pol\r\n A_opt = A[Pol.astype(int)]\r\n \r\n fig = plt.subplots(figsize = (8,5))\r\n ax = [None,None]\r\n pltgrid = (1,2)\r\n \r\n ax[0] = plt.subplot2grid(pltgrid, (0,0))\r\n ax[1] = plt.subplot2grid(pltgrid, (0,1))\r\n \r\n ax[0].plot(A[:],V[:,0,0], linewidth = 2, color = 'blue', label = r'$V(a)$: Low $w$')\r\n ax[0].plot(A[:],V[:,0,5], linewidth = 2, color = 'green', label = r'$V(a)$: Median $w$')\r\n ax[0].plot(A[:],V[:,0,-1], linewidth = 2, color = 'red', label = r'$V(a)$: High $w$')\r\n \r\n ax[1].plot(A[:],A_opt[:,0,0], linewidth = 2, color = 'blue', label = r'$a\\'(a)$: Low $w$')\r\n ax[1].plot(A[:],A_opt[:,0,5], linewidth = 2, color = 'green', label = r'$a\\'(a)$: Median $w$')\r\n ax[1].plot(A[:],A_opt[:,0,-1], linewidth = 2, color = 'red', label = r'$a\\'(a)$: High $w$')\r\n ax[1].plot(A[:],A[:], linewidth = 2, color = 'violet', linestyle = 'dashed', zorder = 1)\r\n \r\n \r\n ax[0].set_xlabel(r'$a$') ; ax[0].legend()\r\n ax[1].set_xlabel(r'$a$') ; ax[1].legend()\r\n ax[0].set_title('Value function')\r\n ax[1].set_title('Asset policy')\r\n \r\n plt.tight_layout()\r\n plt.show()","def plot(self):\n self.fig = plt.figure('black hole')\n self.fig.clf() #clear the graph to avoir superposing data from the same set (can be deactivated if need to superpose)\n self.ax = plt.subplot()\n\n if self.img2 is not None:\n self.ax.imshow(self.img2)\n else:\n print(\"No black hole deformation in the memory, displayed the original image instead.\")\n self.ax.imshow(self.img_debut)\n\n self.fig.canvas.set_window_title('Black hole')\n self.ax.set_title(\"scrool to zoom in or out \\nright click to add an offset in the background \\nleft click to refresh image \\n close the option windows to stop the program\")\n self.fig.canvas.mpl_connect('scroll_event', self.onscroll)\n self.fig.canvas.mpl_connect('button_press_event', self.onclick)\n self.fig.canvas.mpl_connect('axes_leave_event', self.disconnect)\n self.fig.canvas.mpl_connect('axes_enter_event', self.connect)\n\n self.draw()","def plot_1d_systems(model):\n\n # Construct grid to evaluate the Green's function\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\n x_G_star = X_G.flatten()[:, None]\n y_G_star = Y_G.flatten()[:, None]\n\n # Create the figure\n n_plots = max(model.n_input + 1, model.n_output)\n scaling = n_plots / 2\n fig, ax = newfig(1.0 * scaling, 1.5)\n ax.axis('off')\n gs = gridspec.GridSpec(n_plots, n_plots)\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9,\n wspace=0.6 * scaling, hspace=0.6 * scaling)\n\n # Plot the Green's functions\n for i in range(model.n_output):\n for j in range(model.n_input):\n input_data = np.concatenate((x_G_star, y_G_star), 1)\n G_pred_identifier = model.sess.run(\n model.G_network[i][j].evaluate(input_data))\n G_pred = G_pred_identifier.reshape(X_G.shape)\n ax = plt.subplot(gs[i, j])\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\n model.y_G), np.max(model.y_G)],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('$G_{%d,%d}$' % (i + 1, j + 1), fontsize=10)\n\n # Plot the homogeneous solutions\n for i in range(model.n_output):\n N_pred = model.sess.run(model.idn_N_pred[i].evaluate(model.x))\n ax = plt.subplot(gs[i, model.n_input])\n ax.plot(model.x, model.U_hom[:, i], label='Exact')\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\n divider = make_axes_locatable(ax)\n ymin = min([np.min(N_pred), np.min(model.U_hom[:, i])])\n ymax = max([np.max(N_pred), np.max(model.U_hom[:, i])])\n ax.set_xlim(np.min(model.x), np.max(model.x))\n ax.set_ylim(ymin, ymax)\n if ymax - ymin < 1e-2:\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\"%1.1e\"))\n ax.set_xlabel('$x$')\n ax.set_title('Hom$_{%d}$' % (i + 1), fontsize=10)\n ax.legend()\n\n # Save the figure\n savefig(\"%s/%s_%s\" % (model.path_result, model.example_name,\n model.activation_name), crop=False)","def _plot(self, step, rewards, losses):\n plt.figure(figsize=(20, 5))\n plt.subplot(131)\n plt.title('Total Episode Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('MSE Loss')\n plt.plot(losses)\n plt.show()","def _plot_arm(self):\n fig, axs = plt.subplots()\n fig.show()\n axs.cla()\n axs.axis([-1, 2.5, -1, 2.5])\n axs.plot([0], [0], 'o')\n config_plots = []\n for t_step in range(0, int(self._t_sim / self._dt) + 1, 1000):\n axs.plot([0, self._x_1[t_step]], [0, self._y_1[t_step]])\n axs.plot(self._x_1[t_step], self._y_1[t_step], 'o')\n axs.plot(\n [self._x_1[t_step], self._x_2[t_step]],\n [self._y_1[t_step], self._y_2[t_step]]\n )\n axs.plot(self._x_2[t_step], self._y_2[t_step], 'o')\n axs.plot(\n [self._x_2[t_step], self._x_e[t_step]],\n [self._y_2[t_step], self._y_e[t_step]]\n )\n axs.plot(self._x_e[t_step], self._y_e[t_step], 'ro')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 0],\n self._obj_coords_plot[t_step, 1, 0], 'g+')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 1],\n self._obj_coords_plot[t_step, 1, 1], 'g.')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 2],\n self._obj_coords_plot[t_step, 1, 2], 'g.')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 3],\n self._obj_coords_plot[t_step, 1, 3], 'g.')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 4],\n self._obj_coords_plot[t_step, 1, 4], 'g.')\n plt.axis('off')\n plt.pause(1 / self._plot_fps)\n fig.canvas.draw()\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n config_plots.append(image.reshape(\n fig.canvas.get_width_height()[::-1] + (3, )))\n\n # Draw and create image\n return config_plots","def draw(self):\n\n super().draw()\n \n self.dim = self.getdim()\n start_x, start_y, = self.x(), self.y()\n\n for y in range(self.r):\n for x in range(self.c):\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\n self.tiles[y][x].resize(x_pos, y_pos, self.dim, self.dim)","def plot(self):\n\t\tself.plotOfCos1().plot()","def force_draw(self):\n import matplotlib.pyplot as plt\n\n plt.show()","def plot_desired_velocity(self,id=1,dpi=150):\n fig = plt.figure(id)\n ax1 = fig.add_subplot(111)\n ax1.imshow(self.image,interpolation='nearest',\n extent=[self.xmin,self.xmax,self.ymin,self.ymax], origin='lower')\n ax1.imshow(self.door_distance,interpolation='nearest',\n extent=[self.xmin,self.xmax,self.ymin,self.ymax],alpha=0.7,\n origin='lower')\n step = 10\n ax1.quiver(self.X[::step, ::step],self.Y[::step, ::step],\n self.desired_velocity_X[::step, ::step],\n self.desired_velocity_Y[::step, ::step])\n #plt.savefig('.png',dpi=dpi)\n plt.draw()","def _setFig(self):\n self.p.background_fill_color = grey['light']\n self.p.xgrid.grid_line_color = None\n self.p.ygrid.grid_line_color = None\n self.p.ygrid.grid_line_dash = 'dotted'\n self.p.ygrid.grid_line_dash = 'dotted'\n\n self.p.xgrid.minor_grid_line_color = grey['median']\n self.p.ygrid.minor_grid_line_color = grey['median']\n self.p.xgrid.minor_grid_line_dash = 'dotted'\n self.p.ygrid.minor_grid_line_dash = 'dotted'\n\n self.p.xaxis.axis_label = \"tsne_feature_0\"\n self.p.yaxis.axis_label = \"tsne_feature_1\"","def plot_velocity(self):\n \n plt.figure(figsize=[2,6])\n plt.plot(self.velocity_model['vp'],self.velocity_model['depth'],'r',label='vp')\n plt.plot(self.velocity_model['vs'],self.velocity_model['depth'],'b',label='vs')\n\n plt.ylim(np.max(self.velocity_model['depth']),np.min(self.velocity_model['depth']))\n \n plt.xlabel('Velocity (km/s)')\n plt.ylabel('Depth (km)')\n plt.legend()\n plt.grid()\n plt.show()","def tiledplot(self, stims):\r\n nstim = stims.shape[0]\r\n plotrows = int(np.sqrt(nstim))\r\n plotcols = int(np.ceil(nstim/plotrows))\r\n f, axes = plt.subplots(plotrows, plotcols, sharex=True, sharey=True)\r\n for ii in range(nstim):\r\n axes.flatten()[ii].plot(stims[ii])\r\n f.subplots_adjust(hspace=0, wspace=0)\r\n plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)\r\n plt.setp([a.get_yticklabels() for a in f.axes[:-1]], visible=False)"],"string":"[\n \"def show_grid(frame, episode_nr):\\n plt.grid('on')\\n ax = plt.gca()\\n ax.set_xticks(np.arange(0.5, 10, 1))\\n ax.set_yticks(np.arange(0.5, 10, 1))\\n ax.set_xticklabels([])\\n ax.set_yticklabels([])\\n ax.imshow(frame, cmap='binary')\\n ax.set_title(\\\"Episode {}\\\".format(episode_nr))\\n plt.pause(0.01)\\n plt.clf()\",\n \"def plot_flow(x, y, u, v, ax, flow_type, units, regrid_shape=40,\\n thin_quivers=None, quiver_length=1.0, palette='YlGnBu', colour='0.8', \\n plot_magnitude=False, colour_bounds=None):\\n\\n if type(u) == numpy.ma.core.MaskedArray:\\n u = u.filled(numpy.nan)\\n v = v.filled(numpy.nan)\\n\\n assert flow_type in ['streamlines', 'quivers']\\n\\n if colour_bounds:\\n vmin, vmax = colour_bounds\\n norm = matplotlib.colors.Normalize(vmin=0, vmax=30)\\n else:\\n norm = None\\n\\n if flow_type == 'streamlines' and plot_magnitude:\\n magnitude = (u ** 2 + v ** 2) ** 0.5\\n cmap = get_palette(palette)\\n ax.streamplot(x, y, u, v, transform=ccrs.PlateCarree(),\\n color=magnitude, cmap=cmap, norm=norm) #linewidth=2, density=2\\n elif flow_type == 'streamlines':\\n ax.streamplot(x, y, u, v, transform=ccrs.PlateCarree(), color=colour)\\n elif flow_type == 'quivers':\\n if thin_quivers:\\n qplot = ax.quiver(x[::thin_quivers], y[::thin_quivers],\\n u[::thin_quivers, ::thin_quivers], v[::thin_quivers, ::thin_quivers],\\n transform=ccrs.PlateCarree()) \\n else: \\n qplot = ax.quiver(x, y, u, v, transform=ccrs.PlateCarree(), regrid_shape=regrid_shape, color=colour)\\n #regrid_shape seems to problematic for a simple PlateCarree plot (i.e. no transform) \\n\\n label = str(quiver_length) + ' ' + str(units)\\n ax.quiverkey(qplot, 0.95, 1.02, quiver_length, label, labelpos='W')\",\n \"def draw_grid(self):\\n plt.imshow(py.array(\\n map(lambda x: map(lambda y: mplc.colorConverter.to_rgb(colord[y]), x), self.create_grid(self.graph))),\\n interpolation='nearest')\\n plt.show()\",\n \"def plot_outputgrid(self, scalefactor=1, **kwargs):\\n\\n if not (type(scalefactor) == 'int'):\\n scalefactor = round(scalefactor)\\n\\n xx = np.arange(self.xori, self.xend, scalefactor * self.dx)\\n yy = np.arange(self.yori, self.yend, scalefactor * self.dy)\\n plt.hlines(yy, self.xori, self.xend, linewidth=0.2, **kwargs)\\n plt.vlines(xx, self.yori, self.yend, linewidth=0.2, **kwargs)\\n\\n logger.debug('Adding output grid to plot')\",\n \"def show_grid(self):\\n for ax in (self.time_velocity, self.time_power, self.power_velocity):\\n ax.grid(True)\",\n \"def SimpleFlowMapPlotHelper(self,filename,grid_type,log_max=4):\\n flowmap_object = iodriver.load_field(filename,\\n file_type=iodriver.get_file_extension(filename),\\n field_type='Generic',\\n grid_type=grid_type)\\n flowmap = flowmap_object.get_data()\\n plt.figure()\\n plt.subplot(111)\\n if log_max == 0:\\n log_max = math.log(np.amax(flowmap))\\n levels = np.logspace(0,log_max,num=50)\\n #ctrs = plt.contourf(flowmap,levels=levels,norm=colors.LogNorm())\\n #plt.contourf(flowmap,levels=levels,norm=colors.LogNorm())\\n plt.contourf(flowmap,levels=levels)\\n #cbar = plt.colorbar(ctrs)\\n cbar = plt.colorbar()\\n cbar.ax.set_ylabel('Number of cells flowing to cell')\\n pts.set_ticks_to_zero()\\n if self.save:\\n #plt.savefig('')\\n pass\",\n \"def plotgrid(data,d=10,shape=(30,30)):\\n ion()\\n gray()\\n clf()\\n for i in range(min(d*d,len(data))):\\n subplot(d,d,i+1)\\n row = data[i]\\n if shape is not None: row = row.reshape(shape)\\n imshow(row)\\n ginput(1,timeout=0.1)\",\n \"def render(self, mode = 'human'):\\n if mode == 'human':\\n\\n if self.is_2d:\\n fig = plt.figure()\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n plt.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n plt.scatter(*index, c='blue', s=1000, alpha=0.2)\\n plt.xlim(-1, self.dim[0])\\n plt.ylim(-1, self.dim[1])\\n plt.xticks([])\\n plt.yticks([])\\n plt.grid(True)\\n\\n if self.is_3d:\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\\n ax.set_xlim(0, self.dim[0] - 1)\\n ax.set_ylim(0, self.dim[1] - 1)\\n ax.set_zlim(0, self.dim[2] - 1)\\n\\n else:\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\\n\\n ax.set_xlim(0, self.dim[0] - 1)\\n ax.set_ylim(0, self.dim[1] - 1)\\n ax.set_zlim(0, self.dim[2] - 1)\\n ax.set_title('Nr of steps: ' + str(self.steps))\\n\\n plt.show()\\n return fig\",\n \"def plot(self):\\n R = self.length\\n\\n plt.figure()\\n for ii, car in enumerate(self.cars):\\n theta = self.positions[ii] + car.position\\n x = R * np.cos(theta)\\n y = R * np.sin(theta)\\n if ii == 0:\\n plt.scatter(x, y, marker='x')\\n else:\\n plt.scatter(x, y)\\n\\n plt.axis('scaled')\\n lim = (-1.2 * R, 1.2 * R)\\n plt.ylim(lim)\\n plt.xlim(lim)\\n plt.savefig('traffic_{:d}.png'.format(self.time))\\n plt.close()\",\n \"def drawGrid(self):\\n for div in range(NBCELL):\\n sec = SSIZE*div\\n self.can.create_line(0, sec, GSIZE, sec, width=3, fill=GFILL)\\n self.can.create_line(sec, 0, sec, GSIZE, width=3, fill=GFILL)\",\n \"def plot_graph(self) -> None:\",\n \"def coordPlt(grid, buffer=10, step=5):\\n plt.cla()\\n\\n plt.plot(grid[1][0::step, 0::step],\\n grid[0][0::step, 0::step],\\n '.-b' )\\n\\n plt.plot(grid[1][0::step, 0::step].T,\\n grid[0][0::step, 0::step].T,\\n '.-b' )\\n\\n plt.axis( [ grid[1].max() + buffer,\\n grid[1].min() - buffer,\\n grid[0].max() + buffer,\\n grid[0].min() - buffer],\\n )\\n plt.axis('off')\\n plt.grid()\",\n \"def scree_plot(self, ev):\\n plt.scatter(range(1,len(ev)+1), ev)\\n plt.plot(range(1,len(ev)+1), ev)\\n plt.title(\\\"Scree Plot\\\")\\n plt.xlabel(\\\"Factors\\\")\\n plt.ylabel(\\\"Eigenvalue\\\")\\n plt.grid()\\n plt.show()\",\n \"def grid_frame(self, steps, figure_size=(12, 12)):\\r\\n\\r\\n x = self.seed\\r\\n counts = []\\r\\n for n in np.arange(0, steps):\\r\\n x, stats = self.update_grid(x)\\r\\n counts.append(stats)\\r\\n\\r\\n counts = np.array(counts)\\r\\n\\r\\n fig, ax = plt.subplots(figsize=figure_size)\\r\\n ax.get_xaxis().set_visible(False)\\r\\n ax.get_yaxis().set_visible(False)\\r\\n color_map = matplotlib.colors.ListedColormap(['white', 'black'])\\r\\n img = plt.imshow(x, interpolation='nearest', cmap=color_map)\\r\\n img.axes.grid(False)\\r\\n plt.title(self.title + ' | Step ' + str(steps))\\r\\n plt.show()\\r\\n\\r\\n return x, counts\",\n \"def plot(self):\\n pass\",\n \"def _plot_grid(frames: Figure, ncols: int = 3) -> Figure:\\n for frame in frames:\\n frame.plot_height = frame.plot_height // ncols\\n frame.plot_width = frame.plot_width // ncols\\n return gridplot(frames, ncols=ncols)\",\n \"def show_plot() :\\n logger.info(\\\"Show plot\\\")\\n pylab.axis('equal')\\n pylab.xlabel(\\\"Longitud\\\")\\n pylab.ylabel(\\\"Latitud\\\")\\n pylab.grid(True)\\n pylab.title(\\\"Product tiles and product source\\\")\\n pylab.show()\",\n \"def plot_plasma(self):\\n x = self.geom.x\\n fig, axes = plt.subplots(1, 2, figsize=(8, 3),\\n constrained_layout=True)\\n # plot densities\\n ax = axes[0]\\n ax.plot(x, self.ne, 'b-')\\n ax.plot(x, self.ni, 'r-')\\n ax.legend(['E', 'Ion'])\\n ax.set_xlabel('Position (m)')\\n ax.set_ylabel('Density (m^-3)')\\n # plot temperature\\n ax = axes[1]\\n ax.plot(x, self.Te, 'b-')\\n ax.plot(x, self.Ti, 'r-')\\n ax.legend(['Te', 'Ti'])\\n ax.set_xlabel('Position (m)')\\n ax.set_ylabel('Temperature (eV)')\\n plt.show()\",\n \"def display_game(self):\\n display = plt.figure()\\n\\n # Plots dots.\\n for dot in self.dots:\\n plt.scatter(dot.x + .5, dot.y + .5, color=dot.color, s=1000)\\n\\n # Makes a uniform grid,\\n axes = display.gca()\\n axes.set_aspect('equal', adjustable='box')\\n axes.set_xticks(np.arange(0, self.dimension + 1, 1))\\n axes.set_yticks(np.arange(0, self.dimension + 1, 1))\\n plt.grid(True, color=\\\"black\\\", linestyle=\\\"-\\\")\\n axes.set_xticklabels([])\\n axes.set_yticklabels([])\\n for tic in axes.xaxis.get_major_ticks():\\n tic.tick1On = tic.tick2On = False\\n for tic in axes.yaxis.get_major_ticks():\\n tic.tick1On = tic.tick2On = False\\n plt.show()\",\n \"def plot_slice(self,res):\\n x = np.linspace(0,1,res)\\n y = np.linspace(0,1,res)\\n X,Y = np.meshgrid(x,y)\\n plt.figure()\\n ax = plt.axes(projection = '3d')\\n ax.plot_surface(X,Y,abs(self.psi)[:,:,math.floor(res/2)])\\n plt.show()\",\n \"def plot_price_evolution_for_nr_run(nr_log):\\n plt.figure(figsize=(10, 5))\\n\\n plt.plot(nr_log['time'], nr_log['virtual_price'], '.', label='NR')\\n\\n plt.legend()\\n\\n plt.grid()\\n\\n plt.title('Network Relaxation run - Grid price evolution')\\n\\n plt.xlabel('time [s]')\\n\\n plt.ylabel('price [$]')\\n\\n plt.show()\",\n \"def plot(self):\\n\\t\\tself.plotOfTF().plot()\",\n \"def plot_graphon(graphon, resolution=1000):\\n labels = _np.linspace(0, 1, resolution)\\n heights = evaluate(graphon, labels)\\n _plt.matshow(heights, cmap=_plt.cm.gray_r, vmin=0, vmax=1)\\n ax = _plt.gca()\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\",\n \"def make_grid(self):\\n length = self.size / 8\\n # draw horizontal lines\\n for y in range(0, self.size, length):\\n self.window.create_line(0, y, self.size, y, fill = \\\"blue\\\")\\n \\n # draw vertical lines\\n for x in range(0, self.size, length):\\n self.window.create_line(x, 0, x, self.size, fill = \\\"blue\\\")\\n\\n # draw the axes red\\n self.window.create_line(\\n 0,\\n self.size / 2,\\n self.size, \\n self.size / 2, \\n fill = \\\"red\\\"\\n )\\n self.window.create_line(\\n self.size / 2, 0,\\n self.size / 2, \\n self.size, \\n fill = \\\"red\\\"\\n )\\n print(\\\"Grid Made.\\\")\",\n \"def plot_cost(self):\\n steps = np.arange(len(self.cost_values))\\n plt.plot(steps, self.cost_values, '-o')\\n plt.xlabel(\\\"Steps\\\")\\n plt.ylabel(\\\"Cost value\\\")\\n plt.title(\\\"Cost value per step using Gradient Descent\\\")\\n plt.show()\",\n \"def plot_grid(filename, title, names, x):\\n fig = plt.figure(figsize=(10,6))\\n ax = fig.add_subplot(111)\\n ax.set_title(title)\\n plt.imshow(x, interpolation=\\\"nearest\\\", cmap=plt.get_cmap(\\\"hot\\\"))\\n ax.set_aspect('equal')\\n plt.xticks(range(6), names, rotation='vertical')\\n plt.yticks(range(6), names)\\n plt.subplots_adjust(bottom=0.25)\\n # ax.set_xticklabels(('',) + names)\\n # ax.set_yticklabels(('',) + names)\\n cax = fig.add_axes([0.12, 0.1, 0.78, 0.8])\\n cax.get_xaxis().set_visible(False)\\n cax.get_yaxis().set_visible(False)\\n cax.patch.set_alpha(0)\\n cax.set_frame_on(False)\\n plt.colorbar(orientation='vertical')\\n plt.savefig(filename+\\\".pdf\\\")\\n fig.clear()\",\n \"def draw_grid(self):\\n for x in range(0, WIDTH, TILESIZE):\\n pg.draw.line(self.screen, LIGHTGREY, (x, 0), (x, HEIGHT))\\n \\n for y in range(0, HEIGHT, TILESIZE):\\n pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y))\",\n \"def plot_phase_diagram(self):\\n t_max = np.log(max(self.temperatures))\\n d_min = np.log(min(self.distortions))\\n y_axis = [np.log(i) - d_min for i in self.distortions]\\n x_axis = [t_max - np.log(i) for i in self.temperatures]\\n\\n plt.figure(figsize=(12, 9))\\n plt.plot(x_axis, y_axis)\\n\\n region = {}\\n for i, c in list(enumerate(self.n_eff_clusters)):\\n if c not in region:\\n region[c] = {}\\n region[c]['min'] = x_axis[i]\\n region[c]['max'] = x_axis[i]\\n for c in region:\\n if c == 0:\\n continue\\n plt.text((region[c]['min'] + region[c]['max']) / 2, 0.2,\\n 'K={}'.format(c), rotation=90)\\n plt.axvspan(region[c]['min'], region[c]['max'], color='C' + str(c),\\n alpha=0.2)\\n plt.title('Phases diagram (log)')\\n plt.xlabel('Temperature')\\n plt.ylabel('Distortion')\\n plt.show()\",\n \"def plot(self, x_unit='ft', y_unit='psi'):\\n\\n #Find the grid centers (where the solution exists)\\n x_pos = np.cumsum(self.dx_arr) - self.dx_arr[0] / 2.0\\n\\n #Loop over all stored solutions and plot stair-step line (because\\n #pressure is constant over grid block). We skip the first stored values\\n #because they are just the initialization values.\\n plt.figure()\\n for P in self.P_plot:\\n plt.plot(x_pos, P)\\n\\n #Labels, etc.\\n plt.xlabel('Reservoir position (' + x_unit + ')')\\n plt.ylabel('Pressure (' + y_unit + ')')\\n plt.xlim([0, self.res_length])\\n plt.show()\",\n \"def draw_plot(yscale='linear'):\\n plt.yscale(yscale)\\n plt.xticks(list(range(0, 101, 5)))\\n plt.xlabel('percentile [%]')\\n plt.grid(True)\\n plt.ylabel('operation time [ns]')\\n plt.legend()\\n plt.show()\",\n \"def fdplot(self, imx):\\n fig = plt.figure()\\n maxval = np.max(imx)\\n ims = list(map(lambda im: [plt.imshow(np.fabs(im),norm=colors.Normalize(0.0,maxval))], imx))\\n animation = anim.ArtistAnimation(fig,ims,interval=50)\\n plt.show()\",\n \"def plot(self):\\n self.plotsite()\\n self.plotbond()\\n plt.show()\",\n \"def visualize(self):\\n\\n check_is_fitted(self, \\\"sm_\\\")\\n\\n fig = plt.figure(figsize=(6, 4))\\n inner = gridspec.GridSpec(2, 1, hspace=0.1, height_ratios=[6, 1])\\n ax1_main = plt.Subplot(fig, inner[0]) \\n xgrid = np.linspace(self.xmin, self.xmax, 100).reshape([-1, 1])\\n ygrid = self.decision_function(xgrid)\\n ax1_main.plot(xgrid, ygrid)\\n ax1_main.set_xticklabels([])\\n ax1_main.set_title(\\\"Shape Function\\\", fontsize=12)\\n fig.add_subplot(ax1_main)\\n \\n ax1_density = plt.Subplot(fig, inner[1]) \\n xint = ((np.array(self.bins_[1:]) + np.array(self.bins_[:-1])) / 2).reshape([-1, 1]).reshape([-1])\\n ax1_density.bar(xint, self.density_, width=xint[1] - xint[0])\\n ax1_main.get_shared_x_axes().join(ax1_main, ax1_density)\\n ax1_density.set_yticklabels([])\\n ax1_density.autoscale()\\n fig.add_subplot(ax1_density)\\n plt.show()\",\n \"def vis_latent_space_abs(self):\\n gen_input = self.init_vec.detach().numpy()\\n\\n grid_x, grid_y = np.mgrid[-2:2:200j, -2:2:200j]\\n\\n gen_input = torch.tensor(\\n np.stack([grid_x.reshape(-1,), grid_y.reshape(-1,)], axis=1), requires_grad=False).float()\\n gen_output = self.generator(gen_input).detach().numpy()\\n\\n grid_color = griddata(gen_input, np.abs(gen_output[:, 1])-np.abs(gen_output[:, 0]),\\n (grid_x, grid_y), method='cubic')\\n\\n fig, ax = plt.subplots(figsize=(14, 12))\\n col = ax.imshow(grid_color.T, extent=(-2, 2, -2, 2))\\n plt.colorbar(col, label='|Y| - |X|')\\n plt.title(\\\"Latent Space coloring (Cross)\\\")\",\n \"def visualize_M_gridworld(self, state=0):\\n\\n\\t\\tplt.subplot(221); plt.imshow(self.M[12,0,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.subplot(222); plt.imshow(self.M[12,1,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.subplot(223); plt.imshow(self.M[12,2,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.subplot(224); plt.imshow(self.M[12,3,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.show()\",\n \"def draw_grid(G: 'Graph') -> None:\\n xgrid_precision = 5\\n ygrid_precision = 12\\n rounding = 3\\n for i in range(G.grid_lines):\\n pygame.draw.line(screen, black, (0, i * height//G.grid_lines),\\n (width, i * height//G.grid_lines), 1)\\n pygame.draw.line(screen, black, (i * width//G.grid_lines, 0),\\n (i * width//G.grid_lines, height), 1)\\n\\n for i in range(xgrid_precision):\\n x = G.dependant[round(i*len(G.dependant)/xgrid_precision)][0]\\n x = grid_coord(str(round(x, rounding)))\\n x_rec = x.get_rect()\\n x_rec.center = (i*width/xgrid_precision, height//2 + 10)\\n screen.blit(x, x_rec)\\n pygame.draw.line(screen, gray, (i*width/xgrid_precision, 0),\\n (i*width/xgrid_precision, height), 1)\\n\\n for i in range(ygrid_precision, 0, -1):\\n y = i*(G.ymin - G.ymax)/ygrid_precision + G.ymax\\n y = grid_coord(str(round(y, rounding)))\\n y_rec = y.get_rect()\\n y_rec.center = (width//2 + 8, i*height/ygrid_precision)\\n screen.blit(y, y_rec)\\n pygame.draw.line(screen, gray, (0, i*width/ygrid_precision),\\n (width, i*width/ygrid_precision), 1)\",\n \"def __init__(self, nx, ny, nxsize=5.4, nysize=6.2):\\n self.nx = nx\\n self.ny = ny\\n self.n = 1\\n plt.figure(figsize=(nysize*ny, nxsize*nx))\\n plt.subplot(nx, ny, self.n)\",\n \"def plotKinetic(self, phys, forces, step):\\r\\n self.plotQuantity(step, TopologyUtilities.kineticEnergy(phys.myTop, phys.velvec), 'kineticenergy')\",\n \"def create_grid(self):\\n\\n # initial point of the path\\n self.p0 = np.array([self.start_x, self.start_y])\\n self.pf = np.array([self.end_x, self.end_y]) # final point of the path\\n\\n self.l1 = np.linalg.norm(np.subtract(self.pf, self.p0))\\n self.l2 = 0.2 * self.l1\\n\\n # we define the 2 unit vectors self.d1 and self.d2 in which directions we are moving along\\n # then we apply to them the size of the desired displacement\\n self.d1 = np.subtract(self.pf, self.p0) / \\\\\\n (np.linalg.norm(np.subtract(self.pf, self.p0)))\\n\\n self.d2 = np.array([-self.d1[1], self.d1[0]])\\n self.d2 = self.d2/(np.linalg.norm(self.d2))\\n\\n # we create our grid moving with self.d1 and self.d2\\n # each point of the grid has the following properties:\\n # position, distance to self.d1, distance to self.pf, velocity\\n n_displacements_2 = 0\\n self.lines_list = []\\n\\n # variables for making easier the plotting afterwards\\n self.x_list_grid = []\\n self.y_list_grid = []\\n time_n = 1\\n\\n while True:\\n current_point = np.subtract(\\n self.p0, self.d2*(n_displacements_2*self.displacement))\\n current_length_2 = np.linalg.norm(\\n np.subtract(current_point, self.p0))\\n if current_length_2 > self.l2/2:\\n if time_n == 2:\\n break\\n else:\\n time_n += 1\\n self.lines_list = list(reversed(self.lines_list))\\n self.d2 = -1 * self.d2\\n n_displacements_2 = 1\\n current_point = np.subtract(\\n self.p0, self.d2*(n_displacements_2*self.displacement))\\n\\n line_points = []\\n self.x_list_grid.append(current_point[0])\\n self.y_list_grid.append(current_point[1])\\n\\n # TODO: add fish real prediction\\n line_points.append({\\n \\\"position\\\": current_point.tolist(),\\n \\\"distance_to_l1\\\": n_displacements_2*self.displacement,\\n \\\"distance_to_pf\\\": np.linalg.norm(np.subtract(self.pf, current_point)),\\n \\\"fish\\\": random.random()\\n })\\n\\n initial_point_1 = current_point\\n while True:\\n current_point = np.sum(\\n [current_point, self.d1 * self.displacement], axis=0)\\n current_length_1 = np.linalg.norm(\\n np.subtract(current_point, initial_point_1))\\n if current_length_1 >= self.l1:\\n current_point = self.pf - self.d2*n_displacements_2*self.displacement\\n self.x_list_grid.append(current_point[0])\\n self.y_list_grid.append(current_point[1])\\n # TODO: add fish real prediction\\n line_points.append({\\n \\\"position\\\": current_point.tolist(),\\n \\\"distance_to_l1\\\": n_displacements_2*self.displacement,\\n \\\"distance_to_pf\\\": np.linalg.norm(np.subtract(self.pf, current_point)),\\n \\\"fish\\\": random.random()\\n })\\n break\\n\\n self.x_list_grid.append(current_point[0])\\n self.y_list_grid.append(current_point[1])\\n\\n # TODO: add fish real prediction\\n line_points.append({\\n \\\"position\\\": current_point.tolist(),\\n \\\"distance_to_l1\\\": n_displacements_2*self.displacement,\\n \\\"distance_to_pf\\\": np.linalg.norm(np.subtract(self.pf, current_point)),\\n \\\"fish\\\": random.random()\\n })\\n\\n self.lines_list.append(line_points)\\n n_displacements_2 += 1\",\n \"def plot(self):\\n\\t\\tself.plotOfXray().plot()\",\n \"def plot_final_grid(generated_images):\\n\\n fig = plt.figure(figsize=(8, 6))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\\n\\n for ind in range(GRID_IMGS):\\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\\n\\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\\n plt.savefig('/content/drive/My Drive/WGAN/results/DCGAN.png')\\n plt.show()\",\n \"def plot_dynamic_system(f, nb_sub=10, ax=None, xlim=[-1, 1], ylim=[-1, 1], scale=0.01,\\n name=None, equal=False, **kwargs):\\n\\n Y, X = np.mgrid[ylim[0]:ylim[1]:complex(nb_sub), xlim[0]:xlim[\\n 1]:complex(nb_sub)]\\n mesh_data = np.vstack([X.ravel(), Y.ravel()])\\n\\n field = f(mesh_data.T).T\\n\\n U = field[0]\\n V = field[1]\\n U = U.reshape(nb_sub, nb_sub)\\n V = V.reshape(nb_sub, nb_sub)\\n speed = np.sqrt(U * U + V * V)\\n\\n if name is not None:\\n plt.suptitle(name)\\n\\n if ax is not None:\\n strm = ax.streamplot(X, Y, U, V, linewidth=scale * speed, **kwargs)\\n ax.set_xlim(xlim)\\n ax.set_ylim(ylim)\\n\\n if equal:\\n ax.set_aspect('equal')\\n\\n else:\\n strm = plt.streamplot(X, Y, U, V, linewidth=scale * speed, **kwargs)\\n plt.xlim(xlim)\\n plt.ylim(ylim)\\n\\n if equal:\\n plt.axes().set_aspect('equal')\\n\\n return [strm]\",\n \"def drawGrid(self,gridLines=True):\\n if not self.changed: self.edit()\\n cGrid = Fmap.GRID\\n cBorder = Fmap.BORDER\\n if gridLines: #--Some fools don't want the grid!\\n #--Grid\\n for uv in range(-25,26,5):\\n xy = 512/2 - 9*uv + 4\\n self.drawRect(cGrid,0,xy,512,xy+1)\\n self.drawRect(cGrid,xy,0,xy+1,512)\\n #--Grid axes\\n xy = 512/2 + 4\\n self.drawRect(cBorder,0,xy,512,xy+1)\\n self.drawRect(cBorder,xy,0,xy+1,512)\\n #--Border\\n self.drawBorder(cBorder,0,0,512,512,4)\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect().plot()\",\n \"def plot_final_grid(generated_images):\\n\\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\\n\\n for ind in range(GRID_IMGS):\\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\\n\\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\\n plt.savefig('/content/drive/My Drive/WGAN/results/WGAN.png')\\n plt.show()\",\n \"def show_image_grid(imgs):\\n grd = make_grid(imgs)\\n npimg = grd.numpy()\\n plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\\n plt.ion()\\n plt.show()\",\n \"def init_plot(self):\\n self.dpi = 100\\n self.fig = Figure((5.0, 5.0), dpi = self.dpi)\\n\\n self.main_plot = self.fig.add_subplot(111)\\n self.main_plot.set_axis_bgcolor('black')\\n self.main_plot.set_title('Dynamic venous flow view', size = 12)\\n\\n pylab.setp(self.main_plot.get_xticklabels(), fontsize = 8)\\n pylab.setp(self.main_plot.get_yticklabels(), fontsize = 8)\\n\\n # Plot the data as a green line\\n self.plot_data = self.main_plot.plot(\\n self.daq.data0,\\n linewidth = 1,\\n color = (0, 1, 0),\\n )[0]\\n self.main_plot.grid(True, color='gray')\",\n \"def cplot(self, figure, i, n):\\n xx, yy = np.meshgrid(range(self.L), range(self.L))\\n ax = figure.add_subplot(2,2,n)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n plt.setp(ax.get_xticklabels(), visible=False) \\n plt.pcolormesh(xx, yy, self.config, cmap=plt.cm.RdBu);\\n plt.title('Time=%d'%i, fontsize=20)\\n plt.xlabel('X', fontsize=12)\\n plt.ylabel('Y',fontsize=12) \\n plt.axis('tight') \\n self.ax = ax\",\n \"def plot(self, n_confs):\\n \\n import pandas as pd\\n import numpy as np\\n import matplotlib as mpl\\n mpl.use('Agg')\\n import matplotlib.pyplot as plt\\n import csv\\n \\n n_iter = len(self.plot_data)\\n \\n data = np.ndarray((n_iter, n_confs+1))\\n data[:,0] = [i[0] for i in self.plot_data]\\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\\n\\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n df.to_csv(f\\\"{self.plot_name}.tab\\\", sep=\\\"\\\\t\\\", quoting=csv.QUOTE_NONE) \\n\\n d = data[:,1:].reshape(-1)\\n d = d[~np.isnan(d)]\\n mine = d.min() - 0.01\\n for i in range(n_confs): \\n data[:,i+1] -= mine\\n \\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n \\n colors = (0,0,0)\\n area = 10\\n \\n # Plot\\n fig = plt.figure(figsize=(15, 15))\\n ax = fig.add_subplot(1,1,1)\\n for i in range(n_confs):\\n ax.plot('iter', f'c{i+1}', data=df)\\n ax.set_yscale('log')\\n\\n plt.xlabel('iter')\\n plt.ylabel('loss')\\n plt.savefig(f'{self.plot_name}.png')\",\n \"def draw_grid(self, verbosity=0):\\n log.debug(\\\"Drawing grid\\\")\\n (x0, y0) = self.origin\\n color = (191, 191, 191)\\n\\n (w, h) = self.surface.get_size()\\n\\n i = x0\\n while True:\\n (x, ignore) = self.map_to_screen((i, 0))\\n if x > w:\\n break\\n pygame.draw.line(self.surface, color, (x, 0), (x, h), 1)\\n i += 10\\n\\n j = y0\\n while True:\\n (ignore, y) = self.map_to_screen((0, j))\\n if y > h:\\n break\\n pygame.draw.line(self.surface, color, (0, y), (w, y), 1)\\n j -= 10\",\n \"def draw_grid(plt):\\n x0, x1, x2, x3 = 0, 3057, 6508, 9860\\n y0, y1, y2, y3, y4, y5, y6, y7, y8 = 0, 1535, 2041, 2547, 3053, 3559, 4257, 5303, 6978\\n alpha, linewidth = 0.3, 0.5\\n\\n # Vertical Lines\\n plt.plot((x0, x0), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x1, x1), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x2, x2), (y0, y5), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x3, x3), (y0, y8), 'black', alpha=alpha, linewidth=linewidth)\\n\\n # Horizontal Lines\\n plt.plot((x0, x3), (y0, y0), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y1, y1), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y2, y2), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y3, y3), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y4, y4), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y5, y5), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x1), (y6, y6), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x1, x3), (y7, y7), 'black', alpha=alpha, linewidth=linewidth)\\n plt.plot((x0, x3), (y8, y8), 'black', alpha=alpha, linewidth=linewidth)\",\n \"def test_sizergrid():\\n regular_grid(8, 3)\\n mpl.show()\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def visualize_network_samples_grid(net, start=5, stop=100, step=10,\\n f_ext=\\\"pdf\\\"):\\n save_dir = make_memnet_checkpoint_dir(\\n Path(\\\"plots/vis_memnet_samples/grid/\\\"), net)\\n if not save_dir.exists():\\n save_dir.makedirs()\\n inds = list(product(range(start, stop, step), range(start, stop, step)))\\n grid_width = len(range(start, stop, step))\\n print(\\\"Loading plants.\\\")\\n inputs, stim_vals = load_plants(\\n net.image_width,\\n net.trainingset_dir,\\n layer_type=net.layer_type,\\n normalize=True)\\n print(\\\"Finished.\\\")\\n fig, axes = plt.subplots(grid_width, grid_width, figsize=(50, 50))\\n preds = []\\n print(\\\"Making plots...\\\")\\n for i in range(len(stim_vals)):\\n if tuple(stim_vals[i]) in inds:\\n print(\\\"Making \\\", stim_vals[i])\\n preds.append(\\n net.predict(inputs[i:i + 1], keep_session=True).reshape(\\n net.image_width, net.image_width))\\n grid_coord = tuple(stim_vals[i] / step)\\n ax = axes[int(grid_coord[1]), int(grid_coord[0])]\\n # ax = axes[tuple(stim_vals[i] / step)]\\n ax.imshow(preds[-1], cmap=\\\"gray_r\\\")\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_xticks([])\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_yticks([])\\n ax.set_yticklabels(\\\"\\\")\\n plt.savefig(save_dir.joinpath('grid.' + f_ext))\\n print(\\\"Saved to \\\", save_dir.joinpath('grid.' + f_ext))\\n return\",\n \"def visualisation(self):\\n plt.plot(self.x, self.y, 'o', label = 'Example data')\\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\\n plt.xlim([-1,1])\\n plt.ylim([-1,1])\",\n \"def show_grid(grid, edges, path1, path2):\\n plt.imshow(grid, origin='lower', cmap='Greys')\\n\\n if edges is not None:\\n for e in edges:\\n p1 = e[0]\\n p2 = e[1]\\n plt.plot([p1[1], p2[1]], [p1[0], p2[0]], 'b-')\\n\\n # Stepping through each edge\\n if path1 is not None:\\n p1 = path1[0]\\n for p in path1[1:]:\\n p2 = p\\n plt.plot([p1[1], p2[1]], [p1[0], p2[0]], 'ro')\\n p1 = p2\\n\\n if path2 is not None:\\n p1 = path2[0]\\n for p in path2[1:]:\\n p2 = p\\n plt.plot([p1[1], p2[1]], [p1[0], p2[0]], 'g-', linewidth=3)\\n p1 = p2\\n\\n plt.plot(start[1], start[0], 'rx')\\n plt.plot(goal[1], goal[0], 'rx')\\n plt.grid()\\n plt.xlabel('EAST')\\n plt.ylabel('NORTH')\\n plt.xticks([x for x in range(0, 1000, 50)])\\n plt.yticks([y for y in range(0, 1000, 50)])\\n plt.show()\",\n \"def Traffic_Perform_Plot(performance, hurricanes):\\n fig = plt.figure(figsize = (8, 6))\\n for i in range(len(performance)):\\n temp1 = performance[i]\\n temp2 = hurricanes[i]\\n perform = sf.Normalize(temp1, Type = 'max')\\n plt.plot(np.arange(0, len(perform), 1), perform, color = temp2.c, label = temp2.name, marker = 'o')\\n plt.xlabel('Time Step')\\n plt.xticks(np.arange(0, len(perform), 1))\\n plt.ylabel('Performance')\\n plt.legend(bbox_to_anchor=(1, 1), loc='upper left', ncol=1, frameon = 0)\\n plt.grid(True)\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect()\",\n \"def plot_tessellation(self):\\n\\n if (self.ndim != 2):\\n print(\\\"Only able to plot the tessellation in two dimensions.\\\")\\n return\\n\\n # find bounds:\\n xmin = np.nanmin(self.grid[:,0])\\n xmax = np.nanmax(self.grid[:,0])\\n ymin = np.nanmin(self.grid[:,1])\\n ymax = np.nanmax(self.grid[:,1])\\n dx = xmax-xmin\\n dy = ymax-ymin\\n xmin -= dx*0.03\\n xmax += dx*0.03\\n ymin -= dy*0.05\\n ymax += dy*0.05\\n\\n #plt.semilogy(self.grid[:,0],self.grid[:,1],'o')\\n plt.plot(self.grid[:,0],self.grid[:,1],'o')\\n plt.triplot(self.grid[:,0],self.grid[:,1],self.tessellation.simplices.copy())\\n plt.xlim((xmin,xmax))\\n plt.ylim((ymin,ymax))\\n plt.xlabel(string_to_latex(self.grid_params[0]))\\n plt.ylabel(string_to_latex(self.grid_params[1]))\\n plt.savefig(\\\"tessellation.eps\\\")\",\n \"def plot_activity(opts, points, activity, labels, plot_state=False):\\n sort_ix = sort_weights(opts)\\n activity[:,opts.state_size:] = activity[:,opts.state_size+sort_ix]\\n\\n x = np.arange(0, opts.state_size)\\n # x = np.linspace(np.amin(points[:, 0]), np.amax(points[:, 0]))\\n scale = 2 * np.pi / opts.state_size\\n x_rad = x * scale\\n cos, sin = np.cos(x_rad), np.sin(x_rad)\\n if opts.velocity:\\n y = np.linspace(np.amin(points[:, 1]), np.amax(points[:, 1]))\\n else:\\n y = np.zeros(1)\\n\\n x_mesh, y_mesh = np.meshgrid(x, y)\\n cos, _ = np.meshgrid(cos, y)\\n sin, _ = np.meshgrid(sin, y)\\n if plot_state:\\n nc, nr = 5, 4\\n neurons = np.arange(opts.state_size) # state neurons\\n else:\\n nc, nr = 5, 8\\n neurons = np.arange(opts.state_size, opts.rnn_size) # extra neurons\\n\\n\\n f_linear, ax_linear = plt.subplots(ncols=nc, nrows=nr)\\n # plt.suptitle('Linear Interpolated Data')\\n\\n c, r = 0, 0\\n for i, n in enumerate(neurons):\\n z_lin = griddata(points[:, :2], activity[:, n], (x_mesh, y_mesh), method='linear')\\n plt.sca(ax_linear[r, c])\\n # plt.title('Neuron {}'.format(n))\\n plt.contourf(x, y, z_lin, cmap='RdBu_r')\\n plt.axis('off')\\n\\n # find the global centroid\\n if np.nanmax(z_lin) <= 0:\\n z_lin -= np.nanmean(z_lin) # center activations at the median\\n\\n z_lin[np.isnan(z_lin)] = 0\\n z_lin[z_lin < 0] = 0\\n norm = np.sum(z_lin)\\n\\n cos_mean = np.sum(cos * z_lin) / norm\\n sin_mean = np.sum(sin * z_lin) / norm\\n com_rad = np.arctan2(sin_mean, cos_mean)\\n com_x = (com_rad / scale) % 20\\n com_y = np.sum(y_mesh * z_lin) / norm\\n # plt.scatter(com_x, com_y, c='k')\\n\\n c += 1\\n if c == nc:\\n c = 0\\n r += 1\\n if r == nr:\\n break\\n # plt.tight_layout()\\n plt.show()\",\n \"def makeGrid(self):\\n self.h = self.step_x\\n self.k = self.step_t\\n self.t, self.x = np.meshgrid(np.arange(self.min_t, self.max_t, self.step_t), np.arange(self.min_x, self.max_x\\n , self.step_x))\",\n \"def draw_grid(self):\\n if self.grid_center == True:\\n (n, m) = (self.n, self.m)\\n (dx, dy) = (self.dx // 2, self.dy // 2)\\n else:\\n (n, m) = (self.n + 1, self.m + 1)\\n (dx, dy) = (0, 0)\\n\\n x0 = self.x0 + dx\\n y0 = self.y0 + dy\\n\\n # vertical lines\\n for j in range(m):\\n p0 = (x0 + j * self.dx, y0)\\n p1 = (x0 + j * self.dx, y0 + (n-1) * self.dy)\\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d) \\n # horizontal lines\\n for i in range(n):\\n p0 = (x0, y0 + i * self.dy)\\n p1 = (x0 + (m-1) * self.dx, y0 + i * self.dy)\\n pygame.draw.line(self.screen, self.grid_col, p0, p1, self.grid_d)\",\n \"def plot_tiles(self):\\n \\n #TODO: adjust plot, border and text_box sizes\\n \\n ordered_projections = []\\n flat_clusters = []\\n colors_2D = []\\n\\n for cluster, nodes in clusters.items():\\n for n in nodes:\\n ordered_projections.append(projection_2D[n])\\n\\n for n in nodes:\\n flat_clusters.append(n)\\n\\n for i, n in enumerate(G.nodes):\\n if n in nodes:\\n colors_2D.append(colors[i])\\n\\n grid_cols = int(np.ceil(np.sqrt(len(ordered_projections))))\\n\\n if len(ordered_projections) <= (grid_cols**2 - grid_cols):\\n grid_rows = grid_cols - 1\\n else:\\n grid_rows = grid_cols\\n\\n #assuming images are same size, get shape\\n l, w = ordered_projections[0].shape\\n\\n #add blank images to pack in grid\\n while len(ordered_projections) < grid_rows*grid_cols:\\n ordered_projections.append(np.zeros((l, w)))\\n colors_2D.append((0., 0., 0.))\\n flat_clusters.append('')\\n\\n f = Figure()\\n\\n grid = ImageGrid(f, 111, #similar to subplot(111)\\n nrows_ncols=(grid_rows, grid_cols), #creates grid of axes\\n axes_pad=0.05) #pad between axes in inch\\n \\n lw = 1.75\\n text_box_size = 5 \\n props = dict(boxstyle='round', facecolor='white')\\n \\n for i, (ax, im) in enumerate(zip(grid, ordered_projections)):\\n ax.imshow(im, cmap='gray')\\n\\n for side, spine in ax.spines.items():\\n spine.set_color(colors_2D[i])\\n spine.set_linewidth(lw)\\n\\n ax.get_yaxis().set_ticks([])\\n ax.get_xaxis().set_ticks([])\\n\\n text = str(flat_clusters[i])\\n ax.text(1, 1, text, va='top', ha='left', bbox=props, size=text_box_size)\\n \\n newWindow = tk.Toplevel()\\n newWindow.grid_rowconfigure(0, weight=1)\\n newWindow.grid_columnconfigure(0, weight=1)\\n \\n #PLOT FRAME\\n plotFrame = tk.Frame(newWindow, bg='lightgrey', width=600, height=400)\\n plotFrame.grid(row=0, column=0, sticky='nsew')\\n \\n canvas = FigureCanvasTkAgg(f, plotFrame)\\n canvas.draw()\\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)\\n canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)\\n canvas.figure.tight_layout()\\n \\n\\n #TOOLBAR FRAME\\n toolbarFrame = ttk.Frame(newWindow, width=600, height=100)\\n toolbarFrame.grid(row=1, column=0, sticky='nsew')\\n toolbarFrame.grid_propagate(0)\\n \\n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)\\n toolbar.update()\",\n \"def grid(self):\\n def startEndPoints(start, end, num):\\n \\\"\\\"\\\"Generate num points between a start and stop point. Assumed to be (t,x) points.\\n \\\"\\\"\\\"\\n ll = np.linspace(0,1,num)\\n xxs = start[0]*(1-ll)+end[0]*ll\\n tts = start[1]*(1-ll)+end[1]*ll\\n return( np.array([xxs, tts]) )\\n \\n fig, ax = plt.subplots( figsize=(10,8) )\\n # The slope is beta.\\n # x' axis, input points in (x,t) S points\\n boost = self.boost()\\n invboost = np.linalg.inv( boost )\\n astart = np.dot(invboost, [0, 0] )\\n aend = np.dot(invboost, [0,10] )\\n aaxis = startEndPoints( astart, aend, 40 )\\n\\n ax.plot(aaxis[0], aaxis[1], 'b-')\\n \\n # t' axis\\n astart = np.dot(invboost, [0, 0])\\n aend = np.dot(invboost, [10, 0])\\n aaxis = startEndPoints( astart, aend, 40 )\\n\\n ax.plot(aaxis[0], aaxis[1], 'b-')\\n \\n # light lines on all 45 degrees\\n aaxis = startEndPoints( [-10, -10], [10, 10], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k--')\\n aaxis = startEndPoints( [-10, 10], [10, -10], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k--')\\n \\n # t-hat and x-hat axes\\n aaxis = startEndPoints( [0, 0], [10, 0], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k-')\\n aaxis = startEndPoints( [0, 0], [0, 10], 40 )\\n ax.plot(aaxis[0], aaxis[1], 'k-')\\n ax.grid(True)\\n \\n return( (fig, ax) )\",\n \"def _plot_camera_view(self):\\n fig, axs = plt.subplots()\\n fig.show()\\n axs.cla()\\n axs.axis([-0.003, 0.003, -0.003, 0.003])\\n axs.grid()\\n axs.plot([0], [0], 'r+')\\n for t_step in range(0, int(self._t_sim / self._dt) + 1, 250):\\n axs.plot(\\n self._feat_vec[t_step, 0, 0],\\n self._feat_vec[t_step, 1, 0], 'ro')\\n axs.plot(\\n self._feat_vec[t_step, 0, 1],\\n self._feat_vec[t_step, 1, 1], 'bo')\\n axs.plot(\\n self._feat_vec[t_step, 0, 2],\\n self._feat_vec[t_step, 1, 2], 'yo')\\n axs.plot(\\n self._feat_vec[t_step, 0, 3],\\n self._feat_vec[t_step, 1, 3], 'go')\\n axs.plot(\\n self._feat_vec[t_step, 0, 4],\\n self._feat_vec[t_step, 1, 4], 'ro')\\n plt.pause(1 / self._plot_fps)\",\n \"def SimpleMeasuredGrid(min_x,min_y,max_x,max_y,x_spacing,y_spacing,\\n color=(0.5,1.0,0.5,1.0),xoff=-0.14,yoff=1.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 # Round to nearest integer space\\n max_x=min_x+numpy.floor((max_x-min_x)/x_spacing)*x_spacing\\n max_y=min_y+numpy.floor((max_y-min_y)/y_spacing)*y_spacing\\n\\n lxoff=(max_x-min_x)*xoff # horizontal label placement\\n lyoff=(max_y-min_y)*yoff # vertical label placement\\n\\n for hval in numpy.arange(min_x,\\n max_x+x_spacing/100.0,\\n x_spacing):\\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',\\\"%d\\\" % int(hval+0.5))\\n shps.append(pshp)\\n\\n for vval in numpy.arange(min_y,\\n max_y+y_spacing/100.0,\\n y_spacing):\\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',\\\"%d\\\" % int(vval+0.5))\\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 plot(self):\\n\\t\\tplot_chain(self.database_path, self.temp_folder)\\n\\t\\tplot_density(self.database_path, self.temp_folder, self.cal_params)\",\n \"def gen_grids(self):\\n self.dx = self.grid_width / self.grid_resol\\n self.dk = 2 * np.pi/self.grid_width\\n self.grid_x_shifted = -self.grid_width/2 + self.dx * np.arange(0, self.grid_resol)\\n self.grid_x = self.grid_x_shifted + self.grid_center\\n self.grid_k = - (np.pi * self.grid_resol)/self.grid_width + self.dk * np.arange(0, self.grid_resol)\\n self.grid_k = np.roll(self.grid_k, int((self.grid_resol)/2))\\n self.grid_kin = np.square(self.h)/ (2*self.m) * np.square(self.grid_k)\",\n \"def plot(self):\\n\\n fig, ax = plt.subplots()\\n\\n for run in self.runs:\\n # Load datasets\\n data_measure = run.get_dataset(\\\"stats-collect_link_congestion-raw-*.csv\\\")\\n data_sp = run.get_dataset(\\\"stats-collect_link_congestion-sp-*.csv\\\")\\n\\n # Extract link congestion information\\n data_measure = data_measure['msgs']\\n data_sp = data_sp['msgs']\\n\\n # Compute ECDF and plot it\\n ecdf_measure = sm.distributions.ECDF(data_measure)\\n ecdf_sp = sm.distributions.ECDF(data_sp)\\n\\n variable_label = \\\"\\\"\\n size = run.orig.settings.get('size', None)\\n if size is not None:\\n variable_label = \\\" (n=%d)\\\" % size\\n\\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\\n label=\\\"U-Sphere%s\\\" % variable_label)\\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\\n label=u\\\"Klasični usmerjevalni protokol%s\\\" % variable_label)\\n\\n ax.set_xlabel('Obremenjenost povezave')\\n ax.set_ylabel('Kumulativna verjetnost')\\n ax.grid()\\n ax.axis((28, None, 0.99, 1.0005))\\n self.convert_axes_to_bw(ax)\\n\\n legend = ax.legend(loc='lower right')\\n if self.settings.GRAPH_TRANSPARENCY:\\n legend.get_frame().set_alpha(0.8)\\n fig.savefig(self.get_figure_filename())\",\n \"def continuous_plot(iterations, grn):\\n width, height = size = (600,600)\\n screen = pygame.display.set_mode(size)\\n # order the colors for the TF andP proteins\\n colors = []\\n conc_list = []\\n extra_up, extra_down = False, False\\n\\n for gene in grn.genes:\\n \\n if gene.gene_type == \\\"TF\\\":\\n colors.append((0, 0, 255))\\n elif gene.gene_type == \\\"P\\\":\\n colors.append((0, 255, 0))\\n elif gene.gene_type == \\\"EXTRA\\\":\\n colors.append((255,0,0))\\n prev_extra = 600-(gene.concentration * 600)\\n\\n conc_list.append(600-(gene.concentration * 600))\\n\\n # add variables for user input\\n\\n for i in range(iterations):\\n #check for keypress\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n pygame.quit()\\n sys.exit()\\n elif event.type == pygame.KEYDOWN:\\n if pygame.key.get_pressed()[pygame.K_UP]:\\n extra_up = True\\n if pygame.key.get_pressed()[pygame.K_DOWN]:\\n extra_down = True\\n elif event.type == pygame.KEYUP:\\n extra_up, extra_down = False, False\\n if extra_up: \\n grn.change_extra(0.01)\\n if extra_down: \\n grn.change_extra(-0.01)\\n #run grn and get protein concentration\\n results = grn.regulate_matrix(2, False)\\n scaled = [int(600-(x * 600)) for x in results]\\n old_conc = conc_list\\n conc_list = scaled\\n \\n for idx, conc in enumerate(conc_list):\\n pygame.draw.line(screen, colors[idx], \\n (width-3, old_conc[idx]), \\n (width-2, conc))\\n\\n # if draw_extra:\\n # pygame.draw.line(screen, colors[-1], \\n # (width-3, 600-prev_extra-1), \\n # (width-2, 600-extra))\\n\\n pygame.display.flip()\\n #screen.blit(screen, (-1, 0))\\n screen.scroll(-1,0)\\n pygame.time.wait(5)\",\n \"def plot_model(self):\\n \\n plt.figure(figsize=[10,5])\\n \\n plt.scatter(self.receivers['recxs'],self.receivers['reczs'],marker='v')\\n if self.source['src_type']==4:\\n from obspy.imaging.beachball import beach\\n beach = beach(self.source['mt'], xy=(self.source['srcx'],self.source['srcz']), width=self.model_parameters['xmax']*0.05)\\n ax = plt.gca()\\n \\n ax.add_collection(beach) \\n ax.set_aspect(\\\"equal\\\")\\n \\n else:\\n plt.scatter(self.source['srcx'],self.source['srcz'],marker='*',color='r',s=200)\\n \\n plt.axhline(y=0,c='0.5')\\n plt.xlim(0,self.model_parameters['xmax'])\\n plt.ylim(self.model_parameters['zmax'],-0.1*self.model_parameters['zmax'])\\n \\n plt.xlabel('Distance (km)')\\n plt.ylabel('Depth (km)')\\n plt.grid()\\n plt.show()\",\n \"def visualize_network_samples_grid_1D(net, start=5, stop=100, step=10,\\n f_ext=\\\"pdf\\\"):\\n save_dir = make_memnet_checkpoint_dir(\\n Path(\\\"plots/vis_memnet_samples/grid/\\\"), net)\\n if not save_dir.exists():\\n save_dir.makedirs()\\n relevant_vals = range(start, stop, step)\\n grid_width = len(relevant_vals)\\n print(\\\"Loading plants.\\\")\\n inputs0, stim_vals0 = load_plants(\\n net.image_width,\\n net.trainingset_dir,\\n layer_type=net.layer_type,\\n normalize=True)\\n inputs0 = inputs0 / 255. # Normalize\\n print(\\\"Finished.\\\")\\n irrelevant_dim = int(net.input_distribution_dim == 0)\\n if irrelevant_dim == 0:\\n inds = list(product([50], relevant_vals))\\n else:\\n inds = list(product(relevant_vals, [50]))\\n inputs_valid = inputs0[stim_vals0[:, irrelevant_dim] == 50]\\n stim_vals = stim_vals0[stim_vals0[:, irrelevant_dim] == 50]\\n fig, axes = plt.subplots(\\n 1, grid_width, figsize=(50, 50 / len(relevant_vals)))\\n preds = []\\n inputs = []\\n print(\\\"Making plots...\\\")\\n for i in range(len(stim_vals)):\\n if tuple(stim_vals[i]) in inds:\\n print(\\\"Making \\\", stim_vals[i])\\n inputs.append(inputs_valid[i])\\n preds = net.predict(inputs, keep_session=True)\\n for i in range(len(preds)):\\n ax = axes[i]\\n ax.imshow(\\n preds[i:i + 1].reshape(net.image_width, net.image_width),\\n cmap=\\\"gray_r\\\")\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_xticks([])\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_yticks([])\\n ax.set_yticklabels(\\\"\\\")\\n plt.savefig(save_dir.joinpath('grid.' + f_ext))\\n print(\\\"Saved to \\\", save_dir.joinpath('grid.' + f_ext))\\n return\",\n \"def visualize_scan(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n ax.scatter(self.p1_points[:, 0], self.p1_points[:, 1], self.p1_points[:, 2], c='r')\\n ax.scatter(self.p2_points[:, 0], self.p2_points[:, 1], self.p2_points[:, 2], c='g')\\n ax.scatter(self.p3_points[:, 0], self.p3_points[:, 1], self.p3_points[:, 2], c='b')\\n ax.scatter(self.p4_points[:, 0], self.p4_points[:, 1], self.p4_points[:, 2])\\n\\n ax.set_xlabel('x')\\n ax.set_ylabel('y')\\n ax.set_zlabel('z')\\n plt.show()\",\n \"def visualize_flow(flow, mode='Y'):\\n if mode == 'Y':\\n # Ccbcr color wheel\\n img = flow_to_image(flow)\\n plt.imshow(img)\\n plt.show()\\n elif mode == 'RGB':\\n (h, w) = flow.shape[0:2]\\n du = flow[:, :, 0]\\n dv = flow[:, :, 1]\\n valid = flow[:, :, 2]\\n max_flow = max(np.max(du), np.max(dv))\\n img = np.zeros((h, w, 3), dtype=np.float64)\\n # angle layer\\n img[:, :, 0] = np.arctan2(dv, du) / (2 * np.pi)\\n # magnitude layer, normalized to 1\\n img[:, :, 1] = np.sqrt(du * du + dv * dv) * 8 / max_flow\\n # phase layer\\n img[:, :, 2] = 8 - img[:, :, 1]\\n # clip to [0,1]\\n small_idx = img[:, :, 0:3] < 0\\n large_idx = img[:, :, 0:3] > 1\\n img[small_idx] = 0\\n img[large_idx] = 1\\n # convert to rgb\\n img = cl.hsv_to_rgb(img)\\n # remove invalid point\\n img[:, :, 0] = img[:, :, 0] * valid\\n img[:, :, 1] = img[:, :, 1] * valid\\n img[:, :, 2] = img[:, :, 2] * valid\\n # show\\n plt.imshow(img)\\n plt.show()\\n\\n return None\",\n \"def plot(self):\\n\\t\\tself.plotOfLoopVoltage()\",\n \"def _DoUpdatePlot( self, wd, ht ):\\n self.ax.grid(\\n True, 'both', 'both',\\n\\tcolor = '#c8c8c8', linestyle = ':', linewidth = 1\\n\\t)\",\n \"def make_grid(self):\\n for k in range(0, NUM + 1):\\n self.create_line(k * UNIT, 0, k * UNIT, SIZE, width=THICKNESS)\\n self.create_line(0, k * UNIT, SIZE, k * UNIT, width=THICKNESS)\",\n \"def draw_grid(self) -> None:\\n for x in range(0, WIDTH, TILE_SIZE):\\n pg.draw.line(self.screen, LIGHT_GREY, (x, INFO_HEIGHT), (x, HEIGHT))\\n for y in range(INFO_HEIGHT, INFO_HEIGHT + HEIGHT, TILE_SIZE):\\n pg.draw.line(self.screen, LIGHT_GREY, (0, y), (WIDTH, y))\",\n \"def show_flow(filename):\\n flow = read_flow(filename)\\n img = flow_to_image(flow)\\n plt.imshow(img)\\n plt.show()\",\n \"def plot(self, x, fname=None):\\n logger.debug('plotting inducing grid')\\n assert np.all(self.grid_sub_dim == 1), \\\"only works when grid dims are 1d\\\"\\n import matplotlib\\n if fname is not None:\\n matplotlib.use('Agg')\\n from matplotlib.backends.backend_pdf import PdfPages\\n matplotlib.rcParams.update({'font.size': 10})\\n import matplotlib.pyplot as plt\\n def plot1dim(i_dim):\\n \\\"\\\"\\\" function for ploting one grid dimension\\\"\\\"\\\"\\n freq = plt.hist(x=x[:,i_dim], bins=min(100,4*self.grid_shape[i_dim]))[0]\\n plt.plot(self.xg[i_dim][:,0],np.zeros(self.grid_shape[i_dim]) + 0.5*np.max(freq),'ko',markersize=3)\\n plt.xlabel(r'x_%d'%i_dim)\\n plt.ylabel('Frequency')\\n plt.title('Dim %d, m = %d' % (i_dim, self.grid_shape[i_dim]))\\n\\n # now loop through and plot\\n if fname is None: # then plot to screen\\n plt.figure(figsize=(4,4*self.grid_dim))\\n for i in range(self.grid_dim):\\n plt.subplot(self.grid_dim,1,i+1)\\n plot1dim(i_dim=i)\\n plt.suptitle('Inducing Grid and Train Point Dist.')\\n plt.show(block=False)\\n else: # save to file\\n with PdfPages(fname) as pdf:\\n for i in range(self.grid_dim):\\n plt.figure(figsize=(4,4))\\n plot1dim(i_dim=i)\\n pdf.savefig()\\n plt.close()\",\n \"def debugplots(fig,data):\\n grid = AxesGrid(fig, 111, # similar to subplot(142)\\n nrows_ncols=(1, 6),\\n axes_pad=0.0,\\n share_all=True,\\n label_mode=\\\"L\\\",\\n cbar_location=\\\"right\\\",\\n cbar_mode=\\\"none\\\",\\n )\\n\\n Z0=data[0].real\\n Z1=data[1].real\\n Z2=data[2].real\\n Z3=data[3].real\\n Z4=data[4].real\\n Z5=data[5].real\\n \\n Z=[Z0,Z1,Z2,Z3,Z4,Z5]\\n \\n for i in range(6):\\n grid[i].set_title(r\\\"$t=%u\\\\Delta t$\\\"%(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\\n im = grid[i].imshow(Z[i], extent=(-2, 2, -2, 2), interpolation=\\\"Nearest\\\",origin=\\\"lower\\\",cmap='seismic',vmin=-1,vmax=1)\\n grid[i].set_aspect(ratio)\\n grid[i].set_xlabel(\\\"$x/10$\\\",size=16)\\n grid[0].set_ylabel(\\\"$y/10$\\\",size=16)\\n pos2 = [0.905,0.25,0.01,0.5]\\n position = fig.add_axes(pos2)\\n fig.colorbar(im, ax=grid[2],cax=position,extend=\\\"both\\\")\\n \\n for cax in grid.cbar_axes:\\n cax.toggle_label(True)\\n \\n # This affects all axes as share_all = True.\\n grid.axes_llc.set_xticks([-2,-1, 0,1])\\n #grid[0].set_xticks([-20,-10, 0,10, 20])\\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])\",\n \"def show_filters(self):\\n w_mat = np.transpose(self.sess.run(self.W_fc1))\\n\\n plt.figure(figsize=(10,10), facecolor='w', edgecolor='w')\\n plot_positions = [(0,0),(0,1),(1,0),(1,1)]\\n for ch in range(self.n_input_channels):\\n grid,_ = ia.image_grid_RGB( w_mat,\\n n_channels=self.n_input_channels,\\n image_size=(self.y_res,self.x_res), n_x=6, n_y=6,\\n channel_order=(ch,ch,ch), amplitude_scaling=(1,1,1),\\n line_color=1, auto_scale=True, return_borders=False )\\n colormax = np.abs(grid).max()\\n with sns.axes_style(\\\"white\\\"):\\n ax = plt.subplot2grid( (2,2), plot_positions[ch] )\\n ax.imshow( grid[:,:,0], interpolation='nearest',\\n cmap=plt.get_cmap('seismic'),\\n clim=(-1*colormax,colormax) )\\n ax.set_title(\\\"Hidden units, channel {}\\\".format(ch))\\n plt.axis('tight')\\n plt.axis('off')\\n plt.tight_layout()\",\n \"def plot(self, transform=None, label=None, style='hull', autoscale=True,\\n zorder=None, ax=None, figsize=None, fc='gray'):\\n if style.lower() not in ['hull', 'scatter', 'cell']:\\n raise ValueError(f'Unknown plotting style \\\"{style}\\\". Choose from: '\\n f'\\\"hull\\\", \\\"scatter\\\", \\\"cell\\\"')\\n if ax is None:\\n ax = plt.gca()\\n if figsize is not None:\\n ax.figure.set_size_inches(figsize)\\n ax.set_aspect('equal')\\n if autoscale:\\n ax.autoscale(True)\\n if zorder is None:\\n zorder = ZORDER['background']\\n\\n x, y = self.x, self.y\\n try:\\n # Step might be a tuple:\\n x_step, y_step = self.step\\n except TypeError:\\n x_step = self.step\\n y_step = self.step\\n\\n if style.lower() == 'cell':\\n # Show a polygon for every grid cell that we are simulating:\\n if self.type == 'hexagonal':\\n raise NotImplementedError\\n patches = []\\n for xret, yret in zip(x.ravel(), y.ravel()):\\n # Outlines of the cell are given by (x,y) and the step size:\\n vertices = np.array([\\n [xret - x_step / 2, yret - y_step / 2],\\n [xret - x_step / 2, yret + y_step / 2],\\n [xret + x_step / 2, yret + y_step / 2],\\n [xret + x_step / 2, yret - y_step / 2],\\n ])\\n if transform is not None:\\n vertices = np.array(transform(*vertices.T)).T\\n patches.append(Polygon(vertices, alpha=0.3, ec='k', fc=fc,\\n ls='--', zorder=zorder))\\n ax.add_collection(PatchCollection(patches, match_original=True,\\n zorder=zorder, label=label))\\n else:\\n # Show either the convex hull or a scatter plot:\\n if transform is not None:\\n x, y = transform(self.x, self.y)\\n points = np.vstack((x.ravel(), y.ravel()))\\n # Remove NaN values from the grid:\\n points = points[:, ~np.logical_or(*np.isnan(points))]\\n if style.lower() == 'hull':\\n hull = ConvexHull(points.T)\\n ax.add_patch(Polygon(points[:, hull.vertices].T, alpha=0.3, ec='k',\\n fc=fc, ls='--', zorder=zorder, label=label))\\n elif style.lower() == 'scatter':\\n ax.scatter(*points, alpha=0.3, ec=fc, color=fc, marker='+',\\n zorder=zorder, label=label)\\n # This is needed in MPL 3.0.X to set the axis limit correctly:\\n ax.autoscale_view()\\n return ax\",\n \"def tiled_plot(self, stims):\\n nstim = stims.shape[0]\\n plotrows = int(np.sqrt(nstim))\\n plotcols = int(np.ceil(nstim/plotrows))\\n f, axes = plt.subplots(plotrows, plotcols, sharex=True, sharey=True)\\n for ii in range(nstim):\\n axes.flatten()[ii].plot(stims[ii])\\n f.subplots_adjust(hspace=0, wspace=0)\\n plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)\\n plt.setp([a.get_yticklabels() for a in f.axes[:-1]], visible=False)\",\n \"def plotLoss():\\n # ssr\\n ssr = np.log(gradientDescent(X, y)[1])\\n # number of iterations \\n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\\n # plot reduction of ssr\\n plt.plot(iterations, ssr)\\n # xlabel\\n plt.xlabel(\\\"Iteration\\\")\\n # ylabel\\n plt.ylabel(\\\"SSR\\\")\\n # title\\n plt.title(\\\"Reduction of SSR by number of Iterations\\\")\\n # show plot \\n plt.show()\",\n \"def plot(self):\\n # Find only unmasked data :\\n # xyz, sData, sColor, _ = self._select_unmasked()\\n xyz, sData, sColor = self.xyz, self.sData, self.sColor\\n\\n # Render as cloud points :\\n self.mesh = visu.Markers(name='Sources')\\n self.mesh.set_data(xyz, edge_color=self.edgecolor, face_color=sColor,\\n size=sData, scaling=self.scaling,\\n edge_width=self.edgewidth, symbol=self.symbol)\\n self.mesh.set_gl_state('translucent')\",\n \"def mesh_grid(self,width,height):\\n # get\\n \\n x_linspace=tf.linspace(-self.cx_,1-self.cx_,width)\\n y_linspace=tf.linspace(-self.cy_,1-self.cy_,height)\\n \\n# x_cord,y_cord=tf.meshgrid(x_linspace,y_linspace)\\n y_cord,x_cord=tf.meshgrid(y_linspace,x_linspace)\\n \\n \\n x_cord=tf.reshape(x_cord,[-1])\\n y_cord=tf.reshape(y_cord,[-1])\\n \\n f_=tf.ones_like(x_cord)\\n \\n x_=tf.div(x_cord,self.cf)\\n y_=tf.div(y_cord,self.cf)\\n \\n grid=tf.concat([x_,y_,f_],0)\\n return grid\",\n \"def plot(self):\\n layout = self.graph.layout(\\\"kk\\\")\\n bbox = igraph.BoundingBox(600, 600)\\n figure = igraph.Plot(bbox=bbox, background=\\\"white\\\")\\n bbox = bbox.contract(100)\\n figure.add(self.graph, layout = layout, bbox=bbox)\\n figure.show()\",\n \"def plot_graph(self):\\r\\n A = self.a_grid ; V = self.V1 ; Pol = self.Pol\\r\\n A_opt = A[Pol.astype(int)]\\r\\n \\r\\n fig = plt.subplots(figsize = (8,5))\\r\\n ax = [None,None]\\r\\n pltgrid = (1,2)\\r\\n \\r\\n ax[0] = plt.subplot2grid(pltgrid, (0,0))\\r\\n ax[1] = plt.subplot2grid(pltgrid, (0,1))\\r\\n \\r\\n ax[0].plot(A[:],V[:,0,0], linewidth = 2, color = 'blue', label = r'$V(a)$: Low $w$')\\r\\n ax[0].plot(A[:],V[:,0,5], linewidth = 2, color = 'green', label = r'$V(a)$: Median $w$')\\r\\n ax[0].plot(A[:],V[:,0,-1], linewidth = 2, color = 'red', label = r'$V(a)$: High $w$')\\r\\n \\r\\n ax[1].plot(A[:],A_opt[:,0,0], linewidth = 2, color = 'blue', label = r'$a\\\\'(a)$: Low $w$')\\r\\n ax[1].plot(A[:],A_opt[:,0,5], linewidth = 2, color = 'green', label = r'$a\\\\'(a)$: Median $w$')\\r\\n ax[1].plot(A[:],A_opt[:,0,-1], linewidth = 2, color = 'red', label = r'$a\\\\'(a)$: High $w$')\\r\\n ax[1].plot(A[:],A[:], linewidth = 2, color = 'violet', linestyle = 'dashed', zorder = 1)\\r\\n \\r\\n \\r\\n ax[0].set_xlabel(r'$a$') ; ax[0].legend()\\r\\n ax[1].set_xlabel(r'$a$') ; ax[1].legend()\\r\\n ax[0].set_title('Value function')\\r\\n ax[1].set_title('Asset policy')\\r\\n \\r\\n plt.tight_layout()\\r\\n plt.show()\",\n \"def plot(self):\\n self.fig = plt.figure('black hole')\\n self.fig.clf() #clear the graph to avoir superposing data from the same set (can be deactivated if need to superpose)\\n self.ax = plt.subplot()\\n\\n if self.img2 is not None:\\n self.ax.imshow(self.img2)\\n else:\\n print(\\\"No black hole deformation in the memory, displayed the original image instead.\\\")\\n self.ax.imshow(self.img_debut)\\n\\n self.fig.canvas.set_window_title('Black hole')\\n self.ax.set_title(\\\"scrool to zoom in or out \\\\nright click to add an offset in the background \\\\nleft click to refresh image \\\\n close the option windows to stop the program\\\")\\n self.fig.canvas.mpl_connect('scroll_event', self.onscroll)\\n self.fig.canvas.mpl_connect('button_press_event', self.onclick)\\n self.fig.canvas.mpl_connect('axes_leave_event', self.disconnect)\\n self.fig.canvas.mpl_connect('axes_enter_event', self.connect)\\n\\n self.draw()\",\n \"def plot_1d_systems(model):\\n\\n # Construct grid to evaluate the Green's function\\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\\n x_G_star = X_G.flatten()[:, None]\\n y_G_star = Y_G.flatten()[:, None]\\n\\n # Create the figure\\n n_plots = max(model.n_input + 1, model.n_output)\\n scaling = n_plots / 2\\n fig, ax = newfig(1.0 * scaling, 1.5)\\n ax.axis('off')\\n gs = gridspec.GridSpec(n_plots, n_plots)\\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9,\\n wspace=0.6 * scaling, hspace=0.6 * scaling)\\n\\n # Plot the Green's functions\\n for i in range(model.n_output):\\n for j in range(model.n_input):\\n input_data = np.concatenate((x_G_star, y_G_star), 1)\\n G_pred_identifier = model.sess.run(\\n model.G_network[i][j].evaluate(input_data))\\n G_pred = G_pred_identifier.reshape(X_G.shape)\\n ax = plt.subplot(gs[i, j])\\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\\n model.y_G), np.max(model.y_G)],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('$G_{%d,%d}$' % (i + 1, j + 1), fontsize=10)\\n\\n # Plot the homogeneous solutions\\n for i in range(model.n_output):\\n N_pred = model.sess.run(model.idn_N_pred[i].evaluate(model.x))\\n ax = plt.subplot(gs[i, model.n_input])\\n ax.plot(model.x, model.U_hom[:, i], label='Exact')\\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\\n divider = make_axes_locatable(ax)\\n ymin = min([np.min(N_pred), np.min(model.U_hom[:, i])])\\n ymax = max([np.max(N_pred), np.max(model.U_hom[:, i])])\\n ax.set_xlim(np.min(model.x), np.max(model.x))\\n ax.set_ylim(ymin, ymax)\\n if ymax - ymin < 1e-2:\\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\\\"%1.1e\\\"))\\n ax.set_xlabel('$x$')\\n ax.set_title('Hom$_{%d}$' % (i + 1), fontsize=10)\\n ax.legend()\\n\\n # Save the figure\\n savefig(\\\"%s/%s_%s\\\" % (model.path_result, model.example_name,\\n model.activation_name), crop=False)\",\n \"def _plot(self, step, rewards, losses):\\n plt.figure(figsize=(20, 5))\\n plt.subplot(131)\\n plt.title('Total Episode Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('MSE Loss')\\n plt.plot(losses)\\n plt.show()\",\n \"def _plot_arm(self):\\n fig, axs = plt.subplots()\\n fig.show()\\n axs.cla()\\n axs.axis([-1, 2.5, -1, 2.5])\\n axs.plot([0], [0], 'o')\\n config_plots = []\\n for t_step in range(0, int(self._t_sim / self._dt) + 1, 1000):\\n axs.plot([0, self._x_1[t_step]], [0, self._y_1[t_step]])\\n axs.plot(self._x_1[t_step], self._y_1[t_step], 'o')\\n axs.plot(\\n [self._x_1[t_step], self._x_2[t_step]],\\n [self._y_1[t_step], self._y_2[t_step]]\\n )\\n axs.plot(self._x_2[t_step], self._y_2[t_step], 'o')\\n axs.plot(\\n [self._x_2[t_step], self._x_e[t_step]],\\n [self._y_2[t_step], self._y_e[t_step]]\\n )\\n axs.plot(self._x_e[t_step], self._y_e[t_step], 'ro')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 0],\\n self._obj_coords_plot[t_step, 1, 0], 'g+')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 1],\\n self._obj_coords_plot[t_step, 1, 1], 'g.')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 2],\\n self._obj_coords_plot[t_step, 1, 2], 'g.')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 3],\\n self._obj_coords_plot[t_step, 1, 3], 'g.')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 4],\\n self._obj_coords_plot[t_step, 1, 4], 'g.')\\n plt.axis('off')\\n plt.pause(1 / self._plot_fps)\\n fig.canvas.draw()\\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\\n config_plots.append(image.reshape(\\n fig.canvas.get_width_height()[::-1] + (3, )))\\n\\n # Draw and create image\\n return config_plots\",\n \"def draw(self):\\n\\n super().draw()\\n \\n self.dim = self.getdim()\\n start_x, start_y, = self.x(), self.y()\\n\\n for y in range(self.r):\\n for x in range(self.c):\\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\\n self.tiles[y][x].resize(x_pos, y_pos, self.dim, self.dim)\",\n \"def plot(self):\\n\\t\\tself.plotOfCos1().plot()\",\n \"def force_draw(self):\\n import matplotlib.pyplot as plt\\n\\n plt.show()\",\n \"def plot_desired_velocity(self,id=1,dpi=150):\\n fig = plt.figure(id)\\n ax1 = fig.add_subplot(111)\\n ax1.imshow(self.image,interpolation='nearest',\\n extent=[self.xmin,self.xmax,self.ymin,self.ymax], origin='lower')\\n ax1.imshow(self.door_distance,interpolation='nearest',\\n extent=[self.xmin,self.xmax,self.ymin,self.ymax],alpha=0.7,\\n origin='lower')\\n step = 10\\n ax1.quiver(self.X[::step, ::step],self.Y[::step, ::step],\\n self.desired_velocity_X[::step, ::step],\\n self.desired_velocity_Y[::step, ::step])\\n #plt.savefig('.png',dpi=dpi)\\n plt.draw()\",\n \"def _setFig(self):\\n self.p.background_fill_color = grey['light']\\n self.p.xgrid.grid_line_color = None\\n self.p.ygrid.grid_line_color = None\\n self.p.ygrid.grid_line_dash = 'dotted'\\n self.p.ygrid.grid_line_dash = 'dotted'\\n\\n self.p.xgrid.minor_grid_line_color = grey['median']\\n self.p.ygrid.minor_grid_line_color = grey['median']\\n self.p.xgrid.minor_grid_line_dash = 'dotted'\\n self.p.ygrid.minor_grid_line_dash = 'dotted'\\n\\n self.p.xaxis.axis_label = \\\"tsne_feature_0\\\"\\n self.p.yaxis.axis_label = \\\"tsne_feature_1\\\"\",\n \"def plot_velocity(self):\\n \\n plt.figure(figsize=[2,6])\\n plt.plot(self.velocity_model['vp'],self.velocity_model['depth'],'r',label='vp')\\n plt.plot(self.velocity_model['vs'],self.velocity_model['depth'],'b',label='vs')\\n\\n plt.ylim(np.max(self.velocity_model['depth']),np.min(self.velocity_model['depth']))\\n \\n plt.xlabel('Velocity (km/s)')\\n plt.ylabel('Depth (km)')\\n plt.legend()\\n plt.grid()\\n plt.show()\",\n \"def tiledplot(self, stims):\\r\\n nstim = stims.shape[0]\\r\\n plotrows = int(np.sqrt(nstim))\\r\\n plotcols = int(np.ceil(nstim/plotrows))\\r\\n f, axes = plt.subplots(plotrows, plotcols, sharex=True, sharey=True)\\r\\n for ii in range(nstim):\\r\\n axes.flatten()[ii].plot(stims[ii])\\r\\n f.subplots_adjust(hspace=0, wspace=0)\\r\\n plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False)\\r\\n plt.setp([a.get_yticklabels() for a in f.axes[:-1]], visible=False)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64805615","0.6395517","0.63600767","0.6321238","0.6193627","0.61895263","0.6010808","0.59778","0.5938082","0.5934734","0.59344804","0.592055","0.58944136","0.5893408","0.5877107","0.58597356","0.58251846","0.5823605","0.58234686","0.58124083","0.57849604","0.5777001","0.57552034","0.5748812","0.574008","0.5735497","0.57315123","0.57241863","0.57048094","0.56917113","0.5688964","0.5687382","0.56738454","0.5657903","0.5655973","0.5644791","0.5641889","0.56245315","0.5612293","0.5606155","0.5604995","0.55975735","0.55975723","0.5594734","0.5582033","0.5576188","0.55749184","0.5572686","0.5572658","0.5569116","0.55633956","0.55594933","0.5550621","0.55487245","0.5548284","0.55270594","0.5521081","0.55113953","0.5503894","0.55029035","0.5498669","0.5494117","0.54858","0.5483392","0.5480496","0.54798406","0.547849","0.54781675","0.546641","0.54663783","0.5461766","0.54499596","0.54472226","0.5444638","0.54277825","0.54254794","0.54245555","0.54203373","0.54201716","0.54041934","0.5404142","0.5401853","0.5400623","0.5399487","0.5397792","0.5397789","0.53967077","0.53865796","0.53851116","0.53834736","0.53822565","0.53813404","0.5378092","0.537523","0.53747666","0.5374631","0.5374366","0.53737694","0.5372481","0.53710663"],"string":"[\n \"0.64805615\",\n \"0.6395517\",\n \"0.63600767\",\n \"0.6321238\",\n \"0.6193627\",\n \"0.61895263\",\n \"0.6010808\",\n \"0.59778\",\n \"0.5938082\",\n \"0.5934734\",\n \"0.59344804\",\n \"0.592055\",\n \"0.58944136\",\n \"0.5893408\",\n \"0.5877107\",\n \"0.58597356\",\n \"0.58251846\",\n \"0.5823605\",\n \"0.58234686\",\n \"0.58124083\",\n \"0.57849604\",\n \"0.5777001\",\n \"0.57552034\",\n \"0.5748812\",\n \"0.574008\",\n \"0.5735497\",\n \"0.57315123\",\n \"0.57241863\",\n \"0.57048094\",\n \"0.56917113\",\n \"0.5688964\",\n \"0.5687382\",\n \"0.56738454\",\n \"0.5657903\",\n \"0.5655973\",\n \"0.5644791\",\n \"0.5641889\",\n \"0.56245315\",\n \"0.5612293\",\n \"0.5606155\",\n \"0.5604995\",\n \"0.55975735\",\n \"0.55975723\",\n \"0.5594734\",\n \"0.5582033\",\n \"0.5576188\",\n \"0.55749184\",\n \"0.5572686\",\n \"0.5572658\",\n \"0.5569116\",\n \"0.55633956\",\n \"0.55594933\",\n \"0.5550621\",\n \"0.55487245\",\n \"0.5548284\",\n \"0.55270594\",\n \"0.5521081\",\n \"0.55113953\",\n \"0.5503894\",\n \"0.55029035\",\n \"0.5498669\",\n \"0.5494117\",\n \"0.54858\",\n \"0.5483392\",\n \"0.5480496\",\n \"0.54798406\",\n \"0.547849\",\n \"0.54781675\",\n \"0.546641\",\n \"0.54663783\",\n \"0.5461766\",\n \"0.54499596\",\n \"0.54472226\",\n \"0.5444638\",\n \"0.54277825\",\n \"0.54254794\",\n \"0.54245555\",\n \"0.54203373\",\n \"0.54201716\",\n \"0.54041934\",\n \"0.5404142\",\n \"0.5401853\",\n \"0.5400623\",\n \"0.5399487\",\n \"0.5397792\",\n \"0.5397789\",\n \"0.53967077\",\n \"0.53865796\",\n \"0.53851116\",\n \"0.53834736\",\n \"0.53822565\",\n \"0.53813404\",\n \"0.5378092\",\n \"0.537523\",\n \"0.53747666\",\n \"0.5374631\",\n \"0.5374366\",\n \"0.53737694\",\n \"0.5372481\",\n \"0.53710663\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7789411"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76568,"cells":{"query":{"kind":"string","value":"Save some images and plots during training"},"document":{"kind":"string","value":"def generate_plots(fixed, moving, warped, flows, train_loss, val_loss, reg_loss, epoch):\n moving = moving.detach().cpu().numpy()\n fixed = fixed.detach().cpu().numpy()\n warped = [w.detach().cpu().numpy() for w in warped]\n flows = [f.detach().cpu().numpy() for f in flows]\n\n fig = plt.figure(constrained_layout=True, figsize=(4 * 5, 4 * 3))\n ax_dict = fig.subplot_mosaic(\"\"\"\n FABCD\n LGHIE\n MKJWX\n \"\"\")\n\n ax_dict['F'].imshow(moving[0, 0, ...], cmap='gray')\n ax_dict['F'].set_title('Moving')\n\n ax_dict['W'].imshow(fixed[0, 0, ...], cmap='gray')\n ax_dict['W'].set_title('Fixed')\n\n for i, ax_name in enumerate(list(\"ABCDEX\")):\n ax_dict[ax_name].imshow(warped[i][0, 0, ...], cmap='gray')\n if ax_name == \"A\":\n ax_dict[ax_name].set_title(\"Affine\")\n else:\n ax_dict[ax_name].set_title(f\"Cascade {i}\")\n\n ax_dict['L'].plot(train_loss, color='red', label='train_loss')\n ax_dict['L'].plot(val_loss, label='val_loss', color='blue')\n ax_dict['L'].plot(reg_loss, label='train_reg_loss', color='green')\n ax_dict['L'].set_title(\"Losses\")\n ax_dict['L'].grid()\n ax_dict['L'].set_xlim(0, args.e)\n ax_dict['L'].legend(loc='upper right')\n ax_dict['L'].scatter(len(train_loss) - 1, train_loss[-1], s=20, color='red')\n ax_dict['L'].scatter(len(val_loss) - 1, val_loss[-1], s=20, color='blue')\n ax_dict['L'].scatter(len(reg_loss) - 1, reg_loss[-1], s=20, color='green')\n\n for i, ax_name in enumerate(list(\"GHIJKM\")):\n plot_grid(ax_dict[ax_name], flows[i][0, ...])\n if ax_name == \"G\":\n ax_dict[ax_name].set_title(\"Affine\")\n else:\n ax_dict[ax_name].set_title(f\"Cascade {i}\")\n\n plt.suptitle(f\"Epoch {epoch}\")\n plt.savefig(f'./ckp/visualization/epoch_{epoch}.png')"},"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 save_images(PATH, show_img, datasets, from_dataset):\n dataset = datasets[from_dataset]\n imgModels = dataset['models']\n for modelname, model in imgModels.items():\n print('save', modelname)\n plt.imshow(model[70])\n plt.set_cmap(\"gray\")\n plt.axis('off')\n plt.savefig(PATH + '/' + from_dataset + '_' + modelname + '.png', dpi=400)\n\n if show_img == True:\n plt.show()","def save_images(self, samples, label=None, dir=\"\"):\n if label is None:\n label = self.global_step_\n fig = plt.figure()\n self.net_.eval()\n self.dist.visualize(fig, samples, self.energy)\n plot_fn = os.path.join(dir, f\"samples_{label}.png\")\n fig.savefig(plot_fn)\n plt.close(fig)","def save_images(self):\n for q in range(self.N_itr):\n plt.clf()\n self.plot_EM_estimate(q)\n plt.savefig('img%d.png' % (100 + q))","def generate_and_save_images(model, epoch, test_input):\n #Training is set to false\n #so all layers run in inference mode (batchnorm)(?)\n predictions = model(test_input, training=False)\n fig = plt.figure(figsize=(4,4))\n for i in range(predictions.shape[0]):\n plt.subplot(4,4, i+1)\n img = tf.constant(predictions[i]) #Turn prediction into tf.constant\n #so it can easily be transformed int a uint8 array\n img = tf.image.convert_image_dtype(img, tf.uint8)\n plt.imshow(img)#Show the images in color\n plt.axis(\"off\")\n #for()\n\n #update epoch_total or create a new tracker\n if os.path.exists(os.path.join(\"outputColor\",\"epoch_total.txt\")):\n f = open(os.path.join(\"outputColor\",\"epoch_total.txt\"),\"r\")\n epoch = int(f.readline()) + 1\n print(\"Total Epochs:{}\".format(epoch))\n f = open(os.path.join(\"outputColor\",\"epoch_total.txt\"),\"w\")\n f.write(str(epoch))\n #if()\n else:\n f = open(os.path.join(\"outputColor\",\"epoch_total.txt\"),\"w\")\n f.write(str(epoch))\n #else()\n f.close()\n\n plt.savefig(\"outputPhotosColor/image_at_epoch_{:04d}.png\".format(epoch)) #save image\n #plt.show() # Turn on to show each new image after it's made\n plt.close()","def generate_and_save_images(model, seed, output_path, title):\n\n predictions = model(tf.Variable(seed, trainable=False))\n\n fig = plt.figure(figsize=(4,4))\n\n for i in range(predictions.shape[0]):\n plt.subplot(4, 4, i+1)\n plt.imshow(denormalize_generate_image(predictions[i, :, :, 0]), cmap='gray')\n plt.axis('off')\n if not os.path.exists(output_path):\n os.mkdir(output_path)\n\n plt.savefig(os.path.join(output_path, '{}.png'.format(title)))\n plt.close()","def test_plot_images(self):\n save_file(self.quart.plot_images)","def save_images(args,path,images, epoch, nrow=None):\n if nrow == None:\n nrow = int(np.floor(np.sqrt(images.size(0)\n )))\n\n img = torchvision.utils.make_grid(images, nrow=nrow, normalize=True).numpy()\n img = np.transpose(img, (1,2,0))\n\n plt.figure()\n plt.imshow(img)\n plt.savefig(path+\"/epoch{:04d}\".format(epoch))\n plt.close()","def visualize(**images):\n n_images = len(images)\n plt.figure(figsize=(20,8))\n for idx, (name, image) in enumerate(images.items()):\n plt.subplot(1, n_images, idx + 1)\n plt.xticks([]); \n plt.yticks([])\n # get title from the parameter names\n plt.title(name.replace('_',' ').title(), fontsize=20)\n plt.imshow(image)\n plt.savefig('sample_gt_pred_2_max.jpeg')\n plt.show()","def plot_reconstruction_images(inputs, pred, name):\n\n plt.clf()\n nb_plots = min(inputs.shape[0], 4)\n #inputs\n for i in range(nb_plots):\n ax = plt.subplot2grid((2, nb_plots), (0, i), rowspan=1, colspan=1)\n ax.imshow(inputs[i])\n ax.axis('off')\n #pred\n for i in range(nb_plots):\n ax = plt.subplot2grid((2, nb_plots), (1, i), rowspan=1, colspan=1)\n ax.imshow(pred[i])\n ax.axis('off')\n\n if name != None:\n plt.savefig(name, format='svg', bbox_inches='tight')\n else:\n plt.show()","def visualize(**images):\n n = len(images)\n plt.figure(figsize=(16, 5))\n for i, (name, image) in enumerate(images.items()):\n plt.subplot(1, n, i + 1)\n plt.xticks([])\n plt.yticks([])\n plt.title(' '.join(name.split('_')).title())\n plt.imshow(image)\n plt.show()\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')","def save_images(self, step, images):\n\n # Save\n with self.summary_writer.as_default():\n for name, batch in images.items():\n image = batch[0]\n image = tf.expand_dims(image, axis=0)\n tf.summary.image(name, image, step)","def save_images(self, sess, epoch):\n if not os.path.exists(self._images_dir):\n os.makedirs(self._images_dir)\n\n names = ['inputA_', 'inputB_', 'fakeA_',\n 'fakeB_', 'cycA_', 'cycB_']\n\n with open(os.path.join(\n self._output_dir, 'epoch_' + str(epoch) + '.html'\n ), 'w') as v_html:\n for i in range(0, self._num_imgs_to_save):\n print(\"Saving image {}/{}\".format(i, self._num_imgs_to_save))\n inputs = sess.run(self.inputs)\n fake_A_temp, fake_B_temp, cyc_A_temp, cyc_B_temp = sess.run([\n self.fake_images_a,\n self.fake_images_b,\n self.cycle_images_a,\n self.cycle_images_b\n ], feed_dict={\n self.input_a: inputs['images_i'],\n self.input_b: inputs['images_j']\n })\n\n tensors = [inputs['images_i'], inputs['images_j'],\n fake_B_temp, fake_A_temp, cyc_A_temp, cyc_B_temp]\n\n for name, tensor in zip(names, tensors):\n image_name = name + str(epoch) + \"_\" + str(i) + \".jpg\"\n imsave(os.path.join(self._images_dir, image_name),\n ((tensor[0] + 1) * 127.5).astype(np.uint8)\n )\n v_html.write(\n \"<img src=\\\"\" +\n os.path.join('imgs', image_name) + \"\\\">\"\n )\n v_html.write(\"<br>\")","def save_dataset_visual(lines, output_dir):\n\n # Ensure output directory exists\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n cols = 3\n rows = 3\n fig_size = (7 * cols, 4 * rows) # Figure width and height, in inches\n # Random sample of images\n save_name = \"training_data_sample.png\"\n fig, ax = plt.subplots(rows, cols, figsize=fig_size)\n for row in range(rows):\n for col in range(cols):\n idx = np.random.randint(0, len(lines))\n ax[row, col].imshow(ndimage.imread(lines[idx][0]))\n ax[row, col].set_title(\"Angle = \" + str(round(lines[idx][1], 3)))\n plt.savefig(output_dir + save_name, bbox_inches='tight')\n # Distribution of steering angles\n save_name = \"data_histogram.png\"\n fig_size = (5, 3) # Figure width and height, in inches\n num_bins = 100\n angles = np.array([line[1] for line in lines])\n hist, bins = np.histogram(angles, bins=num_bins)\n fig = plt.figure(figsize=fig_size)\n plt.bar(bins[:-1], hist)\n plt.xlabel(\"Steering Angle\")\n plt.ylabel(\"Frequency\")\n plt.title(\"Distribution of Steering Angles in Training Data\")\n plt.savefig(output_dir + save_name, bbox_inches='tight')","def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\n viz.evaluate()\n if upsampled == True:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\n else:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\n viz.visualizer.show(outpath=outpath_, clear_figure=True)","def main(image_path):\n temp_dir = tempfile.mkdtemp()\n print('Saving output to {}'.format(temp_dir))\n estimator = run_image(image_path)\n visualize(estimator, image_path, temp_dir)","def __save_datasets(self):\n self.train.to_csv('{}/{}/{}'.format(path_to_train_set, img_format, 'train.csv'))\n self.valid.to_csv('{}/{}/{}'.format(path_to_valid_set, img_format, 'valid.csv'))\n self.test.to_csv('{}/{}/{}'.format(path_to_test_set, img_format, 'test.csv'))","def save_images(self, sess, epoch):\n if not os.path.exists(self._images_dir):\n os.makedirs(self._images_dir)\n\n if not os.path.exists(os.path.join(self._images_dir, 'imgs')):\n os.makedirs(os.path.join(self._images_dir, 'imgs'))\n \n names = ['inputB_', 'fakeB_depth_' , 'cycB_']\n\n with open(os.path.join(\n self._output_dir, 'epoch_' + str(epoch) + '.html'), 'w') as v_html:\n for i in range(0, self._num_imgs_to_save):\n print(\"Saving image {}/{}\".format(i, self._num_imgs_to_save))\n x1_t, name1 = self.dataset.next_batch()\n count = 0\n fake_A_temp, cyc_B_temp = sess.run([\n self.fake_images_a,\n self.cycle_images_b], \n feed_dict={self.input_b: x1_t})\n \n fakedepth = fake_A_temp[:,:,:,-1]\n tensors = [x1_t, fakedepth, cyc_B_temp]\n\n for name, tensor in zip(names, tensors):\n #print(name)\n # if name == 'inputB_' or name == 'fakeB_depth_':\n # image_name = name1[count] + '_' + name + str(epoch) + \"_\" + str(i) + \".jpg\"\n # imsave(os.path.join(self._images_dir, 'imgs', image_name), ((tensor[0] + 1) * 127.5).astype(np.uint8))\n # else:\n image_name = name + str(epoch) + \"_\" + str(i) + \".jpg\"\n imsave(os.path.join(self._images_dir, image_name), ((tensor[0] + 1) * 127.5).astype(np.uint8))\n v_html.write(\n \"<img src=\\\"\" +\n os.path.join('imgs', image_name) + \"\\\">\"\n )\n v_html.write(\"<br>\")\n count += 1","def show_train_images(train_data, train_labels):\n plt.figure(1, figsize=(8, 8))\n n = 0\n\n for i in range(16):\n n += 1\n # each time random images are loaded\n # r = np.random.randint(0, train_data.shape[0], 1)\n plt.subplot(4, 4, n)\n plt.subplots_adjust(hspace=0.5, wspace=0.5)\n plt.imshow(train_data[i] / 255.)\n plt.title('{}'.format(train_labels[i]))\n plt.xticks([]), plt.yticks([])\n plt.show()","def generate_images(self, model, test_input, step, dst_dir):\n prediction = model(test_input)\n\n plt.figure(figsize=(12, 12))\n display_list = [test_input[0], prediction[0]]\n title = ['Input Image', 'Predicted Image']\n\n for i in range(2):\n plt.subplot(1, 2, i+1)\n plt.title(title[i])\n # getting the pixel values between [0, 1] to plot it.\n plt.imshow(display_list[i] * 0.5 + 0.5)\n plt.axis('off')\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\n plt.savefig(filename)","def quick_plot_save(self, mode='png'):\n batch = self.meta['batch']\n cellid = self.meta['cellid']\n modelname = self.meta['modelname']\n\n fig = plt.figure(figsize=(8, 9))\n plot_set = []\n for idx, m in enumerate(self.modules):\n if m.auto_plot:\n plot_set.append(idx)\n \n for sp, idx in enumerate(plot_set):\n m=self.modules[idx]\n log.info(self.mod_names[idx])\n plt.subplot(len(plot_set), 1, sp+1)\n m.do_plot(m)\n \n if len(plot_set)<6:\n plt.tight_layout()\n\n filename = (\n sc.DIRECTORY_ROOT + \"nems_saved_images/batch{0}/{1}/{2}.{3}\"\n .format(batch, cellid, modelname, mode)\n )\n\n if AWS:\n s3 = boto3.resource('s3')\n key = filename[len(sc.DIRECTORY_ROOT):]\n fileobj = io.BytesIO()\n fig.savefig(fileobj, format=mode)\n fileobj.seek(0)\n s3.Object(sc.PRIMARY_BUCKET, key).put(Body=fileobj)\n # return (\"s3://\" + sc.PRIMARY_BUCKET + \"/\" + key)\n else:\n dr = (\n sc.DIRECTORY_ROOT\n + \"nems_saved_images/batch{0}/{1}/\".format(batch, cellid)\n )\n try:\n os.stat(dr)\n if os.path.isfile(filename):\n os.remove(filename)\n except BaseException:\n os.mkdir(dr)\n\n try:\n fig.savefig(filename)\n except Exception as e:\n log.warn(\"Bad file extension for figure or couldn't save\")\n raise e\n\n try:\n os.chmod(filename, 0o666)\n except Exception as e:\n log.warn(\"Couldn't modify file permissions for figure\")\n raise e\n\n return filename","def view_image(train_dataloader):\n for (x, target) in train_dataloader:\n np.save(\"img.npy\", x)\n print(x.shape)\n exit(0)","def save_plot_as_image(self):\r\n plt.savefig(ROOT_DIR + '/presentation/images/' + self.folder + '/' + self.generated_image_name + '.png',\r\n bbox_inches='tight')","def train_visualization(output_path): \n log_path = output_path + 'output.log'\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\n n_epoch = len(Train_Cost)\n\n x1 = range(n_epoch)\n x2 = range(n_epoch)\n y1 = Train_Cost\n y2 = Valid_Cost\n y3 = Test_Cost\n y4 = Train_Acc\n y5 = Valid_Acc\n y6 = Test_Acc\n plt.subplot(2, 1, 1)\n plt.plot(x1, y1, label=\"Train_Cost\", linewidth=2)\n plt.plot(x1, y2, label=\"Valid_Cost\", linewidth=2)\n plt.plot(x1, y3, label=\"Test_Cost\", linewidth=2)\n\n plt.title('binary cross entropy vs. epoches')\n plt.ylabel('binary cross entropy')\n plt.legend(loc='best')\n plt.subplot(2, 1, 2)\n plt.plot(x2, y4, label=\"Train_Acc\", linewidth=2)\n plt.plot(x2, y5, label=\"Valid_Acc\", linewidth=2)\n plt.plot(x2, y6, label=\"Test_Acc\", linewidth=2)\n plt.xlabel('Accuracy@20 vs. epoches')\n plt.ylabel('Accuracy@20')\n plt.legend(loc='best')\n plt.savefig(output_path + 'loss_fig.png')\n # plt.show()","def plot_callback(model):\n\n # Get samples & Display them\n pred_img = model.predict([masked, mask])\n pred_time = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')\n\n # Clear current output and display test images\n combine_imgs = np.concatenate([pred_img, masked, mask, ori], axis=2)\n for i in range(len(combine_imgs)):\n img_array = combine_imgs[i]\n img = Image.fromarray(img_array.astype(np.uint8))\n img.save(r'data/train_samples/img_{}_{}.png'.format(i, pred_time))","def save_figures(expt):\n if isinstance(expt, str):\n expt = get_experiment(expt)\n \n tr_expt = get_training_expt(expt)\n\n storage.ensure_directory(expt.figures_dir())\n\n for it in tr_expt.save_after:\n for avg in AVG_VALS:\n print 'Iteration', it\n try:\n rbm = load_rbm(expt, it, avg)\n except:\n continue\n final_states = storage.load(expt.final_states_file(it, avg))\n gibbs_states = storage.load(expt.gibbs_states_file(it, avg))\n\n fig = rbm_vis.show_particles(rbm, final_states, expt.dataset)\n misc.save_image(fig, expt.final_states_figure_file(it, avg))\n\n fig = rbm_vis.show_particles(rbm, gibbs_states, expt.dataset)\n misc.save_image(fig, expt.gibbs_states_figure_file(it, avg))\n\n print_log_probs(expt, open(expt.log_probs_text_file(), 'w'))","def save_plot(self):\r\n\t\t# Generate the plot\r\n\t\tself.generate_plot()\r\n\t\t# Create save directory\r\n\t\tdirectory = self.dir + '/%s/' % str(int(self.universe.init_time))\r\n\t\tif not path_exists(directory):\r\n\t\t\tmakedirs(directory)\r\n\t\t# Save image file\r\n\t\tself.fig.savefig(directory+str(self.universe.time))","def plot_predictions(model, dataset=None, sample_batch=None, num=1, save_filepaths=None):\n if save_filepaths is not None:\n assert isinstance(save_filepaths, list) and len(save_filepaths) == num\n if dataset is not None:\n for i, (image, mask) in enumerate(dataset.take(num)):\n pred_raster = model.predict(image)\n display_sample([image[0], mask, create_mask(pred_raster)])\n if save_filepaths is not None:\n fig = plt.gcf()\n fig.savefig(save_filepaths[i], bbox_inches='tight', dpi=300)\n else:\n image, mask = sample_batch\n pred_raster = model.predict(image)\n pred_mask = create_mask(pred_raster)\n for i in range(num):\n display_sample([image[i], mask[i], pred_mask[i]])\n if save_filepaths is not None:\n fig = plt.gcf()\n fig.savefig(save_filepaths[i], bbox_inches='tight', dpi=300)","def save_reconstructed_images(self, filename, rows, cols):\n # print(filename)\n num_images = self.reconstructed.shape[0]\n images = np.zeros((rows, cols*num_images))\n for i in range(num_images):\n start = int(i * cols)\n end = int((i+1) * cols)\n images[0:rows, start:end] = self.reconstructed[i].reshape((rows, cols))\n\n plt.imshow(images, cmap='gray', aspect='equal', interpolation='none')\n #plt.show()\n plt.savefig(filename)\n return","def save_model_data():\n print(\"Getting the training, validation, and testing sets...\")\n df = get_data()\n\n # First read in & group by type\n image_styles = {key: [] for key in df['Period'].unique()}\n for pic in df.to_dict(\"records\"):\n db = pic['file'][:pic['file'].find(\"_\")]\n img = Image.open(os.path.join(MODEL_DIR, f\"{db}/sculpture_images/{pic['file']}\"))\n img.load()\n image_styles[pic['Period']].append(img)\n\n\n # Split each type up...not just the whole thing\n for style in image_styles.keys():\n # Split into Train/Test - 75/25\n feats, labels = image_styles[style], [style] * len(image_styles[style])\n feat_train, feat_test, label_train, label_test = train_test_split(feats, labels, test_size=.25, random_state=42)\n\n # Create dirs if needed\n for pic_type in ['train', 'test']:\n if not os.path.exists(os.path.join(MODEL_DIR, f\"model_data/gan/{pic_type}/{style}\")):\n os.makedirs(os.path.join(MODEL_DIR, f\"model_data/gan/{pic_type}/{style}\"))\n\n # Save in train/validation/test folders\n for style_type_pics in [[\"train\", feat_train], [\"test\", feat_test]]:\n for pic in range(len(style_type_pics[1])):\n file_name = style + format(pic, '03d') + \".jpg\"\n if not os.path.isfile(os.path.join(MODEL_DIR, f\"model_data/gan/{style_type_pics[0]}/{style}/{file_name}\")):\n style_type_pics[1][pic].save(os.path.join(MODEL_DIR, f\"model_data/gan/{style_type_pics[0]}/{style}/{file_name}\"))\n\n print(\"Split data for\", style)","def cb_save(event):\n fig.savefig('sample.univariate_discrete.py.png', dpi=300, format='png', transparent=True)","def save_images(images, filenames, output_dir):\n for i, filename in enumerate(filenames):\n # Images for inception classifier are normalized to be in [-1, 1] interval,\n # so rescale them back to [0, 1].\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\n imsave(f, (images[i, :, :, :] + 1.0) * 0.5, format='png')","def save_images(images, filenames, output_dir):\n for i, filename in enumerate(filenames):\n # Images for inception classifier are normalized to be in [-1, 1] interval,\n # so rescale them back to [0, 1].\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\n imsave(f, (images[i, :, :, :] + 1.0) * 0.5, format='png')","def save_images(images, filenames, output_dir):\n for i, filename in enumerate(filenames):\n # Images for inception classifier are normalized to be in [-1, 1] interval,\n # so rescale them back to [0, 1].\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\n imsave(f, (images[i] + 1.0) * 0.5, format='png')","def plot_example_images(\n output_dir, epoch, generator, label_imgs, test_imgs, imgs_count,\n examples=4):\n random_ints = np.random.randint(0, imgs_count, examples)\n image_batch_hr = denormalize(label_imgs[random_ints])\n image_batch_lr = test_imgs[random_ints]\n gen_img = generator.predict(image_batch_lr)\n generated_image = denormalize(gen_img)\n image_batch_lr = denormalize(image_batch_lr)\n\n plt.clf()\n\n for idx in range(examples):\n plt.subplot(examples, 3, 1 + idx * 3)\n plt.imshow(image_batch_lr[idx], interpolation='nearest')\n plt.axis('off')\n\n plt.subplot(examples, 3, 2 + idx * 3)\n plt.imshow(generated_image[idx], interpolation='nearest')\n plt.axis('off')\n\n plt.subplot(examples, 3, 3 + idx * 3)\n plt.imshow(image_batch_hr[idx], interpolation='nearest')\n plt.axis('off')\n\n plt.subplots_adjust(wspace=0.01)\n plt.savefig(\n path.join(output_dir, f'generated_image_{epoch}.svg'),\n bbox_inches='tight', pad_inches=0, )","def main():\n nn = CarsClassifierModel()\n train_x, train_y, test_x, test_y = nn.load_data_preprocess()\n history = nn.run(train_x,train_y)\n nn.evaluate(test_x, test_y)\n nn.save(\"keras_nn_5\")\n #nn.plots(history)\n #print(train_x.shape)\n #plt.imshow(train_x[52])\n #plt.title(\"Car\")\n #plt.show()\n #print(train_y[52])","def save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image):\n # Make folder for current run\n output_dir = os.path.join(runs_dir, str(time.time()))\n if os.path.exists(output_dir):\n shutil.rmtree(output_dir)\n os.makedirs(output_dir)\n\n # Run NN on test images and save them to HD\n print('Training Finished. Saving test images to: {}'.format(output_dir))\n image_outputs = gen_test_output(sess, logits, keep_prob, input_image, os.path.join(\n data_dir, 'data_road', 'testing'), image_shape)\n for name, image in image_outputs:\n scipy.misc.imsave(os.path.join(output_dir, name), image)","def prediction():\r\n\r\n loaded_model = load_model('imageTrainedModel.h5')\r\n print(loaded_model.summary())\r\n\r\n # retrieve history also:\r\n f = open('history.pckl', 'rb')\r\n history = pickle.load(f)\r\n f.close()\r\n\r\n print(history.keys())\r\n print(history)\r\n\r\n epochs = len(history['loss']) # length of the list stored at 'loss'\r\n # Plot losses for train and validation\r\n plt.figure()\r\n plt.title('Loss as training progresses')\r\n plt.xlabel('Epoch')\r\n plt.ylabel('Loss')\r\n plt.plot(history['loss'], label='Train Error')\r\n plt.plot(history['val_loss'], label='Val Error')\r\n plt.legend()\r\n plt.show()\r\n\r\n # Plot metrics\r\n plt.plot(history['acc']) # use same metric that was used for training. 'history' is a dictionary.\r\n plt.title('Accuracy as training progresses')\r\n plt.ylabel('Accuracy (%)')\r\n plt.xlabel('Epoch')\r\n ymax = max(history['acc'])\r\n xpos = history['acc'].index(ymax)\r\n xmax = xpos\r\n plt.annotate('Maximum accuracy: %s' % round(ymax, 3),\r\n xy=(xmax, ymax), xycoords='data',\r\n xytext=(0.5, 0.5), textcoords='axes fraction',\r\n fontsize=12)\r\n plt.show()\r\n\r\n # make predictions using x_test\r\n test_y_predictions = loaded_model.predict(x_test, batch_size=None, verbose=1, steps=None)\r\n test_y_predictions = np.around(test_y_predictions, decimals=0) # round to whole integers\r\n true_false_array = np.equal(y_test, test_y_predictions) # test of equality.\r\n true_count = np.sum(true_false_array) # number of correctly categorised images\r\n false_count = true_false_array.shape[0] - true_count # number of images not correctly categorised\r\n\r\n # Plot predicted and actual image categories\r\n fig = plt.figure()\r\n ax1 = fig.add_subplot(111)\r\n plt.title('Classification of Image Categories')\r\n plt.ylabel('Number of Images')\r\n plt.xlabel('Image Classification')\r\n label = ['Correct', 'Incorrect']\r\n index = np.arange(len(label))\r\n plt.xticks(index, label, fontsize=10, rotation=0)\r\n ax1.bar(index, [true_count, false_count])\r\n plt.show()","def visualize_manipulation_training(flow, epoch, save_dir=None):\n\n # Basic figure setup\n images_x = 3\n images_y = 3 if isinstance(flow.codec, DCN) else 2\n fig = Figure(figsize=(18, 10 / images_x * images_y))\n conf = np.array(flow.fan.performance['confusion'])\n \n # Draw the plots\n ax = fig.add_subplot(images_y, images_x, 1)\n ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))\n ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))\n ax.set_title('Loss')\n\n ax = fig.add_subplot(images_y, images_x, 2)\n ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))\n ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))\n ax.set_title('PSNR')\n ax.set_ylim([30, 50])\n\n ax = fig.add_subplot(images_y, images_x, 3)\n ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))\n ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))\n ax.set_title('SSIM')\n ax.set_ylim([0.8, 1])\n \n ax = fig.add_subplot(images_y, images_x, 4)\n ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))\n ax.set_ylabel('FAN loss')\n\n ax = fig.add_subplot(images_y, images_x, 5)\n ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'], 0))\n ax.set_ylabel('FAN accuracy')\n ax.set_ylim([0, 1])\n\n # The confusion matrix\n ax = fig.add_subplot(images_y, images_x, 6)\n ax.imshow(conf, vmin=0, vmax=1)\n\n ax.set_xticks(range(flow.n_classes))\n ax.set_xticklabels(flow._forensics_classes, rotation='vertical')\n ax.set_yticks(range(flow.n_classes))\n ax.set_yticklabels(flow._forensics_classes)\n\n for r in range(flow.n_classes):\n ax.text(r, r, '{:.2f}'.format(conf[r, r]), horizontalalignment='center', color='b' if conf[r, r] > 0.5 else 'w')\n\n ax.set_xlabel('PREDICTED class')\n ax.set_ylabel('TRUE class')\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\n\n # If the compression model is a trainable DCN, include it's validation metrics\n if images_y == 3:\n ax = fig.add_subplot(images_y, images_x, 7)\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\n ax.set_ylabel('DCN loss')\n\n ax = fig.add_subplot(images_y, images_x, 8)\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\n ax.set_ylabel('DCN ssim')\n ax.set_ylim([0.8, 1])\n\n ax = fig.add_subplot(images_y, images_x, 9)\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\n ax.set_ylabel('DCN entropy')\n\n if save_dir is not None:\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\n del fig\n\n else:\n return fig","def saving_test_images(self, segmented_images_dir, data_test_dir, session,\\\n\t\t\t\t\t\t\t image_shape, logits, keep_prob, input_image):\n\n\t\tprint('Training Done ...')\n\t\t# get the segmented result for all images\n\t\timage_outputs = self.segment_images(session, logits, keep_prob, input_image,\\\n\t\t\t\t\t\t\t\t\t\t\t data_test_dir, image_shape)\n\t\t# save all the images at the required path\n\t\tfor name, image in image_outputs:\n\t\t\tscipy.misc.imsave(os.path.join(segmented_images_dir, name), image)","def plot_eval_1(trained_model, image_name):\n # Get training evaluation data\n train_accuracy = trained_model.history['acc']\n train_val_accuracy = trained_model.history['val_acc']\n train_loss = trained_model.history['loss']\n train_val_loss = trained_model.history['val_loss']\n \n # Generate accuracy plot\n epochs = range(len(train_accuracy))\n plt.figure()\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\n plt.title('Training and validation accuracy')\n plt.legend()\n \n # Save accuracy plot\n plot_file = os.path.join(OUTPUT_DIR,\n \"{}_training_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')\n \n # Generate loss plot\n plt.figure()\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n \n # Save loss plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_training_loss\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def plot(path, subjects):\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\n data = data_load.load_data(path, subjects)\n dimx = int(data[0][\"meta\"][\"dimx\"][0])\n dimy = int(data[0][\"meta\"][\"dimy\"][0])\n dimz = int(data[0][\"meta\"][\"dimz\"][0])\n coordToCol = data[0][\"meta\"][\"coordToCol\"][0][0]\n images = {}\n max_val = 0\n voxels = np.load(\"data/general_selected_500_1.npy\")\n directory = os.listdir(\"data/input/\")\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\n for file in directory:\n file_name = \"data/input/{}\".format(file)\n fh = open(file_name)\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\",\")))))\n fh.close()\n plot_matrix = np.zeros((dimx, dimy, dimz))\n for x in range(dimx):\n for y in range(dimy):\n for z in range(dimz):\n indice = coordToCol[x][y][z]\n if indice != 0:\n if indice in list(voxels):\n voxel_indice = list(voxels).index(indice)\n value = activation_values[voxel_indice]\n if abs(value) > max_val:\n max_val = abs(value)\n plot_matrix[x][y][z] = value\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\n images[file_name] = image\n bar.update(force_flush=True)\n print(bar)\n for image in images:\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\"{}-wom1.png\".format(image))\n bar2.update(force_flush=True)\n print(bar2)","def save_images(images, filenames, output_dir):\n for i, filename in enumerate(filenames):\n # Images for inception classifier are normalized to be in [-1, 1] interval,\n # so rescale them back to [0, 1].\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\n img = (((images[i, :, :, :] + 1.0) * 0.5) * 255.0).astype(np.uint8)\n Image.fromarray(img).save(f, format='PNG')","def save_images(images, filenames, output_dir):\n for i, filename in enumerate(filenames):\n\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\n image = images[i, :, :, :]\n image[:, :, 0] += _R_MEAN\n image[:, :, 1] += _G_MEAN\n image[:, :, 2] += _B_MEAN\n image = imresize(image, [299, 299])\n imsave(f, image, format='png')","def visualize(base_path, test_dataset, plot_dir, batch_size=4, ):\n device = torch.device('cuda')\n dataset = HeadDataset(test_dataset,\n base_path,\n dataset_param={},\n train=False)\n batch_iterator = iter(data.DataLoader(dataset, batch_size,\n shuffle=False,\n num_workers=4,\n collate_fn=coco_collate))\n for ind, (images, targets) in enumerate(tqdm(batch_iterator)):\n images = list(img.to(device) for img in images)\n np_images = [(ims.cpu().numpy()*255.).astype(np.uint8) for ims in images]\n gt_boxes = [gt['boxes'].numpy().astype(np.float64) for gt in targets]\n for np_im, gt_box in zip(np_images, gt_boxes):\n plot_images = plot_ims(np_im, [], gt_box)\n imsave(osp.join(plot_dir, str(ind) + '.jpg'), plot_images)","def save_imgs(self, epoch):\n row, column = 5, 5\n\n # Generates r*c images from the model, saves them individually and as a gallery\n images_generated = self.generate_images(row * column)\n\n # ???\n images_generated = 0.5 * images_generated + 0.5\n\n for index, np_array_image in enumerate(images_generated):\n path = f\"{self.output_directory}/generated_{self.img_size[0]}x{self.img_size[1]}\"\n if not os.path.exists(path):\n os.makedirs(path)\n imsave(path + f\"/{unique_name()}_{epoch}_{index}.png\", np_array_image)\n\n # 4D array:\n nindex, height, width, intensity = images_generated.shape\n\n nrows = nindex // column\n\n assert nindex == nrows * column\n\n # Form the gallery by combining the data at pixel levels (may not be the best approach)\n # want result.shape = (height*n-rows, width*n-cols, intensity)\n gallery = (\n images_generated.reshape(nrows, column, height, width, intensity)\n .swapaxes(1, 2)\n .reshape(height * nrows, width * column, intensity)\n )\n\n path = f\"{self.output_directory}/gallery_generated_{self.img_size[0]}x{self.img_size[1]}\"\n if not os.path.exists(path):\n os.makedirs(path)\n imsave(path + f\"/{unique_name()}_{epoch}.png\", gallery)","def save_images(images, filenames, output_dir):\n for i, filename in enumerate(filenames):\n # Images for inception classifier are normalized to be in [-1, 1] interval,\n # so rescale them back to [0, 1].\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\n img = np.round(((images[i] + 1.0) * 0.5) * 255.0).astype(np.uint8)\n Image.fromarray(img).save(f, format='PNG')","def visualize_training(features, labels, pl):\n print(\"Visualizing training\")\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n # Take out each feature type, one at a time\n label_map = get_label_map(labels)\n\n for key in label_map.keys():\n like_ind = label_map[key]\n like_data = np.array([features[i] for i in like_ind])\n\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\n\n # get limits\n xmin = features.column_min(0) - .5\n xmax = features.column_max(0) + .5\n ymin = features.column_min(1) - .5\n ymax = features.column_max(1) + .5\n\n plt.xlim(xmin,xmax)\n plt.ylim(ymin,ymax)\n\n # Track the current dividing line, as well as the number of epochs passed\n divider, = plt.plot([],[])\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\n\n def update(i):\n \"\"\"\n 1.) Get the next set of weights from the tracker\n 2.) Calculate and draw the new divider line\n 3.) Update the epoch counter\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\n \"\"\"\n epoch = i//features.instance_count\n w = pl.weights_tracker[i]\n a = pl.accuracy_tracker[epoch]\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\n epoch_tracker.set_text(\"{} {}\".format(epoch + 1, a))\n\n # Keep a shadow of the hyperplane at the end of each epoch\n if i % features.instance_count == 0:\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\n\n return divider\n\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\n plt.legend()\n\n # optional save file\n if len(sys.argv) >= 3 :\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\n\n plt.show()","def plot_eval_2(trained_model, image_name):\n # Get training evaluation data\n train_accuracy = trained_model.history['acc']\n train_val_accuracy = trained_model.history['val_acc']\n train_loss = trained_model.history['loss']\n train_val_loss = trained_model.history['val_loss']\n \n # Generate accuracy plot\n epochs = range(len(train_accuracy))\n plt.figure()\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\n plt.title('Training and validation accuracy')\n plt.legend()\n \n # Save accuracy plot\n plot_file = os.path.join(OUTPUT_DIR,\n \"{}_training_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')\n \n # Generate loss plot\n plt.figure()\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\n plt.title('Training and validation loss')\n plt.legend()\n \n # Save loss plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_training_loss\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def train_one_epoch_Image_display(self):\n print('Training......')\n\n # set mode train\n self.network.train()\n\n # prepare data\n train_loss = 0\n transform = transforms.Compose([Rescale(params.rescale_size),\n RandomCrop(params.image_size),\n RandomHorizontalFlip(),\n ToTensor()\n ])\n\n\n\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\n\n train_loader = DataLoader(dataset,\n batch_size=params.train_batch,\n shuffle=params.shuffle,\n num_workers=params.dataloader_workers)\n \n train_size = 1896\n if train_size % self.params.train_batch != 0:\n total_batch = train_size // self.params.train_batch + 1\n else:\n total_batch = train_size // self.params.train_batch\n recal = 0\n precision = 0\n F_one = 0\n IOU = 0\n accuracy_new = 0 \n # train through dataset\n for batch_idx, batch in enumerate(train_loader):\n self.pb.click(batch_idx, total_batch)\n image, label = batch['image'], batch['label']\n image_cuda, label_cuda = image.cuda(), label.cuda()\n\n # checkpoint split\n if self.params.should_split:\n image_cuda.requires_grad_()\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\n else:\n out = self.network(image_cuda)\n \n pred = image_cuda\n pred = pred.to(torch.device(\"cpu\"))\n pred = pred.detach()\n img_grid = pred[0]\n #img_grid = torchvision.utils.make_grid(out) \n img_grid = img_grid.numpy().transpose(1, 2, 0)*255\n cv2.imwrite(\"/content/drive/My Drive/Train_images/original%d.jpg\" % batch_idx, img_grid)\n\n \n loss = self.loss_fn(out, label_cuda)\n \n #display_image(out, label_cuda)\n TP, FP, TN, FN = confusion(out, label_cuda)\n recal = recal+TP\n precision = precision+FP\n F_one = F_one + TN\n IOU = IOU+ FN \n _,predict = torch.max(out.data,1)\n predict = predict.to(torch.device(\"cpu\"))\n predict = predict.detach()\n img = predict[0]\n img = img.numpy()*255\n #img_grid = torchvision.utils.make_grid(out) \n cv2.imwrite(\"/content/drive/My Drive/Train_images/predict_label%d.png\" % batch_idx, img)\n label = label_cuda.to(torch.device(\"cpu\"))\n label = label.detach()\n label = label[0].numpy()*255\n cv2.imwrite(\"/content/drive/My Drive/Train_images/original_label%d.png\" % batch_idx, label)\n\n \n \n\n accuracy_final = accuracy(out, label_cuda)\n accuracy_new = accuracy_new + accuracy_final\n\n \n print(\"\\t\")\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\n print(accuracy_new/total_batch)","def _update(self):\n print(\"Saving prediction json files...\")\n self._dump_json()\n print(\"Saving prediction json files done...\")\n print(\"Saving prediction images...\")\n self._dump_image()\n print(\"Saving prediction images done...\")","def draw_image(self):\n \n pixel_array = self.imageprepare(self.image_path)\n newArr = self.reshape_pixel_array(pixel_array)\n plt.imshow(newArr, interpolation='nearest')\n plt.savefig('MNIST_IMAGE.png')#save MNIST image\n plt.show()#Show / plot that image","def save_test_images(images):\n for description, img in images.items():\n save_to_image(img, description)\n save_to_netcdf(img, description)","def main():\n\n # first figure: betas for each predictor\n fig, axes = plt.subplots(figsize=(8, 18), nrows=3)\n\n image_paths = {\n \"3T\": (\n f\"{PATHS['figures_misc']}/figure_3_images/\"\n f\"C1051_20161006_childVSall_depth_1.png\"\n ),\n \"7T\": (\n f\"{PATHS['figures_misc']}/figure_3_images/\"\n f\"C1051_20160212_childVSall_depth_1_sim2pt4.png\"\n ),\n \"7T_noise\": (\n f\"{PATHS['figures_misc']}/figure_3_images/\"\n f\"C1051_20160212_childVSall_depth_1_sim2pt4_noise.png\"\n ),\n }\n\n for ax, (_, image_path) in zip(axes, image_paths.items()):\n assert os.path.isfile(image_path)\n img = imread(image_path)\n img[np.where(np.sum(img, axis=2) == 0.0)] = 1.0\n\n ax.imshow(img[200:-100, 50:-50, :])\n ax.axis(\"off\")\n\n savefig(f\"{PATHS['figures']}/figure_3ac.png\")\n plt.close(fig)","def _add_images(self, epoch, train_batch, train_outputs, valid_batch, valid_outputs):\n raise NotImplementedError","def main(): # pylint: disable=R0914, R0915\n args = parse_args()\n\n # load dataset\n test_dataset = load_dataset(dataset_name=args.dataset, dataset_part='test')\n\n # load model\n model_name = args.model\n model = load_model(model_name)\n model.load_state_dict(torch.load(args.checkpoint_path)['model'])\n model.eval()\n\n # create sets of samples of images and their corresponding saliency maps\n all_samples = []\n all_saliency_maps = []\n sample_to_image = lambda x: np.transpose(x, (1, 2, 0))\n\n for _ in range(6):\n samples, true_labels = next(iter(DataLoader(test_dataset,\n batch_size=6,\n shuffle=True)))\n all_samples.append(torch.cat([sample_to_image(s).unsqueeze(0)\n for s in samples]))\n saliency_maps = compute_gradient_saliency_maps(samples.to(device),\n true_labels.to(device),\n model)\n all_saliency_maps.append(saliency_maps.cpu().detach())\n\n all_samples = torch.cat(all_samples)\n all_saliency_maps = torch.cat(all_saliency_maps)\n\n saliency_maps_and_images_pairs = plt.figure()\n plt.suptitle('Images and their saliency maps')\n for idx, (image, saliency_map) in enumerate(zip(all_samples,\n all_saliency_maps)):\n plt.subplot(6, 6 * 2, 2 * idx + 1)\n # plot image\n image -= image.min()\n image /= image.max()\n plt.imshow(image)\n plt.xticks([])\n plt.yticks([])\n # plot saliency map\n plt.subplot(6, 6 * 2, 2 * idx + 2)\n saliency_map -= saliency_map.min()\n saliency_map /= saliency_map.max()\n plt.imshow(saliency_map)\n plt.xticks([])\n plt.yticks([])\n\n saliency_maps_and_images_pairs.set_size_inches((8, 8))\n saliency_maps_and_images_pairs.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_'\n f'saliency_maps_and_images_pairs.png'))\n\n # loop through the images in the test set and compute saliency map for\n # each image. Compute the average map of all real face image and\n # all fake face image images.\n dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)\n real_images_saliency_maps = []\n fake_images_saliency_maps = []\n\n for samples, true_labels in dataloader:\n fake_samples = samples[true_labels == 1].to(device)\n fake_labels = true_labels[true_labels == 1].to(device)\n real_samples = samples[true_labels == 0].to(device)\n real_labels = true_labels[true_labels == 0].to(device)\n saliency_maps = compute_gradient_saliency_maps(fake_samples,\n fake_labels,\n model)\n fake_images_saliency_maps.append(saliency_maps.cpu().detach())\n saliency_maps = compute_gradient_saliency_maps(real_samples,\n real_labels,\n model)\n real_images_saliency_maps.append(saliency_maps.cpu().detach())\n\n all_real_saliency_maps = torch.cat(real_images_saliency_maps)\n all_fake_saliency_maps = torch.cat(fake_images_saliency_maps)\n\n for idx in range(all_real_saliency_maps.shape[0]):\n all_real_saliency_maps[idx] -= all_real_saliency_maps[idx].min()\n all_real_saliency_maps[idx] /= all_real_saliency_maps[idx].max()\n\n for idx in range(all_fake_saliency_maps.shape[0]):\n all_fake_saliency_maps[idx] -= all_fake_saliency_maps[idx].min()\n all_fake_saliency_maps[idx] /= all_fake_saliency_maps[idx].max()\n\n mean_saliency_maps = plt.figure()\n plt.subplot(1, 2, 1)\n mean_map = all_fake_saliency_maps.mean(axis=0)\n mean_map -= mean_map.min()\n mean_map /= mean_map.max()\n plt.imshow(mean_map)\n plt.title('mean of fake images saliency maps')\n plt.subplot(1, 2, 2)\n mean_map = all_real_saliency_maps.mean(axis=0)\n mean_map -= mean_map.min()\n mean_map /= mean_map.max()\n plt.imshow(mean_map)\n plt.title('mean of real images saliency maps')\n mean_saliency_maps.set_size_inches((8, 6))\n mean_saliency_maps.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_mean_saliency_maps.png'))","def test_save_images(self):\n save_file(self.quart.save_images, to_single_file=False)","def visualize(self):\r\n self.aggregator.plot_loss()\r\n self.save_figure()","def save_step_4(imgs, output_path=\"./output/step4\"):\n # ... your code here ...\n cv2.imwrite(output_path+\"/output.jpg\", imgs)","def persist_resized_test_image_and_label(self, answer_path):\n print('writing files on new data')\n n_partition = 3\n # read the images\n images_all, names_all = self.scale_images(self.input_root_dir, image_name_flag=True)\n nb_images = len(images_all)\n # read the answer file to a dict\n answer_map = map(str.split, open(answer_path))\n name_label_dict = dict()\n for i in range(1, len(answer_map)):\n name_label_dict[answer_map[i][0]] = answer_map[i][1]\n\n images = []\n labels = []\n for name in name_label_dict.keys():\n if name in names_all:\n idx = names_all.index(name)\n images.append(images_all[idx])\n labels.append(int(name_label_dict[name]))\n\n data = zip(images, labels)\n random.shuffle(data)\n train_data, validation_data = train_test_split(data, test_size=0.1, random_state=35)\n train_images, train_labels = zip(*train_data)\n validation_images, validation_labels = zip(*validation_data)\n# train_images = images\n# train_labels = labels\n train_batch_length = len(train_images) / n_partition\n validation_batch_length = len(validation_images) / n_partition\n \n \n# while 1:\n# i = random.randint(0, len(labels)-1)\n# plt.imshow(images[i])\n# plt.title(self.reverse_label_map[labels[i]])\n n_shift = 30\n for partition_idx in range(n_partition):\n if(partition_idx < n_partition - 1):\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('train', partition_idx + n_shift)), \n [train_images[partition_idx * train_batch_length : (partition_idx + 1) * train_batch_length], \n train_labels[partition_idx * train_batch_length : (partition_idx + 1) * train_batch_length]])\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('validation', partition_idx + n_shift)), \n [validation_images[partition_idx * validation_batch_length : (partition_idx + 1) * validation_batch_length], \n validation_labels[partition_idx * validation_batch_length : (partition_idx + 1) * validation_batch_length]])\n else:\n print('last partition')\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('train', partition_idx + n_shift)), \n [train_images[partition_idx * train_batch_length:], \n train_labels[partition_idx * train_batch_length:]])\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('validation', partition_idx + n_shift)), \n [validation_images[partition_idx * validation_batch_length:], \n validation_labels[partition_idx * validation_batch_length:]])","def save_test_sample(real_imgs_lab, fake_imgs_lab1, fake_imgs_lab2, save_path, plot_size=14, scale=1.6, show=False):\n batch_size = real_imgs_lab.size()[0]\n plot_size = min(plot_size, batch_size)\n\n # create white canvas\n canvas = np.ones((plot_size*32 + (plot_size+1)*6, 4*32 + 5*8, 3), dtype=np.uint8)*255\n\n real_imgs_lab = real_imgs_lab.cpu().numpy()\n fake_imgs_lab1 = fake_imgs_lab1.cpu().numpy()\n fake_imgs_lab2 = fake_imgs_lab2.cpu().numpy()\n\n for i in range(0, plot_size):\n # post-process real and fake samples\n real_bgr = postprocess(real_imgs_lab[i])\n fake_bgr1 = postprocess(fake_imgs_lab1[i])\n fake_bgr2 = postprocess(fake_imgs_lab2[i])\n grayscale = np.expand_dims(cv2.cvtColor(real_bgr.astype(np.float32), cv2.COLOR_BGR2GRAY), 2)\n # paint\n x = (i+1)*6+i*32\n canvas[x:x+32, 8:40, :] = real_bgr\n canvas[x:x+32, 48:80, :] = np.repeat(grayscale, 3, axis=2)\n canvas[x:x+32, 88:120, :] = fake_bgr1\n canvas[x:x+32, 128:160, :] = fake_bgr2\n\n # scale\n canvas = cv2.resize(canvas, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST)\n # save\n cv2.imwrite(os.path.join(save_path), canvas)\n\n if show:\n cv2.destroyAllWindows()\n cv2.imshow('sample', canvas)\n cv2.waitKey(10000)","def load_png_data():\n m=1 #训练文件个数\n n=1 #测试文件个数\n train_set_x=[]#训练数据集\n train_set_y=[]#训练标签集\n\n test_set_x=[]#测试数据集\n test_set_y=[]#测试标签集\n\n train_data={}\n\n train_path=r\".\\dataset\\train_label\\\\\"\n dirs=os.listdir(train_path)\n\n for file in dirs:\n srcImg=cv2.imread(train_path+file)\n #将label数据集保存为numpy格式并保存\n npImg=np.array(srcImg)\n np.save(train_path+str(m)+'.npy',npImg)\n train_set_x.append(npImg)\n\n\n NoiseImg = GaussianNoise(srcImg, 25, 4, 0.8)\n npNoiseImg = np.array(NoiseImg)\n cv2.imwrite(r\".\\dataset\\trainset\\\\\"+str(m)+'.png', NoiseImg, [int(cv2.IMWRITE_PNG_STRATEGY_DEFAULT)])\n np.save(r\".\\dataset\\trainset\\\\\" + str(m) + '.npy', npNoiseImg)\n train_set_y.append(npNoiseImg)\n m=m+1\n train_data['train_set_x']=train_set_x\n train_data['train_set_y']=train_set_y\n\n test_path = r\".\\dataset\\test_label\\\\\"\n dirs_test = os.listdir(test_path)\n for file in dirs_test:\n srcImg=cv2.imread(test_path+file)\n #将label数据集保存为numpy格式并保存\n npImg=np.array(srcImg)\n np.save(test_path+str(n)+'.npy',npImg)\n test_set_x.append(npImg)\n\n\n NoiseImg = GaussianNoise(srcImg, 25, 4, 0.8)\n npNoiseImg = np.array(NoiseImg)\n cv2.imwrite(r\".\\dataset\\testset\\\\\"+str(n)+'.png', NoiseImg, [int(cv2.IMWRITE_PNG_STRATEGY_DEFAULT)])\n np.save(r\".\\dataset\\testset\\\\\" + str(n) + '.npy', npNoiseImg)\n test_set_y.append(npNoiseImg)\n n=n+1\n train_data['test_set_x']=test_set_x\n train_data['test_set_y']=test_set_y\n\n np.savez(r\"E:\\DeepLearning\\CNNDenoiser\\dataset\\train_data.npz\",**train_data)","def save_augmentation_visual(lines, output_dir):\n\n # Ensure output directory exists\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n save_name = 'data_augmentation.png'\n idx = np.random.randint(0, len(lines))\n image = ndimage.imread(lines[idx][0])\n angle = lines[idx][1]\n fig = visualize_augmentation(image, angle)\n fig.savefig(output_dir + save_name, bbox_inches='tight')","def evaluate(self):\n eval_save_dir = os.path.join(self.imsave_dir, \"test\")\n samples = self.sample(np.random.uniform(-1, 1, (self.batch_size, self.z_dim)))\n if not os.path.exists(eval_save_dir):\n os.makedirs(eval_save_dir)\n # save images\n for index, sample in enumerate(samples):\n if self.C == 1:\n imsave(os.path.join(eval_save_dir, \"%s.png\" % index), samples[index].reshape(self.H, self.W))\n else:\n imsave(os.path.join(eval_save_dir, \"%s.png\" % index),\n recover_img(samples[index].reshape(self.H, self.W, self.C)))\n\n # display some images\n row, col = 4, 4\n random_index = np.random.randint(0, self.batch_size, size=row * col)\n for i in range(row*col):\n plt.subplot(row, col, i+1)\n plt.imshow(recover_img(samples[random_index[i]].reshape(self.H, self.W, self.C))\n , cmap=\"gray\" if self.C==1 else None)\n plt.gca().axis(\"off\")\n plt.show()","def plot_predictions(images, filename):\n imagex = format_image(images, 4)\n mosaic = create_mosaic(imagex, 2, 2)\n plt.figure(figsize=(12, 12))\n plt.imshow(mosaic, cmap='gray')\n plt.axis('off')\n plt.savefig(filename + '.png', bbox_inches='tight')","def result_plotting(n_images,epoch,dataset,result_path,labels,predictions,indices):\n \n coord,connectivity = [],[] # List of prediction and ground truth images\n for k in range(n_images):\n \n or_case = int(np.where(np.array(dataset.data.case)==indices[k])[0][0]) # Get index of case\n \n # Get the coordinate and connectivity data\n coord += [dataset[or_case].coord.numpy()] \n connectivity += [dataset[or_case].connectivity.numpy()]\n\n # Save npz array with the results of this iteration\n np.savez(join(result_path,'Temp.npz'),labels=n(labels),predictions=n(predictions)\n ,indices=n(indices),coord=n(coord),connectivity=n(connectivity))\n\n # Call mesh_plotter to create the figures\n subprocess.call(['python', 'mesh_plotter.py','-p',result_path,'-e',str(epoch),'-ni',str(n_images)])\n \n # Send image for visualization in W&B\n images = wandb.Image(join(result_path,'Result_'+str(epoch).zfill(3)+'.png'),caption = \"Epoch \"+str(epoch))\n wandb.log({\"Prediction\": images})","def write_data(data_to_write_train, data_to_write_test, train_path, eval_path ,test_path):\n aligned_lists_train = data_to_write_train[0]\n raw_lists_train = data_to_write_train[2]\n\n aligned_lists_eval = data_to_write_test[0]\n raw_lists_eval = data_to_write_test[2]\n\n aligned_lists_test = data_to_write_test[1]\n raw_lists_test = data_to_write_test[3]\n\n filelist = list([train_path, eval_path, test_path])\n\n for file in filelist:\n aligned_path = os.path.join(file, 'aligned_image')\n raw_path = os.path.join(file, 'raw_image')\n os.mkdir(aligned_path)\n os.mkdir(raw_path)\n\n # raw image data\n for Idx, train_raw in enumerate(raw_lists_train):\n img = Image.open(train_raw)\n img.save(train_path+'/raw_image/img_'+f'{Idx:04d}.jpg')\n if Idx%100 == 0:\n print('\\t%d images are saved'% Idx); \n print('\\tTrain raw images saved! ')\n\n for Idx, eval_raw in enumerate(raw_lists_eval):\n img = Image.open(eval_raw)\n img.save(eval_path+'/raw_image/img_'+f'{Idx:04d}.jpg')\n if Idx%100 == 0:\n print('\\t%d images are saved'% Idx); \n print('\\tEval raw images saved! ')\n\n for Idx, test_raw in enumerate(raw_lists_test):\n img = Image.open(test_raw)\n img.save(test_path+'/raw_image/img_'+f'{Idx:04d}.jpg')\n if Idx%100 == 0:\n print('\\t%d images are saved'% Idx); \n print('\\tTest raw images saved! ')\n\n # aligned image data\n for Idx, train_aligned in enumerate(aligned_lists_train):\n img = Image.open(train_aligned)\n img.save(train_path+'/aligned_image/img_'+f'{Idx:04d}.jpg')\n if Idx%100 == 0:\n print('\\t%d images are saved'% Idx); \n print('\\tTrain aligned images saved! ')\n\n for Idx, eval_aligned in enumerate(aligned_lists_eval):\n img = Image.open(eval_aligned)\n img.save(eval_path+'/aligned_image/img_'+f'{Idx:04d}.jpg')\n if Idx%100 == 0:\n print('\\t%d images are saved'% Idx); \n print('\\tEval aligned images saved! ')\n\n for Idx, test_aligned in enumerate(aligned_lists_test):\n img = Image.open(test_aligned)\n img.save(test_path+'/aligned_image/img_'+f'{Idx:04d}.jpg')\n if Idx%100 == 0:\n print('\\t%d images are saved'% Idx); \n print('\\tTest aligned images saved! ')","def visualize(self, paths, instance, during_analysis):\r\n xvalues = np.arange(self.data.shape[0])\r\n\r\n model_data = self.model_data_from_instance(instance=instance)\r\n\r\n residual_map = self.data - model_data\r\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\r\n\r\n \"\"\"The visualizer now outputs images of the best-fit results to hard-disk (checkout `visualizer.py`).\"\"\"\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=self.data,\r\n title=\"Data\",\r\n ylabel=\"Data Values\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"data\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=model_data,\r\n title=\"Model Data\",\r\n ylabel=\"Model Data Values\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"model_data\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=residual_map,\r\n title=\"Residual Map\",\r\n ylabel=\"Residuals\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"residual_map\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=chi_squared_map,\r\n title=\"Chi-Squared Map\",\r\n ylabel=\"Chi-Squareds\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"chi_squared_map\",\r\n )","def test(file_path: str):\n # Build the generator network\n generator = build_generator()\n\n # Load model weights\n generator.load_weights(\"models/generator.h5\")\n\n # Make a low-res counterpart to predict upon\n image = imread(file_path, mode=\"RGB\")\n image = image.astype(np.float32)\n low_resolution_image = [imresize(image, low_resolution_shape)]\n\n low_resolution_image = np.array(low_resolution_image) / 127.5 - 1.0\n\n # Generate high-resolution images from low-resolution images\n generated_image = generator.predict_on_batch(low_resolution_image)\n\n # Make a common figure\n fig = plt.figure(figsize=(16, 9))\n\n # Add the low resolution image on the left side\n ax = fig.add_subplot(1, 2, 1)\n ax.imshow(low_resolution_image[0], interpolation=\"nearest\")\n ax.axis(\"off\")\n ax.set_title(\"Low-resolution\")\n\n # Add generated image to figure on the right side\n ax = fig.add_subplot(1, 2, 2)\n ax.imshow(generated_image[0], interpolation=\"nearest\")\n ax.axis(\"off\")\n ax.set_title(\"Generated\")\n\n # Save the figure\n plt.savefig(\"{0}{1}\".format(TEST_IMAGES_RESULT, file_path.split(\"/\")[-1]))","def train_test_plot():\n plt.title('Crude Oil Time-Series')\n plt.plot(train,label=\"Training Set\")\n plt.plot(test,label=\"Test Set\")\n plt.xlabel('Number of Days')\n plt.ylabel('Price in USD')\n plt.legend(loc = 'upper left')\n plt.savefig('../plots/Time-Series.jpg')","def display_sample_images(self):\n if self.train_dataset is None:\n self.init_datasets()\n\n images, labels = next(self.train_dataset)\n plt.figure(figsize=(5,5))\n for n in range(min(25, images.shape[0])):\n ax = plt.subplot(5,5,n+1)\n plt.imshow(images[n])\n if len(labels.shape) == 1:\n plt.title(self.class_names[int(labels[n])].title())\n else:\n m = np.argmax(labels[n])\n plt.title(self.class_names[int(labels[n, m])].title())\n plt.axis('off')\n\n plt.tight_layout()\n plt.show()","def save_plot(self, ):\n pass","def save():\n pl.savefig('/home/filippini/Documents/plot/RUN55/compa'+INFO_RUN+'.png')","def save_step_1(imgs, output_path='./output/step1'):\n # ... your code here ...\n i=0\n for each in imgs:\n i+=1\n cv2.imwrite(output_path+\"/output\"+str(i)+\".jpg\", each)","def visualize(original, s, m, l, s_pred, m_pred, l_pred):\n\tfig = plt.figure(figsize=(20, 10))\n\tplt.subplot(1,7,1)\n\tplt.title('Original image')\n\tplt.imshow(original)\n\n\tplt.subplot(1,7,2)\n\tplt.title('S image')\n\tplt.imshow(s)\n\tplt.subplot(1,7,3)\n\tplt.title('S Pred image')\n\tplt.imshow(s_pred)\n\n\tplt.subplot(1,7,4)\n\tplt.title('M image')\n\tplt.imshow(m)\n\tplt.subplot(1,7,5)\n\tplt.title('M Pred image')\n\tplt.imshow(m_pred)\n\n\tplt.subplot(1,7,6)\n\tplt.title('L image')\n\tplt.imshow(l)\n\tplt.subplot(1,7,7)\n\tplt.title('L Pred image')\n\tplt.imshow(l_pred)","def plot_images(imgs_org, imgs_pred, nb_examples=10):\n if nb_examples == 0:\n return\n\n n = nb_examples\n plt.figure(figsize=(nb_examples * 2, 4))\n for i in range(n):\n # display original\n ax = plt.subplot(2, n, i + 1)\n plt.imshow(imgs_org[i].reshape(84, 84))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n\n # display reconstruction\n ax = plt.subplot(2, n, i + 1 + n)\n plt.imshow(imgs_pred[i].reshape(84, 84))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n plt.show()","def save_predictions(predictions, img_paths, output_dir='predictions'):\n\n print(f'\\nSaving prediction to {output_dir} ...')\n\n if not osp.exists(output_dir):\n os.mkdir(output_dir)\n\n for pred, img_path in tqdm(zip(predictions, img_paths), total=len(predictions)):\n img_name = osp.basename(img_path)\n pred = pred.astype('uint8')\n Image.fromarray(pred * 255).save(osp.join(output_dir, img_name))","def save_sample(real_imgs_lab, fake_imgs_lab, save_path, plot_size=20, scale=2.2, show=False):\n batch_size = real_imgs_lab.size()[0]\n plot_size = min(plot_size, batch_size)\n\n # create white canvas\n canvas = np.ones((3*32 + 4*6, plot_size*32 + (plot_size+1)*6, 3), dtype=np.uint8)*255\n\n real_imgs_lab = real_imgs_lab.cpu().numpy()\n fake_imgs_lab = fake_imgs_lab.cpu().numpy()\n\n for i in range(0, plot_size):\n # postprocess real and fake samples\n real_bgr = postprocess(real_imgs_lab[i])\n fake_bgr = postprocess(fake_imgs_lab[i])\n grayscale = np.expand_dims(cv2.cvtColor(real_bgr.astype(np.float32), cv2.COLOR_BGR2GRAY), 2)\n # paint\n x = (i+1)*6+i*32\n canvas[6:38, x:x+32, :] = real_bgr\n canvas[44:76, x:x+32, :] = np.repeat(grayscale, 3, axis=2)\n canvas[82:114, x:x+32, :] = fake_bgr\n\n # scale\n canvas = cv2.resize(canvas, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST)\n # save\n cv2.imwrite(os.path.join(save_path), canvas)\n\n if show:\n cv2.destroyAllWindows()\n cv2.imshow('sample', canvas)\n cv2.waitKey(10000)","def save_processed_images(exp_dir, img_dict):\n # save them into a directory called \"processed\"\n img_fname = os.path.join(exp_dir, str(experiment) + '_processed.jpg')","def img_viewer_examples(images, labels, prediction = None, size=0, greyscale=False):\n batchSize = min(size, images.shape[0])\n \n if size == 0:\n batchSize = images.shape[0]\n\n # I CAN TAKE THE BATCH_SIZE from the images size/shape according the sent data type\n no_of_columns = round(math.sqrt(batchSize))\n no_of_rows = math.ceil(batchSize / no_of_columns)\n print(\"batch size {}, no_of_rows {}, no_of_columns {}\".format(batchSize, no_of_rows, no_of_columns))\n fig = plt.figure(figsize=(no_of_columns*1.25, no_of_rows*1.5))\n # (width, height)\n for idx in np.arange(batchSize):\n ax = fig.add_subplot(no_of_rows, no_of_columns,\n idx+1, xticks=[], yticks=[])\n if greyscale:\n ax.imshow(np.squeeze(images[idx]), cmap='gray')\n else:\n ax.imshow(np.squeeze(images[idx]))\n # print out the correct label for each image\n # .item() gets the value contained in a Tensor\n # WAIT FOR TASNEEM TO SEE THE RETURNED DATA TYPE\n if not prediction is None:\n ax.set_title(\"{} ({})\".format(str(prediction[idx]), str(labels[idx])),\n color=(\"green\" if prediction[idx] == labels[idx] else \"red\"))\n else:\n ax.set_title(str(labels[idx]))","def save_images(images, filenames, output_dir):\n for i, filename in enumerate(filenames):\n dirname = os.path.dirname(filename)\n\n if dirname!='':\n dirpath = os.path.join(output_dir, dirname)\n if not os.path.exists(dirpath):\n os.makedirs(dirpath)\n\n # Images for inception classifier are normalized to be in [-1, 1] interval,\n # so rescale them back to [0, 1].\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\n img = (((images[i, :, :, :] + 1.0) * 0.5) * 255.0).astype(np.uint8)\n Image.fromarray(img).save(f)","def save(images, output):\n for image, frame in images:\n image.save(output(frame))","def generate_image(noise_list, save_path):\n check_points_path = os.path.join(save_path, 'check_points')\n output_image_path = os.path.join(save_path, 'images')\n components.create_folder(output_image_path, False)\n latest_checkpoint = tf.train.latest_checkpoint(check_points_path)\n assert latest_checkpoint is not None, \"no check points found\"\n saver = tf.train.import_meta_graph(latest_checkpoint + '.meta')\n with tf.Session() as sess:\n saver.restore(sess, latest_checkpoint)\n iterations = sess.run('saved_iterations:0')\n for i in range(len(noise_list)):\n generated_images = sess.run('generator/output_layer/tanh/during_inference:0',\n feed_dict={\"noise_for_inference:0\": noise_list[i]})\n Gan.__save_images(output_image_path, generated_images, int(np.sqrt(generated_images.shape[0])), iterations, i)","def save_images(img_list, img_saving_path, label_list, label_saving_path):\n img_index = SAVING_INDEX\n label_index=SAVING_INDEX\n for img in img_list:\n img.save(img_saving_path + str(img_index) + '.png', 'PNG')\n img_index+=1\n for label in label_list:\n label.save(label_saving_path + str(label_index) + '.png', 'PNG')\n label_index += 1","def generate_images(model, input_image, target_image, plots=1):\r\n assert plots <= input_image.shape[\r\n 0], \"plots number should be less than batch size\"\r\n\r\n prediction = model.predict(input_image)\r\n plt.figure(figsize=(50, 50))\r\n\r\n # target_image = tf.argmax(target_image, axis=-1)\r\n # prediction = tf.argmax(prediction, axis=-1)\r\n\r\n for i in range(plots):\r\n plt.subplot(plots, 3, i * 3 + 1)\r\n plt.imshow(tf.cast(input_image[i] * 255, dtype=tf.uint8))\r\n plt.subplot(plots, 3, i * 3 + 2)\r\n plt.imshow(tf.cast(target_image[i] * 255, dtype=tf.uint8))\r\n plt.subplot(plots, 3, i * 3 + 3)\r\n plt.imshow(tf.cast(prediction[i] * 255, dtype=tf.uint8))\r\n plt.show()","def save(self, output_folder: str, show_confidence: bool = True) -> None:\n if output_folder:\n os.makedirs(output_folder, exist_ok=True)\n\n for i, prediction in enumerate(self._images_prediction_lst):\n image_output_path = os.path.join(output_folder, f\"pred_{i}.jpg\")\n prediction.save(output_path=image_output_path, show_confidence=show_confidence)","def save_to_disk(x_data, y_data, usage, output_dir='cifar10_images'):\n assert usage in ['train', 'val', 'test']\n\n # Set paths\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n for label in np.unique(y_data):\n label_path = os.path.join(output_dir, usage, str(label))\n if not os.path.exists(label_path):\n os.makedirs(label_path)\n\n for idx, img in enumerate(x_data):\n bgr_img = img[..., ::-1] # RGB -> BGR\n # label = y_data[idx][0]\n label = y_data[idx]\n img_path = os.path.join(\n output_dir, usage, str(label), 'img_{}.jpg'.format(idx)\n )\n retval = cv2.imwrite(img_path, bgr_img)\n\n assert retval, 'Problem saving image at index: {}'.format(idx)","def create_png(image, label):\n sv = \"/home/avojtekova/Desktop/final_results/star_det/generated_images/\" \n \n for i in range(len(image)):\n data = fits.getdata(image[i][0], ext = 0)\n norm = ImageNormalize(data,interval = ZScaleInterval(), stretch = LinearStretch())\n \n print(image[i][0])\n plt.imshow(data, cmap='Greys_r', origin='lower', norm=norm)#[1250:1750, 2000:2500] add this when you want just part of image \n plt.title(label[i])\n plt.axis('off')\n plt.tight_layout()\n plt.legend\n if i<2:\n if not os.path.isdir(sv + image[i][0][-33:-25] + \"/\") :\n os.makedirs(sv + image[i][0][-33:-25] + \"/\")\n plt.savefig(sv + image[i][0][-33:-25] + \"/\" + label[i]+ \"_\" + image[i][0][-33:-25] + \"_big.png\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0) \n else:\n if not os.path.isdir(sv + image[i][0][-40:-32] + \"/\") :\n os.makedirs(sv + image[i][0][-40:-32] + \"/\")\n plt.savefig(sv + image[i][0][-40:-32] + \"/\" + label[i]+image[i][0][-40:-32] + \"_big.png\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0)\n plt.close()","def main():\n args = parse_args()\n\n with open(args.train_details_json, mode='r', encoding='utf-8') as json_f:\n results_dict = json.load(json_f)[-1]\n\n losses_plot = plt.figure()\n plt.plot(range(1, len(results_dict['train_loss']) + 1),\n results_dict['train_loss'])\n plt.plot(range(1, len(results_dict['val_loss']) + 1),\n results_dict['val_loss'])\n plt.plot(range(1, len(results_dict['test_loss']) + 1),\n results_dict['test_loss'])\n plt.legend(['train', 'val', 'test'])\n plt.title(f'loss vs epoch for {args.model} model on {args.dataset} dataset')\n plt.xlabel('epoch')\n plt.ylabel('loss')\n plt.grid(True)\n losses_plot.set_size_inches((8, 8))\n losses_plot.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_losses_plot.png'))\n\n accuracies_plot = plt.figure()\n plt.plot(range(1, len(results_dict['train_acc']) + 1),\n results_dict['train_acc'])\n plt.plot(range(1, len(results_dict['val_acc']) + 1),\n results_dict['val_acc'])\n plt.plot(range(1, len(results_dict['test_acc']) + 1),\n results_dict['test_acc'])\n plt.legend(['train', 'val', 'test'])\n plt.title(f'accuracy vs epoch for {args.model} '\n f'model on {args.dataset} dataset')\n plt.xlabel('epoch')\n plt.ylabel('accuracy')\n plt.grid(True)\n accuracies_plot.set_size_inches((8, 8))\n accuracies_plot.savefig(\n os.path.join(FIGURES_DIR,\n f'{args.dataset}_{args.model}_accuracies_plot.png'))","def _saveFig(self):\r\n # Save plot\r\n filenameG = self._vna.getDateFormatted() + \".png\"\r\n filenameG = \"Graphs/\" + filenameG \r\n plt.savefig(filenameG) # Plot saved in directory named Graphs located in same directory as pyTekVNA\r\n plt.clf()","def save_particles_image(self):\n base_filename = self.config['info']['filename_microscope']\n self.save_image_microscope_camera(base_filename)","def save(file_name):\n setup()\n plt.savefig(file_name)","def save(self) -> None:\n graph = 'loss' if self.loss else 'accuracy'\n save = os.path.join(self.savepath, graph + '.png')\n self.fig.savefig(save)","def save_predictions(self, preds_all, save_dir, scale_pred=False):\n for idx, fname in enumerate(self.test_files):\n fh = open(fname, 'rb')\n img = pil.open(fh)\n orig_h, orig_w = self.gt_depths[idx].shape\n pred_resize = cv2.resize(preds_all[idx], (orig_w, orig_h), interpolation=cv2.INTER_LINEAR)\n if scale_pred:\n scaled_disp, _ = self.scale_depth_disp(pred_resize)\n disp_img = self.generate_disparity_img(scaled_disp)\n else:\n disp_img = self.generate_disparity_img(1./pred_resize)\n\n imgname = \"{0:04d}\".format(idx)\n name_img = os.path.join(save_dir, imgname+\".jpeg\")\n img.save(name_img)\n name_disp = os.path.join(save_dir, imgname+\"_disp.jpeg\")\n disp_img.save(name_disp)","def train(self, nsamples = 1, verbose = False, random = True):\n imgs, skels = self.images.get_batch(nimages = nsamples, random = random);\n self.trainer.run(session = self.session, feed_dict={self.input : imgs, self.skeleton : skels})\n if verbose:\n self.plot_results(imgs);","def save_plot(epoch_num, step, rewards, filepath):\n fig, ax = plt.subplots() \n ax.plot(range(0, epoch_num + 1, step), rewards)#,'.')\n ax.plot(range(0, epoch_num + 1, step), np.ones(len(range(0, epoch_num + 1, step)))*rewards[0], 'r')\n fig.savefig(filepath)\n plt.close(fig) # close the figure ","def save_figure(self, data):\n\n\t\tsizes = np.shape(data)\n\t\tfig = plt.figure()\n\t\tfig.set_size_inches(1, 1. * sizes[0]/sizes[1], forward = False)\n\t\tax = plt.Axes(fig, [0., 0., 1., 1.])\n\t\tax.set_axis_off()\n\t\tfig.add_axes(ax)\n\t\tax.imshow(data, \"gray\")\n\n\t\t#plt.show()\n\t\tself.plotfile = os.path.join('static', 'Figure' + '.png')\n\t\tplt.savefig(self.plotfile, dpi = sizes[1])","def save_imgs(self):\n print(\"Saving the images with required categories ...\")\n os.makedirs(self.imgs_dir, exist_ok=True)\n # Save the images into a local folder\n for im in tqdm(self.images):\n img_data = requests.get(im['coco_url']).content\n with open(os.path.join(self.imgs_dir, im['file_name']), 'wb') as handler:\n handler.write(img_data)","def save(self, x, y, names, path=\"\", zoom=False):\n for i in range(len(x)):\n image = self.generate(x[i], label=np.argmax(y[i]), zoom=zoom)\n image = Image.fromarray((image*255).astype(\"uint8\"))\n image.save(path + names[i] + \".png\", \"PNG\")","def save(self, fn):\n plt.imsave(fn, self.image)","def saveImage(self, observation):\n image_path = \"{}/{}/frame{:06d}\".format(self.data_folder, self.episode_folder, self.episode_step)\n relative_path = \"{}/{}/frame{:06d}\".format(self.name, self.episode_folder, self.episode_step)\n self.images_path.append(relative_path)\n # in the case of dual/multi-camera\n if observation.shape[2] > 3:\n observation1 = cv2.cvtColor(observation[:, :, :3], cv2.COLOR_BGR2RGB)\n observation2 = cv2.cvtColor(observation[:, :, 3:], cv2.COLOR_BGR2RGB)\n\n cv2.imwrite(\"{}_1.jpg\".format(image_path), observation1)\n cv2.imwrite(\"{}_2.jpg\".format(image_path), observation2)\n else:\n observation = cv2.cvtColor(observation, cv2.COLOR_BGR2RGB)\n cv2.imwrite(\"{}.jpg\".format(image_path), observation)","def make_gifs_train(title, path):\n images = os.listdir(path)\n generated_images = []\n\n for i in range(len(images)):\n file = os.path.join(path, '%s_Samples_Epoch_%03d.png' % (title, i+1))\n generated_images.append(imageio.imread(file))\n\n imageio.mimsave(path + '{}_Train_Results.gif'.format(title), generated_images, fps=2)\n print(\"{} gif file is generated.\".format(title))"],"string":"[\n \"def save_images(PATH, show_img, datasets, from_dataset):\\n dataset = datasets[from_dataset]\\n imgModels = dataset['models']\\n for modelname, model in imgModels.items():\\n print('save', modelname)\\n plt.imshow(model[70])\\n plt.set_cmap(\\\"gray\\\")\\n plt.axis('off')\\n plt.savefig(PATH + '/' + from_dataset + '_' + modelname + '.png', dpi=400)\\n\\n if show_img == True:\\n plt.show()\",\n \"def save_images(self, samples, label=None, dir=\\\"\\\"):\\n if label is None:\\n label = self.global_step_\\n fig = plt.figure()\\n self.net_.eval()\\n self.dist.visualize(fig, samples, self.energy)\\n plot_fn = os.path.join(dir, f\\\"samples_{label}.png\\\")\\n fig.savefig(plot_fn)\\n plt.close(fig)\",\n \"def save_images(self):\\n for q in range(self.N_itr):\\n plt.clf()\\n self.plot_EM_estimate(q)\\n plt.savefig('img%d.png' % (100 + q))\",\n \"def generate_and_save_images(model, epoch, test_input):\\n #Training is set to false\\n #so all layers run in inference mode (batchnorm)(?)\\n predictions = model(test_input, training=False)\\n fig = plt.figure(figsize=(4,4))\\n for i in range(predictions.shape[0]):\\n plt.subplot(4,4, i+1)\\n img = tf.constant(predictions[i]) #Turn prediction into tf.constant\\n #so it can easily be transformed int a uint8 array\\n img = tf.image.convert_image_dtype(img, tf.uint8)\\n plt.imshow(img)#Show the images in color\\n plt.axis(\\\"off\\\")\\n #for()\\n\\n #update epoch_total or create a new tracker\\n if os.path.exists(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\")):\\n f = open(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\"),\\\"r\\\")\\n epoch = int(f.readline()) + 1\\n print(\\\"Total Epochs:{}\\\".format(epoch))\\n f = open(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\"),\\\"w\\\")\\n f.write(str(epoch))\\n #if()\\n else:\\n f = open(os.path.join(\\\"outputColor\\\",\\\"epoch_total.txt\\\"),\\\"w\\\")\\n f.write(str(epoch))\\n #else()\\n f.close()\\n\\n plt.savefig(\\\"outputPhotosColor/image_at_epoch_{:04d}.png\\\".format(epoch)) #save image\\n #plt.show() # Turn on to show each new image after it's made\\n plt.close()\",\n \"def generate_and_save_images(model, seed, output_path, title):\\n\\n predictions = model(tf.Variable(seed, trainable=False))\\n\\n fig = plt.figure(figsize=(4,4))\\n\\n for i in range(predictions.shape[0]):\\n plt.subplot(4, 4, i+1)\\n plt.imshow(denormalize_generate_image(predictions[i, :, :, 0]), cmap='gray')\\n plt.axis('off')\\n if not os.path.exists(output_path):\\n os.mkdir(output_path)\\n\\n plt.savefig(os.path.join(output_path, '{}.png'.format(title)))\\n plt.close()\",\n \"def test_plot_images(self):\\n save_file(self.quart.plot_images)\",\n \"def save_images(args,path,images, epoch, nrow=None):\\n if nrow == None:\\n nrow = int(np.floor(np.sqrt(images.size(0)\\n )))\\n\\n img = torchvision.utils.make_grid(images, nrow=nrow, normalize=True).numpy()\\n img = np.transpose(img, (1,2,0))\\n\\n plt.figure()\\n plt.imshow(img)\\n plt.savefig(path+\\\"/epoch{:04d}\\\".format(epoch))\\n plt.close()\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def plot_reconstruction_images(inputs, pred, name):\\n\\n plt.clf()\\n nb_plots = min(inputs.shape[0], 4)\\n #inputs\\n for i in range(nb_plots):\\n ax = plt.subplot2grid((2, nb_plots), (0, i), rowspan=1, colspan=1)\\n ax.imshow(inputs[i])\\n ax.axis('off')\\n #pred\\n for i in range(nb_plots):\\n ax = plt.subplot2grid((2, nb_plots), (1, i), rowspan=1, colspan=1)\\n ax.imshow(pred[i])\\n ax.axis('off')\\n\\n if name != None:\\n plt.savefig(name, format='svg', bbox_inches='tight')\\n else:\\n plt.show()\",\n \"def visualize(**images):\\n n = len(images)\\n plt.figure(figsize=(16, 5))\\n for i, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n, i + 1)\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(' '.join(name.split('_')).title())\\n plt.imshow(image)\\n plt.show()\\n # plt.savefig('./drive/My Drive/Colab Notebooks/TACK/Large/result' + ' '.join(name.split('_')).title() + '.png')\",\n \"def save_images(self, step, images):\\n\\n # Save\\n with self.summary_writer.as_default():\\n for name, batch in images.items():\\n image = batch[0]\\n image = tf.expand_dims(image, axis=0)\\n tf.summary.image(name, image, step)\",\n \"def save_images(self, sess, epoch):\\n if not os.path.exists(self._images_dir):\\n os.makedirs(self._images_dir)\\n\\n names = ['inputA_', 'inputB_', 'fakeA_',\\n 'fakeB_', 'cycA_', 'cycB_']\\n\\n with open(os.path.join(\\n self._output_dir, 'epoch_' + str(epoch) + '.html'\\n ), 'w') as v_html:\\n for i in range(0, self._num_imgs_to_save):\\n print(\\\"Saving image {}/{}\\\".format(i, self._num_imgs_to_save))\\n inputs = sess.run(self.inputs)\\n fake_A_temp, fake_B_temp, cyc_A_temp, cyc_B_temp = sess.run([\\n self.fake_images_a,\\n self.fake_images_b,\\n self.cycle_images_a,\\n self.cycle_images_b\\n ], feed_dict={\\n self.input_a: inputs['images_i'],\\n self.input_b: inputs['images_j']\\n })\\n\\n tensors = [inputs['images_i'], inputs['images_j'],\\n fake_B_temp, fake_A_temp, cyc_A_temp, cyc_B_temp]\\n\\n for name, tensor in zip(names, tensors):\\n image_name = name + str(epoch) + \\\"_\\\" + str(i) + \\\".jpg\\\"\\n imsave(os.path.join(self._images_dir, image_name),\\n ((tensor[0] + 1) * 127.5).astype(np.uint8)\\n )\\n v_html.write(\\n \\\"<img src=\\\\\\\"\\\" +\\n os.path.join('imgs', image_name) + \\\"\\\\\\\">\\\"\\n )\\n v_html.write(\\\"<br>\\\")\",\n \"def save_dataset_visual(lines, output_dir):\\n\\n # Ensure output directory exists\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n cols = 3\\n rows = 3\\n fig_size = (7 * cols, 4 * rows) # Figure width and height, in inches\\n # Random sample of images\\n save_name = \\\"training_data_sample.png\\\"\\n fig, ax = plt.subplots(rows, cols, figsize=fig_size)\\n for row in range(rows):\\n for col in range(cols):\\n idx = np.random.randint(0, len(lines))\\n ax[row, col].imshow(ndimage.imread(lines[idx][0]))\\n ax[row, col].set_title(\\\"Angle = \\\" + str(round(lines[idx][1], 3)))\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\\n # Distribution of steering angles\\n save_name = \\\"data_histogram.png\\\"\\n fig_size = (5, 3) # Figure width and height, in inches\\n num_bins = 100\\n angles = np.array([line[1] for line in lines])\\n hist, bins = np.histogram(angles, bins=num_bins)\\n fig = plt.figure(figsize=fig_size)\\n plt.bar(bins[:-1], hist)\\n plt.xlabel(\\\"Steering Angle\\\")\\n plt.ylabel(\\\"Frequency\\\")\\n plt.title(\\\"Distribution of Steering Angles in Training Data\\\")\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\",\n \"def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\\n viz.evaluate()\\n if upsampled == True:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\\n else:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\\n viz.visualizer.show(outpath=outpath_, clear_figure=True)\",\n \"def main(image_path):\\n temp_dir = tempfile.mkdtemp()\\n print('Saving output to {}'.format(temp_dir))\\n estimator = run_image(image_path)\\n visualize(estimator, image_path, temp_dir)\",\n \"def __save_datasets(self):\\n self.train.to_csv('{}/{}/{}'.format(path_to_train_set, img_format, 'train.csv'))\\n self.valid.to_csv('{}/{}/{}'.format(path_to_valid_set, img_format, 'valid.csv'))\\n self.test.to_csv('{}/{}/{}'.format(path_to_test_set, img_format, 'test.csv'))\",\n \"def save_images(self, sess, epoch):\\n if not os.path.exists(self._images_dir):\\n os.makedirs(self._images_dir)\\n\\n if not os.path.exists(os.path.join(self._images_dir, 'imgs')):\\n os.makedirs(os.path.join(self._images_dir, 'imgs'))\\n \\n names = ['inputB_', 'fakeB_depth_' , 'cycB_']\\n\\n with open(os.path.join(\\n self._output_dir, 'epoch_' + str(epoch) + '.html'), 'w') as v_html:\\n for i in range(0, self._num_imgs_to_save):\\n print(\\\"Saving image {}/{}\\\".format(i, self._num_imgs_to_save))\\n x1_t, name1 = self.dataset.next_batch()\\n count = 0\\n fake_A_temp, cyc_B_temp = sess.run([\\n self.fake_images_a,\\n self.cycle_images_b], \\n feed_dict={self.input_b: x1_t})\\n \\n fakedepth = fake_A_temp[:,:,:,-1]\\n tensors = [x1_t, fakedepth, cyc_B_temp]\\n\\n for name, tensor in zip(names, tensors):\\n #print(name)\\n # if name == 'inputB_' or name == 'fakeB_depth_':\\n # image_name = name1[count] + '_' + name + str(epoch) + \\\"_\\\" + str(i) + \\\".jpg\\\"\\n # imsave(os.path.join(self._images_dir, 'imgs', image_name), ((tensor[0] + 1) * 127.5).astype(np.uint8))\\n # else:\\n image_name = name + str(epoch) + \\\"_\\\" + str(i) + \\\".jpg\\\"\\n imsave(os.path.join(self._images_dir, image_name), ((tensor[0] + 1) * 127.5).astype(np.uint8))\\n v_html.write(\\n \\\"<img src=\\\\\\\"\\\" +\\n os.path.join('imgs', image_name) + \\\"\\\\\\\">\\\"\\n )\\n v_html.write(\\\"<br>\\\")\\n count += 1\",\n \"def show_train_images(train_data, train_labels):\\n plt.figure(1, figsize=(8, 8))\\n n = 0\\n\\n for i in range(16):\\n n += 1\\n # each time random images are loaded\\n # r = np.random.randint(0, train_data.shape[0], 1)\\n plt.subplot(4, 4, n)\\n plt.subplots_adjust(hspace=0.5, wspace=0.5)\\n plt.imshow(train_data[i] / 255.)\\n plt.title('{}'.format(train_labels[i]))\\n plt.xticks([]), plt.yticks([])\\n plt.show()\",\n \"def generate_images(self, model, test_input, step, dst_dir):\\n prediction = model(test_input)\\n\\n plt.figure(figsize=(12, 12))\\n display_list = [test_input[0], prediction[0]]\\n title = ['Input Image', 'Predicted Image']\\n\\n for i in range(2):\\n plt.subplot(1, 2, i+1)\\n plt.title(title[i])\\n # getting the pixel values between [0, 1] to plot it.\\n plt.imshow(display_list[i] * 0.5 + 0.5)\\n plt.axis('off')\\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\\n plt.savefig(filename)\",\n \"def quick_plot_save(self, mode='png'):\\n batch = self.meta['batch']\\n cellid = self.meta['cellid']\\n modelname = self.meta['modelname']\\n\\n fig = plt.figure(figsize=(8, 9))\\n plot_set = []\\n for idx, m in enumerate(self.modules):\\n if m.auto_plot:\\n plot_set.append(idx)\\n \\n for sp, idx in enumerate(plot_set):\\n m=self.modules[idx]\\n log.info(self.mod_names[idx])\\n plt.subplot(len(plot_set), 1, sp+1)\\n m.do_plot(m)\\n \\n if len(plot_set)<6:\\n plt.tight_layout()\\n\\n filename = (\\n sc.DIRECTORY_ROOT + \\\"nems_saved_images/batch{0}/{1}/{2}.{3}\\\"\\n .format(batch, cellid, modelname, mode)\\n )\\n\\n if AWS:\\n s3 = boto3.resource('s3')\\n key = filename[len(sc.DIRECTORY_ROOT):]\\n fileobj = io.BytesIO()\\n fig.savefig(fileobj, format=mode)\\n fileobj.seek(0)\\n s3.Object(sc.PRIMARY_BUCKET, key).put(Body=fileobj)\\n # return (\\\"s3://\\\" + sc.PRIMARY_BUCKET + \\\"/\\\" + key)\\n else:\\n dr = (\\n sc.DIRECTORY_ROOT\\n + \\\"nems_saved_images/batch{0}/{1}/\\\".format(batch, cellid)\\n )\\n try:\\n os.stat(dr)\\n if os.path.isfile(filename):\\n os.remove(filename)\\n except BaseException:\\n os.mkdir(dr)\\n\\n try:\\n fig.savefig(filename)\\n except Exception as e:\\n log.warn(\\\"Bad file extension for figure or couldn't save\\\")\\n raise e\\n\\n try:\\n os.chmod(filename, 0o666)\\n except Exception as e:\\n log.warn(\\\"Couldn't modify file permissions for figure\\\")\\n raise e\\n\\n return filename\",\n \"def view_image(train_dataloader):\\n for (x, target) in train_dataloader:\\n np.save(\\\"img.npy\\\", x)\\n print(x.shape)\\n exit(0)\",\n \"def save_plot_as_image(self):\\r\\n plt.savefig(ROOT_DIR + '/presentation/images/' + self.folder + '/' + self.generated_image_name + '.png',\\r\\n bbox_inches='tight')\",\n \"def train_visualization(output_path): \\n log_path = output_path + 'output.log'\\n Train_Cost, Valid_Cost, Test_Cost, Train_Acc, Valid_Acc, Test_Acc = log_reader(log_path)\\n n_epoch = len(Train_Cost)\\n\\n x1 = range(n_epoch)\\n x2 = range(n_epoch)\\n y1 = Train_Cost\\n y2 = Valid_Cost\\n y3 = Test_Cost\\n y4 = Train_Acc\\n y5 = Valid_Acc\\n y6 = Test_Acc\\n plt.subplot(2, 1, 1)\\n plt.plot(x1, y1, label=\\\"Train_Cost\\\", linewidth=2)\\n plt.plot(x1, y2, label=\\\"Valid_Cost\\\", linewidth=2)\\n plt.plot(x1, y3, label=\\\"Test_Cost\\\", linewidth=2)\\n\\n plt.title('binary cross entropy vs. epoches')\\n plt.ylabel('binary cross entropy')\\n plt.legend(loc='best')\\n plt.subplot(2, 1, 2)\\n plt.plot(x2, y4, label=\\\"Train_Acc\\\", linewidth=2)\\n plt.plot(x2, y5, label=\\\"Valid_Acc\\\", linewidth=2)\\n plt.plot(x2, y6, label=\\\"Test_Acc\\\", linewidth=2)\\n plt.xlabel('Accuracy@20 vs. epoches')\\n plt.ylabel('Accuracy@20')\\n plt.legend(loc='best')\\n plt.savefig(output_path + 'loss_fig.png')\\n # plt.show()\",\n \"def plot_callback(model):\\n\\n # Get samples & Display them\\n pred_img = model.predict([masked, mask])\\n pred_time = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')\\n\\n # Clear current output and display test images\\n combine_imgs = np.concatenate([pred_img, masked, mask, ori], axis=2)\\n for i in range(len(combine_imgs)):\\n img_array = combine_imgs[i]\\n img = Image.fromarray(img_array.astype(np.uint8))\\n img.save(r'data/train_samples/img_{}_{}.png'.format(i, pred_time))\",\n \"def save_figures(expt):\\n if isinstance(expt, str):\\n expt = get_experiment(expt)\\n \\n tr_expt = get_training_expt(expt)\\n\\n storage.ensure_directory(expt.figures_dir())\\n\\n for it in tr_expt.save_after:\\n for avg in AVG_VALS:\\n print 'Iteration', it\\n try:\\n rbm = load_rbm(expt, it, avg)\\n except:\\n continue\\n final_states = storage.load(expt.final_states_file(it, avg))\\n gibbs_states = storage.load(expt.gibbs_states_file(it, avg))\\n\\n fig = rbm_vis.show_particles(rbm, final_states, expt.dataset)\\n misc.save_image(fig, expt.final_states_figure_file(it, avg))\\n\\n fig = rbm_vis.show_particles(rbm, gibbs_states, expt.dataset)\\n misc.save_image(fig, expt.gibbs_states_figure_file(it, avg))\\n\\n print_log_probs(expt, open(expt.log_probs_text_file(), 'w'))\",\n \"def save_plot(self):\\r\\n\\t\\t# Generate the plot\\r\\n\\t\\tself.generate_plot()\\r\\n\\t\\t# Create save directory\\r\\n\\t\\tdirectory = self.dir + '/%s/' % str(int(self.universe.init_time))\\r\\n\\t\\tif not path_exists(directory):\\r\\n\\t\\t\\tmakedirs(directory)\\r\\n\\t\\t# Save image file\\r\\n\\t\\tself.fig.savefig(directory+str(self.universe.time))\",\n \"def plot_predictions(model, dataset=None, sample_batch=None, num=1, save_filepaths=None):\\n if save_filepaths is not None:\\n assert isinstance(save_filepaths, list) and len(save_filepaths) == num\\n if dataset is not None:\\n for i, (image, mask) in enumerate(dataset.take(num)):\\n pred_raster = model.predict(image)\\n display_sample([image[0], mask, create_mask(pred_raster)])\\n if save_filepaths is not None:\\n fig = plt.gcf()\\n fig.savefig(save_filepaths[i], bbox_inches='tight', dpi=300)\\n else:\\n image, mask = sample_batch\\n pred_raster = model.predict(image)\\n pred_mask = create_mask(pred_raster)\\n for i in range(num):\\n display_sample([image[i], mask[i], pred_mask[i]])\\n if save_filepaths is not None:\\n fig = plt.gcf()\\n fig.savefig(save_filepaths[i], bbox_inches='tight', dpi=300)\",\n \"def save_reconstructed_images(self, filename, rows, cols):\\n # print(filename)\\n num_images = self.reconstructed.shape[0]\\n images = np.zeros((rows, cols*num_images))\\n for i in range(num_images):\\n start = int(i * cols)\\n end = int((i+1) * cols)\\n images[0:rows, start:end] = self.reconstructed[i].reshape((rows, cols))\\n\\n plt.imshow(images, cmap='gray', aspect='equal', interpolation='none')\\n #plt.show()\\n plt.savefig(filename)\\n return\",\n \"def save_model_data():\\n print(\\\"Getting the training, validation, and testing sets...\\\")\\n df = get_data()\\n\\n # First read in & group by type\\n image_styles = {key: [] for key in df['Period'].unique()}\\n for pic in df.to_dict(\\\"records\\\"):\\n db = pic['file'][:pic['file'].find(\\\"_\\\")]\\n img = Image.open(os.path.join(MODEL_DIR, f\\\"{db}/sculpture_images/{pic['file']}\\\"))\\n img.load()\\n image_styles[pic['Period']].append(img)\\n\\n\\n # Split each type up...not just the whole thing\\n for style in image_styles.keys():\\n # Split into Train/Test - 75/25\\n feats, labels = image_styles[style], [style] * len(image_styles[style])\\n feat_train, feat_test, label_train, label_test = train_test_split(feats, labels, test_size=.25, random_state=42)\\n\\n # Create dirs if needed\\n for pic_type in ['train', 'test']:\\n if not os.path.exists(os.path.join(MODEL_DIR, f\\\"model_data/gan/{pic_type}/{style}\\\")):\\n os.makedirs(os.path.join(MODEL_DIR, f\\\"model_data/gan/{pic_type}/{style}\\\"))\\n\\n # Save in train/validation/test folders\\n for style_type_pics in [[\\\"train\\\", feat_train], [\\\"test\\\", feat_test]]:\\n for pic in range(len(style_type_pics[1])):\\n file_name = style + format(pic, '03d') + \\\".jpg\\\"\\n if not os.path.isfile(os.path.join(MODEL_DIR, f\\\"model_data/gan/{style_type_pics[0]}/{style}/{file_name}\\\")):\\n style_type_pics[1][pic].save(os.path.join(MODEL_DIR, f\\\"model_data/gan/{style_type_pics[0]}/{style}/{file_name}\\\"))\\n\\n print(\\\"Split data for\\\", style)\",\n \"def cb_save(event):\\n fig.savefig('sample.univariate_discrete.py.png', dpi=300, format='png', transparent=True)\",\n \"def save_images(images, filenames, output_dir):\\n for i, filename in enumerate(filenames):\\n # Images for inception classifier are normalized to be in [-1, 1] interval,\\n # so rescale them back to [0, 1].\\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\\n imsave(f, (images[i, :, :, :] + 1.0) * 0.5, format='png')\",\n \"def save_images(images, filenames, output_dir):\\n for i, filename in enumerate(filenames):\\n # Images for inception classifier are normalized to be in [-1, 1] interval,\\n # so rescale them back to [0, 1].\\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\\n imsave(f, (images[i, :, :, :] + 1.0) * 0.5, format='png')\",\n \"def save_images(images, filenames, output_dir):\\n for i, filename in enumerate(filenames):\\n # Images for inception classifier are normalized to be in [-1, 1] interval,\\n # so rescale them back to [0, 1].\\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\\n imsave(f, (images[i] + 1.0) * 0.5, format='png')\",\n \"def plot_example_images(\\n output_dir, epoch, generator, label_imgs, test_imgs, imgs_count,\\n examples=4):\\n random_ints = np.random.randint(0, imgs_count, examples)\\n image_batch_hr = denormalize(label_imgs[random_ints])\\n image_batch_lr = test_imgs[random_ints]\\n gen_img = generator.predict(image_batch_lr)\\n generated_image = denormalize(gen_img)\\n image_batch_lr = denormalize(image_batch_lr)\\n\\n plt.clf()\\n\\n for idx in range(examples):\\n plt.subplot(examples, 3, 1 + idx * 3)\\n plt.imshow(image_batch_lr[idx], interpolation='nearest')\\n plt.axis('off')\\n\\n plt.subplot(examples, 3, 2 + idx * 3)\\n plt.imshow(generated_image[idx], interpolation='nearest')\\n plt.axis('off')\\n\\n plt.subplot(examples, 3, 3 + idx * 3)\\n plt.imshow(image_batch_hr[idx], interpolation='nearest')\\n plt.axis('off')\\n\\n plt.subplots_adjust(wspace=0.01)\\n plt.savefig(\\n path.join(output_dir, f'generated_image_{epoch}.svg'),\\n bbox_inches='tight', pad_inches=0, )\",\n \"def main():\\n nn = CarsClassifierModel()\\n train_x, train_y, test_x, test_y = nn.load_data_preprocess()\\n history = nn.run(train_x,train_y)\\n nn.evaluate(test_x, test_y)\\n nn.save(\\\"keras_nn_5\\\")\\n #nn.plots(history)\\n #print(train_x.shape)\\n #plt.imshow(train_x[52])\\n #plt.title(\\\"Car\\\")\\n #plt.show()\\n #print(train_y[52])\",\n \"def save_inference_samples(runs_dir, data_dir, sess, image_shape, logits, keep_prob, input_image):\\n # Make folder for current run\\n output_dir = os.path.join(runs_dir, str(time.time()))\\n if os.path.exists(output_dir):\\n shutil.rmtree(output_dir)\\n os.makedirs(output_dir)\\n\\n # Run NN on test images and save them to HD\\n print('Training Finished. Saving test images to: {}'.format(output_dir))\\n image_outputs = gen_test_output(sess, logits, keep_prob, input_image, os.path.join(\\n data_dir, 'data_road', 'testing'), image_shape)\\n for name, image in image_outputs:\\n scipy.misc.imsave(os.path.join(output_dir, name), image)\",\n \"def prediction():\\r\\n\\r\\n loaded_model = load_model('imageTrainedModel.h5')\\r\\n print(loaded_model.summary())\\r\\n\\r\\n # retrieve history also:\\r\\n f = open('history.pckl', 'rb')\\r\\n history = pickle.load(f)\\r\\n f.close()\\r\\n\\r\\n print(history.keys())\\r\\n print(history)\\r\\n\\r\\n epochs = len(history['loss']) # length of the list stored at 'loss'\\r\\n # Plot losses for train and validation\\r\\n plt.figure()\\r\\n plt.title('Loss as training progresses')\\r\\n plt.xlabel('Epoch')\\r\\n plt.ylabel('Loss')\\r\\n plt.plot(history['loss'], label='Train Error')\\r\\n plt.plot(history['val_loss'], label='Val Error')\\r\\n plt.legend()\\r\\n plt.show()\\r\\n\\r\\n # Plot metrics\\r\\n plt.plot(history['acc']) # use same metric that was used for training. 'history' is a dictionary.\\r\\n plt.title('Accuracy as training progresses')\\r\\n plt.ylabel('Accuracy (%)')\\r\\n plt.xlabel('Epoch')\\r\\n ymax = max(history['acc'])\\r\\n xpos = history['acc'].index(ymax)\\r\\n xmax = xpos\\r\\n plt.annotate('Maximum accuracy: %s' % round(ymax, 3),\\r\\n xy=(xmax, ymax), xycoords='data',\\r\\n xytext=(0.5, 0.5), textcoords='axes fraction',\\r\\n fontsize=12)\\r\\n plt.show()\\r\\n\\r\\n # make predictions using x_test\\r\\n test_y_predictions = loaded_model.predict(x_test, batch_size=None, verbose=1, steps=None)\\r\\n test_y_predictions = np.around(test_y_predictions, decimals=0) # round to whole integers\\r\\n true_false_array = np.equal(y_test, test_y_predictions) # test of equality.\\r\\n true_count = np.sum(true_false_array) # number of correctly categorised images\\r\\n false_count = true_false_array.shape[0] - true_count # number of images not correctly categorised\\r\\n\\r\\n # Plot predicted and actual image categories\\r\\n fig = plt.figure()\\r\\n ax1 = fig.add_subplot(111)\\r\\n plt.title('Classification of Image Categories')\\r\\n plt.ylabel('Number of Images')\\r\\n plt.xlabel('Image Classification')\\r\\n label = ['Correct', 'Incorrect']\\r\\n index = np.arange(len(label))\\r\\n plt.xticks(index, label, fontsize=10, rotation=0)\\r\\n ax1.bar(index, [true_count, false_count])\\r\\n plt.show()\",\n \"def visualize_manipulation_training(flow, epoch, save_dir=None):\\n\\n # Basic figure setup\\n images_x = 3\\n images_y = 3 if isinstance(flow.codec, DCN) else 2\\n fig = Figure(figsize=(18, 10 / images_x * images_y))\\n conf = np.array(flow.fan.performance['confusion'])\\n \\n # Draw the plots\\n ax = fig.add_subplot(images_y, images_x, 1)\\n ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))\\n ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))\\n ax.set_title('Loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 2)\\n ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))\\n ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))\\n ax.set_title('PSNR')\\n ax.set_ylim([30, 50])\\n\\n ax = fig.add_subplot(images_y, images_x, 3)\\n ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))\\n ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))\\n ax.set_title('SSIM')\\n ax.set_ylim([0.8, 1])\\n \\n ax = fig.add_subplot(images_y, images_x, 4)\\n ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))\\n ax.set_ylabel('FAN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 5)\\n ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'], 0))\\n ax.set_ylabel('FAN accuracy')\\n ax.set_ylim([0, 1])\\n\\n # The confusion matrix\\n ax = fig.add_subplot(images_y, images_x, 6)\\n ax.imshow(conf, vmin=0, vmax=1)\\n\\n ax.set_xticks(range(flow.n_classes))\\n ax.set_xticklabels(flow._forensics_classes, rotation='vertical')\\n ax.set_yticks(range(flow.n_classes))\\n ax.set_yticklabels(flow._forensics_classes)\\n\\n for r in range(flow.n_classes):\\n ax.text(r, r, '{:.2f}'.format(conf[r, r]), horizontalalignment='center', color='b' if conf[r, r] > 0.5 else 'w')\\n\\n ax.set_xlabel('PREDICTED class')\\n ax.set_ylabel('TRUE class')\\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\\n\\n # If the compression model is a trainable DCN, include it's validation metrics\\n if images_y == 3:\\n ax = fig.add_subplot(images_y, images_x, 7)\\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\\n ax.set_ylabel('DCN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 8)\\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\\n ax.set_ylabel('DCN ssim')\\n ax.set_ylim([0.8, 1])\\n\\n ax = fig.add_subplot(images_y, images_x, 9)\\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\\n ax.set_ylabel('DCN entropy')\\n\\n if save_dir is not None:\\n if not os.path.exists(save_dir):\\n os.makedirs(save_dir)\\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\\n del fig\\n\\n else:\\n return fig\",\n \"def saving_test_images(self, segmented_images_dir, data_test_dir, session,\\\\\\n\\t\\t\\t\\t\\t\\t\\t image_shape, logits, keep_prob, input_image):\\n\\n\\t\\tprint('Training Done ...')\\n\\t\\t# get the segmented result for all images\\n\\t\\timage_outputs = self.segment_images(session, logits, keep_prob, input_image,\\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t data_test_dir, image_shape)\\n\\t\\t# save all the images at the required path\\n\\t\\tfor name, image in image_outputs:\\n\\t\\t\\tscipy.misc.imsave(os.path.join(segmented_images_dir, name), image)\",\n \"def plot_eval_1(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def plot(path, subjects):\\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\\n data = data_load.load_data(path, subjects)\\n dimx = int(data[0][\\\"meta\\\"][\\\"dimx\\\"][0])\\n dimy = int(data[0][\\\"meta\\\"][\\\"dimy\\\"][0])\\n dimz = int(data[0][\\\"meta\\\"][\\\"dimz\\\"][0])\\n coordToCol = data[0][\\\"meta\\\"][\\\"coordToCol\\\"][0][0]\\n images = {}\\n max_val = 0\\n voxels = np.load(\\\"data/general_selected_500_1.npy\\\")\\n directory = os.listdir(\\\"data/input/\\\")\\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\\n for file in directory:\\n file_name = \\\"data/input/{}\\\".format(file)\\n fh = open(file_name)\\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\\\",\\\")))))\\n fh.close()\\n plot_matrix = np.zeros((dimx, dimy, dimz))\\n for x in range(dimx):\\n for y in range(dimy):\\n for z in range(dimz):\\n indice = coordToCol[x][y][z]\\n if indice != 0:\\n if indice in list(voxels):\\n voxel_indice = list(voxels).index(indice)\\n value = activation_values[voxel_indice]\\n if abs(value) > max_val:\\n max_val = abs(value)\\n plot_matrix[x][y][z] = value\\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\\n images[file_name] = image\\n bar.update(force_flush=True)\\n print(bar)\\n for image in images:\\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\\\"{}-wom1.png\\\".format(image))\\n bar2.update(force_flush=True)\\n print(bar2)\",\n \"def save_images(images, filenames, output_dir):\\n for i, filename in enumerate(filenames):\\n # Images for inception classifier are normalized to be in [-1, 1] interval,\\n # so rescale them back to [0, 1].\\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\\n img = (((images[i, :, :, :] + 1.0) * 0.5) * 255.0).astype(np.uint8)\\n Image.fromarray(img).save(f, format='PNG')\",\n \"def save_images(images, filenames, output_dir):\\n for i, filename in enumerate(filenames):\\n\\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\\n image = images[i, :, :, :]\\n image[:, :, 0] += _R_MEAN\\n image[:, :, 1] += _G_MEAN\\n image[:, :, 2] += _B_MEAN\\n image = imresize(image, [299, 299])\\n imsave(f, image, format='png')\",\n \"def visualize(base_path, test_dataset, plot_dir, batch_size=4, ):\\n device = torch.device('cuda')\\n dataset = HeadDataset(test_dataset,\\n base_path,\\n dataset_param={},\\n train=False)\\n batch_iterator = iter(data.DataLoader(dataset, batch_size,\\n shuffle=False,\\n num_workers=4,\\n collate_fn=coco_collate))\\n for ind, (images, targets) in enumerate(tqdm(batch_iterator)):\\n images = list(img.to(device) for img in images)\\n np_images = [(ims.cpu().numpy()*255.).astype(np.uint8) for ims in images]\\n gt_boxes = [gt['boxes'].numpy().astype(np.float64) for gt in targets]\\n for np_im, gt_box in zip(np_images, gt_boxes):\\n plot_images = plot_ims(np_im, [], gt_box)\\n imsave(osp.join(plot_dir, str(ind) + '.jpg'), plot_images)\",\n \"def save_imgs(self, epoch):\\n row, column = 5, 5\\n\\n # Generates r*c images from the model, saves them individually and as a gallery\\n images_generated = self.generate_images(row * column)\\n\\n # ???\\n images_generated = 0.5 * images_generated + 0.5\\n\\n for index, np_array_image in enumerate(images_generated):\\n path = f\\\"{self.output_directory}/generated_{self.img_size[0]}x{self.img_size[1]}\\\"\\n if not os.path.exists(path):\\n os.makedirs(path)\\n imsave(path + f\\\"/{unique_name()}_{epoch}_{index}.png\\\", np_array_image)\\n\\n # 4D array:\\n nindex, height, width, intensity = images_generated.shape\\n\\n nrows = nindex // column\\n\\n assert nindex == nrows * column\\n\\n # Form the gallery by combining the data at pixel levels (may not be the best approach)\\n # want result.shape = (height*n-rows, width*n-cols, intensity)\\n gallery = (\\n images_generated.reshape(nrows, column, height, width, intensity)\\n .swapaxes(1, 2)\\n .reshape(height * nrows, width * column, intensity)\\n )\\n\\n path = f\\\"{self.output_directory}/gallery_generated_{self.img_size[0]}x{self.img_size[1]}\\\"\\n if not os.path.exists(path):\\n os.makedirs(path)\\n imsave(path + f\\\"/{unique_name()}_{epoch}.png\\\", gallery)\",\n \"def save_images(images, filenames, output_dir):\\n for i, filename in enumerate(filenames):\\n # Images for inception classifier are normalized to be in [-1, 1] interval,\\n # so rescale them back to [0, 1].\\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\\n img = np.round(((images[i] + 1.0) * 0.5) * 255.0).astype(np.uint8)\\n Image.fromarray(img).save(f, format='PNG')\",\n \"def visualize_training(features, labels, pl):\\n print(\\\"Visualizing training\\\")\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n # Take out each feature type, one at a time\\n label_map = get_label_map(labels)\\n\\n for key in label_map.keys():\\n like_ind = label_map[key]\\n like_data = np.array([features[i] for i in like_ind])\\n\\n plt.scatter(like_data[:,0],like_data[:,1],label=key)\\n\\n # get limits\\n xmin = features.column_min(0) - .5\\n xmax = features.column_max(0) + .5\\n ymin = features.column_min(1) - .5\\n ymax = features.column_max(1) + .5\\n\\n plt.xlim(xmin,xmax)\\n plt.ylim(ymin,ymax)\\n\\n # Track the current dividing line, as well as the number of epochs passed\\n divider, = plt.plot([],[])\\n epoch_tracker = plt.text(-1,.9, '', fontsize=15)\\n\\n def update(i):\\n \\\"\\\"\\\"\\n 1.) Get the next set of weights from the tracker\\n 2.) Calculate and draw the new divider line\\n 3.) Update the epoch counter\\n 4.) If we are at the end of an epoch, plot a dashed divider line to track progress\\n \\\"\\\"\\\"\\n epoch = i//features.instance_count\\n w = pl.weights_tracker[i]\\n a = pl.accuracy_tracker[epoch]\\n divider.set_data([xmin,xmax],[(-xmin * w[0] - w[2]) / w[1], (-xmax * w[0] - w[2]) / w[1]])\\n epoch_tracker.set_text(\\\"{} {}\\\".format(epoch + 1, a))\\n\\n # Keep a shadow of the hyperplane at the end of each epoch\\n if i % features.instance_count == 0:\\n plot_hyperplane(w,xmin,xmax,iter = i, alpha = .3, color='black',linestyle='dashed')\\n\\n return divider\\n\\n ani = animation.FuncAnimation(fig, update, frames=range(len(pl.weights_tracker)), interval=250,repeat=False)\\n plt.legend()\\n\\n # optional save file\\n if len(sys.argv) >= 3 :\\n ani.save(sys.argv[2], writer='imagemagick', fps=5)\\n\\n plt.show()\",\n \"def plot_eval_2(trained_model, image_name):\\n # Get training evaluation data\\n train_accuracy = trained_model.history['acc']\\n train_val_accuracy = trained_model.history['val_acc']\\n train_loss = trained_model.history['loss']\\n train_val_loss = trained_model.history['val_loss']\\n \\n # Generate accuracy plot\\n epochs = range(len(train_accuracy))\\n plt.figure()\\n plt.plot(epochs, train_accuracy, 'bo', label='Training accuracy')\\n plt.plot(epochs, train_val_accuracy, 'b', label='Validation accuracy')\\n plt.title('Training and validation accuracy')\\n plt.legend()\\n \\n # Save accuracy plot\\n plot_file = os.path.join(OUTPUT_DIR,\\n \\\"{}_training_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\\n \\n # Generate loss plot\\n plt.figure()\\n plt.plot(epochs, train_loss, 'bo', label='Training loss')\\n plt.plot(epochs, train_val_loss, 'b', label='Validation loss')\\n plt.title('Training and validation loss')\\n plt.legend()\\n \\n # Save loss plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_training_loss\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def train_one_epoch_Image_display(self):\\n print('Training......')\\n\\n # set mode train\\n self.network.train()\\n\\n # prepare data\\n train_loss = 0\\n transform = transforms.Compose([Rescale(params.rescale_size),\\n RandomCrop(params.image_size),\\n RandomHorizontalFlip(),\\n ToTensor()\\n ])\\n\\n\\n\\n dataset = Cityscapes(params.dataset_root, mode='train', transforms = transform)\\n\\n train_loader = DataLoader(dataset,\\n batch_size=params.train_batch,\\n shuffle=params.shuffle,\\n num_workers=params.dataloader_workers)\\n \\n train_size = 1896\\n if train_size % self.params.train_batch != 0:\\n total_batch = train_size // self.params.train_batch + 1\\n else:\\n total_batch = train_size // self.params.train_batch\\n recal = 0\\n precision = 0\\n F_one = 0\\n IOU = 0\\n accuracy_new = 0 \\n # train through dataset\\n for batch_idx, batch in enumerate(train_loader):\\n self.pb.click(batch_idx, total_batch)\\n image, label = batch['image'], batch['label']\\n image_cuda, label_cuda = image.cuda(), label.cuda()\\n\\n # checkpoint split\\n if self.params.should_split:\\n image_cuda.requires_grad_()\\n out = checkpoint_sequential(self.network, self.params.split, image_cuda)\\n else:\\n out = self.network(image_cuda)\\n \\n pred = image_cuda\\n pred = pred.to(torch.device(\\\"cpu\\\"))\\n pred = pred.detach()\\n img_grid = pred[0]\\n #img_grid = torchvision.utils.make_grid(out) \\n img_grid = img_grid.numpy().transpose(1, 2, 0)*255\\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/original%d.jpg\\\" % batch_idx, img_grid)\\n\\n \\n loss = self.loss_fn(out, label_cuda)\\n \\n #display_image(out, label_cuda)\\n TP, FP, TN, FN = confusion(out, label_cuda)\\n recal = recal+TP\\n precision = precision+FP\\n F_one = F_one + TN\\n IOU = IOU+ FN \\n _,predict = torch.max(out.data,1)\\n predict = predict.to(torch.device(\\\"cpu\\\"))\\n predict = predict.detach()\\n img = predict[0]\\n img = img.numpy()*255\\n #img_grid = torchvision.utils.make_grid(out) \\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/predict_label%d.png\\\" % batch_idx, img)\\n label = label_cuda.to(torch.device(\\\"cpu\\\"))\\n label = label.detach()\\n label = label[0].numpy()*255\\n cv2.imwrite(\\\"/content/drive/My Drive/Train_images/original_label%d.png\\\" % batch_idx, label)\\n\\n \\n \\n\\n accuracy_final = accuracy(out, label_cuda)\\n accuracy_new = accuracy_new + accuracy_final\\n\\n \\n print(\\\"\\\\t\\\")\\n print(recal/total_batch, precision/ total_batch, F_one/ total_batch, IOU/ total_batch)\\n print(accuracy_new/total_batch)\",\n \"def _update(self):\\n print(\\\"Saving prediction json files...\\\")\\n self._dump_json()\\n print(\\\"Saving prediction json files done...\\\")\\n print(\\\"Saving prediction images...\\\")\\n self._dump_image()\\n print(\\\"Saving prediction images done...\\\")\",\n \"def draw_image(self):\\n \\n pixel_array = self.imageprepare(self.image_path)\\n newArr = self.reshape_pixel_array(pixel_array)\\n plt.imshow(newArr, interpolation='nearest')\\n plt.savefig('MNIST_IMAGE.png')#save MNIST image\\n plt.show()#Show / plot that image\",\n \"def save_test_images(images):\\n for description, img in images.items():\\n save_to_image(img, description)\\n save_to_netcdf(img, description)\",\n \"def main():\\n\\n # first figure: betas for each predictor\\n fig, axes = plt.subplots(figsize=(8, 18), nrows=3)\\n\\n image_paths = {\\n \\\"3T\\\": (\\n f\\\"{PATHS['figures_misc']}/figure_3_images/\\\"\\n f\\\"C1051_20161006_childVSall_depth_1.png\\\"\\n ),\\n \\\"7T\\\": (\\n f\\\"{PATHS['figures_misc']}/figure_3_images/\\\"\\n f\\\"C1051_20160212_childVSall_depth_1_sim2pt4.png\\\"\\n ),\\n \\\"7T_noise\\\": (\\n f\\\"{PATHS['figures_misc']}/figure_3_images/\\\"\\n f\\\"C1051_20160212_childVSall_depth_1_sim2pt4_noise.png\\\"\\n ),\\n }\\n\\n for ax, (_, image_path) in zip(axes, image_paths.items()):\\n assert os.path.isfile(image_path)\\n img = imread(image_path)\\n img[np.where(np.sum(img, axis=2) == 0.0)] = 1.0\\n\\n ax.imshow(img[200:-100, 50:-50, :])\\n ax.axis(\\\"off\\\")\\n\\n savefig(f\\\"{PATHS['figures']}/figure_3ac.png\\\")\\n plt.close(fig)\",\n \"def _add_images(self, epoch, train_batch, train_outputs, valid_batch, valid_outputs):\\n raise NotImplementedError\",\n \"def main(): # pylint: disable=R0914, R0915\\n args = parse_args()\\n\\n # load dataset\\n test_dataset = load_dataset(dataset_name=args.dataset, dataset_part='test')\\n\\n # load model\\n model_name = args.model\\n model = load_model(model_name)\\n model.load_state_dict(torch.load(args.checkpoint_path)['model'])\\n model.eval()\\n\\n # create sets of samples of images and their corresponding saliency maps\\n all_samples = []\\n all_saliency_maps = []\\n sample_to_image = lambda x: np.transpose(x, (1, 2, 0))\\n\\n for _ in range(6):\\n samples, true_labels = next(iter(DataLoader(test_dataset,\\n batch_size=6,\\n shuffle=True)))\\n all_samples.append(torch.cat([sample_to_image(s).unsqueeze(0)\\n for s in samples]))\\n saliency_maps = compute_gradient_saliency_maps(samples.to(device),\\n true_labels.to(device),\\n model)\\n all_saliency_maps.append(saliency_maps.cpu().detach())\\n\\n all_samples = torch.cat(all_samples)\\n all_saliency_maps = torch.cat(all_saliency_maps)\\n\\n saliency_maps_and_images_pairs = plt.figure()\\n plt.suptitle('Images and their saliency maps')\\n for idx, (image, saliency_map) in enumerate(zip(all_samples,\\n all_saliency_maps)):\\n plt.subplot(6, 6 * 2, 2 * idx + 1)\\n # plot image\\n image -= image.min()\\n image /= image.max()\\n plt.imshow(image)\\n plt.xticks([])\\n plt.yticks([])\\n # plot saliency map\\n plt.subplot(6, 6 * 2, 2 * idx + 2)\\n saliency_map -= saliency_map.min()\\n saliency_map /= saliency_map.max()\\n plt.imshow(saliency_map)\\n plt.xticks([])\\n plt.yticks([])\\n\\n saliency_maps_and_images_pairs.set_size_inches((8, 8))\\n saliency_maps_and_images_pairs.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_'\\n f'saliency_maps_and_images_pairs.png'))\\n\\n # loop through the images in the test set and compute saliency map for\\n # each image. Compute the average map of all real face image and\\n # all fake face image images.\\n dataloader = DataLoader(test_dataset, batch_size=32, shuffle=True)\\n real_images_saliency_maps = []\\n fake_images_saliency_maps = []\\n\\n for samples, true_labels in dataloader:\\n fake_samples = samples[true_labels == 1].to(device)\\n fake_labels = true_labels[true_labels == 1].to(device)\\n real_samples = samples[true_labels == 0].to(device)\\n real_labels = true_labels[true_labels == 0].to(device)\\n saliency_maps = compute_gradient_saliency_maps(fake_samples,\\n fake_labels,\\n model)\\n fake_images_saliency_maps.append(saliency_maps.cpu().detach())\\n saliency_maps = compute_gradient_saliency_maps(real_samples,\\n real_labels,\\n model)\\n real_images_saliency_maps.append(saliency_maps.cpu().detach())\\n\\n all_real_saliency_maps = torch.cat(real_images_saliency_maps)\\n all_fake_saliency_maps = torch.cat(fake_images_saliency_maps)\\n\\n for idx in range(all_real_saliency_maps.shape[0]):\\n all_real_saliency_maps[idx] -= all_real_saliency_maps[idx].min()\\n all_real_saliency_maps[idx] /= all_real_saliency_maps[idx].max()\\n\\n for idx in range(all_fake_saliency_maps.shape[0]):\\n all_fake_saliency_maps[idx] -= all_fake_saliency_maps[idx].min()\\n all_fake_saliency_maps[idx] /= all_fake_saliency_maps[idx].max()\\n\\n mean_saliency_maps = plt.figure()\\n plt.subplot(1, 2, 1)\\n mean_map = all_fake_saliency_maps.mean(axis=0)\\n mean_map -= mean_map.min()\\n mean_map /= mean_map.max()\\n plt.imshow(mean_map)\\n plt.title('mean of fake images saliency maps')\\n plt.subplot(1, 2, 2)\\n mean_map = all_real_saliency_maps.mean(axis=0)\\n mean_map -= mean_map.min()\\n mean_map /= mean_map.max()\\n plt.imshow(mean_map)\\n plt.title('mean of real images saliency maps')\\n mean_saliency_maps.set_size_inches((8, 6))\\n mean_saliency_maps.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_mean_saliency_maps.png'))\",\n \"def test_save_images(self):\\n save_file(self.quart.save_images, to_single_file=False)\",\n \"def visualize(self):\\r\\n self.aggregator.plot_loss()\\r\\n self.save_figure()\",\n \"def save_step_4(imgs, output_path=\\\"./output/step4\\\"):\\n # ... your code here ...\\n cv2.imwrite(output_path+\\\"/output.jpg\\\", imgs)\",\n \"def persist_resized_test_image_and_label(self, answer_path):\\n print('writing files on new data')\\n n_partition = 3\\n # read the images\\n images_all, names_all = self.scale_images(self.input_root_dir, image_name_flag=True)\\n nb_images = len(images_all)\\n # read the answer file to a dict\\n answer_map = map(str.split, open(answer_path))\\n name_label_dict = dict()\\n for i in range(1, len(answer_map)):\\n name_label_dict[answer_map[i][0]] = answer_map[i][1]\\n\\n images = []\\n labels = []\\n for name in name_label_dict.keys():\\n if name in names_all:\\n idx = names_all.index(name)\\n images.append(images_all[idx])\\n labels.append(int(name_label_dict[name]))\\n\\n data = zip(images, labels)\\n random.shuffle(data)\\n train_data, validation_data = train_test_split(data, test_size=0.1, random_state=35)\\n train_images, train_labels = zip(*train_data)\\n validation_images, validation_labels = zip(*validation_data)\\n# train_images = images\\n# train_labels = labels\\n train_batch_length = len(train_images) / n_partition\\n validation_batch_length = len(validation_images) / n_partition\\n \\n \\n# while 1:\\n# i = random.randint(0, len(labels)-1)\\n# plt.imshow(images[i])\\n# plt.title(self.reverse_label_map[labels[i]])\\n n_shift = 30\\n for partition_idx in range(n_partition):\\n if(partition_idx < n_partition - 1):\\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('train', partition_idx + n_shift)), \\n [train_images[partition_idx * train_batch_length : (partition_idx + 1) * train_batch_length], \\n train_labels[partition_idx * train_batch_length : (partition_idx + 1) * train_batch_length]])\\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('validation', partition_idx + n_shift)), \\n [validation_images[partition_idx * validation_batch_length : (partition_idx + 1) * validation_batch_length], \\n validation_labels[partition_idx * validation_batch_length : (partition_idx + 1) * validation_batch_length]])\\n else:\\n print('last partition')\\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('train', partition_idx + n_shift)), \\n [train_images[partition_idx * train_batch_length:], \\n train_labels[partition_idx * train_batch_length:]])\\n write_data(os.path.join(self.output_root_dir, ('%s_cropped_224_224_ndarray_%d.pkl') % ('validation', partition_idx + n_shift)), \\n [validation_images[partition_idx * validation_batch_length:], \\n validation_labels[partition_idx * validation_batch_length:]])\",\n \"def save_test_sample(real_imgs_lab, fake_imgs_lab1, fake_imgs_lab2, save_path, plot_size=14, scale=1.6, show=False):\\n batch_size = real_imgs_lab.size()[0]\\n plot_size = min(plot_size, batch_size)\\n\\n # create white canvas\\n canvas = np.ones((plot_size*32 + (plot_size+1)*6, 4*32 + 5*8, 3), dtype=np.uint8)*255\\n\\n real_imgs_lab = real_imgs_lab.cpu().numpy()\\n fake_imgs_lab1 = fake_imgs_lab1.cpu().numpy()\\n fake_imgs_lab2 = fake_imgs_lab2.cpu().numpy()\\n\\n for i in range(0, plot_size):\\n # post-process real and fake samples\\n real_bgr = postprocess(real_imgs_lab[i])\\n fake_bgr1 = postprocess(fake_imgs_lab1[i])\\n fake_bgr2 = postprocess(fake_imgs_lab2[i])\\n grayscale = np.expand_dims(cv2.cvtColor(real_bgr.astype(np.float32), cv2.COLOR_BGR2GRAY), 2)\\n # paint\\n x = (i+1)*6+i*32\\n canvas[x:x+32, 8:40, :] = real_bgr\\n canvas[x:x+32, 48:80, :] = np.repeat(grayscale, 3, axis=2)\\n canvas[x:x+32, 88:120, :] = fake_bgr1\\n canvas[x:x+32, 128:160, :] = fake_bgr2\\n\\n # scale\\n canvas = cv2.resize(canvas, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST)\\n # save\\n cv2.imwrite(os.path.join(save_path), canvas)\\n\\n if show:\\n cv2.destroyAllWindows()\\n cv2.imshow('sample', canvas)\\n cv2.waitKey(10000)\",\n \"def load_png_data():\\n m=1 #训练文件个数\\n n=1 #测试文件个数\\n train_set_x=[]#训练数据集\\n train_set_y=[]#训练标签集\\n\\n test_set_x=[]#测试数据集\\n test_set_y=[]#测试标签集\\n\\n train_data={}\\n\\n train_path=r\\\".\\\\dataset\\\\train_label\\\\\\\\\\\"\\n dirs=os.listdir(train_path)\\n\\n for file in dirs:\\n srcImg=cv2.imread(train_path+file)\\n #将label数据集保存为numpy格式并保存\\n npImg=np.array(srcImg)\\n np.save(train_path+str(m)+'.npy',npImg)\\n train_set_x.append(npImg)\\n\\n\\n NoiseImg = GaussianNoise(srcImg, 25, 4, 0.8)\\n npNoiseImg = np.array(NoiseImg)\\n cv2.imwrite(r\\\".\\\\dataset\\\\trainset\\\\\\\\\\\"+str(m)+'.png', NoiseImg, [int(cv2.IMWRITE_PNG_STRATEGY_DEFAULT)])\\n np.save(r\\\".\\\\dataset\\\\trainset\\\\\\\\\\\" + str(m) + '.npy', npNoiseImg)\\n train_set_y.append(npNoiseImg)\\n m=m+1\\n train_data['train_set_x']=train_set_x\\n train_data['train_set_y']=train_set_y\\n\\n test_path = r\\\".\\\\dataset\\\\test_label\\\\\\\\\\\"\\n dirs_test = os.listdir(test_path)\\n for file in dirs_test:\\n srcImg=cv2.imread(test_path+file)\\n #将label数据集保存为numpy格式并保存\\n npImg=np.array(srcImg)\\n np.save(test_path+str(n)+'.npy',npImg)\\n test_set_x.append(npImg)\\n\\n\\n NoiseImg = GaussianNoise(srcImg, 25, 4, 0.8)\\n npNoiseImg = np.array(NoiseImg)\\n cv2.imwrite(r\\\".\\\\dataset\\\\testset\\\\\\\\\\\"+str(n)+'.png', NoiseImg, [int(cv2.IMWRITE_PNG_STRATEGY_DEFAULT)])\\n np.save(r\\\".\\\\dataset\\\\testset\\\\\\\\\\\" + str(n) + '.npy', npNoiseImg)\\n test_set_y.append(npNoiseImg)\\n n=n+1\\n train_data['test_set_x']=test_set_x\\n train_data['test_set_y']=test_set_y\\n\\n np.savez(r\\\"E:\\\\DeepLearning\\\\CNNDenoiser\\\\dataset\\\\train_data.npz\\\",**train_data)\",\n \"def save_augmentation_visual(lines, output_dir):\\n\\n # Ensure output directory exists\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n save_name = 'data_augmentation.png'\\n idx = np.random.randint(0, len(lines))\\n image = ndimage.imread(lines[idx][0])\\n angle = lines[idx][1]\\n fig = visualize_augmentation(image, angle)\\n fig.savefig(output_dir + save_name, bbox_inches='tight')\",\n \"def evaluate(self):\\n eval_save_dir = os.path.join(self.imsave_dir, \\\"test\\\")\\n samples = self.sample(np.random.uniform(-1, 1, (self.batch_size, self.z_dim)))\\n if not os.path.exists(eval_save_dir):\\n os.makedirs(eval_save_dir)\\n # save images\\n for index, sample in enumerate(samples):\\n if self.C == 1:\\n imsave(os.path.join(eval_save_dir, \\\"%s.png\\\" % index), samples[index].reshape(self.H, self.W))\\n else:\\n imsave(os.path.join(eval_save_dir, \\\"%s.png\\\" % index),\\n recover_img(samples[index].reshape(self.H, self.W, self.C)))\\n\\n # display some images\\n row, col = 4, 4\\n random_index = np.random.randint(0, self.batch_size, size=row * col)\\n for i in range(row*col):\\n plt.subplot(row, col, i+1)\\n plt.imshow(recover_img(samples[random_index[i]].reshape(self.H, self.W, self.C))\\n , cmap=\\\"gray\\\" if self.C==1 else None)\\n plt.gca().axis(\\\"off\\\")\\n plt.show()\",\n \"def plot_predictions(images, filename):\\n imagex = format_image(images, 4)\\n mosaic = create_mosaic(imagex, 2, 2)\\n plt.figure(figsize=(12, 12))\\n plt.imshow(mosaic, cmap='gray')\\n plt.axis('off')\\n plt.savefig(filename + '.png', bbox_inches='tight')\",\n \"def result_plotting(n_images,epoch,dataset,result_path,labels,predictions,indices):\\n \\n coord,connectivity = [],[] # List of prediction and ground truth images\\n for k in range(n_images):\\n \\n or_case = int(np.where(np.array(dataset.data.case)==indices[k])[0][0]) # Get index of case\\n \\n # Get the coordinate and connectivity data\\n coord += [dataset[or_case].coord.numpy()] \\n connectivity += [dataset[or_case].connectivity.numpy()]\\n\\n # Save npz array with the results of this iteration\\n np.savez(join(result_path,'Temp.npz'),labels=n(labels),predictions=n(predictions)\\n ,indices=n(indices),coord=n(coord),connectivity=n(connectivity))\\n\\n # Call mesh_plotter to create the figures\\n subprocess.call(['python', 'mesh_plotter.py','-p',result_path,'-e',str(epoch),'-ni',str(n_images)])\\n \\n # Send image for visualization in W&B\\n images = wandb.Image(join(result_path,'Result_'+str(epoch).zfill(3)+'.png'),caption = \\\"Epoch \\\"+str(epoch))\\n wandb.log({\\\"Prediction\\\": images})\",\n \"def write_data(data_to_write_train, data_to_write_test, train_path, eval_path ,test_path):\\n aligned_lists_train = data_to_write_train[0]\\n raw_lists_train = data_to_write_train[2]\\n\\n aligned_lists_eval = data_to_write_test[0]\\n raw_lists_eval = data_to_write_test[2]\\n\\n aligned_lists_test = data_to_write_test[1]\\n raw_lists_test = data_to_write_test[3]\\n\\n filelist = list([train_path, eval_path, test_path])\\n\\n for file in filelist:\\n aligned_path = os.path.join(file, 'aligned_image')\\n raw_path = os.path.join(file, 'raw_image')\\n os.mkdir(aligned_path)\\n os.mkdir(raw_path)\\n\\n # raw image data\\n for Idx, train_raw in enumerate(raw_lists_train):\\n img = Image.open(train_raw)\\n img.save(train_path+'/raw_image/img_'+f'{Idx:04d}.jpg')\\n if Idx%100 == 0:\\n print('\\\\t%d images are saved'% Idx); \\n print('\\\\tTrain raw images saved! ')\\n\\n for Idx, eval_raw in enumerate(raw_lists_eval):\\n img = Image.open(eval_raw)\\n img.save(eval_path+'/raw_image/img_'+f'{Idx:04d}.jpg')\\n if Idx%100 == 0:\\n print('\\\\t%d images are saved'% Idx); \\n print('\\\\tEval raw images saved! ')\\n\\n for Idx, test_raw in enumerate(raw_lists_test):\\n img = Image.open(test_raw)\\n img.save(test_path+'/raw_image/img_'+f'{Idx:04d}.jpg')\\n if Idx%100 == 0:\\n print('\\\\t%d images are saved'% Idx); \\n print('\\\\tTest raw images saved! ')\\n\\n # aligned image data\\n for Idx, train_aligned in enumerate(aligned_lists_train):\\n img = Image.open(train_aligned)\\n img.save(train_path+'/aligned_image/img_'+f'{Idx:04d}.jpg')\\n if Idx%100 == 0:\\n print('\\\\t%d images are saved'% Idx); \\n print('\\\\tTrain aligned images saved! ')\\n\\n for Idx, eval_aligned in enumerate(aligned_lists_eval):\\n img = Image.open(eval_aligned)\\n img.save(eval_path+'/aligned_image/img_'+f'{Idx:04d}.jpg')\\n if Idx%100 == 0:\\n print('\\\\t%d images are saved'% Idx); \\n print('\\\\tEval aligned images saved! ')\\n\\n for Idx, test_aligned in enumerate(aligned_lists_test):\\n img = Image.open(test_aligned)\\n img.save(test_path+'/aligned_image/img_'+f'{Idx:04d}.jpg')\\n if Idx%100 == 0:\\n print('\\\\t%d images are saved'% Idx); \\n print('\\\\tTest aligned images saved! ')\",\n \"def visualize(self, paths, instance, during_analysis):\\r\\n xvalues = np.arange(self.data.shape[0])\\r\\n\\r\\n model_data = self.model_data_from_instance(instance=instance)\\r\\n\\r\\n residual_map = self.data - model_data\\r\\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\\r\\n\\r\\n \\\"\\\"\\\"The visualizer now outputs images of the best-fit results to hard-disk (checkout `visualizer.py`).\\\"\\\"\\\"\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=self.data,\\r\\n title=\\\"Data\\\",\\r\\n ylabel=\\\"Data Values\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"data\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=model_data,\\r\\n title=\\\"Model Data\\\",\\r\\n ylabel=\\\"Model Data Values\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"model_data\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=residual_map,\\r\\n title=\\\"Residual Map\\\",\\r\\n ylabel=\\\"Residuals\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"residual_map\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=chi_squared_map,\\r\\n title=\\\"Chi-Squared Map\\\",\\r\\n ylabel=\\\"Chi-Squareds\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"chi_squared_map\\\",\\r\\n )\",\n \"def test(file_path: str):\\n # Build the generator network\\n generator = build_generator()\\n\\n # Load model weights\\n generator.load_weights(\\\"models/generator.h5\\\")\\n\\n # Make a low-res counterpart to predict upon\\n image = imread(file_path, mode=\\\"RGB\\\")\\n image = image.astype(np.float32)\\n low_resolution_image = [imresize(image, low_resolution_shape)]\\n\\n low_resolution_image = np.array(low_resolution_image) / 127.5 - 1.0\\n\\n # Generate high-resolution images from low-resolution images\\n generated_image = generator.predict_on_batch(low_resolution_image)\\n\\n # Make a common figure\\n fig = plt.figure(figsize=(16, 9))\\n\\n # Add the low resolution image on the left side\\n ax = fig.add_subplot(1, 2, 1)\\n ax.imshow(low_resolution_image[0], interpolation=\\\"nearest\\\")\\n ax.axis(\\\"off\\\")\\n ax.set_title(\\\"Low-resolution\\\")\\n\\n # Add generated image to figure on the right side\\n ax = fig.add_subplot(1, 2, 2)\\n ax.imshow(generated_image[0], interpolation=\\\"nearest\\\")\\n ax.axis(\\\"off\\\")\\n ax.set_title(\\\"Generated\\\")\\n\\n # Save the figure\\n plt.savefig(\\\"{0}{1}\\\".format(TEST_IMAGES_RESULT, file_path.split(\\\"/\\\")[-1]))\",\n \"def train_test_plot():\\n plt.title('Crude Oil Time-Series')\\n plt.plot(train,label=\\\"Training Set\\\")\\n plt.plot(test,label=\\\"Test Set\\\")\\n plt.xlabel('Number of Days')\\n plt.ylabel('Price in USD')\\n plt.legend(loc = 'upper left')\\n plt.savefig('../plots/Time-Series.jpg')\",\n \"def display_sample_images(self):\\n if self.train_dataset is None:\\n self.init_datasets()\\n\\n images, labels = next(self.train_dataset)\\n plt.figure(figsize=(5,5))\\n for n in range(min(25, images.shape[0])):\\n ax = plt.subplot(5,5,n+1)\\n plt.imshow(images[n])\\n if len(labels.shape) == 1:\\n plt.title(self.class_names[int(labels[n])].title())\\n else:\\n m = np.argmax(labels[n])\\n plt.title(self.class_names[int(labels[n, m])].title())\\n plt.axis('off')\\n\\n plt.tight_layout()\\n plt.show()\",\n \"def save_plot(self, ):\\n pass\",\n \"def save():\\n pl.savefig('/home/filippini/Documents/plot/RUN55/compa'+INFO_RUN+'.png')\",\n \"def save_step_1(imgs, output_path='./output/step1'):\\n # ... your code here ...\\n i=0\\n for each in imgs:\\n i+=1\\n cv2.imwrite(output_path+\\\"/output\\\"+str(i)+\\\".jpg\\\", each)\",\n \"def visualize(original, s, m, l, s_pred, m_pred, l_pred):\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tplt.subplot(1,7,1)\\n\\tplt.title('Original image')\\n\\tplt.imshow(original)\\n\\n\\tplt.subplot(1,7,2)\\n\\tplt.title('S image')\\n\\tplt.imshow(s)\\n\\tplt.subplot(1,7,3)\\n\\tplt.title('S Pred image')\\n\\tplt.imshow(s_pred)\\n\\n\\tplt.subplot(1,7,4)\\n\\tplt.title('M image')\\n\\tplt.imshow(m)\\n\\tplt.subplot(1,7,5)\\n\\tplt.title('M Pred image')\\n\\tplt.imshow(m_pred)\\n\\n\\tplt.subplot(1,7,6)\\n\\tplt.title('L image')\\n\\tplt.imshow(l)\\n\\tplt.subplot(1,7,7)\\n\\tplt.title('L Pred image')\\n\\tplt.imshow(l_pred)\",\n \"def plot_images(imgs_org, imgs_pred, nb_examples=10):\\n if nb_examples == 0:\\n return\\n\\n n = nb_examples\\n plt.figure(figsize=(nb_examples * 2, 4))\\n for i in range(n):\\n # display original\\n ax = plt.subplot(2, n, i + 1)\\n plt.imshow(imgs_org[i].reshape(84, 84))\\n plt.gray()\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n\\n # display reconstruction\\n ax = plt.subplot(2, n, i + 1 + n)\\n plt.imshow(imgs_pred[i].reshape(84, 84))\\n plt.gray()\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n plt.show()\",\n \"def save_predictions(predictions, img_paths, output_dir='predictions'):\\n\\n print(f'\\\\nSaving prediction to {output_dir} ...')\\n\\n if not osp.exists(output_dir):\\n os.mkdir(output_dir)\\n\\n for pred, img_path in tqdm(zip(predictions, img_paths), total=len(predictions)):\\n img_name = osp.basename(img_path)\\n pred = pred.astype('uint8')\\n Image.fromarray(pred * 255).save(osp.join(output_dir, img_name))\",\n \"def save_sample(real_imgs_lab, fake_imgs_lab, save_path, plot_size=20, scale=2.2, show=False):\\n batch_size = real_imgs_lab.size()[0]\\n plot_size = min(plot_size, batch_size)\\n\\n # create white canvas\\n canvas = np.ones((3*32 + 4*6, plot_size*32 + (plot_size+1)*6, 3), dtype=np.uint8)*255\\n\\n real_imgs_lab = real_imgs_lab.cpu().numpy()\\n fake_imgs_lab = fake_imgs_lab.cpu().numpy()\\n\\n for i in range(0, plot_size):\\n # postprocess real and fake samples\\n real_bgr = postprocess(real_imgs_lab[i])\\n fake_bgr = postprocess(fake_imgs_lab[i])\\n grayscale = np.expand_dims(cv2.cvtColor(real_bgr.astype(np.float32), cv2.COLOR_BGR2GRAY), 2)\\n # paint\\n x = (i+1)*6+i*32\\n canvas[6:38, x:x+32, :] = real_bgr\\n canvas[44:76, x:x+32, :] = np.repeat(grayscale, 3, axis=2)\\n canvas[82:114, x:x+32, :] = fake_bgr\\n\\n # scale\\n canvas = cv2.resize(canvas, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST)\\n # save\\n cv2.imwrite(os.path.join(save_path), canvas)\\n\\n if show:\\n cv2.destroyAllWindows()\\n cv2.imshow('sample', canvas)\\n cv2.waitKey(10000)\",\n \"def save_processed_images(exp_dir, img_dict):\\n # save them into a directory called \\\"processed\\\"\\n img_fname = os.path.join(exp_dir, str(experiment) + '_processed.jpg')\",\n \"def img_viewer_examples(images, labels, prediction = None, size=0, greyscale=False):\\n batchSize = min(size, images.shape[0])\\n \\n if size == 0:\\n batchSize = images.shape[0]\\n\\n # I CAN TAKE THE BATCH_SIZE from the images size/shape according the sent data type\\n no_of_columns = round(math.sqrt(batchSize))\\n no_of_rows = math.ceil(batchSize / no_of_columns)\\n print(\\\"batch size {}, no_of_rows {}, no_of_columns {}\\\".format(batchSize, no_of_rows, no_of_columns))\\n fig = plt.figure(figsize=(no_of_columns*1.25, no_of_rows*1.5))\\n # (width, height)\\n for idx in np.arange(batchSize):\\n ax = fig.add_subplot(no_of_rows, no_of_columns,\\n idx+1, xticks=[], yticks=[])\\n if greyscale:\\n ax.imshow(np.squeeze(images[idx]), cmap='gray')\\n else:\\n ax.imshow(np.squeeze(images[idx]))\\n # print out the correct label for each image\\n # .item() gets the value contained in a Tensor\\n # WAIT FOR TASNEEM TO SEE THE RETURNED DATA TYPE\\n if not prediction is None:\\n ax.set_title(\\\"{} ({})\\\".format(str(prediction[idx]), str(labels[idx])),\\n color=(\\\"green\\\" if prediction[idx] == labels[idx] else \\\"red\\\"))\\n else:\\n ax.set_title(str(labels[idx]))\",\n \"def save_images(images, filenames, output_dir):\\n for i, filename in enumerate(filenames):\\n dirname = os.path.dirname(filename)\\n\\n if dirname!='':\\n dirpath = os.path.join(output_dir, dirname)\\n if not os.path.exists(dirpath):\\n os.makedirs(dirpath)\\n\\n # Images for inception classifier are normalized to be in [-1, 1] interval,\\n # so rescale them back to [0, 1].\\n with tf.gfile.Open(os.path.join(output_dir, filename), 'w') as f:\\n img = (((images[i, :, :, :] + 1.0) * 0.5) * 255.0).astype(np.uint8)\\n Image.fromarray(img).save(f)\",\n \"def save(images, output):\\n for image, frame in images:\\n image.save(output(frame))\",\n \"def generate_image(noise_list, save_path):\\n check_points_path = os.path.join(save_path, 'check_points')\\n output_image_path = os.path.join(save_path, 'images')\\n components.create_folder(output_image_path, False)\\n latest_checkpoint = tf.train.latest_checkpoint(check_points_path)\\n assert latest_checkpoint is not None, \\\"no check points found\\\"\\n saver = tf.train.import_meta_graph(latest_checkpoint + '.meta')\\n with tf.Session() as sess:\\n saver.restore(sess, latest_checkpoint)\\n iterations = sess.run('saved_iterations:0')\\n for i in range(len(noise_list)):\\n generated_images = sess.run('generator/output_layer/tanh/during_inference:0',\\n feed_dict={\\\"noise_for_inference:0\\\": noise_list[i]})\\n Gan.__save_images(output_image_path, generated_images, int(np.sqrt(generated_images.shape[0])), iterations, i)\",\n \"def save_images(img_list, img_saving_path, label_list, label_saving_path):\\n img_index = SAVING_INDEX\\n label_index=SAVING_INDEX\\n for img in img_list:\\n img.save(img_saving_path + str(img_index) + '.png', 'PNG')\\n img_index+=1\\n for label in label_list:\\n label.save(label_saving_path + str(label_index) + '.png', 'PNG')\\n label_index += 1\",\n \"def generate_images(model, input_image, target_image, plots=1):\\r\\n assert plots <= input_image.shape[\\r\\n 0], \\\"plots number should be less than batch size\\\"\\r\\n\\r\\n prediction = model.predict(input_image)\\r\\n plt.figure(figsize=(50, 50))\\r\\n\\r\\n # target_image = tf.argmax(target_image, axis=-1)\\r\\n # prediction = tf.argmax(prediction, axis=-1)\\r\\n\\r\\n for i in range(plots):\\r\\n plt.subplot(plots, 3, i * 3 + 1)\\r\\n plt.imshow(tf.cast(input_image[i] * 255, dtype=tf.uint8))\\r\\n plt.subplot(plots, 3, i * 3 + 2)\\r\\n plt.imshow(tf.cast(target_image[i] * 255, dtype=tf.uint8))\\r\\n plt.subplot(plots, 3, i * 3 + 3)\\r\\n plt.imshow(tf.cast(prediction[i] * 255, dtype=tf.uint8))\\r\\n plt.show()\",\n \"def save(self, output_folder: str, show_confidence: bool = True) -> None:\\n if output_folder:\\n os.makedirs(output_folder, exist_ok=True)\\n\\n for i, prediction in enumerate(self._images_prediction_lst):\\n image_output_path = os.path.join(output_folder, f\\\"pred_{i}.jpg\\\")\\n prediction.save(output_path=image_output_path, show_confidence=show_confidence)\",\n \"def save_to_disk(x_data, y_data, usage, output_dir='cifar10_images'):\\n assert usage in ['train', 'val', 'test']\\n\\n # Set paths\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n for label in np.unique(y_data):\\n label_path = os.path.join(output_dir, usage, str(label))\\n if not os.path.exists(label_path):\\n os.makedirs(label_path)\\n\\n for idx, img in enumerate(x_data):\\n bgr_img = img[..., ::-1] # RGB -> BGR\\n # label = y_data[idx][0]\\n label = y_data[idx]\\n img_path = os.path.join(\\n output_dir, usage, str(label), 'img_{}.jpg'.format(idx)\\n )\\n retval = cv2.imwrite(img_path, bgr_img)\\n\\n assert retval, 'Problem saving image at index: {}'.format(idx)\",\n \"def create_png(image, label):\\n sv = \\\"/home/avojtekova/Desktop/final_results/star_det/generated_images/\\\" \\n \\n for i in range(len(image)):\\n data = fits.getdata(image[i][0], ext = 0)\\n norm = ImageNormalize(data,interval = ZScaleInterval(), stretch = LinearStretch())\\n \\n print(image[i][0])\\n plt.imshow(data, cmap='Greys_r', origin='lower', norm=norm)#[1250:1750, 2000:2500] add this when you want just part of image \\n plt.title(label[i])\\n plt.axis('off')\\n plt.tight_layout()\\n plt.legend\\n if i<2:\\n if not os.path.isdir(sv + image[i][0][-33:-25] + \\\"/\\\") :\\n os.makedirs(sv + image[i][0][-33:-25] + \\\"/\\\")\\n plt.savefig(sv + image[i][0][-33:-25] + \\\"/\\\" + label[i]+ \\\"_\\\" + image[i][0][-33:-25] + \\\"_big.png\\\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0) \\n else:\\n if not os.path.isdir(sv + image[i][0][-40:-32] + \\\"/\\\") :\\n os.makedirs(sv + image[i][0][-40:-32] + \\\"/\\\")\\n plt.savefig(sv + image[i][0][-40:-32] + \\\"/\\\" + label[i]+image[i][0][-40:-32] + \\\"_big.png\\\", dpi = 1000)#,bbox_inches='tight', pad_inches = 0)\\n plt.close()\",\n \"def main():\\n args = parse_args()\\n\\n with open(args.train_details_json, mode='r', encoding='utf-8') as json_f:\\n results_dict = json.load(json_f)[-1]\\n\\n losses_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_loss']) + 1),\\n results_dict['train_loss'])\\n plt.plot(range(1, len(results_dict['val_loss']) + 1),\\n results_dict['val_loss'])\\n plt.plot(range(1, len(results_dict['test_loss']) + 1),\\n results_dict['test_loss'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'loss vs epoch for {args.model} model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('loss')\\n plt.grid(True)\\n losses_plot.set_size_inches((8, 8))\\n losses_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_losses_plot.png'))\\n\\n accuracies_plot = plt.figure()\\n plt.plot(range(1, len(results_dict['train_acc']) + 1),\\n results_dict['train_acc'])\\n plt.plot(range(1, len(results_dict['val_acc']) + 1),\\n results_dict['val_acc'])\\n plt.plot(range(1, len(results_dict['test_acc']) + 1),\\n results_dict['test_acc'])\\n plt.legend(['train', 'val', 'test'])\\n plt.title(f'accuracy vs epoch for {args.model} '\\n f'model on {args.dataset} dataset')\\n plt.xlabel('epoch')\\n plt.ylabel('accuracy')\\n plt.grid(True)\\n accuracies_plot.set_size_inches((8, 8))\\n accuracies_plot.savefig(\\n os.path.join(FIGURES_DIR,\\n f'{args.dataset}_{args.model}_accuracies_plot.png'))\",\n \"def _saveFig(self):\\r\\n # Save plot\\r\\n filenameG = self._vna.getDateFormatted() + \\\".png\\\"\\r\\n filenameG = \\\"Graphs/\\\" + filenameG \\r\\n plt.savefig(filenameG) # Plot saved in directory named Graphs located in same directory as pyTekVNA\\r\\n plt.clf()\",\n \"def save_particles_image(self):\\n base_filename = self.config['info']['filename_microscope']\\n self.save_image_microscope_camera(base_filename)\",\n \"def save(file_name):\\n setup()\\n plt.savefig(file_name)\",\n \"def save(self) -> None:\\n graph = 'loss' if self.loss else 'accuracy'\\n save = os.path.join(self.savepath, graph + '.png')\\n self.fig.savefig(save)\",\n \"def save_predictions(self, preds_all, save_dir, scale_pred=False):\\n for idx, fname in enumerate(self.test_files):\\n fh = open(fname, 'rb')\\n img = pil.open(fh)\\n orig_h, orig_w = self.gt_depths[idx].shape\\n pred_resize = cv2.resize(preds_all[idx], (orig_w, orig_h), interpolation=cv2.INTER_LINEAR)\\n if scale_pred:\\n scaled_disp, _ = self.scale_depth_disp(pred_resize)\\n disp_img = self.generate_disparity_img(scaled_disp)\\n else:\\n disp_img = self.generate_disparity_img(1./pred_resize)\\n\\n imgname = \\\"{0:04d}\\\".format(idx)\\n name_img = os.path.join(save_dir, imgname+\\\".jpeg\\\")\\n img.save(name_img)\\n name_disp = os.path.join(save_dir, imgname+\\\"_disp.jpeg\\\")\\n disp_img.save(name_disp)\",\n \"def train(self, nsamples = 1, verbose = False, random = True):\\n imgs, skels = self.images.get_batch(nimages = nsamples, random = random);\\n self.trainer.run(session = self.session, feed_dict={self.input : imgs, self.skeleton : skels})\\n if verbose:\\n self.plot_results(imgs);\",\n \"def save_plot(epoch_num, step, rewards, filepath):\\n fig, ax = plt.subplots() \\n ax.plot(range(0, epoch_num + 1, step), rewards)#,'.')\\n ax.plot(range(0, epoch_num + 1, step), np.ones(len(range(0, epoch_num + 1, step)))*rewards[0], 'r')\\n fig.savefig(filepath)\\n plt.close(fig) # close the figure \",\n \"def save_figure(self, data):\\n\\n\\t\\tsizes = np.shape(data)\\n\\t\\tfig = plt.figure()\\n\\t\\tfig.set_size_inches(1, 1. * sizes[0]/sizes[1], forward = False)\\n\\t\\tax = plt.Axes(fig, [0., 0., 1., 1.])\\n\\t\\tax.set_axis_off()\\n\\t\\tfig.add_axes(ax)\\n\\t\\tax.imshow(data, \\\"gray\\\")\\n\\n\\t\\t#plt.show()\\n\\t\\tself.plotfile = os.path.join('static', 'Figure' + '.png')\\n\\t\\tplt.savefig(self.plotfile, dpi = sizes[1])\",\n \"def save_imgs(self):\\n print(\\\"Saving the images with required categories ...\\\")\\n os.makedirs(self.imgs_dir, exist_ok=True)\\n # Save the images into a local folder\\n for im in tqdm(self.images):\\n img_data = requests.get(im['coco_url']).content\\n with open(os.path.join(self.imgs_dir, im['file_name']), 'wb') as handler:\\n handler.write(img_data)\",\n \"def save(self, x, y, names, path=\\\"\\\", zoom=False):\\n for i in range(len(x)):\\n image = self.generate(x[i], label=np.argmax(y[i]), zoom=zoom)\\n image = Image.fromarray((image*255).astype(\\\"uint8\\\"))\\n image.save(path + names[i] + \\\".png\\\", \\\"PNG\\\")\",\n \"def save(self, fn):\\n plt.imsave(fn, self.image)\",\n \"def saveImage(self, observation):\\n image_path = \\\"{}/{}/frame{:06d}\\\".format(self.data_folder, self.episode_folder, self.episode_step)\\n relative_path = \\\"{}/{}/frame{:06d}\\\".format(self.name, self.episode_folder, self.episode_step)\\n self.images_path.append(relative_path)\\n # in the case of dual/multi-camera\\n if observation.shape[2] > 3:\\n observation1 = cv2.cvtColor(observation[:, :, :3], cv2.COLOR_BGR2RGB)\\n observation2 = cv2.cvtColor(observation[:, :, 3:], cv2.COLOR_BGR2RGB)\\n\\n cv2.imwrite(\\\"{}_1.jpg\\\".format(image_path), observation1)\\n cv2.imwrite(\\\"{}_2.jpg\\\".format(image_path), observation2)\\n else:\\n observation = cv2.cvtColor(observation, cv2.COLOR_BGR2RGB)\\n cv2.imwrite(\\\"{}.jpg\\\".format(image_path), observation)\",\n \"def make_gifs_train(title, path):\\n images = os.listdir(path)\\n generated_images = []\\n\\n for i in range(len(images)):\\n file = os.path.join(path, '%s_Samples_Epoch_%03d.png' % (title, i+1))\\n generated_images.append(imageio.imread(file))\\n\\n imageio.mimsave(path + '{}_Train_Results.gif'.format(title), generated_images, fps=2)\\n print(\\\"{} gif file is generated.\\\".format(title))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78799677","0.7536049","0.7308674","0.7303662","0.7167811","0.7157019","0.7031298","0.69756454","0.6960181","0.6957856","0.6898664","0.6836575","0.68074214","0.6796281","0.67932737","0.6753751","0.6747309","0.6742162","0.67349654","0.6719155","0.6683331","0.66761476","0.6659314","0.6657143","0.6633122","0.6605198","0.6588203","0.6571453","0.6566342","0.6560713","0.6557166","0.6553198","0.6539207","0.6525886","0.65195966","0.6485394","0.6478679","0.6475525","0.6463766","0.6462827","0.64558345","0.6445697","0.6442508","0.6440065","0.64395016","0.643525","0.6428194","0.6425681","0.64185226","0.6417618","0.6408333","0.63968354","0.6388538","0.63817596","0.6374909","0.6374856","0.63724405","0.6369477","0.6361737","0.63501906","0.6344098","0.6342929","0.63393676","0.63384813","0.6334461","0.6318421","0.63093257","0.6281819","0.62792087","0.6276669","0.62756205","0.6275149","0.62592924","0.6254121","0.62489533","0.624863","0.62421125","0.62394226","0.6231671","0.6226043","0.62225765","0.6216246","0.62148243","0.6211902","0.6210927","0.6205531","0.6204615","0.6197596","0.61954564","0.61856395","0.6182624","0.6179006","0.6178328","0.61689883","0.61626893","0.61606824","0.6159159","0.61546713","0.61528033","0.6144841","0.6143379"],"string":"[\n \"0.78799677\",\n \"0.7536049\",\n \"0.7308674\",\n \"0.7303662\",\n \"0.7167811\",\n \"0.7157019\",\n \"0.7031298\",\n \"0.69756454\",\n \"0.6960181\",\n \"0.6957856\",\n \"0.6898664\",\n \"0.6836575\",\n \"0.68074214\",\n \"0.6796281\",\n \"0.67932737\",\n \"0.6753751\",\n \"0.6747309\",\n \"0.6742162\",\n \"0.67349654\",\n \"0.6719155\",\n \"0.6683331\",\n \"0.66761476\",\n \"0.6659314\",\n \"0.6657143\",\n \"0.6633122\",\n \"0.6605198\",\n \"0.6588203\",\n \"0.6571453\",\n \"0.6566342\",\n \"0.6560713\",\n \"0.6557166\",\n \"0.6553198\",\n \"0.6539207\",\n \"0.6525886\",\n \"0.65195966\",\n \"0.6485394\",\n \"0.6478679\",\n \"0.6475525\",\n \"0.6463766\",\n \"0.6462827\",\n \"0.64558345\",\n \"0.6445697\",\n \"0.6442508\",\n \"0.6440065\",\n \"0.64395016\",\n \"0.643525\",\n \"0.6428194\",\n \"0.6425681\",\n \"0.64185226\",\n \"0.6417618\",\n \"0.6408333\",\n \"0.63968354\",\n \"0.6388538\",\n \"0.63817596\",\n \"0.6374909\",\n \"0.6374856\",\n \"0.63724405\",\n \"0.6369477\",\n \"0.6361737\",\n \"0.63501906\",\n \"0.6344098\",\n \"0.6342929\",\n \"0.63393676\",\n \"0.63384813\",\n \"0.6334461\",\n \"0.6318421\",\n \"0.63093257\",\n \"0.6281819\",\n \"0.62792087\",\n \"0.6276669\",\n \"0.62756205\",\n \"0.6275149\",\n \"0.62592924\",\n \"0.6254121\",\n \"0.62489533\",\n \"0.624863\",\n \"0.62421125\",\n \"0.62394226\",\n \"0.6231671\",\n \"0.6226043\",\n \"0.62225765\",\n \"0.6216246\",\n \"0.62148243\",\n \"0.6211902\",\n \"0.6210927\",\n \"0.6205531\",\n \"0.6204615\",\n \"0.6197596\",\n \"0.61954564\",\n \"0.61856395\",\n \"0.6182624\",\n \"0.6179006\",\n \"0.6178328\",\n \"0.61689883\",\n \"0.61626893\",\n \"0.61606824\",\n \"0.6159159\",\n \"0.61546713\",\n \"0.61528033\",\n \"0.6144841\",\n \"0.6143379\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76569,"cells":{"query":{"kind":"string","value":"GIFOutput a model defined in Swagger"},"document":{"kind":"string","value":"def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\n\n self._gif_fps = None\n self._color_depth = None\n self._gif_loop = None\n self._height = None\n self._start = None\n self._duration = None\n self._suffix = None\n self._overlay = None\n self._overlay_alignment = None\n self._overlay_scale = None\n self._label = None\n self.discriminator = None\n\n if gif_fps is not None:\n self.gif_fps = gif_fps\n if color_depth is not None:\n self.color_depth = color_depth\n if gif_loop is not None:\n self.gif_loop = gif_loop\n self.height = height\n self.start = start\n if duration is not None:\n self.duration = duration\n if suffix is not None:\n self.suffix = suffix\n if overlay is not None:\n self.overlay = overlay\n if overlay_alignment is not None:\n self.overlay_alignment = overlay_alignment\n if overlay_scale is not None:\n self.overlay_scale = overlay_scale\n if label is not None:\n self.label = label"},"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 generate_random_gif():\n\n random_gif_url = giphy_random_generator()\n return jsonify(random_gif_url)","def run(self):\n generated_gif = self.generate()\n with open(self.out_filename, 'wb') as out_fd:\n out_fd.write(generated_gif)","def generate_im(self, model):\n kappa = kappy.KappaStd()\n model_str = export.export(model, 'kappa')\n kappa.add_model_string(model_str)\n kappa.project_parse()\n imap = kappa.analyses_influence_map(accuracy='medium')\n graph = im_json_to_graph(imap)\n return graph","def image_png():\n data = resource(\"images/pig_icon.png\")\n return Response(data, headers={\"Content-Type\": \"image/png\"})","def gif(self):\n\n if self._gif is None:\n\n url = self.url.replace('f=fits', 'f=gif')\n\n try:\n url_data = urllib.request.urlopen(url)\n except urllib.request.URLError as ee:\n raise ValueError(f'cannot open URL for these parameters: {ee}')\n\n data = url_data.read()\n\n image = PIL.Image.open(io.BytesIO(data))\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\n\n self._gif = image\n\n return self._gif","async def gif(self, ctx, *keywords):\n if keywords:\n keywords = \"+\".join(keywords)\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='sigh.. **`{}help gif`**'.format(self.config['prefix']),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\n return\n await self.bot.send_typing(ctx.message.channel)\n url = (\"http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}\"\n \"\".format(self.config['giphy-api-key'], keywords))\n\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as response:\n source = await response.json(encoding='utf8')\n\n source = json.dumps(source)\n result = json.loads(str(source))\n\n if response.status == 200:\n if result[\"data\"]:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format(''),\n colour=0xf20006)\n embed.set_image(url=result[\"data\"][\"image_original_url\"])\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['succes'])\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format('No results found.'),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['warning'])\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format('Error contacting the API'),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])","def create_gif():\n anim_file = 'sample/training.gif'\n\n with imageio.get_writer(anim_file, mode='I') as writer:\n filenames = glob.glob('sample/*.jpg')\n filenames = sorted(filenames, key=lambda filename: int(filename[11:-4]))\n for filename in filenames:\n image = imageio.imread(filename)\n writer.append_data(image)\n image = imageio.imread(filename)\n writer.append_data(image)","async def gif(self, ctx: discord.ext.commands.Context, *args):\n print(\"-------------------------\")\n message_channel: discord.abc.Messageable = ctx.message.channel\n currentgifkey = self.botVariables.get_gif_key()\n print(\"GifRequest:Arguments:\" + str(len(args)))\n tag = \"\"\n if len(args) == 0: # request a random gif\n print(\"Gif Request with No arguments\")\n url = \"http://api.giphy.com/v1/gifs/random?api_key=\" + currentgifkey\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as resp:\n r = await resp.json()\n if 'data' in r:\n await message_channel.send(r['data']['url'])\n elif 'message' in r:\n await message_channel.send(\"An error occurred:\" + r['message'])\n else: # request a gif with tags\n for x in range(0, len(args)):\n tag = tag + args[x]\n if x != (len(args) - 1):\n tag += \" \"\n tag = urllib.parse.quote(tag)\n url = \"http://api.giphy.com/v1/gifs/random?api_key=\" + currentgifkey + \"&tag=\" + tag\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as resp:\n r = await resp.json()\n print(\"GifRequest:Gif Found\")\n if (len(r['data'])) == 0:\n await message_channel.send(\"No GIF found with those tags :frowning: \")\n else:\n if 'data' in r:\n await message_channel.send(r['data']['url'])\n elif 'message' in r:\n await message_channel.send(\"An error occurred:\" + r['message'])\n print(\"-------------------------\")","def index():\n\n return \"\"\"\n <div>\n <h1> Image Captioning REST API </h1>\n <h3> The following API end points are valid </h3>\n <ul>\n <h4> Inception V3 </h4>\n <li> <code>/inception/v3/ping </code> - <br/>\n <b> Description : </b> checks availability of the service. returns \"pong\" with status 200 when it is available\n </li>\n <li> <code>/inception/v3/caption/image</code> - <br/>\n <table>\n <tr><th align=\"left\"> Description </th><td> This is a service that can caption images</td></tr>\n <tr><th align=\"left\"> How to supply Image Content </th></tr>\n <tr><th align=\"left\"> With HTTP GET : </th> <td>\n Include a query parameter <code>url </code> which is an http url of JPEG image <br/>\n Example: <code> curl \"localhost:8764/inception/v3/caption/image?url=http://xyz.com/example.jpg\"</code>\n </td></tr>\n <tr><th align=\"left\"> With HTTP POST :</th><td>\n POST JPEG image content as binary data in request body. <br/>\n Example: <code> curl -X POST \"localhost:8764/inception/v3/caption/image\" --data-binary @example.jpg </code>\n </td></tr>\n </table>\n </li>\n <ul>\n </div>\n \"\"\"","def generate_image(self):\n pass","def fig_response(fig):\n img_bytes = io.BytesIO()\n fig.savefig(img_bytes)\n img_bytes.seek(0)\n return send_file(img_bytes, mimetype='image/png')","def __nii4dtoGif(self, inputfile, tgGif, gifSpeed=30):\n gifId = self.__idGenerator()\n \n # Number of volumes in the 4D image\n vSize = mriutil.getNbDirectionsFromDWI(inputfile)\n vols = [gifId + '{0:04}'.format(i) for i in range(vSize)]\n \n # Spliting 4D image\n cmd = 'fslsplit ' + inputfile + ' ' + gifId + ' -t'\n self.launchCommand(cmd)\n \n # Extracting pngs from all volumes\n for vol in vols:\n self.__slicer(vol, None, vol + '.png')\n \n # Creating .gif\n cmd = 'convert '\n for vol in vols:\n cmd += '-delay ' + str(gifSpeed) + ' ' + vol + '.png '\n cmd += tgGif\n self.launchCommand(cmd)\n \n # Cleaning temp files\n cmd = 'rm ' + gifId + '*'\n self.launchCommand(cmd)","def make_gif():\n if MIGRATION:\n import imageio\n for n, JPG_DIR in enumerate(JPG_DIRS):\n images, image_file_names = [], []\n for file_name in os.listdir(JPG_DIR):\n if file_name.endswith('.jpg'):\n image_file_names.append(file_name) \n sorted_files = sorted(image_file_names, key=lambda y: int(y.split('_')[1]))\n for i in range(len(sorted_files)): \n file_path = os.path.join(JPG_DIR, sorted_files[i])\n images.append(imageio.imread(file_path))\n imageio.mimsave(FNAME.rsplit('.', 1)[0] + '_migration' + str(n) + '.gif', images, 'GIF', loop=1, fps=FPS)","def render_image(obj_path, occlusion_vec):\n img_path = obj_path.replace('.obj','.png')\n #Adi: Saving the occlusion state in a pickle file as well\n occlusion_path = obj_path.replace('.obj', '')\n with open(occlusion_path, 'wb') as fp:\n pickle.dump(occlusion_vec, fp, protocol=2)\n\n bpy.ops.render.render()\n bpy.data.images['Render Result'].save_render(filepath=img_path)","def convert_gif(ctx):\n ctx.run(\n 'ffmpeg '\n '-i resources/demo.mkv -filter_complex \"[0:v] palettegen\" '\n 'resources/palette.png',\n pty=True\n )\n ctx.run(\n 'ffmpeg -i resources/demo.mkv '\n '-i resources/palette.png '\n '-filter_complex \"[0:v][1:v] paletteuse\" '\n 'resources/demo.gif',\n pty=True\n )","def obimg():\n # The client might make a call to get a pic for an object which might\n # not have one. Better to return a blank than an error in that case.\n imgdat = B64ENCTRANSPARENT4X4PNG\n try:\n dsType = dbacc.reqarg(\"dt\", \"string\", required=True)\n dsId = dbacc.reqarg(\"di\", \"string\", required=True)\n inst = dbacc.cfbk(dsType, \"dsId\", dsId)\n if inst:\n picfldmap = {\"Point\": \"pic\"}\n imgdat = inst[picfldmap[dsType]]\n imgdat = base64.b64decode(imgdat)\n except ValueError as e:\n return util.serve_value_error(e)\n return util.respond(imgdat, mimetype=\"image/png\")","def figToResponse(self,fig):\n output = io.BytesIO()\n FigureCanvas(fig).print_png(output)\n return Response(output.getvalue(), mimetype='image/png')","def get_image():\n\n url = 'http://skyview.gsfc.nasa.gov/cgi-bin/images'\n params = dict(Position='%s,%s' % (source['ra'], source['dec']),\n Survey=source['survey'].val,\n Return='GIF')\n response = requests.get(url, params=params, stream=True)\n with open(files['image.gif'].rel, 'wb') as out_file:\n shutil.copyfileobj(response.raw, out_file)","def handler(request):\n \n global model\n\n request_json = request.get_json()\n\n if model is None:\n model = tf.keras.applications.inception_v3.InceptionV3()\n \n if request_json and 'image' in request_json:\n \n try:\n image = np.array(request_json['image'])\n image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))\n image = tf.keras.applications.inception_v3.preprocess_input(image)\n yhat = model.predict(image)\n labels = tf.keras.applications.inception_v3.decode_predictions(yhat)[0]\n\n predictions = []\n\n for label in labels:\n predictions.append([label[1],float(label[2]*100)])\n\n return jsonify(dict(prediction=predictions))\n \n except Exception as e:\n return error_response(e)\n \n elif request_json:\n return request_json\n\n return error_response(\"No image in request\")","def make_gifs_train(title, path):\n images = os.listdir(path)\n generated_images = []\n\n for i in range(len(images)):\n file = os.path.join(path, '%s_Samples_Epoch_%03d.png' % (title, i+1))\n generated_images.append(imageio.imread(file))\n\n imageio.mimsave(path + '{}_Train_Results.gif'.format(title), generated_images, fps=2)\n print(\"{} gif file is generated.\".format(title))","def create_gif(trajectory):\r\n gif = []\r\n for i in range(len(trajectory)):\r\n p, s = trajectory[i][0]\r\n filename = 'images/car{}.jpeg'.format(i)\r\n save_caronthehill_image(p, s, filename)\r\n img = imageio.imread(filename)\r\n height, width, layers = img.shape\r\n gif.append(img)\r\n \r\n \r\n imageio.mimsave(\"visualization.gif\", gif, 'GIF')","def ribovision_model_info(filename, output):\n r2dt.write_ribovision(filename, output)","def generate():\n content = request.json\n assert 'svg' in content\n\n bw = BaseWorkflow(content['svg'])\n alt_text = bw.execute()\n print(alt_text)\n\n return jsonify({'alt_text': alt_text})","def image_response(image,format,mimetype):\n buf = StringIO()\n im = image.save(buf,format)\n return Response(buf.getvalue(), mimetype=mimetype)","def image_svg():\n data = resource(\"images/svg_logo.svg\")\n return Response(data, headers={\"Content-Type\": \"image/svg+xml\"})","def get_initial_response():\n # Message to the user\n message = {\n 'apiVersion': 'v1.0',\n 'status': '200',\n 'message': 'Flask API - Doubtnut - OPENCV'\n }\n # Making the message looks good\n resp = jsonify(message)\n # Returning the object\n return resp","def index(request):\n if request.method == \"POST\":\n form = ImageForm(request.POST, request.FILES)\n if form.is_valid():\n form.save()\n\n # get the current instance object to display in template\n img_obj = form.instance\n\n pred = model_predict(img_obj.image.path, model)\n pred_class = decode_predictions(pred, top=1)\n result = str(pred_class[0][0][1])\n\n\n return render(request, 'ImgClassifier/homePg.html',context={\n 'form':form,\n 'img_obj':img_obj,\n 'prediction_label': result\n })\n\n else: # on GET Request\n form = ImageForm()\n return render(request, 'ImgClassifier/homePg.html',context={\n 'form':form,\n })","def api_html():\n\n return jsonify({'version': __version__})","def plot_preview_png():\n name = request.args.get('prev_instance')\n name = str(name)\n fig = create_preview(name)\n output = io.BytesIO()\n FigureCanvas(fig).print_png(output)\n return Response(output.getvalue(), mimetype='image/png')","def upload_icon():\n filename = files.save(request.files['file']) # get file and save as header icon\n return jsonify(dict(filename=filename))","def makeGif(imgPath):\r\n import imageio\r\n filenames = os.listdir(imgPath)\r\n filenames.sort()\r\n images = []\r\n for filename in filenames:\r\n images.append(imageio.imread(os.path.join(imgPath, filename)))\r\n imageio.mimsave(os.path.join(imgPath, \"sharpVid.gif\"), images, duration=0.2)","def img(self, obj):\n return mark_safe(\n f\"<img src='/{obj.image.url}' width='{obj.image.width}' height='{obj.image.height}' />\"\n )","def inference():\n if request.method == \"POST\":\n data = request.json #\n src_img = np.array(data[\"src\"]).astype(np.uint8) # Parsing data\n ref_img = np.array(data[\"ref\"]).astype(np.uint8) #\n ref_label = int(data[\"ref_label\"]) #\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\n return jsonify({\"result\": result.tolist()}) # Returning results into json","async def gasm(self, ctx):\n e = discord.Embed(title=\"Here is a gasm image for you {}.\".format(ctx.author.name), color=discord.Color.magenta())\n e.set_image(url=nekos.img('gasm'))\n await ctx.send(embed=e)","def to_api_repr(self):\n raise NotImplementedError","def image_api():\n PAGE_SIZE=50\n page = int(request.args.get('page', 0))\n print page\n userid = current_user.id\n out= []\n query = db_session.query(Image, Batch.status).\\\n outerjoin(Batch, Image.batch==Batch.batch_id).\\\n filter(Image.user==userid)\n\n count = query.count()\n for row in query.limit(PAGE_SIZE).offset(page*PAGE_SIZE):\n out.append({\n \"url\": url_for('image_views.raw_image', image_path=row.Image.path),\n \"page\": url_for('image_views.view_image', image_id=row.Image.id),\n \"title\": row.Image.title,\n \"status\": row.status\n })\n\n return jsonify({\"images\": out, \"count\": count})","def generate_gif(frames, reward, path, number=None, evaluation=False):\n for i, frame in enumerate(frames):\n frames[i] = resize(frame, (420, 320, 3),\n order=0, preserve_range=True).astype(np.uint8)\n if evaluation:\n path += '/atari-step-{}-reward-{}.gif'.format(number, reward)\n else:\n path += '/atari-play-reward-{}.gif'.format(reward)\n imageio.mimsave(path, frames, duration=1/30)","def make_gif(im_dir, out_file, pattern='*.png', fps=10):\n im_files = glob.glob(os.path.join(im_dir, pattern))\n if len(im_files) == 0:\n raise ValueError(f'No images found in {im_dir}!')\n \n writer = imageio.get_writer(out_file, mode='I', fps=fps)\n for im_file in im_files:\n im = imageio.imread(im_file)\n writer.append_data(im)\n writer.close()","def save_gif(frames):\n print(\"Saving gif images!\")\n for i in range(len(frames)):\n im_out_path = \"gif/gif_emilie_will_\" + str(i) + \".png\"\n plt.imsave(im_out_path, frames[i])","def getimage(self):","def show_picture(self, data):\n raise NotImplementedError","def make_GIF(image_path: Union[Path, str]) -> None:\n import imageio\n from pygifsicle import optimize\n\n if isinstance(image_path, str):\n image_path = Path(image_path)\n\n image_dir = image_path.parent\n image_file = image_path.stem\n gif_path = image_dir / f\"{image_file}.gif\"\n gif_path = Path(\"./xxxx.gif\")\n with imageio.get_writer(gif_path, mode='I') as writer:\n img_files = sorted((img_file for img_file in image_dir.glob('*.png')))\n for img_file in img_files:\n writer.append_data(imageio.imread(img_file))\n print(f\"{len(img_files)} images loaded from {image_path}\")\n try:\n optimize(gif_path)\n except Exception:\n print(\"gifsicle not installed\")","def return_image(val, model_id, message_name, field_name, mime, sind):\n column_data_source = curdoc().get_model_by_name(sind)\n index = column_data_source.tags[0]\n url = \"http://{0}/image/\".format(_host) + \"---\".join([model_id, message_name, field_name, mime, sind, str(index)])\n return url","def make_gif(image_list, gif_name):\n if not gif_name.endswith(\".gif\"):\n gif_name += \".gif\"\n imageio.mimsave(gif_name, [imageio.imread(x) for x in image_list])","def get_html(self):\r\n context = {\r\n 'display_name': self.display_name_with_default,\r\n 'instructions_html': self.instructions,\r\n 'annotation_storage': self.annotation_storage_url,\r\n 'token': retrieve_token(self.user, self.annotation_token_secret),\r\n 'tag': self.instructor_tags,\r\n 'openseadragonjson': self.openseadragonjson,\r\n }\r\n\r\n return self.system.render_template('imageannotation.html', context)","def export_representations(self):\n\n dbpath, config = self._start()\n self.logger.msg1(\"Loading ontology\")\n obo_path = check_file(config.obo, dbpath, \"obo\")\n self.obo = MinimalObo(obo_path, True)\n self._export_reference_representations()\n self._export_model_representations(config)\n self._end()","def _repr_png_(self):\n mol = self.owner.mol\n keku = IPythonConsole.kekulizeStructures\n size = IPythonConsole.molSize\n opts = IPythonConsole.drawOptions\n return Draw._moltoimg(\n mol, size, self.aix, \"\", returnPNG=True, drawOptions=opts,\n kekulize=keku, highlightBonds=self.bix\n )","def _repr_png_(self):\n mol = self.owner.mol\n keku = IPythonConsole.kekulizeStructures\n size = IPythonConsole.molSize\n opts = IPythonConsole.drawOptions\n return Draw._moltoimg(\n mol, size, self.aix, \"\", returnPNG=True, drawOptions=opts,\n kekulize=keku, highlightBonds=self.bix\n )","def put_drawing_gif(self, request):\n HttpRequest = request.to_http_info(self.api_client.configuration)\n return self.__make_request(HttpRequest, 'PUT', 'file')","def image_jpeg():\n data = resource(\"images/jackal.jpg\")\n return Response(data, headers={\"Content-Type\": \"image/jpeg\"})","def generate_gif(directory: (\"Folder name\", \"positional\"),\n image_format: ('Image format', 'positional') = '.png',\n print_file_names=False):\n import imageio\n from glob import glob\n from natsort import natsorted\n\n images = []\n # Create a list of file names in the specified directory\n filenames = glob(directory + '/*' + image_format)\n\n filenames = natsorted(filenames, key=lambda y: y.lower())\n # Sort the list 'filenames' using the traditional method.\n # Traditional method -\n # isolate the entire first number in the string, then sort by that number\n # If this step is not included,\n # files will be sorted like so: 0, 100, 110, 200, 3, 420, etc...\n\n if print_file_names: # For troubleshooting\n for i in filenames:\n print(i)\n\n for filename in filenames:\n images.append(imageio.imread(filename))\n # Append each file to the list that will become the gif\n\n imageio.mimsave(directory + '.gif', images)\n # Save the gif as the name of the directory\n # that the images were generated from\n return","def convert_gif(path: str,\n gif_name: str = 'gif_name.gif',\n frame_limit: int = 100):\n video_path = glob(path + \"/*.mp4\")[-1]\n vidcap = cv2.VideoCapture(video_path)\n success, frame = vidcap.read()\n count = 0\n\n # extracting and saving video frames.\n while success:\n cv2.imwrite(f\"{path}/frame{count}.png\", frame) \n success, frame = vidcap.read()\n count += 1\n if count > frame_limit:\n break\n print(\"total frames:\", count)\n\n # generate animated GIF.\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\"/*.png\"))]\n img.save(fp=f\"{path}/{gif_name}\", format='GIF', append_images=imgs,\n save_all=True, duration=200, loop=0)\n \n # remove frames\n [os.remove(os.path.join(path, f)) for f in glob(path+\"/*.png\")]","def save_GIF(ht, name=\"trajectory\"):\n # Generation of images\n counter = 0\n images = []\n for e in range(0, len(ht), 3):\n p = ht[e][0]\n s = ht[e][1]\n save_caronthehill_image(p, s, \"image\\\\state\" + str(counter) + \".png\")\n images.append(imageio.imread(\"image\\\\state\" + str(counter) + \".png\"))\n counter += 1\n imageio.mimsave(\"{}.gif\".format(name), images)","def makeGifVideo(env, actions, initstate=None, prefix='seq_', duration=0.1,\r\n outdir='../gifs/', tmpdir='../temp/'):\r\n from external_libs.images2gif import writeGif\r\n import Image\r\n env.visualize = True\r\n env.reset()\r\n if initstate is not None:\r\n env.setState(initstate)\r\n env._counter = 1\r\n res_images = []\r\n astring = ''.join([str(a) for a in actions if a is not None])\r\n \r\n def cb(*_):\r\n fn = tmpdir + \"tmp%05d.png\" % env._counter\r\n pygame.image.save(env._game.screen, fn)\r\n res_images.append(Image.open(fn))\r\n env._counter += 1\r\n \r\n env.rollOut(actions, callback=cb)\r\n writeGif(outdir + prefix + '%s.gif' % astring, res_images, duration=duration, dither=0)","def pd_to_gif(data ,xyz ,name ,clrs=None):\r\n\r\n x, y, z = list(data[xyz[0]]), list(data[xyz[1]]), list(data[xyz[2]])\r\n clrs = list(data[clrs]) if clrs != None else ['blue']*len(x)\r\n\r\n lst = create_3d_graph(x, y, z, colors=clrs, fr=36,name=name)\r\n create_gif(lst, name)\r\n clean_workspace(lst)","def transformation():\n AutoGluonClassifierService.load_model()\n data = None\n print(f'Request Content Type: {flask.request.content_type}')\n # Convert from CSV to pandas\n if flask.request.content_type == 'application/x-image':\n data = flask.request.data.decode('utf-8')\n tmp_image_path = f'/tmp/{uuid1().hex}.jpg'\n image_bytes = io.BytesIO(data)\n image = Image.open(image_bytes)\n image.save(tmp_image_path)\n else:\n return flask.Response(\n response='This predictor only supports JSON or CSV data. data is preferred.',\n status=415, mimetype='text/plain'\n )\n\n print('Classifying image with {}')\n # Do the prediction\n class_index, class_probability = AutoGluonClassifierService.predict(tmp_image_path)\n prediction = {\n 'ClassIndex': class_index,\n 'PredictionProba': class_probability\n }\n\n return flask.Response(response=json.dumps(prediction), status=200, mimetype='application/json')","def to_gif(diagram, *diagrams, **params): # pragma: no cover\n path = params.get(\"path\", None)\n timestep = params.get(\"timestep\", 500)\n loop = params.get(\"loop\", False)\n steps, frames = (diagram, ) + diagrams, []\n path = path or os.path.basename(NamedTemporaryFile(\n suffix='.gif', prefix='tmp_', dir='.').name)\n with TemporaryDirectory() as directory:\n for i, _diagram in enumerate(steps):\n tmp_path = os.path.join(directory, '{}.png'.format(i))\n _diagram.draw(path=tmp_path, **params)\n frames.append(Image.open(tmp_path))\n if loop:\n frames = frames + frames[::-1]\n frames[0].save(path, format='GIF', append_images=frames[1:],\n save_all=True, duration=timestep,\n **{'loop': 0} if loop else {})\n try:\n from IPython.display import HTML\n return HTML('<img src=\"{}\">'.format(path))\n except ImportError:\n return '<img src=\"{}\">'.format(path)","def gif_generation(orig_label_path, bound_data_path):\n for sample in os.listdir(bound_data_path):\n if not sample.startswith('.') and osp.isdir(osp.join(bound_data_path, sample)):\n sample_path = osp.join(bound_data_path, sample)\n for artery in os.listdir(sample_path):\n orig_label_pick_path = osp.join(orig_label_path, sample, artery, 'data.pkl')\n bound_pick_path = osp.join(bound_data_path, sample, artery, 'data.pkl')\n\n # function to save result of each artery into gif\n save_gif_artery(orig_label_pick_path, bound_pick_path)","def swagger():\n return jsonify(current_app.spec.to_dict())","def show(self):\n f = open('/tmp/dotty', 'w')\n f.write(self.dot())\n f.close()\n os.system('cat /tmp/dotty | dot -Tgif > /tmp/dotty.gif')\n os.system('eog /tmp/dotty.gif')","def create_resource():\n #deserializer = ImageDeserializer()\n #serializer = ImageSerializer()\n return wsgi.Resource(Controller())","def api_documentation(api: str, summary: str, in_model: BaseModel,\n out_model: BaseModel, out_description: str) -> Callable:\n for model, name in ((in_model, 'Input'), (out_model, 'Output')):\n doc.Object(\n make_dataclass(\n f'Api{api[1:].title()}{name}',\n [(key, val.type_, val.type_)\n for key, val in model.__dict__['__fields__'].items()]))\n im_returns = doc.JsonBody({\n key: val.type_\n for key, val in in_model.__dict__['__fields__'].items()\n })\n\n om_returns = {\n key: val.type_\n for key, val in out_model.__dict__['__fields__'].items()\n }\n\n def decorator(func):\n @doc.summary(summary)\n @doc.response(412,\n 'Error: Precondition Failed',\n description='The passed request-parameters are invalid')\n @doc.response(500,\n 'Error: Server-Error occured',\n description='An internal error occured')\n @doc.consumes(im_returns,\n content_type='application/json',\n location='body')\n @doc.produces(om_returns,\n content_type='application/json',\n description=out_description)\n @wraps(func)\n async def function_wrapper(request, *args, **kwargs):\n return await func(request=request, *args, **kwargs)\n\n return function_wrapper\n\n return decorator","def saveGIFBatch(directory, path, name=''):\n # for each frame in batch\n images = []\n for filename in directory:\n print(filename)\n images.append(imageio.imread(filename))\n\n name_gif = path + '/' + name + '.gif'\n imageio.mimsave(name_gif, images)","def compose_in_gif(images, output_file, delay):\n images[0].save(\n output_file, \n format='GIF', append_images=images[1:], \n save_all=True, duration=delay, loop=0,\n )","def recordAnim(self):\n if self.currentMode == 'export':\n if os.path.isfile(self.tempGIFDir):\n try:\n os.chmod(self.tempGIFDir, 0777)\n os.remove(self.tempGIFDir)\n\n except Exception, result:\n logger.warning(result)\n\n modelPanelList = cmds.getPanel(type='modelPanel')\n for eachModelPanel in modelPanelList:\n cmds.modelEditor(eachModelPanel, e=1, alo=0)\n cmds.modelEditor(eachModelPanel, e=1, pm=1)\n\n startFrame = cmds.playbackOptions(min=1, q=1)\n endFrame = cmds.playbackOptions(max=1, q=1)\n\n tempImageList = list()\n for i in range(int(startFrame), int(endFrame+1)):\n tempImage = cmds.playblast(st=i, et=i, fmt='image', cc=1, v=0, orn=0, fp=1, p=100, c='png',\n wh=[512, 512], cf='%s/tempImg_%s.png' % (self.tempDir, i))\n tempImageList.append(tempImage)\n\n # make GIF from tempImageList\n frames = list()\n for tempImage in tempImageList:\n im = Image.open(tempImage)\n frames.append(im)\n\n frames[0].save(self.tempGIFDir, save_all=True, append_images=frames[1:], duration=50, loop=0)\n\n # remove temp images\n for i in tempImageList:\n if os.path.isfile(i):\n try:\n os.chmod(i, 0777)\n os.remove(i)\n except Exception, result:\n logger.warning(result)\n\n self.recordBtn.loadGIF2Button(path=self.tempGIFDir)","async def get_image(self):\n\n # generating\n fixed_latent = torch.randn(1, 512, 1, 1, device=self.device)\n\n with torch.no_grad():\n # passing through\n fake_images = self.model(fixed_latent)\n # saving\n save_image(fake_images, f'models/FaceGAN_dir/faces/fake.jpg')","def post_drawing_gif(self, request):\n HttpRequest = request.to_http_info(self.api_client.configuration)\n return self.__make_request(HttpRequest, 'POST', 'file')","def image_capture_demo():\n return render_template('image_capture_demo.html')","def get(self):\n self.response.out.write(blobstore.create_upload_url(\n UPLOAD_SCREENSHOT_IMAGE_URL))","def getImage():\n\tsaveimage = request.files['image']\n\n\timagename = saveimage.filename\n\tsaveimage.save(os.path.join(app.config['uploadFolder'], imagename))\n\tfiles = {'image': open(imagename, 'rb')}\n\tjsonfile = getData(files)\t\t\n\treturn render_template('index.html', json_data = jsonfile)","def get(self):\n from fantasm.utils import outputMachineConfig\n\n machineConfig = getMachineConfig(self.request)\n content = outputMachineConfig(machineConfig, skipStateNames=[self.request.GET.get('skipStateName')])\n if self.request.GET.get('type', 'png') == 'png':\n self.response.out.write(\n \"\"\"\n <html>\n <head></head>\n <body onload=\"javascript:document.forms.chartform.submit();\">\n <form id='chartform' action='http://chart.apis.google.com/chart' method='POST'>\n <input type=\"hidden\" name=\"cht\" value=\"gv:dot\" />\n <input type=\"hidden\" name=\"chl\" value='%(chl)s' />\n <input type=\"submit\" value=\"Generate GraphViz .png\" />\n </form>\n </body>\n \"\"\" % {'chl': content.replace('\\n', ' ')})\n else:\n self.response.out.write(content)","def output_handler(response, context):\n print(\"Output handler\")\n \n if response.status_code != 200:\n _return_error(response.status_code, response.content.decode('utf-8'))\n response_content_type = context.accept_header\n content = response.content\n\n predictions = json.loads(content.decode('UTF-8'))\n predictions = np.array(predictions[\"predictions\"])\n res = []\n for pred in predictions:\n top3 = (-pred).argsort()[:3]\n res.append({'file_name': 'no-filename', 'path': 'no-path', 'cls': 'actual', 'prediction':top3[0], 'proba_1':pred[top3[0]], 'prediction2':top3[1], 'proba_2':pred[top3[1]], 'prediction3':top3[2], 'proba_3':pred[top3[2]]})\n\n image_index = pd.DataFrame(res)\n image_index['prediction'] = image_index.prediction.map(cls_map)\n image_index['prediction2'] = image_index.prediction2.map(cls_map)\n image_index['prediction3'] = image_index.prediction3.map(cls_map)\n return image_index.to_csv(index=False, header=False), response_content_type","def api():\n return send_file('templates/bootstrapper.swagger.json')","def visualize(self):\n return \"https://neuroglancer.bossdb.io/#!{'layers':{'image':{'source':'boss://__replace_me__'}}}\".replace(\n \"__replace_me__\",\n f\"{self.volume_provider.boss._project._base_protocol}://{self.volume_provider.boss._project._base_url}/{self.collection_name}/{self.experiment_name}/{self.channel_name}\",\n )","def _repr_html_(self):\n import io\n import base64\n from PIL import Image\n\n library_name = \"vedo.assembly.Assembly\"\n help_url = \"https://vedo.embl.es/docs/vedo/assembly.html\"\n\n arr = self.thumbnail(zoom=1.1, elevation=-60)\n\n im = Image.fromarray(arr)\n buffered = io.BytesIO()\n im.save(buffered, format=\"PNG\", quality=100)\n encoded = base64.b64encode(buffered.getvalue()).decode(\"utf-8\")\n url = \"data:image/png;base64,\" + encoded\n image = f\"<img src='{url}'></img>\"\n\n # statisitics\n bounds = \"<br/>\".join(\n [\n vedo.utils.precision(min_x, 4) + \" ... \" + vedo.utils.precision(max_x, 4)\n for min_x, max_x in zip(self.bounds()[::2], self.bounds()[1::2])\n ]\n )\n\n help_text = \"\"\n if self.name:\n help_text += f\"<b> {self.name}:   </b>\"\n help_text += '<b><a href=\"' + help_url + '\" target=\"_blank\">' + library_name + \"</a></b>\"\n if self.filename:\n dots = \"\"\n if len(self.filename) > 30:\n dots = \"...\"\n help_text += f\"<br/><code><i>({dots}{self.filename[-30:]})</i></code>\"\n\n allt = [\n \"<table>\",\n \"<tr>\",\n \"<td>\",\n image,\n \"</td>\",\n \"<td style='text-align: center; vertical-align: center;'><br/>\",\n help_text,\n \"<table>\",\n \"<tr><td><b> nr. of objects </b></td><td>\"\n + str(self.GetNumberOfPaths())\n + \"</td></tr>\",\n \"<tr><td><b> position </b></td><td>\" + str(self.GetPosition()) + \"</td></tr>\",\n \"<tr><td><b> diagonal size </b></td><td>\"\n + vedo.utils.precision(self.diagonal_size(), 5)\n + \"</td></tr>\",\n \"<tr><td><b> bounds </b> <br/> (x/y/z) </td><td>\" + str(bounds) + \"</td></tr>\",\n \"</table>\",\n \"</table>\",\n ]\n return \"\\n\".join(allt)","def recordVideo(args, env, model, filename):\n # env = model.get_env()\n images = []\n images = images + runAGame(model, env, args.method == 'centralized')\n images = images + runAGame(model, env, args.method == 'centralized')\n images = images + runAGame(model, env, args.method == 'centralized')\n images[0].save(filename + '.gif',\n format='GIF',\n append_images=images[1:],\n save_all=True,\n duration=500,\n loop=0)\n print('Video saved:', filename)","def on_get(self, request, response):\n response.status = falcon.HTTP_200 # alternatively, HTTP_OK\n response.media = DEGS","def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\n viz.evaluate()\n if upsampled == True:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\n else:\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\n viz.visualizer.show(outpath=outpath_, clear_figure=True)","def send_GIF():\n try:\n gif_icon = driver.find_element_by_xpath('//*[@data-tip=\"GIF\"]')\n gif_icon.click()\n wait(wait_time=10)\n gifs = driver.find_elements_by_class_name('giphy-gif')\n src = gifs[0].get_attribute('src')\n gif_ID = src[src.index('media/') + len('media/'):]\n gif_ID = gif_ID[:gif_ID.index('/')]\n gifs[0].click()\n wait()\n except Exception as e:\n return \"Error: \" + str(e)\n if verify_GIF_sent(gif_ID):\n return \"Success\"\n else:\n return \"Error: GIF wasn't sent\"","def render(self, **kwargs):\n return Draw.MolToImage(self._state, **kwargs)","def create_gif(base_folder):\n img_list = []\n search_path = glob.glob(os.path.join(base_folder, '*.png'))\n search_path.sort()\n for f in search_path:\n im = Image.open(f)\n img_list.append(im)\n save_file = os.path.join(base_folder, 'animated_gif.gif')\n img_list[0].save(save_file,\n save_all=True, append_images=img_list[1:], optimize=False, duration=180, loop=0)","def write_annotation(self, ann_file, img_path, new_img_name):\n if self.type == \"imagenet\":\n label = self.in_annotations[img_path]\n logger.debug(f\"Img {img_path}, imagenet label {label}\")\n ann_file.write(str(label) + \"\\n\")\n elif self.type == \"coco\":\n ann_file.write(\"detection_results {\\n\")\n for obj in self.in_annotations[img_path].keys():\n ann_file.write(\" objects {\\n\")\n ann_file.write(f\" class_id: {self.in_annotations[img_path][obj]['label']}\\n\")\n ann_file.write(\" bounding_box {\\n\")\n ann_file.write(f\" normalized_top: {self.in_annotations[img_path][obj]['normalized_bbox'][0]}\\n\")\n ann_file.write(f\" normalized_bottom: {self.in_annotations[img_path][obj]['normalized_bbox'][1]}\\n\")\n ann_file.write(f\" normalized_left: {self.in_annotations[img_path][obj]['normalized_bbox'][2]}\\n\")\n ann_file.write(f\" normalized_right: {self.in_annotations[img_path][obj]['normalized_bbox'][3]}\\n\")\n ann_file.write(\" }\\n\")\n ann_file.write(\" }\\n\")\n ann_file.write(f' image_name: \"{new_img_name}\"\\n')\n ann_file.write(f' image_id: {int(new_img_name.split(\".\")[0])}\\n')\n ann_file.write(\"}\\n\")","def ricoh_feed():\n return Response(gen_ricoh_feed(), mimetype='multipart/x-mixed-replace; boundary=frame')","def format_model_output(self, output, batch_size=1):\r\n return output","def render_er(input, output, mode='auto', include_tables=None, include_columns=None,\n exclude_tables=None, exclude_columns=None, schema=None):\n\n try:\n tables, relationships = all_to_intermediary(input, schema=schema)\n tables, relationships = filter_resources(tables, relationships,\n include_tables=include_tables, include_columns=include_columns,\n exclude_tables=exclude_tables, exclude_columns=exclude_columns)\n intermediary_to_output = get_output_mode(output, mode)\n gvo = intermediary_to_output(tables, relationships, output)\n #return graphviz object which has a _repr_svg_()-method\n #http://graphviz.readthedocs.io/en/stable/manual.html#jupyter-notebooks\n return gvo\n except ImportError as e:\n module_name = e.message.split()[-1]\n print('Please install {0} using \"pip install {0}\".'.format(module_name))\n except ParsingException as e:\n sys.stderr.write(e.message)","def complete_a_picture(viz_client):\n # Get a training set for a set of x-y coordinates, this one is part of a checkerboard pattern\n x_min = 0.0; x_max = 2.0; y_min = 0; y_max = 1.0\n train_in, train_out = make_checkerboard_training_set(num_points=1000, noise=0.00, randomize=True,\n x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max)\n\n # Plot he training set\n viz_client.plot_2d_classes(train_in, train_out, title=\"Training data\",\n x_min=x_min, x_max=x_max,\n y_min=y_min, y_max=y_max, delta=0.01)\n\n training_size = train_in.shape[0]\n batch_size = round(training_size / 3.0)\n num_features = train_in.shape[1]\n\n # Initialize a numpynet object\n numpy_net = NumpyNet(num_features, batch_size,\n num_hidden=5, hidden_sizes=[4, 8, 16, 8, 4],\n activation=[\"tanh\", \"tanh\", \"tanh\", \"tanh\", \"tanh\", \"tanh\"],\n learning_rate=0.0001,\n dropout_rate=None, weight_decay=None,\n random_seed=1337)\n # Hook the object up to the viz client\n numpy_net.set_viz_client(viz_client)\n\n # A basic report of the net to the logs\n numpy_net.report_model()\n\n # Train the model!\n numpy_net.train(train_in, train_out, epochs=10000,\n visualize=True, visualize_percent=1, save_best=\"./numpynet_best_model.pickle\",\n debug_visualize=True)\n\n # A silly viz of the network architecture (if the net isn't too huge to make it muddled)\n if max(numpy_net.layer_sizes) <= 16:\n numpy_net.viz.network_svg(numpy_net)","def cam():\n\treturn Response(gen(camera),\n\t\t\t\t\tmimetype='multipart/x-mixed-replace; boundary=frame'), 200","def main():\n convert(\"env_100000.mp4\", TargetFormat.GIF)","def AnimFromPng(name, gif=True, fps=15):\n if(gif):\n imgconvert = \"convert \" + \"-delay \" + str(int(1000/fps))\n imgconvert += \" -dispose None \" + name + \"*.png -loop 0 \" + name + \".gif\"\n system(imgconvert)\n print imgconvert\n else:\n aviconvert = \"ffmpeg -i \" + name + \"%03d.png -b:v 2048k -r \" + str(fps) + \" \" + name + \".avi\"\n system(aviconvert)\n print aviconvert","def swagger_definition(self, base_path=None, **kwargs):\n return Swagger(\n {\n \"info\": Info(\n {\n key: kwargs.get(key, self.DEFAULT_INFO.get(key))\n for key in Info.fields.keys()\n if key in kwargs or key in self.DEFAULT_INFO\n }\n ),\n \"paths\": self.paths,\n \"swagger\": \"2.0\",\n \"basePath\": base_path,\n }\n ).to_primitive()","def visualize(model: Model, structural_part=True, measurement_part=False,\n view=True, filename=None, title=''):\n g = gv.Digraph(format='jpg', graph_attr={'label': title})\n if structural_part:\n g.node_attr.update(color='red', shape='box')\n for i, j in model.parameters['Beta']:\n lval, rval = model.beta_names[0][i], model.beta_names[0][j]\n g.edge(rval, lval)\n if measurement_part:\n g.node_attr.update(color='black', shape='circle')\n for i, j in model.parameters['Lambda']:\n lval, rval = model.lambda_names[0][i], model.lambda_names[0][j]\n g.edge(lval, rval)\n g.render(filename, view=view)","def GetModelOutputInfo(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def api_get_icon():\n pkg_name = request.args.get('pkg')\n if pkg_name:\n pkg_files = Database().db.get_pkg_files(pkg_name)\n for src in pkg_files:\n if src.startswith(\"/usr/share/icons/hicolor/32x32/apps/\"):\n return send_file(src, as_attachment=False)\n return send_file(\"static/images/null.gif\")\n else:\n src = request.args.get('i')\n if not os.path.isfile(src):\n #abort(404)\n return send_file(\"static/images/null.gif\")\n return send_file(src, as_attachment=False)","def image_webp():\n data = resource(\"images/wolf_1.webp\")\n return Response(data, headers={\"Content-Type\": \"image/webp\"})","def print_image(indiv,name):\n routine = gp.compile(indiv,pset)\n output = gen_beat_output(routine)\n bits = np.array(map(bitlist,output)[0:24000]).transpose()\n plt.style.use('classic')\n plt.imshow(bits,interpolation='nearest',aspect='auto',cmap=plt.get_cmap('Greys'))\n plt.savefig(name+\".png\",dpi=150)","def image(request):\n response = HttpResponse(request.content.data, content_type=request.mime_type)\n filename = re.sub(\n r'[^\\w\\.]', '_', request.patch.filename.encode('ascii', 'replace'))\n response['Content-Disposition'] = 'attachment; filename=\"%s\"' % filename\n response['Cache-Control'] = 'no-cache, no-store'\n return response","def image(request):\n response = HttpResponse(request.content.data, content_type=request.mime_type)\n filename = re.sub(\n r'[^\\w\\.]', '_', request.patch.filename.encode('ascii', 'replace'))\n response['Content-Disposition'] = 'attachment; filename=\"%s\"' % filename\n response['Cache-Control'] = 'no-cache, no-store'\n return response","def to_gifs(self, dst, limit=800):\n if not os.path.isdir(dst):\n os.mkdir(dst)\n\n for table in self._data:\n for subtable in self._data[table]:\n _table = self._data[table][subtable]\n if len(_table) < 1:\n continue\n if table == \"cbdt\":\n _table.to_cbdt_gif(dst)\n elif _table.renderable and self.renderable:\n filename = _table.table_name.replace(\" \", \"_\") + \".gif\"\n img_path = os.path.join(dst, filename)\n if table == \"metrics\":\n _table.to_gif(img_path, prefix_characters=\"II\", suffix_characters=\"II\", limit=limit)\n elif table == \"gdef_mark\":\n prefix = \"A\"\n _table.to_gif(img_path, prefix_characters=prefix, limit=limit)\n elif table == \"gdef_base\":\n suffix = chr(int(\"0301\", 16)) # acutecomb\n _table.to_gif(img_path, suffix_characters=suffix, limit=limit)\n\n else:\n _table.to_gif(img_path, limit=limit)","def get_image(request):\n data = [{'model': i.bike_model, 'image': i.image, 'id': i.id} for i in BikeDetails.objects.all()]\n data = {'data': data}\n return render(request, 'show_image.html', data)","def export_loop(self, model_instance, field_converter, role=None, print_none=False):\n if isinstance(model_instance, self.model_class):\n model_class = model_instance.__class__\n else:\n model_class = self.model_class\n\n tender = model_instance.__parent__\n tender_date = get_first_revision_date(tender, default=get_now())\n status = getattr(model_instance, \"status\")\n if tender_date > BID_UNSUCCESSFUL_FROM and role not in [None, \"plain\"] and status == \"unsuccessful\":\n role = \"bid.unsuccessful\"\n\n shaped = export_loop(model_class, model_instance, field_converter, role=role, print_none=print_none)\n\n if shaped and len(shaped) == 0 and self.allow_none():\n return shaped\n elif shaped:\n return shaped\n elif print_none:\n return shaped","def get_img(self, onehot=False):\n if self.obs_vision:\n img = self.gen_obs(onehot=False)\n img = self.get_obs_render(img, CELL_PIXELS // 4)\n else:\n img = self.gen_obs(onehot=onehot)\n return img"],"string":"[\n \"def generate_random_gif():\\n\\n random_gif_url = giphy_random_generator()\\n return jsonify(random_gif_url)\",\n \"def run(self):\\n generated_gif = self.generate()\\n with open(self.out_filename, 'wb') as out_fd:\\n out_fd.write(generated_gif)\",\n \"def generate_im(self, model):\\n kappa = kappy.KappaStd()\\n model_str = export.export(model, 'kappa')\\n kappa.add_model_string(model_str)\\n kappa.project_parse()\\n imap = kappa.analyses_influence_map(accuracy='medium')\\n graph = im_json_to_graph(imap)\\n return graph\",\n \"def image_png():\\n data = resource(\\\"images/pig_icon.png\\\")\\n return Response(data, headers={\\\"Content-Type\\\": \\\"image/png\\\"})\",\n \"def gif(self):\\n\\n if self._gif is None:\\n\\n url = self.url.replace('f=fits', 'f=gif')\\n\\n try:\\n url_data = urllib.request.urlopen(url)\\n except urllib.request.URLError as ee:\\n raise ValueError(f'cannot open URL for these parameters: {ee}')\\n\\n data = url_data.read()\\n\\n image = PIL.Image.open(io.BytesIO(data))\\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\\n\\n self._gif = image\\n\\n return self._gif\",\n \"async def gif(self, ctx, *keywords):\\n if keywords:\\n keywords = \\\"+\\\".join(keywords)\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='sigh.. **`{}help gif`**'.format(self.config['prefix']),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\\n return\\n await self.bot.send_typing(ctx.message.channel)\\n url = (\\\"http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}\\\"\\n \\\"\\\".format(self.config['giphy-api-key'], keywords))\\n\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as response:\\n source = await response.json(encoding='utf8')\\n\\n source = json.dumps(source)\\n result = json.loads(str(source))\\n\\n if response.status == 200:\\n if result[\\\"data\\\"]:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format(''),\\n colour=0xf20006)\\n embed.set_image(url=result[\\\"data\\\"][\\\"image_original_url\\\"])\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['succes'])\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format('No results found.'),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['warning'])\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format('Error contacting the API'),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\",\n \"def create_gif():\\n anim_file = 'sample/training.gif'\\n\\n with imageio.get_writer(anim_file, mode='I') as writer:\\n filenames = glob.glob('sample/*.jpg')\\n filenames = sorted(filenames, key=lambda filename: int(filename[11:-4]))\\n for filename in filenames:\\n image = imageio.imread(filename)\\n writer.append_data(image)\\n image = imageio.imread(filename)\\n writer.append_data(image)\",\n \"async def gif(self, ctx: discord.ext.commands.Context, *args):\\n print(\\\"-------------------------\\\")\\n message_channel: discord.abc.Messageable = ctx.message.channel\\n currentgifkey = self.botVariables.get_gif_key()\\n print(\\\"GifRequest:Arguments:\\\" + str(len(args)))\\n tag = \\\"\\\"\\n if len(args) == 0: # request a random gif\\n print(\\\"Gif Request with No arguments\\\")\\n url = \\\"http://api.giphy.com/v1/gifs/random?api_key=\\\" + currentgifkey\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as resp:\\n r = await resp.json()\\n if 'data' in r:\\n await message_channel.send(r['data']['url'])\\n elif 'message' in r:\\n await message_channel.send(\\\"An error occurred:\\\" + r['message'])\\n else: # request a gif with tags\\n for x in range(0, len(args)):\\n tag = tag + args[x]\\n if x != (len(args) - 1):\\n tag += \\\" \\\"\\n tag = urllib.parse.quote(tag)\\n url = \\\"http://api.giphy.com/v1/gifs/random?api_key=\\\" + currentgifkey + \\\"&tag=\\\" + tag\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as resp:\\n r = await resp.json()\\n print(\\\"GifRequest:Gif Found\\\")\\n if (len(r['data'])) == 0:\\n await message_channel.send(\\\"No GIF found with those tags :frowning: \\\")\\n else:\\n if 'data' in r:\\n await message_channel.send(r['data']['url'])\\n elif 'message' in r:\\n await message_channel.send(\\\"An error occurred:\\\" + r['message'])\\n print(\\\"-------------------------\\\")\",\n \"def index():\\n\\n return \\\"\\\"\\\"\\n <div>\\n <h1> Image Captioning REST API </h1>\\n <h3> The following API end points are valid </h3>\\n <ul>\\n <h4> Inception V3 </h4>\\n <li> <code>/inception/v3/ping </code> - <br/>\\n <b> Description : </b> checks availability of the service. returns \\\"pong\\\" with status 200 when it is available\\n </li>\\n <li> <code>/inception/v3/caption/image</code> - <br/>\\n <table>\\n <tr><th align=\\\"left\\\"> Description </th><td> This is a service that can caption images</td></tr>\\n <tr><th align=\\\"left\\\"> How to supply Image Content </th></tr>\\n <tr><th align=\\\"left\\\"> With HTTP GET : </th> <td>\\n Include a query parameter <code>url </code> which is an http url of JPEG image <br/>\\n Example: <code> curl \\\"localhost:8764/inception/v3/caption/image?url=http://xyz.com/example.jpg\\\"</code>\\n </td></tr>\\n <tr><th align=\\\"left\\\"> With HTTP POST :</th><td>\\n POST JPEG image content as binary data in request body. <br/>\\n Example: <code> curl -X POST \\\"localhost:8764/inception/v3/caption/image\\\" --data-binary @example.jpg </code>\\n </td></tr>\\n </table>\\n </li>\\n <ul>\\n </div>\\n \\\"\\\"\\\"\",\n \"def generate_image(self):\\n pass\",\n \"def fig_response(fig):\\n img_bytes = io.BytesIO()\\n fig.savefig(img_bytes)\\n img_bytes.seek(0)\\n return send_file(img_bytes, mimetype='image/png')\",\n \"def __nii4dtoGif(self, inputfile, tgGif, gifSpeed=30):\\n gifId = self.__idGenerator()\\n \\n # Number of volumes in the 4D image\\n vSize = mriutil.getNbDirectionsFromDWI(inputfile)\\n vols = [gifId + '{0:04}'.format(i) for i in range(vSize)]\\n \\n # Spliting 4D image\\n cmd = 'fslsplit ' + inputfile + ' ' + gifId + ' -t'\\n self.launchCommand(cmd)\\n \\n # Extracting pngs from all volumes\\n for vol in vols:\\n self.__slicer(vol, None, vol + '.png')\\n \\n # Creating .gif\\n cmd = 'convert '\\n for vol in vols:\\n cmd += '-delay ' + str(gifSpeed) + ' ' + vol + '.png '\\n cmd += tgGif\\n self.launchCommand(cmd)\\n \\n # Cleaning temp files\\n cmd = 'rm ' + gifId + '*'\\n self.launchCommand(cmd)\",\n \"def make_gif():\\n if MIGRATION:\\n import imageio\\n for n, JPG_DIR in enumerate(JPG_DIRS):\\n images, image_file_names = [], []\\n for file_name in os.listdir(JPG_DIR):\\n if file_name.endswith('.jpg'):\\n image_file_names.append(file_name) \\n sorted_files = sorted(image_file_names, key=lambda y: int(y.split('_')[1]))\\n for i in range(len(sorted_files)): \\n file_path = os.path.join(JPG_DIR, sorted_files[i])\\n images.append(imageio.imread(file_path))\\n imageio.mimsave(FNAME.rsplit('.', 1)[0] + '_migration' + str(n) + '.gif', images, 'GIF', loop=1, fps=FPS)\",\n \"def render_image(obj_path, occlusion_vec):\\n img_path = obj_path.replace('.obj','.png')\\n #Adi: Saving the occlusion state in a pickle file as well\\n occlusion_path = obj_path.replace('.obj', '')\\n with open(occlusion_path, 'wb') as fp:\\n pickle.dump(occlusion_vec, fp, protocol=2)\\n\\n bpy.ops.render.render()\\n bpy.data.images['Render Result'].save_render(filepath=img_path)\",\n \"def convert_gif(ctx):\\n ctx.run(\\n 'ffmpeg '\\n '-i resources/demo.mkv -filter_complex \\\"[0:v] palettegen\\\" '\\n 'resources/palette.png',\\n pty=True\\n )\\n ctx.run(\\n 'ffmpeg -i resources/demo.mkv '\\n '-i resources/palette.png '\\n '-filter_complex \\\"[0:v][1:v] paletteuse\\\" '\\n 'resources/demo.gif',\\n pty=True\\n )\",\n \"def obimg():\\n # The client might make a call to get a pic for an object which might\\n # not have one. Better to return a blank than an error in that case.\\n imgdat = B64ENCTRANSPARENT4X4PNG\\n try:\\n dsType = dbacc.reqarg(\\\"dt\\\", \\\"string\\\", required=True)\\n dsId = dbacc.reqarg(\\\"di\\\", \\\"string\\\", required=True)\\n inst = dbacc.cfbk(dsType, \\\"dsId\\\", dsId)\\n if inst:\\n picfldmap = {\\\"Point\\\": \\\"pic\\\"}\\n imgdat = inst[picfldmap[dsType]]\\n imgdat = base64.b64decode(imgdat)\\n except ValueError as e:\\n return util.serve_value_error(e)\\n return util.respond(imgdat, mimetype=\\\"image/png\\\")\",\n \"def figToResponse(self,fig):\\n output = io.BytesIO()\\n FigureCanvas(fig).print_png(output)\\n return Response(output.getvalue(), mimetype='image/png')\",\n \"def get_image():\\n\\n url = 'http://skyview.gsfc.nasa.gov/cgi-bin/images'\\n params = dict(Position='%s,%s' % (source['ra'], source['dec']),\\n Survey=source['survey'].val,\\n Return='GIF')\\n response = requests.get(url, params=params, stream=True)\\n with open(files['image.gif'].rel, 'wb') as out_file:\\n shutil.copyfileobj(response.raw, out_file)\",\n \"def handler(request):\\n \\n global model\\n\\n request_json = request.get_json()\\n\\n if model is None:\\n model = tf.keras.applications.inception_v3.InceptionV3()\\n \\n if request_json and 'image' in request_json:\\n \\n try:\\n image = np.array(request_json['image'])\\n image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))\\n image = tf.keras.applications.inception_v3.preprocess_input(image)\\n yhat = model.predict(image)\\n labels = tf.keras.applications.inception_v3.decode_predictions(yhat)[0]\\n\\n predictions = []\\n\\n for label in labels:\\n predictions.append([label[1],float(label[2]*100)])\\n\\n return jsonify(dict(prediction=predictions))\\n \\n except Exception as e:\\n return error_response(e)\\n \\n elif request_json:\\n return request_json\\n\\n return error_response(\\\"No image in request\\\")\",\n \"def make_gifs_train(title, path):\\n images = os.listdir(path)\\n generated_images = []\\n\\n for i in range(len(images)):\\n file = os.path.join(path, '%s_Samples_Epoch_%03d.png' % (title, i+1))\\n generated_images.append(imageio.imread(file))\\n\\n imageio.mimsave(path + '{}_Train_Results.gif'.format(title), generated_images, fps=2)\\n print(\\\"{} gif file is generated.\\\".format(title))\",\n \"def create_gif(trajectory):\\r\\n gif = []\\r\\n for i in range(len(trajectory)):\\r\\n p, s = trajectory[i][0]\\r\\n filename = 'images/car{}.jpeg'.format(i)\\r\\n save_caronthehill_image(p, s, filename)\\r\\n img = imageio.imread(filename)\\r\\n height, width, layers = img.shape\\r\\n gif.append(img)\\r\\n \\r\\n \\r\\n imageio.mimsave(\\\"visualization.gif\\\", gif, 'GIF')\",\n \"def ribovision_model_info(filename, output):\\n r2dt.write_ribovision(filename, output)\",\n \"def generate():\\n content = request.json\\n assert 'svg' in content\\n\\n bw = BaseWorkflow(content['svg'])\\n alt_text = bw.execute()\\n print(alt_text)\\n\\n return jsonify({'alt_text': alt_text})\",\n \"def image_response(image,format,mimetype):\\n buf = StringIO()\\n im = image.save(buf,format)\\n return Response(buf.getvalue(), mimetype=mimetype)\",\n \"def image_svg():\\n data = resource(\\\"images/svg_logo.svg\\\")\\n return Response(data, headers={\\\"Content-Type\\\": \\\"image/svg+xml\\\"})\",\n \"def get_initial_response():\\n # Message to the user\\n message = {\\n 'apiVersion': 'v1.0',\\n 'status': '200',\\n 'message': 'Flask API - Doubtnut - OPENCV'\\n }\\n # Making the message looks good\\n resp = jsonify(message)\\n # Returning the object\\n return resp\",\n \"def index(request):\\n if request.method == \\\"POST\\\":\\n form = ImageForm(request.POST, request.FILES)\\n if form.is_valid():\\n form.save()\\n\\n # get the current instance object to display in template\\n img_obj = form.instance\\n\\n pred = model_predict(img_obj.image.path, model)\\n pred_class = decode_predictions(pred, top=1)\\n result = str(pred_class[0][0][1])\\n\\n\\n return render(request, 'ImgClassifier/homePg.html',context={\\n 'form':form,\\n 'img_obj':img_obj,\\n 'prediction_label': result\\n })\\n\\n else: # on GET Request\\n form = ImageForm()\\n return render(request, 'ImgClassifier/homePg.html',context={\\n 'form':form,\\n })\",\n \"def api_html():\\n\\n return jsonify({'version': __version__})\",\n \"def plot_preview_png():\\n name = request.args.get('prev_instance')\\n name = str(name)\\n fig = create_preview(name)\\n output = io.BytesIO()\\n FigureCanvas(fig).print_png(output)\\n return Response(output.getvalue(), mimetype='image/png')\",\n \"def upload_icon():\\n filename = files.save(request.files['file']) # get file and save as header icon\\n return jsonify(dict(filename=filename))\",\n \"def makeGif(imgPath):\\r\\n import imageio\\r\\n filenames = os.listdir(imgPath)\\r\\n filenames.sort()\\r\\n images = []\\r\\n for filename in filenames:\\r\\n images.append(imageio.imread(os.path.join(imgPath, filename)))\\r\\n imageio.mimsave(os.path.join(imgPath, \\\"sharpVid.gif\\\"), images, duration=0.2)\",\n \"def img(self, obj):\\n return mark_safe(\\n f\\\"<img src='/{obj.image.url}' width='{obj.image.width}' height='{obj.image.height}' />\\\"\\n )\",\n \"def inference():\\n if request.method == \\\"POST\\\":\\n data = request.json #\\n src_img = np.array(data[\\\"src\\\"]).astype(np.uint8) # Parsing data\\n ref_img = np.array(data[\\\"ref\\\"]).astype(np.uint8) #\\n ref_label = int(data[\\\"ref_label\\\"]) #\\n result = get_inference(src_img, ref_img, ref_label) # Calling helper function\\n return jsonify({\\\"result\\\": result.tolist()}) # Returning results into json\",\n \"async def gasm(self, ctx):\\n e = discord.Embed(title=\\\"Here is a gasm image for you {}.\\\".format(ctx.author.name), color=discord.Color.magenta())\\n e.set_image(url=nekos.img('gasm'))\\n await ctx.send(embed=e)\",\n \"def to_api_repr(self):\\n raise NotImplementedError\",\n \"def image_api():\\n PAGE_SIZE=50\\n page = int(request.args.get('page', 0))\\n print page\\n userid = current_user.id\\n out= []\\n query = db_session.query(Image, Batch.status).\\\\\\n outerjoin(Batch, Image.batch==Batch.batch_id).\\\\\\n filter(Image.user==userid)\\n\\n count = query.count()\\n for row in query.limit(PAGE_SIZE).offset(page*PAGE_SIZE):\\n out.append({\\n \\\"url\\\": url_for('image_views.raw_image', image_path=row.Image.path),\\n \\\"page\\\": url_for('image_views.view_image', image_id=row.Image.id),\\n \\\"title\\\": row.Image.title,\\n \\\"status\\\": row.status\\n })\\n\\n return jsonify({\\\"images\\\": out, \\\"count\\\": count})\",\n \"def generate_gif(frames, reward, path, number=None, evaluation=False):\\n for i, frame in enumerate(frames):\\n frames[i] = resize(frame, (420, 320, 3),\\n order=0, preserve_range=True).astype(np.uint8)\\n if evaluation:\\n path += '/atari-step-{}-reward-{}.gif'.format(number, reward)\\n else:\\n path += '/atari-play-reward-{}.gif'.format(reward)\\n imageio.mimsave(path, frames, duration=1/30)\",\n \"def make_gif(im_dir, out_file, pattern='*.png', fps=10):\\n im_files = glob.glob(os.path.join(im_dir, pattern))\\n if len(im_files) == 0:\\n raise ValueError(f'No images found in {im_dir}!')\\n \\n writer = imageio.get_writer(out_file, mode='I', fps=fps)\\n for im_file in im_files:\\n im = imageio.imread(im_file)\\n writer.append_data(im)\\n writer.close()\",\n \"def save_gif(frames):\\n print(\\\"Saving gif images!\\\")\\n for i in range(len(frames)):\\n im_out_path = \\\"gif/gif_emilie_will_\\\" + str(i) + \\\".png\\\"\\n plt.imsave(im_out_path, frames[i])\",\n \"def getimage(self):\",\n \"def show_picture(self, data):\\n raise NotImplementedError\",\n \"def make_GIF(image_path: Union[Path, str]) -> None:\\n import imageio\\n from pygifsicle import optimize\\n\\n if isinstance(image_path, str):\\n image_path = Path(image_path)\\n\\n image_dir = image_path.parent\\n image_file = image_path.stem\\n gif_path = image_dir / f\\\"{image_file}.gif\\\"\\n gif_path = Path(\\\"./xxxx.gif\\\")\\n with imageio.get_writer(gif_path, mode='I') as writer:\\n img_files = sorted((img_file for img_file in image_dir.glob('*.png')))\\n for img_file in img_files:\\n writer.append_data(imageio.imread(img_file))\\n print(f\\\"{len(img_files)} images loaded from {image_path}\\\")\\n try:\\n optimize(gif_path)\\n except Exception:\\n print(\\\"gifsicle not installed\\\")\",\n \"def return_image(val, model_id, message_name, field_name, mime, sind):\\n column_data_source = curdoc().get_model_by_name(sind)\\n index = column_data_source.tags[0]\\n url = \\\"http://{0}/image/\\\".format(_host) + \\\"---\\\".join([model_id, message_name, field_name, mime, sind, str(index)])\\n return url\",\n \"def make_gif(image_list, gif_name):\\n if not gif_name.endswith(\\\".gif\\\"):\\n gif_name += \\\".gif\\\"\\n imageio.mimsave(gif_name, [imageio.imread(x) for x in image_list])\",\n \"def get_html(self):\\r\\n context = {\\r\\n 'display_name': self.display_name_with_default,\\r\\n 'instructions_html': self.instructions,\\r\\n 'annotation_storage': self.annotation_storage_url,\\r\\n 'token': retrieve_token(self.user, self.annotation_token_secret),\\r\\n 'tag': self.instructor_tags,\\r\\n 'openseadragonjson': self.openseadragonjson,\\r\\n }\\r\\n\\r\\n return self.system.render_template('imageannotation.html', context)\",\n \"def export_representations(self):\\n\\n dbpath, config = self._start()\\n self.logger.msg1(\\\"Loading ontology\\\")\\n obo_path = check_file(config.obo, dbpath, \\\"obo\\\")\\n self.obo = MinimalObo(obo_path, True)\\n self._export_reference_representations()\\n self._export_model_representations(config)\\n self._end()\",\n \"def _repr_png_(self):\\n mol = self.owner.mol\\n keku = IPythonConsole.kekulizeStructures\\n size = IPythonConsole.molSize\\n opts = IPythonConsole.drawOptions\\n return Draw._moltoimg(\\n mol, size, self.aix, \\\"\\\", returnPNG=True, drawOptions=opts,\\n kekulize=keku, highlightBonds=self.bix\\n )\",\n \"def _repr_png_(self):\\n mol = self.owner.mol\\n keku = IPythonConsole.kekulizeStructures\\n size = IPythonConsole.molSize\\n opts = IPythonConsole.drawOptions\\n return Draw._moltoimg(\\n mol, size, self.aix, \\\"\\\", returnPNG=True, drawOptions=opts,\\n kekulize=keku, highlightBonds=self.bix\\n )\",\n \"def put_drawing_gif(self, request):\\n HttpRequest = request.to_http_info(self.api_client.configuration)\\n return self.__make_request(HttpRequest, 'PUT', 'file')\",\n \"def image_jpeg():\\n data = resource(\\\"images/jackal.jpg\\\")\\n return Response(data, headers={\\\"Content-Type\\\": \\\"image/jpeg\\\"})\",\n \"def generate_gif(directory: (\\\"Folder name\\\", \\\"positional\\\"),\\n image_format: ('Image format', 'positional') = '.png',\\n print_file_names=False):\\n import imageio\\n from glob import glob\\n from natsort import natsorted\\n\\n images = []\\n # Create a list of file names in the specified directory\\n filenames = glob(directory + '/*' + image_format)\\n\\n filenames = natsorted(filenames, key=lambda y: y.lower())\\n # Sort the list 'filenames' using the traditional method.\\n # Traditional method -\\n # isolate the entire first number in the string, then sort by that number\\n # If this step is not included,\\n # files will be sorted like so: 0, 100, 110, 200, 3, 420, etc...\\n\\n if print_file_names: # For troubleshooting\\n for i in filenames:\\n print(i)\\n\\n for filename in filenames:\\n images.append(imageio.imread(filename))\\n # Append each file to the list that will become the gif\\n\\n imageio.mimsave(directory + '.gif', images)\\n # Save the gif as the name of the directory\\n # that the images were generated from\\n return\",\n \"def convert_gif(path: str,\\n gif_name: str = 'gif_name.gif',\\n frame_limit: int = 100):\\n video_path = glob(path + \\\"/*.mp4\\\")[-1]\\n vidcap = cv2.VideoCapture(video_path)\\n success, frame = vidcap.read()\\n count = 0\\n\\n # extracting and saving video frames.\\n while success:\\n cv2.imwrite(f\\\"{path}/frame{count}.png\\\", frame) \\n success, frame = vidcap.read()\\n count += 1\\n if count > frame_limit:\\n break\\n print(\\\"total frames:\\\", count)\\n\\n # generate animated GIF.\\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\\\"/*.png\\\"))]\\n img.save(fp=f\\\"{path}/{gif_name}\\\", format='GIF', append_images=imgs,\\n save_all=True, duration=200, loop=0)\\n \\n # remove frames\\n [os.remove(os.path.join(path, f)) for f in glob(path+\\\"/*.png\\\")]\",\n \"def save_GIF(ht, name=\\\"trajectory\\\"):\\n # Generation of images\\n counter = 0\\n images = []\\n for e in range(0, len(ht), 3):\\n p = ht[e][0]\\n s = ht[e][1]\\n save_caronthehill_image(p, s, \\\"image\\\\\\\\state\\\" + str(counter) + \\\".png\\\")\\n images.append(imageio.imread(\\\"image\\\\\\\\state\\\" + str(counter) + \\\".png\\\"))\\n counter += 1\\n imageio.mimsave(\\\"{}.gif\\\".format(name), images)\",\n \"def makeGifVideo(env, actions, initstate=None, prefix='seq_', duration=0.1,\\r\\n outdir='../gifs/', tmpdir='../temp/'):\\r\\n from external_libs.images2gif import writeGif\\r\\n import Image\\r\\n env.visualize = True\\r\\n env.reset()\\r\\n if initstate is not None:\\r\\n env.setState(initstate)\\r\\n env._counter = 1\\r\\n res_images = []\\r\\n astring = ''.join([str(a) for a in actions if a is not None])\\r\\n \\r\\n def cb(*_):\\r\\n fn = tmpdir + \\\"tmp%05d.png\\\" % env._counter\\r\\n pygame.image.save(env._game.screen, fn)\\r\\n res_images.append(Image.open(fn))\\r\\n env._counter += 1\\r\\n \\r\\n env.rollOut(actions, callback=cb)\\r\\n writeGif(outdir + prefix + '%s.gif' % astring, res_images, duration=duration, dither=0)\",\n \"def pd_to_gif(data ,xyz ,name ,clrs=None):\\r\\n\\r\\n x, y, z = list(data[xyz[0]]), list(data[xyz[1]]), list(data[xyz[2]])\\r\\n clrs = list(data[clrs]) if clrs != None else ['blue']*len(x)\\r\\n\\r\\n lst = create_3d_graph(x, y, z, colors=clrs, fr=36,name=name)\\r\\n create_gif(lst, name)\\r\\n clean_workspace(lst)\",\n \"def transformation():\\n AutoGluonClassifierService.load_model()\\n data = None\\n print(f'Request Content Type: {flask.request.content_type}')\\n # Convert from CSV to pandas\\n if flask.request.content_type == 'application/x-image':\\n data = flask.request.data.decode('utf-8')\\n tmp_image_path = f'/tmp/{uuid1().hex}.jpg'\\n image_bytes = io.BytesIO(data)\\n image = Image.open(image_bytes)\\n image.save(tmp_image_path)\\n else:\\n return flask.Response(\\n response='This predictor only supports JSON or CSV data. data is preferred.',\\n status=415, mimetype='text/plain'\\n )\\n\\n print('Classifying image with {}')\\n # Do the prediction\\n class_index, class_probability = AutoGluonClassifierService.predict(tmp_image_path)\\n prediction = {\\n 'ClassIndex': class_index,\\n 'PredictionProba': class_probability\\n }\\n\\n return flask.Response(response=json.dumps(prediction), status=200, mimetype='application/json')\",\n \"def to_gif(diagram, *diagrams, **params): # pragma: no cover\\n path = params.get(\\\"path\\\", None)\\n timestep = params.get(\\\"timestep\\\", 500)\\n loop = params.get(\\\"loop\\\", False)\\n steps, frames = (diagram, ) + diagrams, []\\n path = path or os.path.basename(NamedTemporaryFile(\\n suffix='.gif', prefix='tmp_', dir='.').name)\\n with TemporaryDirectory() as directory:\\n for i, _diagram in enumerate(steps):\\n tmp_path = os.path.join(directory, '{}.png'.format(i))\\n _diagram.draw(path=tmp_path, **params)\\n frames.append(Image.open(tmp_path))\\n if loop:\\n frames = frames + frames[::-1]\\n frames[0].save(path, format='GIF', append_images=frames[1:],\\n save_all=True, duration=timestep,\\n **{'loop': 0} if loop else {})\\n try:\\n from IPython.display import HTML\\n return HTML('<img src=\\\"{}\\\">'.format(path))\\n except ImportError:\\n return '<img src=\\\"{}\\\">'.format(path)\",\n \"def gif_generation(orig_label_path, bound_data_path):\\n for sample in os.listdir(bound_data_path):\\n if not sample.startswith('.') and osp.isdir(osp.join(bound_data_path, sample)):\\n sample_path = osp.join(bound_data_path, sample)\\n for artery in os.listdir(sample_path):\\n orig_label_pick_path = osp.join(orig_label_path, sample, artery, 'data.pkl')\\n bound_pick_path = osp.join(bound_data_path, sample, artery, 'data.pkl')\\n\\n # function to save result of each artery into gif\\n save_gif_artery(orig_label_pick_path, bound_pick_path)\",\n \"def swagger():\\n return jsonify(current_app.spec.to_dict())\",\n \"def show(self):\\n f = open('/tmp/dotty', 'w')\\n f.write(self.dot())\\n f.close()\\n os.system('cat /tmp/dotty | dot -Tgif > /tmp/dotty.gif')\\n os.system('eog /tmp/dotty.gif')\",\n \"def create_resource():\\n #deserializer = ImageDeserializer()\\n #serializer = ImageSerializer()\\n return wsgi.Resource(Controller())\",\n \"def api_documentation(api: str, summary: str, in_model: BaseModel,\\n out_model: BaseModel, out_description: str) -> Callable:\\n for model, name in ((in_model, 'Input'), (out_model, 'Output')):\\n doc.Object(\\n make_dataclass(\\n f'Api{api[1:].title()}{name}',\\n [(key, val.type_, val.type_)\\n for key, val in model.__dict__['__fields__'].items()]))\\n im_returns = doc.JsonBody({\\n key: val.type_\\n for key, val in in_model.__dict__['__fields__'].items()\\n })\\n\\n om_returns = {\\n key: val.type_\\n for key, val in out_model.__dict__['__fields__'].items()\\n }\\n\\n def decorator(func):\\n @doc.summary(summary)\\n @doc.response(412,\\n 'Error: Precondition Failed',\\n description='The passed request-parameters are invalid')\\n @doc.response(500,\\n 'Error: Server-Error occured',\\n description='An internal error occured')\\n @doc.consumes(im_returns,\\n content_type='application/json',\\n location='body')\\n @doc.produces(om_returns,\\n content_type='application/json',\\n description=out_description)\\n @wraps(func)\\n async def function_wrapper(request, *args, **kwargs):\\n return await func(request=request, *args, **kwargs)\\n\\n return function_wrapper\\n\\n return decorator\",\n \"def saveGIFBatch(directory, path, name=''):\\n # for each frame in batch\\n images = []\\n for filename in directory:\\n print(filename)\\n images.append(imageio.imread(filename))\\n\\n name_gif = path + '/' + name + '.gif'\\n imageio.mimsave(name_gif, images)\",\n \"def compose_in_gif(images, output_file, delay):\\n images[0].save(\\n output_file, \\n format='GIF', append_images=images[1:], \\n save_all=True, duration=delay, loop=0,\\n )\",\n \"def recordAnim(self):\\n if self.currentMode == 'export':\\n if os.path.isfile(self.tempGIFDir):\\n try:\\n os.chmod(self.tempGIFDir, 0777)\\n os.remove(self.tempGIFDir)\\n\\n except Exception, result:\\n logger.warning(result)\\n\\n modelPanelList = cmds.getPanel(type='modelPanel')\\n for eachModelPanel in modelPanelList:\\n cmds.modelEditor(eachModelPanel, e=1, alo=0)\\n cmds.modelEditor(eachModelPanel, e=1, pm=1)\\n\\n startFrame = cmds.playbackOptions(min=1, q=1)\\n endFrame = cmds.playbackOptions(max=1, q=1)\\n\\n tempImageList = list()\\n for i in range(int(startFrame), int(endFrame+1)):\\n tempImage = cmds.playblast(st=i, et=i, fmt='image', cc=1, v=0, orn=0, fp=1, p=100, c='png',\\n wh=[512, 512], cf='%s/tempImg_%s.png' % (self.tempDir, i))\\n tempImageList.append(tempImage)\\n\\n # make GIF from tempImageList\\n frames = list()\\n for tempImage in tempImageList:\\n im = Image.open(tempImage)\\n frames.append(im)\\n\\n frames[0].save(self.tempGIFDir, save_all=True, append_images=frames[1:], duration=50, loop=0)\\n\\n # remove temp images\\n for i in tempImageList:\\n if os.path.isfile(i):\\n try:\\n os.chmod(i, 0777)\\n os.remove(i)\\n except Exception, result:\\n logger.warning(result)\\n\\n self.recordBtn.loadGIF2Button(path=self.tempGIFDir)\",\n \"async def get_image(self):\\n\\n # generating\\n fixed_latent = torch.randn(1, 512, 1, 1, device=self.device)\\n\\n with torch.no_grad():\\n # passing through\\n fake_images = self.model(fixed_latent)\\n # saving\\n save_image(fake_images, f'models/FaceGAN_dir/faces/fake.jpg')\",\n \"def post_drawing_gif(self, request):\\n HttpRequest = request.to_http_info(self.api_client.configuration)\\n return self.__make_request(HttpRequest, 'POST', 'file')\",\n \"def image_capture_demo():\\n return render_template('image_capture_demo.html')\",\n \"def get(self):\\n self.response.out.write(blobstore.create_upload_url(\\n UPLOAD_SCREENSHOT_IMAGE_URL))\",\n \"def getImage():\\n\\tsaveimage = request.files['image']\\n\\n\\timagename = saveimage.filename\\n\\tsaveimage.save(os.path.join(app.config['uploadFolder'], imagename))\\n\\tfiles = {'image': open(imagename, 'rb')}\\n\\tjsonfile = getData(files)\\t\\t\\n\\treturn render_template('index.html', json_data = jsonfile)\",\n \"def get(self):\\n from fantasm.utils import outputMachineConfig\\n\\n machineConfig = getMachineConfig(self.request)\\n content = outputMachineConfig(machineConfig, skipStateNames=[self.request.GET.get('skipStateName')])\\n if self.request.GET.get('type', 'png') == 'png':\\n self.response.out.write(\\n \\\"\\\"\\\"\\n <html>\\n <head></head>\\n <body onload=\\\"javascript:document.forms.chartform.submit();\\\">\\n <form id='chartform' action='http://chart.apis.google.com/chart' method='POST'>\\n <input type=\\\"hidden\\\" name=\\\"cht\\\" value=\\\"gv:dot\\\" />\\n <input type=\\\"hidden\\\" name=\\\"chl\\\" value='%(chl)s' />\\n <input type=\\\"submit\\\" value=\\\"Generate GraphViz .png\\\" />\\n </form>\\n </body>\\n \\\"\\\"\\\" % {'chl': content.replace('\\\\n', ' ')})\\n else:\\n self.response.out.write(content)\",\n \"def output_handler(response, context):\\n print(\\\"Output handler\\\")\\n \\n if response.status_code != 200:\\n _return_error(response.status_code, response.content.decode('utf-8'))\\n response_content_type = context.accept_header\\n content = response.content\\n\\n predictions = json.loads(content.decode('UTF-8'))\\n predictions = np.array(predictions[\\\"predictions\\\"])\\n res = []\\n for pred in predictions:\\n top3 = (-pred).argsort()[:3]\\n res.append({'file_name': 'no-filename', 'path': 'no-path', 'cls': 'actual', 'prediction':top3[0], 'proba_1':pred[top3[0]], 'prediction2':top3[1], 'proba_2':pred[top3[1]], 'prediction3':top3[2], 'proba_3':pred[top3[2]]})\\n\\n image_index = pd.DataFrame(res)\\n image_index['prediction'] = image_index.prediction.map(cls_map)\\n image_index['prediction2'] = image_index.prediction2.map(cls_map)\\n image_index['prediction3'] = image_index.prediction3.map(cls_map)\\n return image_index.to_csv(index=False, header=False), response_content_type\",\n \"def api():\\n return send_file('templates/bootstrapper.swagger.json')\",\n \"def visualize(self):\\n return \\\"https://neuroglancer.bossdb.io/#!{'layers':{'image':{'source':'boss://__replace_me__'}}}\\\".replace(\\n \\\"__replace_me__\\\",\\n f\\\"{self.volume_provider.boss._project._base_protocol}://{self.volume_provider.boss._project._base_url}/{self.collection_name}/{self.experiment_name}/{self.channel_name}\\\",\\n )\",\n \"def _repr_html_(self):\\n import io\\n import base64\\n from PIL import Image\\n\\n library_name = \\\"vedo.assembly.Assembly\\\"\\n help_url = \\\"https://vedo.embl.es/docs/vedo/assembly.html\\\"\\n\\n arr = self.thumbnail(zoom=1.1, elevation=-60)\\n\\n im = Image.fromarray(arr)\\n buffered = io.BytesIO()\\n im.save(buffered, format=\\\"PNG\\\", quality=100)\\n encoded = base64.b64encode(buffered.getvalue()).decode(\\\"utf-8\\\")\\n url = \\\"data:image/png;base64,\\\" + encoded\\n image = f\\\"<img src='{url}'></img>\\\"\\n\\n # statisitics\\n bounds = \\\"<br/>\\\".join(\\n [\\n vedo.utils.precision(min_x, 4) + \\\" ... \\\" + vedo.utils.precision(max_x, 4)\\n for min_x, max_x in zip(self.bounds()[::2], self.bounds()[1::2])\\n ]\\n )\\n\\n help_text = \\\"\\\"\\n if self.name:\\n help_text += f\\\"<b> {self.name}:   </b>\\\"\\n help_text += '<b><a href=\\\"' + help_url + '\\\" target=\\\"_blank\\\">' + library_name + \\\"</a></b>\\\"\\n if self.filename:\\n dots = \\\"\\\"\\n if len(self.filename) > 30:\\n dots = \\\"...\\\"\\n help_text += f\\\"<br/><code><i>({dots}{self.filename[-30:]})</i></code>\\\"\\n\\n allt = [\\n \\\"<table>\\\",\\n \\\"<tr>\\\",\\n \\\"<td>\\\",\\n image,\\n \\\"</td>\\\",\\n \\\"<td style='text-align: center; vertical-align: center;'><br/>\\\",\\n help_text,\\n \\\"<table>\\\",\\n \\\"<tr><td><b> nr. of objects </b></td><td>\\\"\\n + str(self.GetNumberOfPaths())\\n + \\\"</td></tr>\\\",\\n \\\"<tr><td><b> position </b></td><td>\\\" + str(self.GetPosition()) + \\\"</td></tr>\\\",\\n \\\"<tr><td><b> diagonal size </b></td><td>\\\"\\n + vedo.utils.precision(self.diagonal_size(), 5)\\n + \\\"</td></tr>\\\",\\n \\\"<tr><td><b> bounds </b> <br/> (x/y/z) </td><td>\\\" + str(bounds) + \\\"</td></tr>\\\",\\n \\\"</table>\\\",\\n \\\"</table>\\\",\\n ]\\n return \\\"\\\\n\\\".join(allt)\",\n \"def recordVideo(args, env, model, filename):\\n # env = model.get_env()\\n images = []\\n images = images + runAGame(model, env, args.method == 'centralized')\\n images = images + runAGame(model, env, args.method == 'centralized')\\n images = images + runAGame(model, env, args.method == 'centralized')\\n images[0].save(filename + '.gif',\\n format='GIF',\\n append_images=images[1:],\\n save_all=True,\\n duration=500,\\n loop=0)\\n print('Video saved:', filename)\",\n \"def on_get(self, request, response):\\n response.status = falcon.HTTP_200 # alternatively, HTTP_OK\\n response.media = DEGS\",\n \"def create_img(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled, IMG_OUTPUT_FILEPATH):\\n viz = Visualizer(X_train, X_test, y_train, y_test, labels, model, visualizer, upsampled=upsampled)\\n viz.evaluate()\\n if upsampled == True:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '_upsampled.png'\\n else:\\n outpath_ = IMG_OUTPUT_FILEPATH + str(model).split('(')[0] + '/' + visualizer + '.png'\\n viz.visualizer.show(outpath=outpath_, clear_figure=True)\",\n \"def send_GIF():\\n try:\\n gif_icon = driver.find_element_by_xpath('//*[@data-tip=\\\"GIF\\\"]')\\n gif_icon.click()\\n wait(wait_time=10)\\n gifs = driver.find_elements_by_class_name('giphy-gif')\\n src = gifs[0].get_attribute('src')\\n gif_ID = src[src.index('media/') + len('media/'):]\\n gif_ID = gif_ID[:gif_ID.index('/')]\\n gifs[0].click()\\n wait()\\n except Exception as e:\\n return \\\"Error: \\\" + str(e)\\n if verify_GIF_sent(gif_ID):\\n return \\\"Success\\\"\\n else:\\n return \\\"Error: GIF wasn't sent\\\"\",\n \"def render(self, **kwargs):\\n return Draw.MolToImage(self._state, **kwargs)\",\n \"def create_gif(base_folder):\\n img_list = []\\n search_path = glob.glob(os.path.join(base_folder, '*.png'))\\n search_path.sort()\\n for f in search_path:\\n im = Image.open(f)\\n img_list.append(im)\\n save_file = os.path.join(base_folder, 'animated_gif.gif')\\n img_list[0].save(save_file,\\n save_all=True, append_images=img_list[1:], optimize=False, duration=180, loop=0)\",\n \"def write_annotation(self, ann_file, img_path, new_img_name):\\n if self.type == \\\"imagenet\\\":\\n label = self.in_annotations[img_path]\\n logger.debug(f\\\"Img {img_path}, imagenet label {label}\\\")\\n ann_file.write(str(label) + \\\"\\\\n\\\")\\n elif self.type == \\\"coco\\\":\\n ann_file.write(\\\"detection_results {\\\\n\\\")\\n for obj in self.in_annotations[img_path].keys():\\n ann_file.write(\\\" objects {\\\\n\\\")\\n ann_file.write(f\\\" class_id: {self.in_annotations[img_path][obj]['label']}\\\\n\\\")\\n ann_file.write(\\\" bounding_box {\\\\n\\\")\\n ann_file.write(f\\\" normalized_top: {self.in_annotations[img_path][obj]['normalized_bbox'][0]}\\\\n\\\")\\n ann_file.write(f\\\" normalized_bottom: {self.in_annotations[img_path][obj]['normalized_bbox'][1]}\\\\n\\\")\\n ann_file.write(f\\\" normalized_left: {self.in_annotations[img_path][obj]['normalized_bbox'][2]}\\\\n\\\")\\n ann_file.write(f\\\" normalized_right: {self.in_annotations[img_path][obj]['normalized_bbox'][3]}\\\\n\\\")\\n ann_file.write(\\\" }\\\\n\\\")\\n ann_file.write(\\\" }\\\\n\\\")\\n ann_file.write(f' image_name: \\\"{new_img_name}\\\"\\\\n')\\n ann_file.write(f' image_id: {int(new_img_name.split(\\\".\\\")[0])}\\\\n')\\n ann_file.write(\\\"}\\\\n\\\")\",\n \"def ricoh_feed():\\n return Response(gen_ricoh_feed(), mimetype='multipart/x-mixed-replace; boundary=frame')\",\n \"def format_model_output(self, output, batch_size=1):\\r\\n return output\",\n \"def render_er(input, output, mode='auto', include_tables=None, include_columns=None,\\n exclude_tables=None, exclude_columns=None, schema=None):\\n\\n try:\\n tables, relationships = all_to_intermediary(input, schema=schema)\\n tables, relationships = filter_resources(tables, relationships,\\n include_tables=include_tables, include_columns=include_columns,\\n exclude_tables=exclude_tables, exclude_columns=exclude_columns)\\n intermediary_to_output = get_output_mode(output, mode)\\n gvo = intermediary_to_output(tables, relationships, output)\\n #return graphviz object which has a _repr_svg_()-method\\n #http://graphviz.readthedocs.io/en/stable/manual.html#jupyter-notebooks\\n return gvo\\n except ImportError as e:\\n module_name = e.message.split()[-1]\\n print('Please install {0} using \\\"pip install {0}\\\".'.format(module_name))\\n except ParsingException as e:\\n sys.stderr.write(e.message)\",\n \"def complete_a_picture(viz_client):\\n # Get a training set for a set of x-y coordinates, this one is part of a checkerboard pattern\\n x_min = 0.0; x_max = 2.0; y_min = 0; y_max = 1.0\\n train_in, train_out = make_checkerboard_training_set(num_points=1000, noise=0.00, randomize=True,\\n x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max)\\n\\n # Plot he training set\\n viz_client.plot_2d_classes(train_in, train_out, title=\\\"Training data\\\",\\n x_min=x_min, x_max=x_max,\\n y_min=y_min, y_max=y_max, delta=0.01)\\n\\n training_size = train_in.shape[0]\\n batch_size = round(training_size / 3.0)\\n num_features = train_in.shape[1]\\n\\n # Initialize a numpynet object\\n numpy_net = NumpyNet(num_features, batch_size,\\n num_hidden=5, hidden_sizes=[4, 8, 16, 8, 4],\\n activation=[\\\"tanh\\\", \\\"tanh\\\", \\\"tanh\\\", \\\"tanh\\\", \\\"tanh\\\", \\\"tanh\\\"],\\n learning_rate=0.0001,\\n dropout_rate=None, weight_decay=None,\\n random_seed=1337)\\n # Hook the object up to the viz client\\n numpy_net.set_viz_client(viz_client)\\n\\n # A basic report of the net to the logs\\n numpy_net.report_model()\\n\\n # Train the model!\\n numpy_net.train(train_in, train_out, epochs=10000,\\n visualize=True, visualize_percent=1, save_best=\\\"./numpynet_best_model.pickle\\\",\\n debug_visualize=True)\\n\\n # A silly viz of the network architecture (if the net isn't too huge to make it muddled)\\n if max(numpy_net.layer_sizes) <= 16:\\n numpy_net.viz.network_svg(numpy_net)\",\n \"def cam():\\n\\treturn Response(gen(camera),\\n\\t\\t\\t\\t\\tmimetype='multipart/x-mixed-replace; boundary=frame'), 200\",\n \"def main():\\n convert(\\\"env_100000.mp4\\\", TargetFormat.GIF)\",\n \"def AnimFromPng(name, gif=True, fps=15):\\n if(gif):\\n imgconvert = \\\"convert \\\" + \\\"-delay \\\" + str(int(1000/fps))\\n imgconvert += \\\" -dispose None \\\" + name + \\\"*.png -loop 0 \\\" + name + \\\".gif\\\"\\n system(imgconvert)\\n print imgconvert\\n else:\\n aviconvert = \\\"ffmpeg -i \\\" + name + \\\"%03d.png -b:v 2048k -r \\\" + str(fps) + \\\" \\\" + name + \\\".avi\\\"\\n system(aviconvert)\\n print aviconvert\",\n \"def swagger_definition(self, base_path=None, **kwargs):\\n return Swagger(\\n {\\n \\\"info\\\": Info(\\n {\\n key: kwargs.get(key, self.DEFAULT_INFO.get(key))\\n for key in Info.fields.keys()\\n if key in kwargs or key in self.DEFAULT_INFO\\n }\\n ),\\n \\\"paths\\\": self.paths,\\n \\\"swagger\\\": \\\"2.0\\\",\\n \\\"basePath\\\": base_path,\\n }\\n ).to_primitive()\",\n \"def visualize(model: Model, structural_part=True, measurement_part=False,\\n view=True, filename=None, title=''):\\n g = gv.Digraph(format='jpg', graph_attr={'label': title})\\n if structural_part:\\n g.node_attr.update(color='red', shape='box')\\n for i, j in model.parameters['Beta']:\\n lval, rval = model.beta_names[0][i], model.beta_names[0][j]\\n g.edge(rval, lval)\\n if measurement_part:\\n g.node_attr.update(color='black', shape='circle')\\n for i, j in model.parameters['Lambda']:\\n lval, rval = model.lambda_names[0][i], model.lambda_names[0][j]\\n g.edge(lval, rval)\\n g.render(filename, view=view)\",\n \"def GetModelOutputInfo(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def api_get_icon():\\n pkg_name = request.args.get('pkg')\\n if pkg_name:\\n pkg_files = Database().db.get_pkg_files(pkg_name)\\n for src in pkg_files:\\n if src.startswith(\\\"/usr/share/icons/hicolor/32x32/apps/\\\"):\\n return send_file(src, as_attachment=False)\\n return send_file(\\\"static/images/null.gif\\\")\\n else:\\n src = request.args.get('i')\\n if not os.path.isfile(src):\\n #abort(404)\\n return send_file(\\\"static/images/null.gif\\\")\\n return send_file(src, as_attachment=False)\",\n \"def image_webp():\\n data = resource(\\\"images/wolf_1.webp\\\")\\n return Response(data, headers={\\\"Content-Type\\\": \\\"image/webp\\\"})\",\n \"def print_image(indiv,name):\\n routine = gp.compile(indiv,pset)\\n output = gen_beat_output(routine)\\n bits = np.array(map(bitlist,output)[0:24000]).transpose()\\n plt.style.use('classic')\\n plt.imshow(bits,interpolation='nearest',aspect='auto',cmap=plt.get_cmap('Greys'))\\n plt.savefig(name+\\\".png\\\",dpi=150)\",\n \"def image(request):\\n response = HttpResponse(request.content.data, content_type=request.mime_type)\\n filename = re.sub(\\n r'[^\\\\w\\\\.]', '_', request.patch.filename.encode('ascii', 'replace'))\\n response['Content-Disposition'] = 'attachment; filename=\\\"%s\\\"' % filename\\n response['Cache-Control'] = 'no-cache, no-store'\\n return response\",\n \"def image(request):\\n response = HttpResponse(request.content.data, content_type=request.mime_type)\\n filename = re.sub(\\n r'[^\\\\w\\\\.]', '_', request.patch.filename.encode('ascii', 'replace'))\\n response['Content-Disposition'] = 'attachment; filename=\\\"%s\\\"' % filename\\n response['Cache-Control'] = 'no-cache, no-store'\\n return response\",\n \"def to_gifs(self, dst, limit=800):\\n if not os.path.isdir(dst):\\n os.mkdir(dst)\\n\\n for table in self._data:\\n for subtable in self._data[table]:\\n _table = self._data[table][subtable]\\n if len(_table) < 1:\\n continue\\n if table == \\\"cbdt\\\":\\n _table.to_cbdt_gif(dst)\\n elif _table.renderable and self.renderable:\\n filename = _table.table_name.replace(\\\" \\\", \\\"_\\\") + \\\".gif\\\"\\n img_path = os.path.join(dst, filename)\\n if table == \\\"metrics\\\":\\n _table.to_gif(img_path, prefix_characters=\\\"II\\\", suffix_characters=\\\"II\\\", limit=limit)\\n elif table == \\\"gdef_mark\\\":\\n prefix = \\\"A\\\"\\n _table.to_gif(img_path, prefix_characters=prefix, limit=limit)\\n elif table == \\\"gdef_base\\\":\\n suffix = chr(int(\\\"0301\\\", 16)) # acutecomb\\n _table.to_gif(img_path, suffix_characters=suffix, limit=limit)\\n\\n else:\\n _table.to_gif(img_path, limit=limit)\",\n \"def get_image(request):\\n data = [{'model': i.bike_model, 'image': i.image, 'id': i.id} for i in BikeDetails.objects.all()]\\n data = {'data': data}\\n return render(request, 'show_image.html', data)\",\n \"def export_loop(self, model_instance, field_converter, role=None, print_none=False):\\n if isinstance(model_instance, self.model_class):\\n model_class = model_instance.__class__\\n else:\\n model_class = self.model_class\\n\\n tender = model_instance.__parent__\\n tender_date = get_first_revision_date(tender, default=get_now())\\n status = getattr(model_instance, \\\"status\\\")\\n if tender_date > BID_UNSUCCESSFUL_FROM and role not in [None, \\\"plain\\\"] and status == \\\"unsuccessful\\\":\\n role = \\\"bid.unsuccessful\\\"\\n\\n shaped = export_loop(model_class, model_instance, field_converter, role=role, print_none=print_none)\\n\\n if shaped and len(shaped) == 0 and self.allow_none():\\n return shaped\\n elif shaped:\\n return shaped\\n elif print_none:\\n return shaped\",\n \"def get_img(self, onehot=False):\\n if self.obs_vision:\\n img = self.gen_obs(onehot=False)\\n img = self.get_obs_render(img, CELL_PIXELS // 4)\\n else:\\n img = self.gen_obs(onehot=onehot)\\n return img\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5817749","0.5611348","0.55694085","0.5549498","0.54999256","0.5440405","0.5431132","0.540683","0.53500056","0.53045505","0.529118","0.526501","0.5244855","0.52252036","0.52224654","0.521024","0.5190709","0.5121285","0.50855976","0.50822467","0.50727075","0.50604826","0.5035468","0.5031037","0.50265545","0.5016825","0.50107557","0.5000806","0.49976224","0.49940956","0.4988046","0.4983373","0.49792477","0.4951921","0.49271455","0.4905524","0.49033728","0.48923922","0.48781097","0.48760828","0.4873147","0.4862367","0.48568386","0.48557326","0.48509672","0.4847753","0.48418078","0.48418078","0.4840472","0.48186842","0.48152724","0.48120272","0.48119855","0.48110828","0.48105225","0.47977164","0.47868842","0.47830215","0.47819373","0.4768637","0.47551396","0.47402498","0.47388837","0.4735019","0.473279","0.4731269","0.47308183","0.47245395","0.47239274","0.4706521","0.47030932","0.46967086","0.46959126","0.46935093","0.4690292","0.46858743","0.46805698","0.46773782","0.46739212","0.46654227","0.466217","0.4653823","0.4648086","0.46479118","0.46458358","0.46373135","0.4634034","0.4630677","0.4629633","0.4625541","0.46143028","0.46137205","0.4609207","0.46089724","0.46036988","0.46030408","0.46030408","0.45990285","0.45967975","0.45848617","0.4582771"],"string":"[\n \"0.5817749\",\n \"0.5611348\",\n \"0.55694085\",\n \"0.5549498\",\n \"0.54999256\",\n \"0.5440405\",\n \"0.5431132\",\n \"0.540683\",\n \"0.53500056\",\n \"0.53045505\",\n \"0.529118\",\n \"0.526501\",\n \"0.5244855\",\n \"0.52252036\",\n \"0.52224654\",\n \"0.521024\",\n \"0.5190709\",\n \"0.5121285\",\n \"0.50855976\",\n \"0.50822467\",\n \"0.50727075\",\n \"0.50604826\",\n \"0.5035468\",\n \"0.5031037\",\n \"0.50265545\",\n \"0.5016825\",\n \"0.50107557\",\n \"0.5000806\",\n \"0.49976224\",\n \"0.49940956\",\n \"0.4988046\",\n \"0.4983373\",\n \"0.49792477\",\n \"0.4951921\",\n \"0.49271455\",\n \"0.4905524\",\n \"0.49033728\",\n \"0.48923922\",\n \"0.48781097\",\n \"0.48760828\",\n \"0.4873147\",\n \"0.4862367\",\n \"0.48568386\",\n \"0.48557326\",\n \"0.48509672\",\n \"0.4847753\",\n \"0.48418078\",\n \"0.48418078\",\n \"0.4840472\",\n \"0.48186842\",\n \"0.48152724\",\n \"0.48120272\",\n \"0.48119855\",\n \"0.48110828\",\n \"0.48105225\",\n \"0.47977164\",\n \"0.47868842\",\n \"0.47830215\",\n \"0.47819373\",\n \"0.4768637\",\n \"0.47551396\",\n \"0.47402498\",\n \"0.47388837\",\n \"0.4735019\",\n \"0.473279\",\n \"0.4731269\",\n \"0.47308183\",\n \"0.47245395\",\n \"0.47239274\",\n \"0.4706521\",\n \"0.47030932\",\n \"0.46967086\",\n \"0.46959126\",\n \"0.46935093\",\n \"0.4690292\",\n \"0.46858743\",\n \"0.46805698\",\n \"0.46773782\",\n \"0.46739212\",\n \"0.46654227\",\n \"0.466217\",\n \"0.4653823\",\n \"0.4648086\",\n \"0.46479118\",\n \"0.46458358\",\n \"0.46373135\",\n \"0.4634034\",\n \"0.4630677\",\n \"0.4629633\",\n \"0.4625541\",\n \"0.46143028\",\n \"0.46137205\",\n \"0.4609207\",\n \"0.46089724\",\n \"0.46036988\",\n \"0.46030408\",\n \"0.46030408\",\n \"0.45990285\",\n \"0.45967975\",\n \"0.45848617\",\n \"0.4582771\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76570,"cells":{"query":{"kind":"string","value":"Gets the gif_fps of this GIFOutput. The frame rate of the GIF. Default is the Video frame rate"},"document":{"kind":"string","value":"def gif_fps(self):\n return self._gif_fps"},"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_fps(self):\n return self._num_frames / (datetime.now() - self._start).total_seconds()","def get_fps(self):\n # Take difference.\n interframe_intervals = np.diff(self.data[\"t\"])\n\n # Inter-frame interval in milliseconds.\n mean_interval = np.mean(interframe_intervals)\n fps = round(1 / (mean_interval / 1000))\n\n return int(fps)","def get_frame_rate(gif=''):\n\n # identify -format \"Frame %s: %Tcs\\n\" ~/test.gif - frame life in centiseconds - how very odd.\n frame_rate_str = subprocess.check_output([\n 'identify',\n '-format',\n '%T\\n',\n gif\n ])\n # If we failed to get a frame lifetime from imagemagick...\n if len(frame_rate_str) <= 0:\n frame_rate = str(FRAME_RATE)\n else:\n # Get gif's lifetime...\n frame_rate_list = frame_rate_str.split('\\n')\n frame_rate_list = [int(n) for n in frame_rate_list if n]\n lifetime = float(sum(frame_rate_list)) / 100\n\n # print \"gif lifetime is \" + str(lifetime) + \"s\"\n # Determine average frames per second\n frame_rate = str(len(frame_rate_list) / lifetime)\n if float(frame_rate) <= 0.0:\n frame_rate = FRAME_RATE\n\n return frame_rate","def get_fps(self):\n return self.fps","def get_fps(self):\n if len(self.times) >= 2:\n dif = np.diff(self.times)\n fps = 1. / dif.min()\n # if the FPS crosses 500, do not update it\n if fps <= 500:\n self.fps = fps\n return self.fps\n else:\n return 0.","def gif_fps(self, gif_fps):\n if gif_fps is not None and gif_fps > 30:\n raise ValueError(\"Invalid value for `gif_fps`, must be a value less than or equal to `30`\")\n\n self._gif_fps = gif_fps","def get_framerate(self):\n return self._framerate","def get_fps(self):\n \n return self.fps, self.average_fps","def get_fps(self):\n raise NotImplementedError(\"get_fps is not implemented\")","def framerate(self):\n return self.config.get('framerate', 15)","def fps(self):\n\t\treturn float(len(self.buf)) / (self.buf[-1][0] - self.buf[0][0])","def get_fps(clock):\n if video_mode:\n return \"30\" # Video FPS will be 30\n else:\n return str(int(round(clock.get_fps(), 0)))","def get_fps(self):\n return self._document.GetFps()","def get_video_fps(self):\n fps = self.video.get(cv2.CAP_PROP_FPS)\n logging.info('Video FPS: {}'.format(fps))\n return fps","def getFrameRate(self):\n if not self.proxy:\n self.proxy = self.session.service(\"ALVideoRecorder\")\n return self.proxy.getFrameRate()","def frame_rate(self):\n return self._frame_rate","def get_fps(self):\n if not self.count_fps:\n logging.error(\"No FPSCounter set\")\n return None\n return self.fps.get_fps()","def get_fps(self):\n if not self.count_fps:\n logging.error(\"No FPSCounter set\")\n return None\n return self.fps.get_fps()","def get_fps(self):\n #return int(self._root.knob('fps').getValue())\n return None","def calculate_fps(self):\n time_difference = self.time_array[-1] - self.time_array[0]\n time_difference_in_seconds = time_difference.to_sec()\n if time_difference_in_seconds == 0:\n pass\n self.fps = self.buffer_size / time_difference_in_seconds\n rospy.loginfo(\"[EulerianMotionMagnification] Estimated FPS: \" + str(self.fps) + \" (Measured timespan: \" + str(time_difference_in_seconds) + \"s)\")\n rospy.loginfo(\"[EulerianMotionMagnification] Video array length: \" + str(len(self.video_array)))","def get_duration(self) -> int:\n return int( (self._frame_count / self._fps) * 1000 )","def max_fps(self):\n return self._max_fps","def getFPS(self):\n # load it each time, since this setting is not limited to a single user\n projectSettingsDB = self.loadProjectSettings()\n try:\n fpsValue = projectSettingsDB[\"FPS\"]\n return fpsValue\n except KeyError:\n msg = \"Database Error while reading projectSettings.json\"\n logger.error(msg)\n return None","def rate(self):\n if self._rate:\n return self._rate\n else:\n return self._wave.getframerate()","def get_video_frame_rate(filename):\n clip = VideoFileClip(filename)\n frame_rate = clip.fps\n clip.close()\n return frame_rate","def get_frame_rate(video):\n\n video = cv2.VideoCapture(video)\n\n # Find OpenCV version\n (major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.')\n\n # With webcam get(CV_CAP_PROP_FPS) does not work.\n # Let's see for ourselves.\n\n if int(major_ver) < 3:\n fps = video.get(cv2.cv.CV_CAP_PROP_FPS)\n logger.info(\"Frames per second using video.get(cv2.cv.CV_CAP_PROP_FPS): {0}\".format(fps))\n else:\n fps = video.get(cv2.CAP_PROP_FPS)\n logger.info(\"Frames per second using video.get(cv2.CAP_PROP_FPS) : {0}\".format(fps))\n\n cv2.destroyAllWindows()\n video.release()\n return fps","def get_fps(vid_path, prefix):\n _, name = os.path.split(vid_path)\n i1 = name.find(prefix) + len(prefix)\n i2 = name[i1:].find('_')\n fps = int(name[i1:i1+i2])\n\n return fps","def framerate(self, interval=None):\n total_frames = 0.0\n\n # These are times when SF begins compositing.\n vsync_events = self.event_intervals(name='VSYNC-sf', interval=interval)\n if not vsync_events:\n vsync_events = self.event_intervals(name='VSYNC', interval=interval)\n\n for vsync_event_a, vsync_event_b in zip(vsync_events, vsync_events[1:]) : \n frames_presented = len(self.event_intervals('postFramebuffer', \n interval=vsync_event_a.interval))\n # Below required to skip interval when we had nothing to do.\n # As this event 'toggles' every VSYNC when SurfaceFlinger has work\n # to do. If nothing is done (i.e. no 'postFramebuffer' events)\n # there was jank in this interval.\n if vsync_event_a.value != vsync_event_b.value and frames_presented:\n total_frames += frames_presented\n \n present_time = self.present_duration(interval=interval)\n return round(total_frames/present_time, 1) if present_time != 0.0 else float('nan')","def calcFrameRate(self):\n\n tot = 0\n count = 0\n for session in self.sessions:\n for sample in session.samples:\n if not sample.isLoading:\n tot += sample.fps\n count += 1\n if count:\n self.avgFps = tot / count\n self.lowFps = (self.avgFps < 10)\n self.highFps = (self.avgFps > 25)","def bspb_frameCounter():\n curTime = int(pm.currentTime())\n maxTime = int(pm.playbackOptions(q=True, maxTime=True))\n return '{0} / {1}'.format(curTime, maxTime)","def frame_duration(self):\n return self.samples_per_frame / self.input_data_sample_rate","def frame_rate():\n def r(x):\n return 6E7/x\n\n def w(x):\n return int(6E7/x)\n return r, w","def get_fps(video, use_opencv=False):\n\n if use_opencv:\n video_cap = cv2.VideoCapture(video)\n fps = video_cap.get(cv2.CAP_PROP_FPS)\n video_cap.release()\n return fps\n else:\n return convert_to_float(\n utils.exec_shell_command(f\"{SHELL_CMD_GET_FPS} '{video}'\", silent=True)[0]\n )","def GetGifFrames(self, path):\n gif = imageio.mimread(path)\n return [\n (image.meta[\"duration\"], cv2.resize(\n cv2.cvtColor(image, cv2.COLOR_RGB2BGR), (64, 64))\n ) for image in gif\n ]","def get_duration(self):\n frame_dur = self.get_frame_duration()\n num_frames = self.get_num_frames()\n motion_dur = frame_dur * (num_frames - 1)\n return motion_dur","def get_frame_duration(self):\n return self._frame_duration","def get_frame_time(self, f):\n return f * self.get_frame_duration()","def f2gif(path,fps):\n print(\"==============================================\")\n print(\"Convert file to GIF!\")\n pathout = path[:-4]+'_'+str(fps)+'.gif'\n if path.endswith('.tif'): \n# import tifffile\n im = tifffile.imread(path)\n nFrames, h,w = im.shape\n dur=1/fps\n clip = []\n for i in range(nFrames):\n fr = cv2.cvtColor(im[i],cv2.COLOR_GRAY2RGB)\n clip.append(mp.ImageClip(fr).set_duration(dur))\n video = mp.concatenate_videoclips(clip, method=\"compose\",ismask=False)#ismask=True to make grayscale\n\n else:\n video = mp.VideoFileClip(path)\n fpsIn = int(video.fps)\n if fps != fpsIn:\n print(\"Conflict in fps! \\n\", \"[0] Use fps of input file;\\n\", \"[1] Use desired fps w/o speedup;\\n\",\n \"[2] Use desired fps w/ speedup:\")\n k = input('Input your selection: ')\n if k == 2:\n sf = fps/fpsIn\n video =video.fx(mp.vfx.speedx, sf)# Not working when sf<1\n elif k == 0:\n fps = fpsIn\n\n video.write_gif(pathout,fps=fps)\n video.reader.close()# To fix handel error problem\n# if path.endswith('.gif'):\n# clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\n print(\"==============================================\")\n print(\"MP4 convertion Done!\")","def current_fps(self, fps: float):\n self.current_fps_label.setText(\"FPS: {0:.2f}\".format(fps))","def FramesPerBurstGap(self):\n\t\treturn self._get_attribute('framesPerBurstGap')","def next_frame(self):\n # Tick will limit framerate and return delta in millis\n delta = self.clock.tick(self.framerate)\n\n # Convert delta to seconds\n delta /= 1000.0\n\n # Limit worst-case delta to make debugging easier\n delta = min(delta, FrameTimer.MAX_FRAME_TIME)\n\n return delta","def display_fps(self):\n template = \"{} - FPS: {:.2f}\"\n caption = template.format(prepare.CAPTION, self.clock.get_fps())\n pg.display.set_caption(caption)","def get_total_frames(self) -> int:\n return self.num_frames","def get_video_frame_rate(video_filename):\n if not os.path.exists(video_filename):\n raise ValueError(\"%s does not exist\" % video_filename)\n \n probe = ffmpeg.probe(video_filename)\n assert len(probe['streams']) == 1\n \n # Seems to be two ways of coding, not sure which is better\n avg_frame_rate = probe['streams'][0]['avg_frame_rate']\n r_frame_rate = probe['streams'][0]['r_frame_rate']\n assert avg_frame_rate == r_frame_rate\n \n # Convert fraction to number\n num, den = avg_frame_rate.split('/')\n frame_rate = float(num) / float(den)\n \n return frame_rate","def read_fps(vid_name):\n\n video = cv2.VideoCapture(vid_name)\n fps = video.get(cv2.CAP_PROP_FPS)\n video.release()\n\n return fps","def gifmp4converter(path,fpsOut):\n# import moviepy.editor as mp\n \n print(\"=========================================\")\n print(\"GIF-MP4 Converter Started!\")\n\n clip = mp.VideoFileClip(path)\n #Get output fps\n fpsIn = int(clip.fps)\n fps=fpsOut\n if fpsOut != fpsIn:\n print(\"Conflict in fps! \\n\",\n \"[0] Use fps of input file;\\n\",\n \"[1] Use desired fps w/o speedup;\\n\",\n \"[2] Use desired fps w/ speedup:\")\n k = input('Input your selection: ')\n if k == 2:\n sf = fpsOut/fpsIn\n fps = fpsOut \n clip =clip.fx(mp.vfx.speedx, sf)\n elif k == 0:\n fps = fpsIn\n \n# Converting formats\n if path.endswith('.gif'):\n pathout = path[:-4]+'_cv'+'.mp4'\n clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\n elif path.endswith('.mp4'):\n pathout = path[:-4]+'_cv'+'.gif'\n clip.write_gif(pathout,fps=fps)\n clip.reader.close()# To fix handel error problem\n print(\"=========================================\")\n print(\"GIF-MP4 Converter Done!\")","def display_fps(self):\n caption = \"{} - FPS: {:.2f}\".format(CAPTION, self.clock.get_fps())\n pg.display.set_caption(caption)","def display_fps(self):\n caption = \"{} - FPS: {:.2f}\".format(CAPTION, self.clock.get_fps())\n pg.display.set_caption(caption)","def video_bitrate(self):\n # type: () -> int\n return self._video_bitrate","def FrameCount(self):\r\n\t\treturn self._get_attribute('frameCount')","def gif(self):\n\n if self._gif is None:\n\n url = self.url.replace('f=fits', 'f=gif')\n\n try:\n url_data = urllib.request.urlopen(url)\n except urllib.request.URLError as ee:\n raise ValueError(f'cannot open URL for these parameters: {ee}')\n\n data = url_data.read()\n\n image = PIL.Image.open(io.BytesIO(data))\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\n\n self._gif = image\n\n return self._gif","def fps(x, y, i):\n\n # Special case for the edges.\n if i < 2:\n return (y[i+1] - y[i]) / (x[i+1] - x[i])\n elif i > len(x) - 3:\n return (y[i] - y[i-1]) / (x[i] - x[i-1])\n\n else:\n h = x[i] - x[i-1]\n f0 = y[i]\n f1 = y[i+1]\n f2 = y[i+2]\n f3 = y[i-1]\n f4 = y[i-2]\n return (-f2 + 8*f1 - 8*f3 + f4) / (12 * h)","def get_frame_time(self):\n return self.get_timings().frame_time","def unit_of_measurement(self) -> str:\n return FPS","def unit_of_measurement(self) -> str:\n return FPS","def Framesize(self):\n\t\treturn self._get_attribute('framesize')","def get_frame_rate(filename):\n cmd = ('ffprobe -v 0 -of flat=s=_ -select_streams v:0 -show_entries '\n 'stream=avg_frame_rate -of default=nokey=1:noprint_wrappers=1 ' +\n filename).split()\n pid = subprocess.run(cmd, stdout=subprocess.PIPE,\n universal_newlines=True)\n if pid.returncode != 0:\n return None\n\n frame_rate_exp = pid.stdout.rstrip()\n try:\n frame_rate = float(frame_rate_exp)\n except:\n if frame_rate_exp == 'N/A':\n frame_rate = 0.\n else:\n numerator, denominator = map(float, frame_rate_exp.split('/'))\n if denominator == 0:\n frame_rate = 0\n else:\n frame_rate = numerator / denominator\n return frame_rate","def video_bitrate(self):\n assert self.has_video\n\n return self.__video_bitrate","def frameTimes(self):\n sr = self.sampleRate\n offset = self.activeOffset\n stride = self.activeStride\n nf = self.numFrames\n t = np.arange(nf) * (stride[0] / sr) + (offset / sr)\n return t","def getGpuFanSpeed(self):\n gpufan = 0\n gpufan = int(str(nvmlDeviceGetFanSpeed(self.handle)))\n return gpufan","def clock_speed(self):\n return self._clock_speed","def _draw_fps_counter(self, fps: float):\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\n\n dpg.draw_rectangle(\n parent=draw_layer_tag,\n pmin=(0, 0),\n pmax=(128, 32),\n fill=(0, 0, 0, 128),\n color=(0, 0, 0, 128)\n )\n\n dpg.draw_text(\n parent=draw_layer_tag,\n text=f'FPS: {fps}',\n pos=(_PADDING*2, _PADDING),\n color=(255, 255, 255, 255),\n size=_FONT_SIZE\n )","def get_maya_framerate():\n current_unit = pm.currentUnit(time=True, query=True)\n if current_unit == 'game':\n framerate = 15.\n elif current_unit == 'film':\n framerate = 24.\n elif current_unit == 'pal':\n framerate = 25.\n elif current_unit == 'ntsc':\n framerate = 30.\n elif current_unit == 'show':\n framerate = 48.\n elif current_unit == 'palf':\n framerate = 50.\n elif current_unit == 'ntscf':\n framerate = 60.\n elif 'fps' in current_unit:\n \tframerate = float(current_unit.split('fps')[0])\n else:\n pm.currentUnit(time='film')\n framerate = 24.\n\n return framerate","def set_fps(self, fps=25):\n raise NotImplementedError(\"set_fps is not implemented\")","def frame_size(self):\n return self._frame_size","def frame_length(self):\r\n return self.config.frame_length","def get_fps_from_sketch(sketch_file_path):\n fps = -1\n # get fps\n with open(sketch_file_path) as json_file:\n data = json.load(json_file)\n fps = float(data[\"fps\"])\n return fps","def changeFps(self):\n check = re.search(\"[1-9][0-9]*\", self.ui.t_fps.text())\n if check:\n num = check.group()\n fps = int(num)\n if fps > self.fps_limit:\n logging.warning(\n \"Too big number for fps. Falling back to {0} fps.\".format(\n self.fps_limit\n )\n )\n fps = self.fps_limit\n self.fps = fps\n self.ui.t_fps.setText(str(fps))\n else:\n logging.info(\"Wrong Input For Fps\")\n self.ui.t_fps.setText(\"30\")\n self.fps = 30","def convert_gif(path: str,\n gif_name: str = 'gif_name.gif',\n frame_limit: int = 100):\n video_path = glob(path + \"/*.mp4\")[-1]\n vidcap = cv2.VideoCapture(video_path)\n success, frame = vidcap.read()\n count = 0\n\n # extracting and saving video frames.\n while success:\n cv2.imwrite(f\"{path}/frame{count}.png\", frame) \n success, frame = vidcap.read()\n count += 1\n if count > frame_limit:\n break\n print(\"total frames:\", count)\n\n # generate animated GIF.\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\"/*.png\"))]\n img.save(fp=f\"{path}/{gif_name}\", format='GIF', append_images=imgs,\n save_all=True, duration=200, loop=0)\n \n # remove frames\n [os.remove(os.path.join(path, f)) for f in glob(path+\"/*.png\")]","def FrameRate(self):\n from ixnetwork_restpy.testplatform.sessions.ixnetwork.traffic.trafficitem.configelement.framerate.framerate import FrameRate\n return FrameRate(self)._select()","def get_frame_size(self) -> Tuple[int, int]:\n return self.__sim.frame_size()","def get_fan_speed(self):\n return self.__fan_speed","def get_score(fps: float, ssim: float,\n ssim_max: float = 30.,\n rate: float = 10.) -> float:\n fps = np.round(fps, 1)\n ssim = np.round(ssim, 3)\n return 0.1 * np.log(fps) / np.log(rate) + min(ssim, ssim_max)","def state(self) -> int | None:\n\n if self.coordinator.data:\n data = self.coordinator.data.get(self._cam_name, {}).get(\n f\"{self._fps_type}_fps\"\n )\n if data is not None:\n try:\n return round(float(data))\n except ValueError:\n pass\n return None","def get_pixel_rate(self):\n return lib.is_PixelClock_dt(self.hcam,5,ctypes.c_uint).value*1E6","def video_duration(self):\n # type: () -> int\n return self._video_duration","def state(self) -> int | None:\n if self.coordinator.data:\n data = self.coordinator.data.get(\"detection_fps\")\n if data is not None:\n try:\n return round(float(data))\n except ValueError:\n pass\n return None","def get(self, flag: int):\n if flag == cv2.CAP_PROP_FRAME_COUNT:\n return self.length","def name(self) -> str:\n return f\"{self._fps_type} fps\"","def get_max_frames(self):\n return 8","def get_fade_fract(self):\n\n FADE_TIME = 2.0 # Adjust this to change fade-in and fade-out times in seconds\n\n if self.show_runtime < FADE_TIME:\n fract = self.show_runtime / FADE_TIME\n elif self.show_runtime > self.max_show_time - FADE_TIME:\n fract = (self.max_show_time - self.show_runtime) / FADE_TIME\n else:\n fract = 1\n\n return fract","def output_statistics(self, run_time):\n fps = self.received_frames / run_time\n MBps_per_frame = self.full_frame_length() / 1000.0 / 1000.0\n print '\\nRun time: %.2f seconds' % (run_time,)\n print 'Received frames: ', self.received_frames\n print 'Avg. frame rate: %s fps' % (fps,)\n print 'Avg. Bit rate: %.2f MB/s' % (MBps_per_frame * fps,)","def update_frame(self):\r\n while not self.stopped:\r\n if not self.grabbed or not self.cap.isOpened():\r\n self.stop()\r\n else:\r\n self.grabbed, self.frame = self.cap.read()\r\n try:\r\n if self.grabbed:\r\n #self.New_Frame_Time = time.time()\r\n #self.FPS = 1/(self.New_Frame_Time-self.Old_Frame_Time)\r\n #self.Old_Frame_Time = self.New_Frame_Time\r\n self.FrameCount += 1\r\n else:\r\n print(f'Grabbed status is: {self.grabbed}')\r\n #self.Old_Frame_Time = time.time()\r\n except ZeroDivisionError:\r\n print(\"Division by zero error when finding video feed fps\")\r\n self.FPS = 0\r\n self.Old_Frame_Time = time.time()","def update_fps(self, fps):\n self.fps_history.append(fps)\n if len(self.fps_history) > FPS_AVERAGES:\n self.fps_history.pop(0)\n\n self.fps_estimate = np.mean(self.fps_history)\n return self.fps_estimate","def get_samplerate(self):\n\t\treturn _PM_UPDATE_RATE / self.output_decimation","def frame_size(self) -> tuple[int, int]:\n return (int(self.get(cv.CAP_PROP_FRAME_HEIGHT)),\n int(self.get(cv.CAP_PROP_FRAME_WIDTH)))","def speed(self) -> float:\n return self._speed","def speed(self) -> float:\n return self._speed","def get_video_property(video_path):\n\tvideocap = cv2.VideoCapture(video_path)\n\tframe_count = videocap.get(cv2.CAP_PROP_FRAME_COUNT)\n\tfps = videocap.get(cv2.CAP_PROP_FPS)\n\theight = videocap.get(cv2.CAP_PROP_FRAME_HEIGHT)\n\twidth = videocap.get(cv2.CAP_PROP_FRAME_WIDTH)\n\treturn frame_count, fps, width, height","def display_frames_as_gif(frames, video_name):\n Writer = animation.writers['ffmpeg']\n writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)\n #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\n patch = plt.imshow(frames[0])\n plt.axis('off')\n\n def animate(i):\n patch.set_data(frames[i])\n\n anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\n# display(display_animation(anim, default_mode='loop'))\n anim.save(result_floder + '/' + video_name, writer=writer)","def _get_duration(self):\n try:\n dur = self.im.info[\"duration\"] / 1000.0\n except KeyError:\n dur = DEFAULT_DURATION / 1000.0 \n\n return dur","def num_frames(self):\n return len(self.video)","def get_frac_secs(self):\n return _uhd_swig.time_spec_t_get_frac_secs(self)","def get_speed(self):\n return self._speed","def speed(self) -> int:\n return self._speed","def speed(self) -> int:\n return self._speed","def update_fps(self):\n self.fps.tick()\n\n\trange_str = \"\"\n gd = self.main_curve_dialog.curve.get_data()[1]\n\trange_str = \"Max: %s, Min: %s, Avg: %0.5s \" \\\n\t\t % (numpy.max(gd), numpy.min(gd), numpy.average(gd))\n\n\n fps_text = \"%s Update: %s FPS\" % (range_str, self.fps.rate())\n self.action_fps_display.setText(fps_text)","def bspb_focalLength():\n shotCam = pm.PyNode('shot_cam').getShape()\n return str(shotCam.focalLength.get())","def bitrate(self) -> float:\n msb = self._read_u8(_REG_BITRATE_MSB)\n lsb = self._read_u8(_REG_BITRATE_LSB)\n return _FXOSC / ((msb << 8) | lsb)","def full_frame_length(self):\n return self.height * self.width * 3"],"string":"[\n \"def get_fps(self):\\n return self._num_frames / (datetime.now() - self._start).total_seconds()\",\n \"def get_fps(self):\\n # Take difference.\\n interframe_intervals = np.diff(self.data[\\\"t\\\"])\\n\\n # Inter-frame interval in milliseconds.\\n mean_interval = np.mean(interframe_intervals)\\n fps = round(1 / (mean_interval / 1000))\\n\\n return int(fps)\",\n \"def get_frame_rate(gif=''):\\n\\n # identify -format \\\"Frame %s: %Tcs\\\\n\\\" ~/test.gif - frame life in centiseconds - how very odd.\\n frame_rate_str = subprocess.check_output([\\n 'identify',\\n '-format',\\n '%T\\\\n',\\n gif\\n ])\\n # If we failed to get a frame lifetime from imagemagick...\\n if len(frame_rate_str) <= 0:\\n frame_rate = str(FRAME_RATE)\\n else:\\n # Get gif's lifetime...\\n frame_rate_list = frame_rate_str.split('\\\\n')\\n frame_rate_list = [int(n) for n in frame_rate_list if n]\\n lifetime = float(sum(frame_rate_list)) / 100\\n\\n # print \\\"gif lifetime is \\\" + str(lifetime) + \\\"s\\\"\\n # Determine average frames per second\\n frame_rate = str(len(frame_rate_list) / lifetime)\\n if float(frame_rate) <= 0.0:\\n frame_rate = FRAME_RATE\\n\\n return frame_rate\",\n \"def get_fps(self):\\n return self.fps\",\n \"def get_fps(self):\\n if len(self.times) >= 2:\\n dif = np.diff(self.times)\\n fps = 1. / dif.min()\\n # if the FPS crosses 500, do not update it\\n if fps <= 500:\\n self.fps = fps\\n return self.fps\\n else:\\n return 0.\",\n \"def gif_fps(self, gif_fps):\\n if gif_fps is not None and gif_fps > 30:\\n raise ValueError(\\\"Invalid value for `gif_fps`, must be a value less than or equal to `30`\\\")\\n\\n self._gif_fps = gif_fps\",\n \"def get_framerate(self):\\n return self._framerate\",\n \"def get_fps(self):\\n \\n return self.fps, self.average_fps\",\n \"def get_fps(self):\\n raise NotImplementedError(\\\"get_fps is not implemented\\\")\",\n \"def framerate(self):\\n return self.config.get('framerate', 15)\",\n \"def fps(self):\\n\\t\\treturn float(len(self.buf)) / (self.buf[-1][0] - self.buf[0][0])\",\n \"def get_fps(clock):\\n if video_mode:\\n return \\\"30\\\" # Video FPS will be 30\\n else:\\n return str(int(round(clock.get_fps(), 0)))\",\n \"def get_fps(self):\\n return self._document.GetFps()\",\n \"def get_video_fps(self):\\n fps = self.video.get(cv2.CAP_PROP_FPS)\\n logging.info('Video FPS: {}'.format(fps))\\n return fps\",\n \"def getFrameRate(self):\\n if not self.proxy:\\n self.proxy = self.session.service(\\\"ALVideoRecorder\\\")\\n return self.proxy.getFrameRate()\",\n \"def frame_rate(self):\\n return self._frame_rate\",\n \"def get_fps(self):\\n if not self.count_fps:\\n logging.error(\\\"No FPSCounter set\\\")\\n return None\\n return self.fps.get_fps()\",\n \"def get_fps(self):\\n if not self.count_fps:\\n logging.error(\\\"No FPSCounter set\\\")\\n return None\\n return self.fps.get_fps()\",\n \"def get_fps(self):\\n #return int(self._root.knob('fps').getValue())\\n return None\",\n \"def calculate_fps(self):\\n time_difference = self.time_array[-1] - self.time_array[0]\\n time_difference_in_seconds = time_difference.to_sec()\\n if time_difference_in_seconds == 0:\\n pass\\n self.fps = self.buffer_size / time_difference_in_seconds\\n rospy.loginfo(\\\"[EulerianMotionMagnification] Estimated FPS: \\\" + str(self.fps) + \\\" (Measured timespan: \\\" + str(time_difference_in_seconds) + \\\"s)\\\")\\n rospy.loginfo(\\\"[EulerianMotionMagnification] Video array length: \\\" + str(len(self.video_array)))\",\n \"def get_duration(self) -> int:\\n return int( (self._frame_count / self._fps) * 1000 )\",\n \"def max_fps(self):\\n return self._max_fps\",\n \"def getFPS(self):\\n # load it each time, since this setting is not limited to a single user\\n projectSettingsDB = self.loadProjectSettings()\\n try:\\n fpsValue = projectSettingsDB[\\\"FPS\\\"]\\n return fpsValue\\n except KeyError:\\n msg = \\\"Database Error while reading projectSettings.json\\\"\\n logger.error(msg)\\n return None\",\n \"def rate(self):\\n if self._rate:\\n return self._rate\\n else:\\n return self._wave.getframerate()\",\n \"def get_video_frame_rate(filename):\\n clip = VideoFileClip(filename)\\n frame_rate = clip.fps\\n clip.close()\\n return frame_rate\",\n \"def get_frame_rate(video):\\n\\n video = cv2.VideoCapture(video)\\n\\n # Find OpenCV version\\n (major_ver, minor_ver, subminor_ver) = (cv2.__version__).split('.')\\n\\n # With webcam get(CV_CAP_PROP_FPS) does not work.\\n # Let's see for ourselves.\\n\\n if int(major_ver) < 3:\\n fps = video.get(cv2.cv.CV_CAP_PROP_FPS)\\n logger.info(\\\"Frames per second using video.get(cv2.cv.CV_CAP_PROP_FPS): {0}\\\".format(fps))\\n else:\\n fps = video.get(cv2.CAP_PROP_FPS)\\n logger.info(\\\"Frames per second using video.get(cv2.CAP_PROP_FPS) : {0}\\\".format(fps))\\n\\n cv2.destroyAllWindows()\\n video.release()\\n return fps\",\n \"def get_fps(vid_path, prefix):\\n _, name = os.path.split(vid_path)\\n i1 = name.find(prefix) + len(prefix)\\n i2 = name[i1:].find('_')\\n fps = int(name[i1:i1+i2])\\n\\n return fps\",\n \"def framerate(self, interval=None):\\n total_frames = 0.0\\n\\n # These are times when SF begins compositing.\\n vsync_events = self.event_intervals(name='VSYNC-sf', interval=interval)\\n if not vsync_events:\\n vsync_events = self.event_intervals(name='VSYNC', interval=interval)\\n\\n for vsync_event_a, vsync_event_b in zip(vsync_events, vsync_events[1:]) : \\n frames_presented = len(self.event_intervals('postFramebuffer', \\n interval=vsync_event_a.interval))\\n # Below required to skip interval when we had nothing to do.\\n # As this event 'toggles' every VSYNC when SurfaceFlinger has work\\n # to do. If nothing is done (i.e. no 'postFramebuffer' events)\\n # there was jank in this interval.\\n if vsync_event_a.value != vsync_event_b.value and frames_presented:\\n total_frames += frames_presented\\n \\n present_time = self.present_duration(interval=interval)\\n return round(total_frames/present_time, 1) if present_time != 0.0 else float('nan')\",\n \"def calcFrameRate(self):\\n\\n tot = 0\\n count = 0\\n for session in self.sessions:\\n for sample in session.samples:\\n if not sample.isLoading:\\n tot += sample.fps\\n count += 1\\n if count:\\n self.avgFps = tot / count\\n self.lowFps = (self.avgFps < 10)\\n self.highFps = (self.avgFps > 25)\",\n \"def bspb_frameCounter():\\n curTime = int(pm.currentTime())\\n maxTime = int(pm.playbackOptions(q=True, maxTime=True))\\n return '{0} / {1}'.format(curTime, maxTime)\",\n \"def frame_duration(self):\\n return self.samples_per_frame / self.input_data_sample_rate\",\n \"def frame_rate():\\n def r(x):\\n return 6E7/x\\n\\n def w(x):\\n return int(6E7/x)\\n return r, w\",\n \"def get_fps(video, use_opencv=False):\\n\\n if use_opencv:\\n video_cap = cv2.VideoCapture(video)\\n fps = video_cap.get(cv2.CAP_PROP_FPS)\\n video_cap.release()\\n return fps\\n else:\\n return convert_to_float(\\n utils.exec_shell_command(f\\\"{SHELL_CMD_GET_FPS} '{video}'\\\", silent=True)[0]\\n )\",\n \"def GetGifFrames(self, path):\\n gif = imageio.mimread(path)\\n return [\\n (image.meta[\\\"duration\\\"], cv2.resize(\\n cv2.cvtColor(image, cv2.COLOR_RGB2BGR), (64, 64))\\n ) for image in gif\\n ]\",\n \"def get_duration(self):\\n frame_dur = self.get_frame_duration()\\n num_frames = self.get_num_frames()\\n motion_dur = frame_dur * (num_frames - 1)\\n return motion_dur\",\n \"def get_frame_duration(self):\\n return self._frame_duration\",\n \"def get_frame_time(self, f):\\n return f * self.get_frame_duration()\",\n \"def f2gif(path,fps):\\n print(\\\"==============================================\\\")\\n print(\\\"Convert file to GIF!\\\")\\n pathout = path[:-4]+'_'+str(fps)+'.gif'\\n if path.endswith('.tif'): \\n# import tifffile\\n im = tifffile.imread(path)\\n nFrames, h,w = im.shape\\n dur=1/fps\\n clip = []\\n for i in range(nFrames):\\n fr = cv2.cvtColor(im[i],cv2.COLOR_GRAY2RGB)\\n clip.append(mp.ImageClip(fr).set_duration(dur))\\n video = mp.concatenate_videoclips(clip, method=\\\"compose\\\",ismask=False)#ismask=True to make grayscale\\n\\n else:\\n video = mp.VideoFileClip(path)\\n fpsIn = int(video.fps)\\n if fps != fpsIn:\\n print(\\\"Conflict in fps! \\\\n\\\", \\\"[0] Use fps of input file;\\\\n\\\", \\\"[1] Use desired fps w/o speedup;\\\\n\\\",\\n \\\"[2] Use desired fps w/ speedup:\\\")\\n k = input('Input your selection: ')\\n if k == 2:\\n sf = fps/fpsIn\\n video =video.fx(mp.vfx.speedx, sf)# Not working when sf<1\\n elif k == 0:\\n fps = fpsIn\\n\\n video.write_gif(pathout,fps=fps)\\n video.reader.close()# To fix handel error problem\\n# if path.endswith('.gif'):\\n# clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\\n print(\\\"==============================================\\\")\\n print(\\\"MP4 convertion Done!\\\")\",\n \"def current_fps(self, fps: float):\\n self.current_fps_label.setText(\\\"FPS: {0:.2f}\\\".format(fps))\",\n \"def FramesPerBurstGap(self):\\n\\t\\treturn self._get_attribute('framesPerBurstGap')\",\n \"def next_frame(self):\\n # Tick will limit framerate and return delta in millis\\n delta = self.clock.tick(self.framerate)\\n\\n # Convert delta to seconds\\n delta /= 1000.0\\n\\n # Limit worst-case delta to make debugging easier\\n delta = min(delta, FrameTimer.MAX_FRAME_TIME)\\n\\n return delta\",\n \"def display_fps(self):\\n template = \\\"{} - FPS: {:.2f}\\\"\\n caption = template.format(prepare.CAPTION, self.clock.get_fps())\\n pg.display.set_caption(caption)\",\n \"def get_total_frames(self) -> int:\\n return self.num_frames\",\n \"def get_video_frame_rate(video_filename):\\n if not os.path.exists(video_filename):\\n raise ValueError(\\\"%s does not exist\\\" % video_filename)\\n \\n probe = ffmpeg.probe(video_filename)\\n assert len(probe['streams']) == 1\\n \\n # Seems to be two ways of coding, not sure which is better\\n avg_frame_rate = probe['streams'][0]['avg_frame_rate']\\n r_frame_rate = probe['streams'][0]['r_frame_rate']\\n assert avg_frame_rate == r_frame_rate\\n \\n # Convert fraction to number\\n num, den = avg_frame_rate.split('/')\\n frame_rate = float(num) / float(den)\\n \\n return frame_rate\",\n \"def read_fps(vid_name):\\n\\n video = cv2.VideoCapture(vid_name)\\n fps = video.get(cv2.CAP_PROP_FPS)\\n video.release()\\n\\n return fps\",\n \"def gifmp4converter(path,fpsOut):\\n# import moviepy.editor as mp\\n \\n print(\\\"=========================================\\\")\\n print(\\\"GIF-MP4 Converter Started!\\\")\\n\\n clip = mp.VideoFileClip(path)\\n #Get output fps\\n fpsIn = int(clip.fps)\\n fps=fpsOut\\n if fpsOut != fpsIn:\\n print(\\\"Conflict in fps! \\\\n\\\",\\n \\\"[0] Use fps of input file;\\\\n\\\",\\n \\\"[1] Use desired fps w/o speedup;\\\\n\\\",\\n \\\"[2] Use desired fps w/ speedup:\\\")\\n k = input('Input your selection: ')\\n if k == 2:\\n sf = fpsOut/fpsIn\\n fps = fpsOut \\n clip =clip.fx(mp.vfx.speedx, sf)\\n elif k == 0:\\n fps = fpsIn\\n \\n# Converting formats\\n if path.endswith('.gif'):\\n pathout = path[:-4]+'_cv'+'.mp4'\\n clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\\n elif path.endswith('.mp4'):\\n pathout = path[:-4]+'_cv'+'.gif'\\n clip.write_gif(pathout,fps=fps)\\n clip.reader.close()# To fix handel error problem\\n print(\\\"=========================================\\\")\\n print(\\\"GIF-MP4 Converter Done!\\\")\",\n \"def display_fps(self):\\n caption = \\\"{} - FPS: {:.2f}\\\".format(CAPTION, self.clock.get_fps())\\n pg.display.set_caption(caption)\",\n \"def display_fps(self):\\n caption = \\\"{} - FPS: {:.2f}\\\".format(CAPTION, self.clock.get_fps())\\n pg.display.set_caption(caption)\",\n \"def video_bitrate(self):\\n # type: () -> int\\n return self._video_bitrate\",\n \"def FrameCount(self):\\r\\n\\t\\treturn self._get_attribute('frameCount')\",\n \"def gif(self):\\n\\n if self._gif is None:\\n\\n url = self.url.replace('f=fits', 'f=gif')\\n\\n try:\\n url_data = urllib.request.urlopen(url)\\n except urllib.request.URLError as ee:\\n raise ValueError(f'cannot open URL for these parameters: {ee}')\\n\\n data = url_data.read()\\n\\n image = PIL.Image.open(io.BytesIO(data))\\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\\n\\n self._gif = image\\n\\n return self._gif\",\n \"def fps(x, y, i):\\n\\n # Special case for the edges.\\n if i < 2:\\n return (y[i+1] - y[i]) / (x[i+1] - x[i])\\n elif i > len(x) - 3:\\n return (y[i] - y[i-1]) / (x[i] - x[i-1])\\n\\n else:\\n h = x[i] - x[i-1]\\n f0 = y[i]\\n f1 = y[i+1]\\n f2 = y[i+2]\\n f3 = y[i-1]\\n f4 = y[i-2]\\n return (-f2 + 8*f1 - 8*f3 + f4) / (12 * h)\",\n \"def get_frame_time(self):\\n return self.get_timings().frame_time\",\n \"def unit_of_measurement(self) -> str:\\n return FPS\",\n \"def unit_of_measurement(self) -> str:\\n return FPS\",\n \"def Framesize(self):\\n\\t\\treturn self._get_attribute('framesize')\",\n \"def get_frame_rate(filename):\\n cmd = ('ffprobe -v 0 -of flat=s=_ -select_streams v:0 -show_entries '\\n 'stream=avg_frame_rate -of default=nokey=1:noprint_wrappers=1 ' +\\n filename).split()\\n pid = subprocess.run(cmd, stdout=subprocess.PIPE,\\n universal_newlines=True)\\n if pid.returncode != 0:\\n return None\\n\\n frame_rate_exp = pid.stdout.rstrip()\\n try:\\n frame_rate = float(frame_rate_exp)\\n except:\\n if frame_rate_exp == 'N/A':\\n frame_rate = 0.\\n else:\\n numerator, denominator = map(float, frame_rate_exp.split('/'))\\n if denominator == 0:\\n frame_rate = 0\\n else:\\n frame_rate = numerator / denominator\\n return frame_rate\",\n \"def video_bitrate(self):\\n assert self.has_video\\n\\n return self.__video_bitrate\",\n \"def frameTimes(self):\\n sr = self.sampleRate\\n offset = self.activeOffset\\n stride = self.activeStride\\n nf = self.numFrames\\n t = np.arange(nf) * (stride[0] / sr) + (offset / sr)\\n return t\",\n \"def getGpuFanSpeed(self):\\n gpufan = 0\\n gpufan = int(str(nvmlDeviceGetFanSpeed(self.handle)))\\n return gpufan\",\n \"def clock_speed(self):\\n return self._clock_speed\",\n \"def _draw_fps_counter(self, fps: float):\\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\\n\\n dpg.draw_rectangle(\\n parent=draw_layer_tag,\\n pmin=(0, 0),\\n pmax=(128, 32),\\n fill=(0, 0, 0, 128),\\n color=(0, 0, 0, 128)\\n )\\n\\n dpg.draw_text(\\n parent=draw_layer_tag,\\n text=f'FPS: {fps}',\\n pos=(_PADDING*2, _PADDING),\\n color=(255, 255, 255, 255),\\n size=_FONT_SIZE\\n )\",\n \"def get_maya_framerate():\\n current_unit = pm.currentUnit(time=True, query=True)\\n if current_unit == 'game':\\n framerate = 15.\\n elif current_unit == 'film':\\n framerate = 24.\\n elif current_unit == 'pal':\\n framerate = 25.\\n elif current_unit == 'ntsc':\\n framerate = 30.\\n elif current_unit == 'show':\\n framerate = 48.\\n elif current_unit == 'palf':\\n framerate = 50.\\n elif current_unit == 'ntscf':\\n framerate = 60.\\n elif 'fps' in current_unit:\\n \\tframerate = float(current_unit.split('fps')[0])\\n else:\\n pm.currentUnit(time='film')\\n framerate = 24.\\n\\n return framerate\",\n \"def set_fps(self, fps=25):\\n raise NotImplementedError(\\\"set_fps is not implemented\\\")\",\n \"def frame_size(self):\\n return self._frame_size\",\n \"def frame_length(self):\\r\\n return self.config.frame_length\",\n \"def get_fps_from_sketch(sketch_file_path):\\n fps = -1\\n # get fps\\n with open(sketch_file_path) as json_file:\\n data = json.load(json_file)\\n fps = float(data[\\\"fps\\\"])\\n return fps\",\n \"def changeFps(self):\\n check = re.search(\\\"[1-9][0-9]*\\\", self.ui.t_fps.text())\\n if check:\\n num = check.group()\\n fps = int(num)\\n if fps > self.fps_limit:\\n logging.warning(\\n \\\"Too big number for fps. Falling back to {0} fps.\\\".format(\\n self.fps_limit\\n )\\n )\\n fps = self.fps_limit\\n self.fps = fps\\n self.ui.t_fps.setText(str(fps))\\n else:\\n logging.info(\\\"Wrong Input For Fps\\\")\\n self.ui.t_fps.setText(\\\"30\\\")\\n self.fps = 30\",\n \"def convert_gif(path: str,\\n gif_name: str = 'gif_name.gif',\\n frame_limit: int = 100):\\n video_path = glob(path + \\\"/*.mp4\\\")[-1]\\n vidcap = cv2.VideoCapture(video_path)\\n success, frame = vidcap.read()\\n count = 0\\n\\n # extracting and saving video frames.\\n while success:\\n cv2.imwrite(f\\\"{path}/frame{count}.png\\\", frame) \\n success, frame = vidcap.read()\\n count += 1\\n if count > frame_limit:\\n break\\n print(\\\"total frames:\\\", count)\\n\\n # generate animated GIF.\\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\\\"/*.png\\\"))]\\n img.save(fp=f\\\"{path}/{gif_name}\\\", format='GIF', append_images=imgs,\\n save_all=True, duration=200, loop=0)\\n \\n # remove frames\\n [os.remove(os.path.join(path, f)) for f in glob(path+\\\"/*.png\\\")]\",\n \"def FrameRate(self):\\n from ixnetwork_restpy.testplatform.sessions.ixnetwork.traffic.trafficitem.configelement.framerate.framerate import FrameRate\\n return FrameRate(self)._select()\",\n \"def get_frame_size(self) -> Tuple[int, int]:\\n return self.__sim.frame_size()\",\n \"def get_fan_speed(self):\\n return self.__fan_speed\",\n \"def get_score(fps: float, ssim: float,\\n ssim_max: float = 30.,\\n rate: float = 10.) -> float:\\n fps = np.round(fps, 1)\\n ssim = np.round(ssim, 3)\\n return 0.1 * np.log(fps) / np.log(rate) + min(ssim, ssim_max)\",\n \"def state(self) -> int | None:\\n\\n if self.coordinator.data:\\n data = self.coordinator.data.get(self._cam_name, {}).get(\\n f\\\"{self._fps_type}_fps\\\"\\n )\\n if data is not None:\\n try:\\n return round(float(data))\\n except ValueError:\\n pass\\n return None\",\n \"def get_pixel_rate(self):\\n return lib.is_PixelClock_dt(self.hcam,5,ctypes.c_uint).value*1E6\",\n \"def video_duration(self):\\n # type: () -> int\\n return self._video_duration\",\n \"def state(self) -> int | None:\\n if self.coordinator.data:\\n data = self.coordinator.data.get(\\\"detection_fps\\\")\\n if data is not None:\\n try:\\n return round(float(data))\\n except ValueError:\\n pass\\n return None\",\n \"def get(self, flag: int):\\n if flag == cv2.CAP_PROP_FRAME_COUNT:\\n return self.length\",\n \"def name(self) -> str:\\n return f\\\"{self._fps_type} fps\\\"\",\n \"def get_max_frames(self):\\n return 8\",\n \"def get_fade_fract(self):\\n\\n FADE_TIME = 2.0 # Adjust this to change fade-in and fade-out times in seconds\\n\\n if self.show_runtime < FADE_TIME:\\n fract = self.show_runtime / FADE_TIME\\n elif self.show_runtime > self.max_show_time - FADE_TIME:\\n fract = (self.max_show_time - self.show_runtime) / FADE_TIME\\n else:\\n fract = 1\\n\\n return fract\",\n \"def output_statistics(self, run_time):\\n fps = self.received_frames / run_time\\n MBps_per_frame = self.full_frame_length() / 1000.0 / 1000.0\\n print '\\\\nRun time: %.2f seconds' % (run_time,)\\n print 'Received frames: ', self.received_frames\\n print 'Avg. frame rate: %s fps' % (fps,)\\n print 'Avg. Bit rate: %.2f MB/s' % (MBps_per_frame * fps,)\",\n \"def update_frame(self):\\r\\n while not self.stopped:\\r\\n if not self.grabbed or not self.cap.isOpened():\\r\\n self.stop()\\r\\n else:\\r\\n self.grabbed, self.frame = self.cap.read()\\r\\n try:\\r\\n if self.grabbed:\\r\\n #self.New_Frame_Time = time.time()\\r\\n #self.FPS = 1/(self.New_Frame_Time-self.Old_Frame_Time)\\r\\n #self.Old_Frame_Time = self.New_Frame_Time\\r\\n self.FrameCount += 1\\r\\n else:\\r\\n print(f'Grabbed status is: {self.grabbed}')\\r\\n #self.Old_Frame_Time = time.time()\\r\\n except ZeroDivisionError:\\r\\n print(\\\"Division by zero error when finding video feed fps\\\")\\r\\n self.FPS = 0\\r\\n self.Old_Frame_Time = time.time()\",\n \"def update_fps(self, fps):\\n self.fps_history.append(fps)\\n if len(self.fps_history) > FPS_AVERAGES:\\n self.fps_history.pop(0)\\n\\n self.fps_estimate = np.mean(self.fps_history)\\n return self.fps_estimate\",\n \"def get_samplerate(self):\\n\\t\\treturn _PM_UPDATE_RATE / self.output_decimation\",\n \"def frame_size(self) -> tuple[int, int]:\\n return (int(self.get(cv.CAP_PROP_FRAME_HEIGHT)),\\n int(self.get(cv.CAP_PROP_FRAME_WIDTH)))\",\n \"def speed(self) -> float:\\n return self._speed\",\n \"def speed(self) -> float:\\n return self._speed\",\n \"def get_video_property(video_path):\\n\\tvideocap = cv2.VideoCapture(video_path)\\n\\tframe_count = videocap.get(cv2.CAP_PROP_FRAME_COUNT)\\n\\tfps = videocap.get(cv2.CAP_PROP_FPS)\\n\\theight = videocap.get(cv2.CAP_PROP_FRAME_HEIGHT)\\n\\twidth = videocap.get(cv2.CAP_PROP_FRAME_WIDTH)\\n\\treturn frame_count, fps, width, height\",\n \"def display_frames_as_gif(frames, video_name):\\n Writer = animation.writers['ffmpeg']\\n writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)\\n #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\\n patch = plt.imshow(frames[0])\\n plt.axis('off')\\n\\n def animate(i):\\n patch.set_data(frames[i])\\n\\n anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\\n# display(display_animation(anim, default_mode='loop'))\\n anim.save(result_floder + '/' + video_name, writer=writer)\",\n \"def _get_duration(self):\\n try:\\n dur = self.im.info[\\\"duration\\\"] / 1000.0\\n except KeyError:\\n dur = DEFAULT_DURATION / 1000.0 \\n\\n return dur\",\n \"def num_frames(self):\\n return len(self.video)\",\n \"def get_frac_secs(self):\\n return _uhd_swig.time_spec_t_get_frac_secs(self)\",\n \"def get_speed(self):\\n return self._speed\",\n \"def speed(self) -> int:\\n return self._speed\",\n \"def speed(self) -> int:\\n return self._speed\",\n \"def update_fps(self):\\n self.fps.tick()\\n\\n\\trange_str = \\\"\\\"\\n gd = self.main_curve_dialog.curve.get_data()[1]\\n\\trange_str = \\\"Max: %s, Min: %s, Avg: %0.5s \\\" \\\\\\n\\t\\t % (numpy.max(gd), numpy.min(gd), numpy.average(gd))\\n\\n\\n fps_text = \\\"%s Update: %s FPS\\\" % (range_str, self.fps.rate())\\n self.action_fps_display.setText(fps_text)\",\n \"def bspb_focalLength():\\n shotCam = pm.PyNode('shot_cam').getShape()\\n return str(shotCam.focalLength.get())\",\n \"def bitrate(self) -> float:\\n msb = self._read_u8(_REG_BITRATE_MSB)\\n lsb = self._read_u8(_REG_BITRATE_LSB)\\n return _FXOSC / ((msb << 8) | lsb)\",\n \"def full_frame_length(self):\\n return self.height * self.width * 3\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7494257","0.7355209","0.7317423","0.71695226","0.70986986","0.7062496","0.70086706","0.69287163","0.69171","0.68915033","0.68721455","0.6822134","0.6741372","0.6735853","0.67118305","0.6672671","0.662301","0.662301","0.6597375","0.6547688","0.64681935","0.6302498","0.628251","0.6219211","0.62094754","0.61327344","0.61198455","0.603681","0.600487","0.59904194","0.59629554","0.5935979","0.5921172","0.5841836","0.5824257","0.5723118","0.5682734","0.5660501","0.56435156","0.5634958","0.5592754","0.557203","0.55717576","0.5555584","0.5547521","0.55169374","0.5506455","0.5506455","0.55021954","0.55019647","0.5489853","0.5476645","0.5467858","0.5454981","0.5454981","0.5450096","0.5442697","0.54382217","0.54099363","0.5393611","0.5387077","0.53666335","0.53448254","0.5325609","0.532196","0.53135544","0.5313474","0.53074896","0.5304358","0.5296702","0.5288054","0.5280073","0.52721584","0.5268454","0.5267673","0.52574265","0.5256644","0.5249135","0.52447855","0.52368563","0.5225918","0.5220913","0.5176418","0.5158698","0.5111525","0.5103031","0.5089194","0.5089194","0.5088523","0.50848114","0.5080241","0.50791043","0.5057466","0.50529057","0.5028102","0.5028102","0.5026278","0.50170344","0.5004307","0.4999289"],"string":"[\n \"0.7494257\",\n \"0.7355209\",\n \"0.7317423\",\n \"0.71695226\",\n \"0.70986986\",\n \"0.7062496\",\n \"0.70086706\",\n \"0.69287163\",\n \"0.69171\",\n \"0.68915033\",\n \"0.68721455\",\n \"0.6822134\",\n \"0.6741372\",\n \"0.6735853\",\n \"0.67118305\",\n \"0.6672671\",\n \"0.662301\",\n \"0.662301\",\n \"0.6597375\",\n \"0.6547688\",\n \"0.64681935\",\n \"0.6302498\",\n \"0.628251\",\n \"0.6219211\",\n \"0.62094754\",\n \"0.61327344\",\n \"0.61198455\",\n \"0.603681\",\n \"0.600487\",\n \"0.59904194\",\n \"0.59629554\",\n \"0.5935979\",\n \"0.5921172\",\n \"0.5841836\",\n \"0.5824257\",\n \"0.5723118\",\n \"0.5682734\",\n \"0.5660501\",\n \"0.56435156\",\n \"0.5634958\",\n \"0.5592754\",\n \"0.557203\",\n \"0.55717576\",\n \"0.5555584\",\n \"0.5547521\",\n \"0.55169374\",\n \"0.5506455\",\n \"0.5506455\",\n \"0.55021954\",\n \"0.55019647\",\n \"0.5489853\",\n \"0.5476645\",\n \"0.5467858\",\n \"0.5454981\",\n \"0.5454981\",\n \"0.5450096\",\n \"0.5442697\",\n \"0.54382217\",\n \"0.54099363\",\n \"0.5393611\",\n \"0.5387077\",\n \"0.53666335\",\n \"0.53448254\",\n \"0.5325609\",\n \"0.532196\",\n \"0.53135544\",\n \"0.5313474\",\n \"0.53074896\",\n \"0.5304358\",\n \"0.5296702\",\n \"0.5288054\",\n \"0.5280073\",\n \"0.52721584\",\n \"0.5268454\",\n \"0.5267673\",\n \"0.52574265\",\n \"0.5256644\",\n \"0.5249135\",\n \"0.52447855\",\n \"0.52368563\",\n \"0.5225918\",\n \"0.5220913\",\n \"0.5176418\",\n \"0.5158698\",\n \"0.5111525\",\n \"0.5103031\",\n \"0.5089194\",\n \"0.5089194\",\n \"0.5088523\",\n \"0.50848114\",\n \"0.5080241\",\n \"0.50791043\",\n \"0.5057466\",\n \"0.50529057\",\n \"0.5028102\",\n \"0.5028102\",\n \"0.5026278\",\n \"0.50170344\",\n \"0.5004307\",\n \"0.4999289\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8816731"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76571,"cells":{"query":{"kind":"string","value":"Sets the gif_fps of this GIFOutput. The frame rate of the GIF. Default is the Video frame rate"},"document":{"kind":"string","value":"def gif_fps(self, gif_fps):\n if gif_fps is not None and gif_fps > 30:\n raise ValueError(\"Invalid value for `gif_fps`, must be a value less than or equal to `30`\")\n\n self._gif_fps = gif_fps"},"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 gif_fps(self):\n return self._gif_fps","def set_fps(self, fps=25):\n raise NotImplementedError(\"set_fps is not implemented\")","def set_framerate(self, framerate):\n self._framerate = int(framerate)","def set_fps(self, fps=25):\n # self._root.knob('fps').setValue(fps)\n pass","def f2gif(path,fps):\n print(\"==============================================\")\n print(\"Convert file to GIF!\")\n pathout = path[:-4]+'_'+str(fps)+'.gif'\n if path.endswith('.tif'): \n# import tifffile\n im = tifffile.imread(path)\n nFrames, h,w = im.shape\n dur=1/fps\n clip = []\n for i in range(nFrames):\n fr = cv2.cvtColor(im[i],cv2.COLOR_GRAY2RGB)\n clip.append(mp.ImageClip(fr).set_duration(dur))\n video = mp.concatenate_videoclips(clip, method=\"compose\",ismask=False)#ismask=True to make grayscale\n\n else:\n video = mp.VideoFileClip(path)\n fpsIn = int(video.fps)\n if fps != fpsIn:\n print(\"Conflict in fps! \\n\", \"[0] Use fps of input file;\\n\", \"[1] Use desired fps w/o speedup;\\n\",\n \"[2] Use desired fps w/ speedup:\")\n k = input('Input your selection: ')\n if k == 2:\n sf = fps/fpsIn\n video =video.fx(mp.vfx.speedx, sf)# Not working when sf<1\n elif k == 0:\n fps = fpsIn\n\n video.write_gif(pathout,fps=fps)\n video.reader.close()# To fix handel error problem\n# if path.endswith('.gif'):\n# clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\n print(\"==============================================\")\n print(\"MP4 convertion Done!\")","def changeFps(self):\n check = re.search(\"[1-9][0-9]*\", self.ui.t_fps.text())\n if check:\n num = check.group()\n fps = int(num)\n if fps > self.fps_limit:\n logging.warning(\n \"Too big number for fps. Falling back to {0} fps.\".format(\n self.fps_limit\n )\n )\n fps = self.fps_limit\n self.fps = fps\n self.ui.t_fps.setText(str(fps))\n else:\n logging.info(\"Wrong Input For Fps\")\n self.ui.t_fps.setText(\"30\")\n self.fps = 30","def gifmp4converter(path,fpsOut):\n# import moviepy.editor as mp\n \n print(\"=========================================\")\n print(\"GIF-MP4 Converter Started!\")\n\n clip = mp.VideoFileClip(path)\n #Get output fps\n fpsIn = int(clip.fps)\n fps=fpsOut\n if fpsOut != fpsIn:\n print(\"Conflict in fps! \\n\",\n \"[0] Use fps of input file;\\n\",\n \"[1] Use desired fps w/o speedup;\\n\",\n \"[2] Use desired fps w/ speedup:\")\n k = input('Input your selection: ')\n if k == 2:\n sf = fpsOut/fpsIn\n fps = fpsOut \n clip =clip.fx(mp.vfx.speedx, sf)\n elif k == 0:\n fps = fpsIn\n \n# Converting formats\n if path.endswith('.gif'):\n pathout = path[:-4]+'_cv'+'.mp4'\n clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\n elif path.endswith('.mp4'):\n pathout = path[:-4]+'_cv'+'.gif'\n clip.write_gif(pathout,fps=fps)\n clip.reader.close()# To fix handel error problem\n print(\"=========================================\")\n print(\"GIF-MP4 Converter Done!\")","def current_fps(self, fps: float):\n self.current_fps_label.setText(\"FPS: {0:.2f}\".format(fps))","def framerate(self):\n return self.config.get('framerate', 15)","def display_fps(self):\n caption = \"{} - FPS: {:.2f}\".format(CAPTION, self.clock.get_fps())\n pg.display.set_caption(caption)","def display_fps(self):\n caption = \"{} - FPS: {:.2f}\".format(CAPTION, self.clock.get_fps())\n pg.display.set_caption(caption)","def get_frame_rate(gif=''):\n\n # identify -format \"Frame %s: %Tcs\\n\" ~/test.gif - frame life in centiseconds - how very odd.\n frame_rate_str = subprocess.check_output([\n 'identify',\n '-format',\n '%T\\n',\n gif\n ])\n # If we failed to get a frame lifetime from imagemagick...\n if len(frame_rate_str) <= 0:\n frame_rate = str(FRAME_RATE)\n else:\n # Get gif's lifetime...\n frame_rate_list = frame_rate_str.split('\\n')\n frame_rate_list = [int(n) for n in frame_rate_list if n]\n lifetime = float(sum(frame_rate_list)) / 100\n\n # print \"gif lifetime is \" + str(lifetime) + \"s\"\n # Determine average frames per second\n frame_rate = str(len(frame_rate_list) / lifetime)\n if float(frame_rate) <= 0.0:\n frame_rate = FRAME_RATE\n\n return frame_rate","def display_fps(self):\n template = \"{} - FPS: {:.2f}\"\n caption = template.format(prepare.CAPTION, self.clock.get_fps())\n pg.display.set_caption(caption)","def convert_gif(path: str,\n gif_name: str = 'gif_name.gif',\n frame_limit: int = 100):\n video_path = glob(path + \"/*.mp4\")[-1]\n vidcap = cv2.VideoCapture(video_path)\n success, frame = vidcap.read()\n count = 0\n\n # extracting and saving video frames.\n while success:\n cv2.imwrite(f\"{path}/frame{count}.png\", frame) \n success, frame = vidcap.read()\n count += 1\n if count > frame_limit:\n break\n print(\"total frames:\", count)\n\n # generate animated GIF.\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\"/*.png\"))]\n img.save(fp=f\"{path}/{gif_name}\", format='GIF', append_images=imgs,\n save_all=True, duration=200, loop=0)\n \n # remove frames\n [os.remove(os.path.join(path, f)) for f in glob(path+\"/*.png\")]","def display_frames_as_gif(frames, video_name):\n Writer = animation.writers['ffmpeg']\n writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)\n #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\n patch = plt.imshow(frames[0])\n plt.axis('off')\n\n def animate(i):\n patch.set_data(frames[i])\n\n anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\n# display(display_animation(anim, default_mode='loop'))\n anim.save(result_floder + '/' + video_name, writer=writer)","def get_fps(self):\n raise NotImplementedError(\"get_fps is not implemented\")","def calculate_fps(self):\n time_difference = self.time_array[-1] - self.time_array[0]\n time_difference_in_seconds = time_difference.to_sec()\n if time_difference_in_seconds == 0:\n pass\n self.fps = self.buffer_size / time_difference_in_seconds\n rospy.loginfo(\"[EulerianMotionMagnification] Estimated FPS: \" + str(self.fps) + \" (Measured timespan: \" + str(time_difference_in_seconds) + \"s)\")\n rospy.loginfo(\"[EulerianMotionMagnification] Video array length: \" + str(len(self.video_array)))","def gif(self, delay=20, savefile=None, iterations=0, show_path=False,\n use_ffmpeg=False):\n from sage.misc.sage_ostools import have_program\n have_convert = have_program('convert')\n have_ffmpeg = self._have_ffmpeg()\n if use_ffmpeg or not have_convert:\n if have_ffmpeg:\n self.ffmpeg(savefile=savefile, show_path=show_path,\n output_format='.gif', delay=delay,\n iterations=iterations)\n else:\n if not have_convert:\n msg = \"\"\"\nError: Neither ImageMagick nor ffmpeg appears to be installed. Saving an\nanimation to a GIF file or displaying an animation requires one of these\npackages, so please install one of them and try again.\n\nSee www.imagemagick.org and www.ffmpeg.org for more information.\"\"\"\n else:\n msg = \"\"\"\nError: ffmpeg does not appear to be installed. Download it from\nwww.ffmpeg.org, or use 'convert' to produce gifs instead.\"\"\"\n raise OSError(msg)\n else:\n if not savefile:\n savefile = graphics_filename(ext='.gif')\n if not savefile.endswith('.gif'):\n savefile += '.gif'\n savefile = os.path.abspath(savefile)\n d = self.png()\n cmd = ( 'cd \"%s\"; sage-native-execute convert -dispose Background '\n '-delay %s -loop %s *.png \"%s\"' ) % ( d, int(delay),\n int(iterations), savefile )\n from subprocess import check_call, CalledProcessError\n try:\n check_call(cmd, shell=True)\n if show_path:\n print(\"Animation saved to file %s.\" % savefile)\n except (CalledProcessError, OSError):\n msg = \"\"\"\nError: Cannot generate GIF animation. Verify that convert\n(ImageMagick) or ffmpeg is installed, and that the objects passed to\nthe animate command can be saved in PNG image format.\n\nSee www.imagemagick.org and www.ffmpeg.org for more information.\"\"\"\n raise OSError(msg)","def get_fps(self):\n return self.fps","def get_fps(self):\n if len(self.times) >= 2:\n dif = np.diff(self.times)\n fps = 1. / dif.min()\n # if the FPS crosses 500, do not update it\n if fps <= 500:\n self.fps = fps\n return self.fps\n else:\n return 0.","def get_fps(self):\n return self._num_frames / (datetime.now() - self._start).total_seconds()","def AnimFromPng(name, gif=True, fps=15):\n if(gif):\n imgconvert = \"convert \" + \"-delay \" + str(int(1000/fps))\n imgconvert += \" -dispose None \" + name + \"*.png -loop 0 \" + name + \".gif\"\n system(imgconvert)\n print imgconvert\n else:\n aviconvert = \"ffmpeg -i \" + name + \"%03d.png -b:v 2048k -r \" + str(fps) + \" \" + name + \".avi\"\n system(aviconvert)\n print aviconvert","def get_framerate(self):\n return self._framerate","def limit_fps(fps):\n global _last_update\n elapsed = time.time() - _last_update\n if elapsed < 1 / fps:\n time.sleep(1 / fps - elapsed)\n _last_update = time.time()","def gif(self):\n\n if self._gif is None:\n\n url = self.url.replace('f=fits', 'f=gif')\n\n try:\n url_data = urllib.request.urlopen(url)\n except urllib.request.URLError as ee:\n raise ValueError(f'cannot open URL for these parameters: {ee}')\n\n data = url_data.read()\n\n image = PIL.Image.open(io.BytesIO(data))\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\n\n self._gif = image\n\n return self._gif","def get_fps(self):\n # Take difference.\n interframe_intervals = np.diff(self.data[\"t\"])\n\n # Inter-frame interval in milliseconds.\n mean_interval = np.mean(interframe_intervals)\n fps = round(1 / (mean_interval / 1000))\n\n return int(fps)","def set_animation_speed(self, speed):\n self.m_animation_speed = self.calculate_animation_speed(speed)","def get_fps(self):\n #return int(self._root.knob('fps').getValue())\n return None","def get_fps(clock):\n if video_mode:\n return \"30\" # Video FPS will be 30\n else:\n return str(int(round(clock.get_fps(), 0)))","def set_gripper_speed(self, speed):\n if self._gripper:\n self._gripper.set_velocity(speed)","def update_fps(self):\n self.fps.tick()\n\n\trange_str = \"\"\n gd = self.main_curve_dialog.curve.get_data()[1]\n\trange_str = \"Max: %s, Min: %s, Avg: %0.5s \" \\\n\t\t % (numpy.max(gd), numpy.min(gd), numpy.average(gd))\n\n\n fps_text = \"%s Update: %s FPS\" % (range_str, self.fps.rate())\n self.action_fps_display.setText(fps_text)","def show_fps(self, screen):\n fps = self.clock.get_fps()\n self.pgtext.display_text(\"FPS: {0:.2f}\".format(fps), screen, 600, 10)","def GetGifFrames(self, path):\n gif = imageio.mimread(path)\n return [\n (image.meta[\"duration\"], cv2.resize(\n cv2.cvtColor(image, cv2.COLOR_RGB2BGR), (64, 64))\n ) for image in gif\n ]","def set_speed(self, ratio):\n self._speed = ratio","def ffmpeg(self, savefile=None, show_path=False, output_format=None,\n ffmpeg_options='', delay=None, iterations=0, pix_fmt='rgb24'):\n if not self._have_ffmpeg():\n msg = \"\"\"Error: ffmpeg does not appear to be installed. Saving an animation to\na movie file in any format other than GIF requires this software, so\nplease install it and try again.\"\"\"\n raise OSError(msg)\n else:\n if savefile is None:\n if output_format is None:\n output_format = '.mpg'\n else:\n if output_format[0] != '.':\n output_format = '.'+output_format\n savefile = graphics_filename(ext=output_format)\n else:\n if output_format is None:\n suffix = os.path.splitext(savefile)[1]\n if len(suffix) > 0:\n output_format = suffix\n else:\n output_format = '.mpg'\n if not savefile.endswith(output_format):\n savefile += output_format\n early_options = ''\n if output_format == '.gif':\n # We try to set reasonable options for gif output.\n #\n # Older versions of ffmpeg (before 0.9, summer 2011)\n # use the option -loop_output instead of -loop.\n # Setting iterations=None is a way of preventing sage\n # from adding the -loop option. A separate\n # -loop_output option can be added with the\n # ffmpeg_options argument.\n if iterations is not None:\n loop_cmd = '-loop {0} '.format(iterations)\n else:\n loop_cmd = ''\n # A pix_fmt value is required for some but not all\n # ffmpeg installations. Setting pix_fmt=None will\n # prevent sage from adding this option, and it may be\n # controlled separately through ffmpeg_options.\n if pix_fmt is not None:\n pix_fmt_cmd = '-pix_fmt {0} '.format(pix_fmt)\n else:\n pix_fmt_cmd = ''\n ffmpeg_options += ' {0}{1}'.format(pix_fmt_cmd,loop_cmd)\n if delay is not None and output_format != '.mpeg' and output_format != '.mpg':\n early_options += ' -r %s ' % int(100/delay)\n savefile = os.path.abspath(savefile)\n pngdir = self.png()\n pngs = os.path.join(pngdir, \"%08d.png\")\n # For ffmpeg, it seems that some options, like '-g ... -r\n # ...', need to come before the input file names, while\n # some options, like '-pix_fmt rgb24', need to come\n # afterwards. Hence 'early_options' and 'ffmpeg_options'\n cmd = 'cd \"%s\"; sage-native-execute ffmpeg -y -f image2 %s -i %s %s %s' % (pngdir, early_options, pngs, ffmpeg_options, savefile)\n from subprocess import check_call, CalledProcessError, PIPE\n try:\n if sage.misc.misc.get_verbose() > 0:\n set_stderr = None\n else:\n set_stderr = PIPE\n sage.misc.misc.verbose(\"Executing '%s'\" % cmd,level=1)\n sage.misc.misc.verbose(\"\\n---- ffmpeg output below ----\\n\")\n check_call(cmd, shell=True, stderr=set_stderr)\n if show_path:\n print(\"Animation saved to file %s.\" % savefile)\n except (CalledProcessError, OSError):\n print(\"Error running ffmpeg.\")\n raise","def animated_gif(folder_with_images, gif_filename, loop_duration, size):\r\n\r\n\tos.chdir(folder_with_images) # changes directory to the folder with the images\r\n\r\n\tpng_files = []\r\n\r\n\t# get list of png files in folder\r\n\tfor fn in os.listdir(folder_with_images):\r\n\t\tif fn.endswith('.png'):\r\n\t\t\tpng_files.append(fn)\r\n\r\n\tsort_nicely(png_files)\r\n\r\n\tprint(png_files)\r\n\r\n\t# number of png_files\r\n\tnum_pngs = len(png_files)\r\n\tpng_time = float(loop_duration)/ float(num_pngs)\r\n\r\n\timages = [Image.open(fn) for fn in png_files]\r\n\tdim = (size, size) # change sizes for the image file dimension\r\n\t#for im in images:\r\n\t#\tim.thumbnail(dim, Image.ANTIALIAS)\r\n\r\n\toutput_file = os.path.join(folder_with_images, gif_filename) # path for output file\r\n\twriteGif(output_file, images, png_time) # writes out GIF\r","def gif_loop(self, gif_loop):\n if gif_loop is not None and gif_loop < -1:\n raise ValueError(\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\")\n\n self._gif_loop = gif_loop","def max_fps(self):\n return self._max_fps","def setframerate(trafficItemName, frameRate):\n queryData = {'from': '/traffic',\n 'nodes': [{'node': 'trafficItem', 'properties': ['name'], 'where': [{'property': 'name', 'regex': trafficItemName}]},\n {'node': 'configElement', 'properties': [], 'where': []}]}\n queryResponse = middleware.ixn.query(data=queryData)\n if queryResponse.json()['result'][0]['trafficItem'] == []:\n print('\\nNo such Traffic Item name found: %s' % trafficItemName)\n return\n configElementObj = queryResponse.json()['result'][0]['trafficItem'][0]['configElement'][0]['href']\n middleware.trafficObj.configTrafficItem(mode='modify', obj=configElementObj, configElements={'frameRate': frameRate})","def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\n\n self._gif_fps = None\n self._color_depth = None\n self._gif_loop = None\n self._height = None\n self._start = None\n self._duration = None\n self._suffix = None\n self._overlay = None\n self._overlay_alignment = None\n self._overlay_scale = None\n self._label = None\n self.discriminator = None\n\n if gif_fps is not None:\n self.gif_fps = gif_fps\n if color_depth is not None:\n self.color_depth = color_depth\n if gif_loop is not None:\n self.gif_loop = gif_loop\n self.height = height\n self.start = start\n if duration is not None:\n self.duration = duration\n if suffix is not None:\n self.suffix = suffix\n if overlay is not None:\n self.overlay = overlay\n if overlay_alignment is not None:\n self.overlay_alignment = overlay_alignment\n if overlay_scale is not None:\n self.overlay_scale = overlay_scale\n if label is not None:\n self.label = label","def interfacespeed(self, interfacespeed):\n\n self._interfacespeed = interfacespeed","def frame_rate(self):\n return self._frame_rate","def setValues(\n self,\n frameRate: int = None,\n timeScale: int = None,\n vpDecorations: Boolean = ON,\n vpBackground: Boolean = OFF,\n compass: Boolean = OFF,\n ):\n pass","def calcFrameRate(self):\n\n tot = 0\n count = 0\n for session in self.sessions:\n for sample in session.samples:\n if not sample.isLoading:\n tot += sample.fps\n count += 1\n if count:\n self.avgFps = tot / count\n self.lowFps = (self.avgFps < 10)\n self.highFps = (self.avgFps > 25)","def get_fps(self):\n \n return self.fps, self.average_fps","def _draw_fps_counter(self, fps: float):\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\n\n dpg.draw_rectangle(\n parent=draw_layer_tag,\n pmin=(0, 0),\n pmax=(128, 32),\n fill=(0, 0, 0, 128),\n color=(0, 0, 0, 128)\n )\n\n dpg.draw_text(\n parent=draw_layer_tag,\n text=f'FPS: {fps}',\n pos=(_PADDING*2, _PADDING),\n color=(255, 255, 255, 255),\n size=_FONT_SIZE\n )","def get_fps(self):\n if not self.count_fps:\n logging.error(\"No FPSCounter set\")\n return None\n return self.fps.get_fps()","def get_fps(self):\n if not self.count_fps:\n logging.error(\"No FPSCounter set\")\n return None\n return self.fps.get_fps()","def write_frames_to_gif(fname: str, frames, duration: int, progress=False):\n\n channels = frames[0].shape[0]\n # Convert to PIL\n pil_images = []\n if progress:\n frames = track(frames, \"Converting Frames\")\n for f in frames:\n pim = Image.fromarray((f*255).astype(np.uint8))\n if channels == 4:\n pim.info['transparency'] = 255\n #pim = pim.convert(\"P\")\n pil_images.append(pim)\n\n # Write GIF, show status spinner with rich\n if progress:\n console = Console()\n with console.status(f\"Writing GIF to {fname}\") as status:\n # loop=0 means the gif just repeats forever, which is what I think everyone probably expects\n pil_images[0].save(fname, save_all=True, append_images=pil_images[1:], loop=0, duration=duration)\n else:\n pil_images[0].save(fname, save_all=True, append_images=pil_images[1:], loop=0, duration=duration)","def get_video_fps(self):\n fps = self.video.get(cv2.CAP_PROP_FPS)\n logging.info('Video FPS: {}'.format(fps))\n return fps","def tick(self, fps):\n self._clock.tick(fps)","def _set_foscam_mjpeg(self, **kwargs):\n self.foscam_mjpeg = kwargs.get(\"value\")\n self.parent.logger.info(\"CameraServer: Foscam Polling set to %s\" % (self.foscam_mjpeg))\n self.set_driver('GV3', self.foscam_mjpeg, uom=25, report=True)\n return True","def get_fps(self):\n return self._document.GetFps()","def make_gif(im_dir, out_file, pattern='*.png', fps=10):\n im_files = glob.glob(os.path.join(im_dir, pattern))\n if len(im_files) == 0:\n raise ValueError(f'No images found in {im_dir}!')\n \n writer = imageio.get_writer(out_file, mode='I', fps=fps)\n for im_file in im_files:\n im = imageio.imread(im_file)\n writer.append_data(im)\n writer.close()","def on_update(self, delta_time):\n self.time += 1\n if self.time <= 900:\n self.gif.update_animation()","def gif(self, num_games, slow_mult=2, delete_pics=True,\n kill_limit_per_game=1000):\n slow_mult = int(slow_mult)\n gif_name = \"gifs\\\\\"+self.name\n\n try:\n os.remove(gif_name+'.gif')\n except Exception:\n pass\n\n kill_limit = kill_limit_per_game * num_games\n\n c = 0\n e = 0\n while c < kill_limit and e < num_games:\n self.env.reset()\n game_over = False\n # get initial input\n input_t = self.env.observe()\n\n plt.imshow(self.env.draw_state(),\n interpolation='none', cmap='gray')\n plt.savefig(\"gifs\\\\%d.png\" % c)\n plt.close()\n c += 1\n while not game_over and c < kill_limit:\n input_tm1 = input_t\n\n # get next action\n q = self.model.predict(input_tm1)\n action = np.argmax(q[0])\n\n # apply action, get rewards and new state\n input_t, reward, game_over = self.env.act(action)\n\n plt.imshow(self.env.draw_state(),\n interpolation='none', cmap='gray')\n plt.savefig(\"gifs\\\\%d.png\" % c)\n plt.close()\n c += 1\n\n e += 1\n\n # Making a temporary gif and slowing it down seems to be the only way I\n # can make a slower gif. For some reason the command works in cmd but\n # not here so i guess I am stuck with fast gifs.\n \"\"\"\n call1 = ['ffmpeg', '-i', '%d.png', gif_name+'_temp.gif']\n subprocess.call(call1)\n call2 = ['ffmpeg', '-i', gif_name+'_temp.gif', '-filter:v',\n '\"setpts={}.0*PTS\"'.format(slow_mult), gif_name+'.gif']\n subprocess.call(call2, shell=True)\n # ffmpeg -i catch_small_model.gif -filter:v \"setpts=3.0*PTS\" catch_small_model_slow.gif\n print(call2)\n try:\n os.remove(gif_name+'_temp.gif')\n except Exception as e:\n print(e)\n \"\"\"\n subprocess.call(['ffmpeg', '-i', 'gifs\\\\%d.png', gif_name+'.gif'])\n\n if delete_pics:\n for i in range(c):\n try:\n os.remove(\"gifs\\\\%d.png\" % i)\n except Exception as e:\n print(e)","def set_speed(self, speed):\n self.speed = speed","def speed(self, value: float):\n self._speed = value","def video_to_gif(input_file, output_file,\n start_time: Union[str, int] = 0, duration=0,\n overwrite=True, open_output=False):\n start_time = f'-ss {start_time} ' if start_time else ''\n duration = f'-t {duration} ' if duration else ''\n overwrite = f'-y ' if overwrite else '-n '\n stream = os.popen('ffmpeg '\n '-filter_complex \"[0:v] fps=12,scale=w=480:h=-1,split [a][b];[a] '\n 'palettegen=stats_mode=single [p];[b][p] paletteuse=new=1\" '\n f'{overwrite}'\n f'{start_time} {duration} '\n f'-i \"{input_file}\" \"{output_file}\"')\n stream.read()\n\n # Open output file\n if open_output:\n os.popen(f'xdg-open \"{Path(output_file).resolve()}\"')","def toggle_show_fps(self, key):\n if key == pg.K_F5:\n self.show_fps = not self.show_fps\n if not self.show_fps:\n pg.display.set_caption(self.caption)","def set_speed(self, speed):\n self._kernel.set_speed(float(speed))","async def async_set_speed(self, value) -> None:\n await self.write_attributes_safe({\"fan_mode\": value})","def clock_speed(self, clock_speed):\n\n self._clock_speed = clock_speed","def set_speed(self,speed):\n self.speed_p = speed","def _update_anim(self):\n if self._skip_frames > 1:\n # Do not render while _skip_frames is > 1\n self._skip_frames -= 1\n else:\n # Render frame\n self._visualization.taskMgr.step()\n # Calculate number of frames that need to be skipped\n self._skip_frames = int(1 / self._fps / self._dt)","def FrameRate(self):\n from ixnetwork_restpy.testplatform.sessions.ixnetwork.traffic.trafficitem.configelement.framerate.framerate import FrameRate\n return FrameRate(self)._select()","def set_cmd_velocity(self, speed):\n self.gripper_io.set_signal_value(\"speed_mps\", speed)","def get_preview_gif_url(self, playback_id):\n return f'https://image.mux.com/{playback_id.id}/animated.gif?end=1'","def paint_fps_data(frame, fps_data):\n frame_height, frame_width, _ = frame.shape\n text = 'running @ {:.0f} fps'.format(fps_data['main'])\n cv2.putText(img=frame,\n text=text,\n org=(10, frame_height - 20),\n fontFace=cv2.FONT_HERSHEY_DUPLEX,\n fontScale=1.0,\n color=(0, 0, 255),\n thickness=1\n )","def rate(self):\n if self._rate:\n return self._rate\n else:\n return self._wave.getframerate()","def __init__(self, outfile, width=512, height=512, framerate=25, videoformat=\"flv\"):\n self.outfile = outfile\n self.width = width\n self.height = height\n self.framerate = framerate\n self.videoformat = videoformat","def set_speed(self, speed):\n assert isinstance(speed, float), \"Must be a float\"\n \n if speed < 0.0:\n raise ValueError(\"Negative speeds not supported\")\n \n self.speed = speed","def framerate(self, interval=None):\n total_frames = 0.0\n\n # These are times when SF begins compositing.\n vsync_events = self.event_intervals(name='VSYNC-sf', interval=interval)\n if not vsync_events:\n vsync_events = self.event_intervals(name='VSYNC', interval=interval)\n\n for vsync_event_a, vsync_event_b in zip(vsync_events, vsync_events[1:]) : \n frames_presented = len(self.event_intervals('postFramebuffer', \n interval=vsync_event_a.interval))\n # Below required to skip interval when we had nothing to do.\n # As this event 'toggles' every VSYNC when SurfaceFlinger has work\n # to do. If nothing is done (i.e. no 'postFramebuffer' events)\n # there was jank in this interval.\n if vsync_event_a.value != vsync_event_b.value and frames_presented:\n total_frames += frames_presented\n \n present_time = self.present_duration(interval=interval)\n return round(total_frames/present_time, 1) if present_time != 0.0 else float('nan')","def set_speed(self,speed):\n self.speed = speed","def setFadeSpeed(self,speed):\n speed = clamp(speed, 1, 255)\n self._sendi2c('f', [speed])","def getFPS(self):\n # load it each time, since this setting is not limited to a single user\n projectSettingsDB = self.loadProjectSettings()\n try:\n fpsValue = projectSettingsDB[\"FPS\"]\n return fpsValue\n except KeyError:\n msg = \"Database Error while reading projectSettings.json\"\n logger.error(msg)\n return None","def save_gif(frames):\n print(\"Saving gif images!\")\n for i in range(len(frames)):\n im_out_path = \"gif/gif_emilie_will_\" + str(i) + \".png\"\n plt.imsave(im_out_path, frames[i])","def set(self, flag: int, value: int):\n if flag == cv2.cv2.CAP_PROP_POS_FRAMES:\n self.buff_idx = value","def set_speed(self, v):\n self.v = v","def getFrameRate(self):\n if not self.proxy:\n self.proxy = self.session.service(\"ALVideoRecorder\")\n return self.proxy.getFrameRate()","def set_speed(self, SHIP_MOVEMENT):\n self._speed = SHIP_MOVEMENT","def set_frame_time(self, frame_time):\n ftr=lib.is_GetFrameTimeRange(self.hcam)\n frame_time=min(max(frame_time,ftr[0]),ftr[1])\n lib.is_SetFrameRate(self.hcam,1./frame_time)\n return self.get_frame_time()","def set_fan_speed(self, value):\n self.parent.fancoolers.set_speed(value)","def display_frames_as_gif(frames):\n fig=e.cube.show_layout(frames[0]) \n print(\"Drawn\")\n def animate(i):\n return e.cube.update_plot(frames[i])\n anim = animation.FuncAnimation(fig, animate, frames = len(frames), interval=50,blit=True)","def set_gripper_speed(self, speed, **kwargs):\r\n return self._arm.set_gripper_speed(speed, **kwargs)","def update_frame(self):\r\n while not self.stopped:\r\n if not self.grabbed or not self.cap.isOpened():\r\n self.stop()\r\n else:\r\n self.grabbed, self.frame = self.cap.read()\r\n try:\r\n if self.grabbed:\r\n #self.New_Frame_Time = time.time()\r\n #self.FPS = 1/(self.New_Frame_Time-self.Old_Frame_Time)\r\n #self.Old_Frame_Time = self.New_Frame_Time\r\n self.FrameCount += 1\r\n else:\r\n print(f'Grabbed status is: {self.grabbed}')\r\n #self.Old_Frame_Time = time.time()\r\n except ZeroDivisionError:\r\n print(\"Division by zero error when finding video feed fps\")\r\n self.FPS = 0\r\n self.Old_Frame_Time = time.time()","def fps(self):\n\t\treturn float(len(self.buf)) / (self.buf[-1][0] - self.buf[0][0])","def get_fps(vid_path, prefix):\n _, name = os.path.split(vid_path)\n i1 = name.find(prefix) + len(prefix)\n i2 = name[i1:].find('_')\n fps = int(name[i1:i1+i2])\n\n return fps","def interface_speed(self, interface_speed: SmartSsdInterfaceSpeed):\n\n self._interface_speed = interface_speed","def render_frames(frame_queue,\n psit_gen: Generator[np.ndarray, None, None],\n duration,\n fps,\n space_vid,\n mask_grid=None,\n progress_interval=None):\n\n if not progress_interval:\n progress_interval = int(fps//2)\n\n # Prepare the discrete space used for video rendering\n video_size = tuple(space_vid.grid)\n\n # Function that is used to identify regions to be masked\n #mask = prop.hamiltonian.potential(*space_vid.grid_points) if mask_potential else None\n\n # Loop over batches of times and render frames\n i = 0\n t = 0.\n while t<=duration:\n # prepare the probabilities and phases\n psi = next(psit_gen)\n frame = prep_frame(psi, mask_grid=mask_grid, size=video_size)\n frame_queue.put(frame)\n\n t += 1 / fps\n i += 1\n\n if i % progress_interval == 0:\n print(f\"\\rProcessed up to time {t:0.2f} of {duration}. {t/duration:0.1%} complete.\", end='')","def update_fps(self, fps):\n self.fps_history.append(fps)\n if len(self.fps_history) > FPS_AVERAGES:\n self.fps_history.pop(0)\n\n self.fps_estimate = np.mean(self.fps_history)\n return self.fps_estimate","def set_refresh_rate(self, refresh_rate : int) -> None:\n if self.stdscr:\n self.stdscr.timeout(int(1000 / refresh_rate))","def bspb_frameCounter():\n curTime = int(pm.currentTime())\n maxTime = int(pm.playbackOptions(q=True, maxTime=True))\n return '{0} / {1}'.format(curTime, maxTime)","def testConfigG(self):\n assert type(self.config['maxfps']) == int","def gif(filename, array, fps=10, scale=1.0):\n # ensure that the file has the .gif extension\n filename = filename + '.gif'\n\n # copy into the color dimension if the images are black and white\n if array.ndim == 3:\n array = array[..., np.newaxis] * np.ones(3)\n\n # make the moviepy clip\n clip = ImageSequenceClip(list(array), fps=fps).resize(scale)\n clip.write_gif(filename, fps=fps)\n return True","def set_speed(self, speed):\n self._set_sub_text('speed', text=str(speed))\n return self","def get_video_frame_rate(filename):\n clip = VideoFileClip(filename)\n frame_rate = clip.fps\n clip.close()\n return frame_rate","def set_speed(self, speed=0):\n speed = clamp(speed)\n self._state.speed = speed\n self.send_command(Command.SET_SPEED, [int(speed)])","def animate(self, save_path=None):\n interval = 100 # 1 frame per interval ms\n frames = int(20 * len(self.experienced_states_kancks_paths) / self.frame_skip) # times to call updatefig\n blit = True # acceralate computation\n ani = animation.FuncAnimation(self.fig, self.updateifig, frames=frames,\n interval=interval, blit=blit)\n if save_path is not None:\n ani.save(os.path.join(save_path, 'anim.mp4'), writer='ffmpeg')\n else:\n plt.show()","def setFloatValue(self, *args):\n return _libsbml.ConversionOption_setFloatValue(self, *args)"],"string":"[\n \"def gif_fps(self):\\n return self._gif_fps\",\n \"def set_fps(self, fps=25):\\n raise NotImplementedError(\\\"set_fps is not implemented\\\")\",\n \"def set_framerate(self, framerate):\\n self._framerate = int(framerate)\",\n \"def set_fps(self, fps=25):\\n # self._root.knob('fps').setValue(fps)\\n pass\",\n \"def f2gif(path,fps):\\n print(\\\"==============================================\\\")\\n print(\\\"Convert file to GIF!\\\")\\n pathout = path[:-4]+'_'+str(fps)+'.gif'\\n if path.endswith('.tif'): \\n# import tifffile\\n im = tifffile.imread(path)\\n nFrames, h,w = im.shape\\n dur=1/fps\\n clip = []\\n for i in range(nFrames):\\n fr = cv2.cvtColor(im[i],cv2.COLOR_GRAY2RGB)\\n clip.append(mp.ImageClip(fr).set_duration(dur))\\n video = mp.concatenate_videoclips(clip, method=\\\"compose\\\",ismask=False)#ismask=True to make grayscale\\n\\n else:\\n video = mp.VideoFileClip(path)\\n fpsIn = int(video.fps)\\n if fps != fpsIn:\\n print(\\\"Conflict in fps! \\\\n\\\", \\\"[0] Use fps of input file;\\\\n\\\", \\\"[1] Use desired fps w/o speedup;\\\\n\\\",\\n \\\"[2] Use desired fps w/ speedup:\\\")\\n k = input('Input your selection: ')\\n if k == 2:\\n sf = fps/fpsIn\\n video =video.fx(mp.vfx.speedx, sf)# Not working when sf<1\\n elif k == 0:\\n fps = fpsIn\\n\\n video.write_gif(pathout,fps=fps)\\n video.reader.close()# To fix handel error problem\\n# if path.endswith('.gif'):\\n# clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\\n print(\\\"==============================================\\\")\\n print(\\\"MP4 convertion Done!\\\")\",\n \"def changeFps(self):\\n check = re.search(\\\"[1-9][0-9]*\\\", self.ui.t_fps.text())\\n if check:\\n num = check.group()\\n fps = int(num)\\n if fps > self.fps_limit:\\n logging.warning(\\n \\\"Too big number for fps. Falling back to {0} fps.\\\".format(\\n self.fps_limit\\n )\\n )\\n fps = self.fps_limit\\n self.fps = fps\\n self.ui.t_fps.setText(str(fps))\\n else:\\n logging.info(\\\"Wrong Input For Fps\\\")\\n self.ui.t_fps.setText(\\\"30\\\")\\n self.fps = 30\",\n \"def gifmp4converter(path,fpsOut):\\n# import moviepy.editor as mp\\n \\n print(\\\"=========================================\\\")\\n print(\\\"GIF-MP4 Converter Started!\\\")\\n\\n clip = mp.VideoFileClip(path)\\n #Get output fps\\n fpsIn = int(clip.fps)\\n fps=fpsOut\\n if fpsOut != fpsIn:\\n print(\\\"Conflict in fps! \\\\n\\\",\\n \\\"[0] Use fps of input file;\\\\n\\\",\\n \\\"[1] Use desired fps w/o speedup;\\\\n\\\",\\n \\\"[2] Use desired fps w/ speedup:\\\")\\n k = input('Input your selection: ')\\n if k == 2:\\n sf = fpsOut/fpsIn\\n fps = fpsOut \\n clip =clip.fx(mp.vfx.speedx, sf)\\n elif k == 0:\\n fps = fpsIn\\n \\n# Converting formats\\n if path.endswith('.gif'):\\n pathout = path[:-4]+'_cv'+'.mp4'\\n clip.write_videofile(pathout,fps=fps,codec='libx264', bitrate='32 M',preset='ultrafast')\\n elif path.endswith('.mp4'):\\n pathout = path[:-4]+'_cv'+'.gif'\\n clip.write_gif(pathout,fps=fps)\\n clip.reader.close()# To fix handel error problem\\n print(\\\"=========================================\\\")\\n print(\\\"GIF-MP4 Converter Done!\\\")\",\n \"def current_fps(self, fps: float):\\n self.current_fps_label.setText(\\\"FPS: {0:.2f}\\\".format(fps))\",\n \"def framerate(self):\\n return self.config.get('framerate', 15)\",\n \"def display_fps(self):\\n caption = \\\"{} - FPS: {:.2f}\\\".format(CAPTION, self.clock.get_fps())\\n pg.display.set_caption(caption)\",\n \"def display_fps(self):\\n caption = \\\"{} - FPS: {:.2f}\\\".format(CAPTION, self.clock.get_fps())\\n pg.display.set_caption(caption)\",\n \"def get_frame_rate(gif=''):\\n\\n # identify -format \\\"Frame %s: %Tcs\\\\n\\\" ~/test.gif - frame life in centiseconds - how very odd.\\n frame_rate_str = subprocess.check_output([\\n 'identify',\\n '-format',\\n '%T\\\\n',\\n gif\\n ])\\n # If we failed to get a frame lifetime from imagemagick...\\n if len(frame_rate_str) <= 0:\\n frame_rate = str(FRAME_RATE)\\n else:\\n # Get gif's lifetime...\\n frame_rate_list = frame_rate_str.split('\\\\n')\\n frame_rate_list = [int(n) for n in frame_rate_list if n]\\n lifetime = float(sum(frame_rate_list)) / 100\\n\\n # print \\\"gif lifetime is \\\" + str(lifetime) + \\\"s\\\"\\n # Determine average frames per second\\n frame_rate = str(len(frame_rate_list) / lifetime)\\n if float(frame_rate) <= 0.0:\\n frame_rate = FRAME_RATE\\n\\n return frame_rate\",\n \"def display_fps(self):\\n template = \\\"{} - FPS: {:.2f}\\\"\\n caption = template.format(prepare.CAPTION, self.clock.get_fps())\\n pg.display.set_caption(caption)\",\n \"def convert_gif(path: str,\\n gif_name: str = 'gif_name.gif',\\n frame_limit: int = 100):\\n video_path = glob(path + \\\"/*.mp4\\\")[-1]\\n vidcap = cv2.VideoCapture(video_path)\\n success, frame = vidcap.read()\\n count = 0\\n\\n # extracting and saving video frames.\\n while success:\\n cv2.imwrite(f\\\"{path}/frame{count}.png\\\", frame) \\n success, frame = vidcap.read()\\n count += 1\\n if count > frame_limit:\\n break\\n print(\\\"total frames:\\\", count)\\n\\n # generate animated GIF.\\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\\\"/*.png\\\"))]\\n img.save(fp=f\\\"{path}/{gif_name}\\\", format='GIF', append_images=imgs,\\n save_all=True, duration=200, loop=0)\\n \\n # remove frames\\n [os.remove(os.path.join(path, f)) for f in glob(path+\\\"/*.png\\\")]\",\n \"def display_frames_as_gif(frames, video_name):\\n Writer = animation.writers['ffmpeg']\\n writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)\\n #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\\n patch = plt.imshow(frames[0])\\n plt.axis('off')\\n\\n def animate(i):\\n patch.set_data(frames[i])\\n\\n anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\\n# display(display_animation(anim, default_mode='loop'))\\n anim.save(result_floder + '/' + video_name, writer=writer)\",\n \"def get_fps(self):\\n raise NotImplementedError(\\\"get_fps is not implemented\\\")\",\n \"def calculate_fps(self):\\n time_difference = self.time_array[-1] - self.time_array[0]\\n time_difference_in_seconds = time_difference.to_sec()\\n if time_difference_in_seconds == 0:\\n pass\\n self.fps = self.buffer_size / time_difference_in_seconds\\n rospy.loginfo(\\\"[EulerianMotionMagnification] Estimated FPS: \\\" + str(self.fps) + \\\" (Measured timespan: \\\" + str(time_difference_in_seconds) + \\\"s)\\\")\\n rospy.loginfo(\\\"[EulerianMotionMagnification] Video array length: \\\" + str(len(self.video_array)))\",\n \"def gif(self, delay=20, savefile=None, iterations=0, show_path=False,\\n use_ffmpeg=False):\\n from sage.misc.sage_ostools import have_program\\n have_convert = have_program('convert')\\n have_ffmpeg = self._have_ffmpeg()\\n if use_ffmpeg or not have_convert:\\n if have_ffmpeg:\\n self.ffmpeg(savefile=savefile, show_path=show_path,\\n output_format='.gif', delay=delay,\\n iterations=iterations)\\n else:\\n if not have_convert:\\n msg = \\\"\\\"\\\"\\nError: Neither ImageMagick nor ffmpeg appears to be installed. Saving an\\nanimation to a GIF file or displaying an animation requires one of these\\npackages, so please install one of them and try again.\\n\\nSee www.imagemagick.org and www.ffmpeg.org for more information.\\\"\\\"\\\"\\n else:\\n msg = \\\"\\\"\\\"\\nError: ffmpeg does not appear to be installed. Download it from\\nwww.ffmpeg.org, or use 'convert' to produce gifs instead.\\\"\\\"\\\"\\n raise OSError(msg)\\n else:\\n if not savefile:\\n savefile = graphics_filename(ext='.gif')\\n if not savefile.endswith('.gif'):\\n savefile += '.gif'\\n savefile = os.path.abspath(savefile)\\n d = self.png()\\n cmd = ( 'cd \\\"%s\\\"; sage-native-execute convert -dispose Background '\\n '-delay %s -loop %s *.png \\\"%s\\\"' ) % ( d, int(delay),\\n int(iterations), savefile )\\n from subprocess import check_call, CalledProcessError\\n try:\\n check_call(cmd, shell=True)\\n if show_path:\\n print(\\\"Animation saved to file %s.\\\" % savefile)\\n except (CalledProcessError, OSError):\\n msg = \\\"\\\"\\\"\\nError: Cannot generate GIF animation. Verify that convert\\n(ImageMagick) or ffmpeg is installed, and that the objects passed to\\nthe animate command can be saved in PNG image format.\\n\\nSee www.imagemagick.org and www.ffmpeg.org for more information.\\\"\\\"\\\"\\n raise OSError(msg)\",\n \"def get_fps(self):\\n return self.fps\",\n \"def get_fps(self):\\n if len(self.times) >= 2:\\n dif = np.diff(self.times)\\n fps = 1. / dif.min()\\n # if the FPS crosses 500, do not update it\\n if fps <= 500:\\n self.fps = fps\\n return self.fps\\n else:\\n return 0.\",\n \"def get_fps(self):\\n return self._num_frames / (datetime.now() - self._start).total_seconds()\",\n \"def AnimFromPng(name, gif=True, fps=15):\\n if(gif):\\n imgconvert = \\\"convert \\\" + \\\"-delay \\\" + str(int(1000/fps))\\n imgconvert += \\\" -dispose None \\\" + name + \\\"*.png -loop 0 \\\" + name + \\\".gif\\\"\\n system(imgconvert)\\n print imgconvert\\n else:\\n aviconvert = \\\"ffmpeg -i \\\" + name + \\\"%03d.png -b:v 2048k -r \\\" + str(fps) + \\\" \\\" + name + \\\".avi\\\"\\n system(aviconvert)\\n print aviconvert\",\n \"def get_framerate(self):\\n return self._framerate\",\n \"def limit_fps(fps):\\n global _last_update\\n elapsed = time.time() - _last_update\\n if elapsed < 1 / fps:\\n time.sleep(1 / fps - elapsed)\\n _last_update = time.time()\",\n \"def gif(self):\\n\\n if self._gif is None:\\n\\n url = self.url.replace('f=fits', 'f=gif')\\n\\n try:\\n url_data = urllib.request.urlopen(url)\\n except urllib.request.URLError as ee:\\n raise ValueError(f'cannot open URL for these parameters: {ee}')\\n\\n data = url_data.read()\\n\\n image = PIL.Image.open(io.BytesIO(data))\\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\\n\\n self._gif = image\\n\\n return self._gif\",\n \"def get_fps(self):\\n # Take difference.\\n interframe_intervals = np.diff(self.data[\\\"t\\\"])\\n\\n # Inter-frame interval in milliseconds.\\n mean_interval = np.mean(interframe_intervals)\\n fps = round(1 / (mean_interval / 1000))\\n\\n return int(fps)\",\n \"def set_animation_speed(self, speed):\\n self.m_animation_speed = self.calculate_animation_speed(speed)\",\n \"def get_fps(self):\\n #return int(self._root.knob('fps').getValue())\\n return None\",\n \"def get_fps(clock):\\n if video_mode:\\n return \\\"30\\\" # Video FPS will be 30\\n else:\\n return str(int(round(clock.get_fps(), 0)))\",\n \"def set_gripper_speed(self, speed):\\n if self._gripper:\\n self._gripper.set_velocity(speed)\",\n \"def update_fps(self):\\n self.fps.tick()\\n\\n\\trange_str = \\\"\\\"\\n gd = self.main_curve_dialog.curve.get_data()[1]\\n\\trange_str = \\\"Max: %s, Min: %s, Avg: %0.5s \\\" \\\\\\n\\t\\t % (numpy.max(gd), numpy.min(gd), numpy.average(gd))\\n\\n\\n fps_text = \\\"%s Update: %s FPS\\\" % (range_str, self.fps.rate())\\n self.action_fps_display.setText(fps_text)\",\n \"def show_fps(self, screen):\\n fps = self.clock.get_fps()\\n self.pgtext.display_text(\\\"FPS: {0:.2f}\\\".format(fps), screen, 600, 10)\",\n \"def GetGifFrames(self, path):\\n gif = imageio.mimread(path)\\n return [\\n (image.meta[\\\"duration\\\"], cv2.resize(\\n cv2.cvtColor(image, cv2.COLOR_RGB2BGR), (64, 64))\\n ) for image in gif\\n ]\",\n \"def set_speed(self, ratio):\\n self._speed = ratio\",\n \"def ffmpeg(self, savefile=None, show_path=False, output_format=None,\\n ffmpeg_options='', delay=None, iterations=0, pix_fmt='rgb24'):\\n if not self._have_ffmpeg():\\n msg = \\\"\\\"\\\"Error: ffmpeg does not appear to be installed. Saving an animation to\\na movie file in any format other than GIF requires this software, so\\nplease install it and try again.\\\"\\\"\\\"\\n raise OSError(msg)\\n else:\\n if savefile is None:\\n if output_format is None:\\n output_format = '.mpg'\\n else:\\n if output_format[0] != '.':\\n output_format = '.'+output_format\\n savefile = graphics_filename(ext=output_format)\\n else:\\n if output_format is None:\\n suffix = os.path.splitext(savefile)[1]\\n if len(suffix) > 0:\\n output_format = suffix\\n else:\\n output_format = '.mpg'\\n if not savefile.endswith(output_format):\\n savefile += output_format\\n early_options = ''\\n if output_format == '.gif':\\n # We try to set reasonable options for gif output.\\n #\\n # Older versions of ffmpeg (before 0.9, summer 2011)\\n # use the option -loop_output instead of -loop.\\n # Setting iterations=None is a way of preventing sage\\n # from adding the -loop option. A separate\\n # -loop_output option can be added with the\\n # ffmpeg_options argument.\\n if iterations is not None:\\n loop_cmd = '-loop {0} '.format(iterations)\\n else:\\n loop_cmd = ''\\n # A pix_fmt value is required for some but not all\\n # ffmpeg installations. Setting pix_fmt=None will\\n # prevent sage from adding this option, and it may be\\n # controlled separately through ffmpeg_options.\\n if pix_fmt is not None:\\n pix_fmt_cmd = '-pix_fmt {0} '.format(pix_fmt)\\n else:\\n pix_fmt_cmd = ''\\n ffmpeg_options += ' {0}{1}'.format(pix_fmt_cmd,loop_cmd)\\n if delay is not None and output_format != '.mpeg' and output_format != '.mpg':\\n early_options += ' -r %s ' % int(100/delay)\\n savefile = os.path.abspath(savefile)\\n pngdir = self.png()\\n pngs = os.path.join(pngdir, \\\"%08d.png\\\")\\n # For ffmpeg, it seems that some options, like '-g ... -r\\n # ...', need to come before the input file names, while\\n # some options, like '-pix_fmt rgb24', need to come\\n # afterwards. Hence 'early_options' and 'ffmpeg_options'\\n cmd = 'cd \\\"%s\\\"; sage-native-execute ffmpeg -y -f image2 %s -i %s %s %s' % (pngdir, early_options, pngs, ffmpeg_options, savefile)\\n from subprocess import check_call, CalledProcessError, PIPE\\n try:\\n if sage.misc.misc.get_verbose() > 0:\\n set_stderr = None\\n else:\\n set_stderr = PIPE\\n sage.misc.misc.verbose(\\\"Executing '%s'\\\" % cmd,level=1)\\n sage.misc.misc.verbose(\\\"\\\\n---- ffmpeg output below ----\\\\n\\\")\\n check_call(cmd, shell=True, stderr=set_stderr)\\n if show_path:\\n print(\\\"Animation saved to file %s.\\\" % savefile)\\n except (CalledProcessError, OSError):\\n print(\\\"Error running ffmpeg.\\\")\\n raise\",\n \"def animated_gif(folder_with_images, gif_filename, loop_duration, size):\\r\\n\\r\\n\\tos.chdir(folder_with_images) # changes directory to the folder with the images\\r\\n\\r\\n\\tpng_files = []\\r\\n\\r\\n\\t# get list of png files in folder\\r\\n\\tfor fn in os.listdir(folder_with_images):\\r\\n\\t\\tif fn.endswith('.png'):\\r\\n\\t\\t\\tpng_files.append(fn)\\r\\n\\r\\n\\tsort_nicely(png_files)\\r\\n\\r\\n\\tprint(png_files)\\r\\n\\r\\n\\t# number of png_files\\r\\n\\tnum_pngs = len(png_files)\\r\\n\\tpng_time = float(loop_duration)/ float(num_pngs)\\r\\n\\r\\n\\timages = [Image.open(fn) for fn in png_files]\\r\\n\\tdim = (size, size) # change sizes for the image file dimension\\r\\n\\t#for im in images:\\r\\n\\t#\\tim.thumbnail(dim, Image.ANTIALIAS)\\r\\n\\r\\n\\toutput_file = os.path.join(folder_with_images, gif_filename) # path for output file\\r\\n\\twriteGif(output_file, images, png_time) # writes out GIF\\r\",\n \"def gif_loop(self, gif_loop):\\n if gif_loop is not None and gif_loop < -1:\\n raise ValueError(\\\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\\\")\\n\\n self._gif_loop = gif_loop\",\n \"def max_fps(self):\\n return self._max_fps\",\n \"def setframerate(trafficItemName, frameRate):\\n queryData = {'from': '/traffic',\\n 'nodes': [{'node': 'trafficItem', 'properties': ['name'], 'where': [{'property': 'name', 'regex': trafficItemName}]},\\n {'node': 'configElement', 'properties': [], 'where': []}]}\\n queryResponse = middleware.ixn.query(data=queryData)\\n if queryResponse.json()['result'][0]['trafficItem'] == []:\\n print('\\\\nNo such Traffic Item name found: %s' % trafficItemName)\\n return\\n configElementObj = queryResponse.json()['result'][0]['trafficItem'][0]['configElement'][0]['href']\\n middleware.trafficObj.configTrafficItem(mode='modify', obj=configElementObj, configElements={'frameRate': frameRate})\",\n \"def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\\n\\n self._gif_fps = None\\n self._color_depth = None\\n self._gif_loop = None\\n self._height = None\\n self._start = None\\n self._duration = None\\n self._suffix = None\\n self._overlay = None\\n self._overlay_alignment = None\\n self._overlay_scale = None\\n self._label = None\\n self.discriminator = None\\n\\n if gif_fps is not None:\\n self.gif_fps = gif_fps\\n if color_depth is not None:\\n self.color_depth = color_depth\\n if gif_loop is not None:\\n self.gif_loop = gif_loop\\n self.height = height\\n self.start = start\\n if duration is not None:\\n self.duration = duration\\n if suffix is not None:\\n self.suffix = suffix\\n if overlay is not None:\\n self.overlay = overlay\\n if overlay_alignment is not None:\\n self.overlay_alignment = overlay_alignment\\n if overlay_scale is not None:\\n self.overlay_scale = overlay_scale\\n if label is not None:\\n self.label = label\",\n \"def interfacespeed(self, interfacespeed):\\n\\n self._interfacespeed = interfacespeed\",\n \"def frame_rate(self):\\n return self._frame_rate\",\n \"def setValues(\\n self,\\n frameRate: int = None,\\n timeScale: int = None,\\n vpDecorations: Boolean = ON,\\n vpBackground: Boolean = OFF,\\n compass: Boolean = OFF,\\n ):\\n pass\",\n \"def calcFrameRate(self):\\n\\n tot = 0\\n count = 0\\n for session in self.sessions:\\n for sample in session.samples:\\n if not sample.isLoading:\\n tot += sample.fps\\n count += 1\\n if count:\\n self.avgFps = tot / count\\n self.lowFps = (self.avgFps < 10)\\n self.highFps = (self.avgFps > 25)\",\n \"def get_fps(self):\\n \\n return self.fps, self.average_fps\",\n \"def _draw_fps_counter(self, fps: float):\\n draw_layer_tag = f'draw_layer_{self.id}_{self.draw_layer_index^1}'\\n\\n dpg.draw_rectangle(\\n parent=draw_layer_tag,\\n pmin=(0, 0),\\n pmax=(128, 32),\\n fill=(0, 0, 0, 128),\\n color=(0, 0, 0, 128)\\n )\\n\\n dpg.draw_text(\\n parent=draw_layer_tag,\\n text=f'FPS: {fps}',\\n pos=(_PADDING*2, _PADDING),\\n color=(255, 255, 255, 255),\\n size=_FONT_SIZE\\n )\",\n \"def get_fps(self):\\n if not self.count_fps:\\n logging.error(\\\"No FPSCounter set\\\")\\n return None\\n return self.fps.get_fps()\",\n \"def get_fps(self):\\n if not self.count_fps:\\n logging.error(\\\"No FPSCounter set\\\")\\n return None\\n return self.fps.get_fps()\",\n \"def write_frames_to_gif(fname: str, frames, duration: int, progress=False):\\n\\n channels = frames[0].shape[0]\\n # Convert to PIL\\n pil_images = []\\n if progress:\\n frames = track(frames, \\\"Converting Frames\\\")\\n for f in frames:\\n pim = Image.fromarray((f*255).astype(np.uint8))\\n if channels == 4:\\n pim.info['transparency'] = 255\\n #pim = pim.convert(\\\"P\\\")\\n pil_images.append(pim)\\n\\n # Write GIF, show status spinner with rich\\n if progress:\\n console = Console()\\n with console.status(f\\\"Writing GIF to {fname}\\\") as status:\\n # loop=0 means the gif just repeats forever, which is what I think everyone probably expects\\n pil_images[0].save(fname, save_all=True, append_images=pil_images[1:], loop=0, duration=duration)\\n else:\\n pil_images[0].save(fname, save_all=True, append_images=pil_images[1:], loop=0, duration=duration)\",\n \"def get_video_fps(self):\\n fps = self.video.get(cv2.CAP_PROP_FPS)\\n logging.info('Video FPS: {}'.format(fps))\\n return fps\",\n \"def tick(self, fps):\\n self._clock.tick(fps)\",\n \"def _set_foscam_mjpeg(self, **kwargs):\\n self.foscam_mjpeg = kwargs.get(\\\"value\\\")\\n self.parent.logger.info(\\\"CameraServer: Foscam Polling set to %s\\\" % (self.foscam_mjpeg))\\n self.set_driver('GV3', self.foscam_mjpeg, uom=25, report=True)\\n return True\",\n \"def get_fps(self):\\n return self._document.GetFps()\",\n \"def make_gif(im_dir, out_file, pattern='*.png', fps=10):\\n im_files = glob.glob(os.path.join(im_dir, pattern))\\n if len(im_files) == 0:\\n raise ValueError(f'No images found in {im_dir}!')\\n \\n writer = imageio.get_writer(out_file, mode='I', fps=fps)\\n for im_file in im_files:\\n im = imageio.imread(im_file)\\n writer.append_data(im)\\n writer.close()\",\n \"def on_update(self, delta_time):\\n self.time += 1\\n if self.time <= 900:\\n self.gif.update_animation()\",\n \"def gif(self, num_games, slow_mult=2, delete_pics=True,\\n kill_limit_per_game=1000):\\n slow_mult = int(slow_mult)\\n gif_name = \\\"gifs\\\\\\\\\\\"+self.name\\n\\n try:\\n os.remove(gif_name+'.gif')\\n except Exception:\\n pass\\n\\n kill_limit = kill_limit_per_game * num_games\\n\\n c = 0\\n e = 0\\n while c < kill_limit and e < num_games:\\n self.env.reset()\\n game_over = False\\n # get initial input\\n input_t = self.env.observe()\\n\\n plt.imshow(self.env.draw_state(),\\n interpolation='none', cmap='gray')\\n plt.savefig(\\\"gifs\\\\\\\\%d.png\\\" % c)\\n plt.close()\\n c += 1\\n while not game_over and c < kill_limit:\\n input_tm1 = input_t\\n\\n # get next action\\n q = self.model.predict(input_tm1)\\n action = np.argmax(q[0])\\n\\n # apply action, get rewards and new state\\n input_t, reward, game_over = self.env.act(action)\\n\\n plt.imshow(self.env.draw_state(),\\n interpolation='none', cmap='gray')\\n plt.savefig(\\\"gifs\\\\\\\\%d.png\\\" % c)\\n plt.close()\\n c += 1\\n\\n e += 1\\n\\n # Making a temporary gif and slowing it down seems to be the only way I\\n # can make a slower gif. For some reason the command works in cmd but\\n # not here so i guess I am stuck with fast gifs.\\n \\\"\\\"\\\"\\n call1 = ['ffmpeg', '-i', '%d.png', gif_name+'_temp.gif']\\n subprocess.call(call1)\\n call2 = ['ffmpeg', '-i', gif_name+'_temp.gif', '-filter:v',\\n '\\\"setpts={}.0*PTS\\\"'.format(slow_mult), gif_name+'.gif']\\n subprocess.call(call2, shell=True)\\n # ffmpeg -i catch_small_model.gif -filter:v \\\"setpts=3.0*PTS\\\" catch_small_model_slow.gif\\n print(call2)\\n try:\\n os.remove(gif_name+'_temp.gif')\\n except Exception as e:\\n print(e)\\n \\\"\\\"\\\"\\n subprocess.call(['ffmpeg', '-i', 'gifs\\\\\\\\%d.png', gif_name+'.gif'])\\n\\n if delete_pics:\\n for i in range(c):\\n try:\\n os.remove(\\\"gifs\\\\\\\\%d.png\\\" % i)\\n except Exception as e:\\n print(e)\",\n \"def set_speed(self, speed):\\n self.speed = speed\",\n \"def speed(self, value: float):\\n self._speed = value\",\n \"def video_to_gif(input_file, output_file,\\n start_time: Union[str, int] = 0, duration=0,\\n overwrite=True, open_output=False):\\n start_time = f'-ss {start_time} ' if start_time else ''\\n duration = f'-t {duration} ' if duration else ''\\n overwrite = f'-y ' if overwrite else '-n '\\n stream = os.popen('ffmpeg '\\n '-filter_complex \\\"[0:v] fps=12,scale=w=480:h=-1,split [a][b];[a] '\\n 'palettegen=stats_mode=single [p];[b][p] paletteuse=new=1\\\" '\\n f'{overwrite}'\\n f'{start_time} {duration} '\\n f'-i \\\"{input_file}\\\" \\\"{output_file}\\\"')\\n stream.read()\\n\\n # Open output file\\n if open_output:\\n os.popen(f'xdg-open \\\"{Path(output_file).resolve()}\\\"')\",\n \"def toggle_show_fps(self, key):\\n if key == pg.K_F5:\\n self.show_fps = not self.show_fps\\n if not self.show_fps:\\n pg.display.set_caption(self.caption)\",\n \"def set_speed(self, speed):\\n self._kernel.set_speed(float(speed))\",\n \"async def async_set_speed(self, value) -> None:\\n await self.write_attributes_safe({\\\"fan_mode\\\": value})\",\n \"def clock_speed(self, clock_speed):\\n\\n self._clock_speed = clock_speed\",\n \"def set_speed(self,speed):\\n self.speed_p = speed\",\n \"def _update_anim(self):\\n if self._skip_frames > 1:\\n # Do not render while _skip_frames is > 1\\n self._skip_frames -= 1\\n else:\\n # Render frame\\n self._visualization.taskMgr.step()\\n # Calculate number of frames that need to be skipped\\n self._skip_frames = int(1 / self._fps / self._dt)\",\n \"def FrameRate(self):\\n from ixnetwork_restpy.testplatform.sessions.ixnetwork.traffic.trafficitem.configelement.framerate.framerate import FrameRate\\n return FrameRate(self)._select()\",\n \"def set_cmd_velocity(self, speed):\\n self.gripper_io.set_signal_value(\\\"speed_mps\\\", speed)\",\n \"def get_preview_gif_url(self, playback_id):\\n return f'https://image.mux.com/{playback_id.id}/animated.gif?end=1'\",\n \"def paint_fps_data(frame, fps_data):\\n frame_height, frame_width, _ = frame.shape\\n text = 'running @ {:.0f} fps'.format(fps_data['main'])\\n cv2.putText(img=frame,\\n text=text,\\n org=(10, frame_height - 20),\\n fontFace=cv2.FONT_HERSHEY_DUPLEX,\\n fontScale=1.0,\\n color=(0, 0, 255),\\n thickness=1\\n )\",\n \"def rate(self):\\n if self._rate:\\n return self._rate\\n else:\\n return self._wave.getframerate()\",\n \"def __init__(self, outfile, width=512, height=512, framerate=25, videoformat=\\\"flv\\\"):\\n self.outfile = outfile\\n self.width = width\\n self.height = height\\n self.framerate = framerate\\n self.videoformat = videoformat\",\n \"def set_speed(self, speed):\\n assert isinstance(speed, float), \\\"Must be a float\\\"\\n \\n if speed < 0.0:\\n raise ValueError(\\\"Negative speeds not supported\\\")\\n \\n self.speed = speed\",\n \"def framerate(self, interval=None):\\n total_frames = 0.0\\n\\n # These are times when SF begins compositing.\\n vsync_events = self.event_intervals(name='VSYNC-sf', interval=interval)\\n if not vsync_events:\\n vsync_events = self.event_intervals(name='VSYNC', interval=interval)\\n\\n for vsync_event_a, vsync_event_b in zip(vsync_events, vsync_events[1:]) : \\n frames_presented = len(self.event_intervals('postFramebuffer', \\n interval=vsync_event_a.interval))\\n # Below required to skip interval when we had nothing to do.\\n # As this event 'toggles' every VSYNC when SurfaceFlinger has work\\n # to do. If nothing is done (i.e. no 'postFramebuffer' events)\\n # there was jank in this interval.\\n if vsync_event_a.value != vsync_event_b.value and frames_presented:\\n total_frames += frames_presented\\n \\n present_time = self.present_duration(interval=interval)\\n return round(total_frames/present_time, 1) if present_time != 0.0 else float('nan')\",\n \"def set_speed(self,speed):\\n self.speed = speed\",\n \"def setFadeSpeed(self,speed):\\n speed = clamp(speed, 1, 255)\\n self._sendi2c('f', [speed])\",\n \"def getFPS(self):\\n # load it each time, since this setting is not limited to a single user\\n projectSettingsDB = self.loadProjectSettings()\\n try:\\n fpsValue = projectSettingsDB[\\\"FPS\\\"]\\n return fpsValue\\n except KeyError:\\n msg = \\\"Database Error while reading projectSettings.json\\\"\\n logger.error(msg)\\n return None\",\n \"def save_gif(frames):\\n print(\\\"Saving gif images!\\\")\\n for i in range(len(frames)):\\n im_out_path = \\\"gif/gif_emilie_will_\\\" + str(i) + \\\".png\\\"\\n plt.imsave(im_out_path, frames[i])\",\n \"def set(self, flag: int, value: int):\\n if flag == cv2.cv2.CAP_PROP_POS_FRAMES:\\n self.buff_idx = value\",\n \"def set_speed(self, v):\\n self.v = v\",\n \"def getFrameRate(self):\\n if not self.proxy:\\n self.proxy = self.session.service(\\\"ALVideoRecorder\\\")\\n return self.proxy.getFrameRate()\",\n \"def set_speed(self, SHIP_MOVEMENT):\\n self._speed = SHIP_MOVEMENT\",\n \"def set_frame_time(self, frame_time):\\n ftr=lib.is_GetFrameTimeRange(self.hcam)\\n frame_time=min(max(frame_time,ftr[0]),ftr[1])\\n lib.is_SetFrameRate(self.hcam,1./frame_time)\\n return self.get_frame_time()\",\n \"def set_fan_speed(self, value):\\n self.parent.fancoolers.set_speed(value)\",\n \"def display_frames_as_gif(frames):\\n fig=e.cube.show_layout(frames[0]) \\n print(\\\"Drawn\\\")\\n def animate(i):\\n return e.cube.update_plot(frames[i])\\n anim = animation.FuncAnimation(fig, animate, frames = len(frames), interval=50,blit=True)\",\n \"def set_gripper_speed(self, speed, **kwargs):\\r\\n return self._arm.set_gripper_speed(speed, **kwargs)\",\n \"def update_frame(self):\\r\\n while not self.stopped:\\r\\n if not self.grabbed or not self.cap.isOpened():\\r\\n self.stop()\\r\\n else:\\r\\n self.grabbed, self.frame = self.cap.read()\\r\\n try:\\r\\n if self.grabbed:\\r\\n #self.New_Frame_Time = time.time()\\r\\n #self.FPS = 1/(self.New_Frame_Time-self.Old_Frame_Time)\\r\\n #self.Old_Frame_Time = self.New_Frame_Time\\r\\n self.FrameCount += 1\\r\\n else:\\r\\n print(f'Grabbed status is: {self.grabbed}')\\r\\n #self.Old_Frame_Time = time.time()\\r\\n except ZeroDivisionError:\\r\\n print(\\\"Division by zero error when finding video feed fps\\\")\\r\\n self.FPS = 0\\r\\n self.Old_Frame_Time = time.time()\",\n \"def fps(self):\\n\\t\\treturn float(len(self.buf)) / (self.buf[-1][0] - self.buf[0][0])\",\n \"def get_fps(vid_path, prefix):\\n _, name = os.path.split(vid_path)\\n i1 = name.find(prefix) + len(prefix)\\n i2 = name[i1:].find('_')\\n fps = int(name[i1:i1+i2])\\n\\n return fps\",\n \"def interface_speed(self, interface_speed: SmartSsdInterfaceSpeed):\\n\\n self._interface_speed = interface_speed\",\n \"def render_frames(frame_queue,\\n psit_gen: Generator[np.ndarray, None, None],\\n duration,\\n fps,\\n space_vid,\\n mask_grid=None,\\n progress_interval=None):\\n\\n if not progress_interval:\\n progress_interval = int(fps//2)\\n\\n # Prepare the discrete space used for video rendering\\n video_size = tuple(space_vid.grid)\\n\\n # Function that is used to identify regions to be masked\\n #mask = prop.hamiltonian.potential(*space_vid.grid_points) if mask_potential else None\\n\\n # Loop over batches of times and render frames\\n i = 0\\n t = 0.\\n while t<=duration:\\n # prepare the probabilities and phases\\n psi = next(psit_gen)\\n frame = prep_frame(psi, mask_grid=mask_grid, size=video_size)\\n frame_queue.put(frame)\\n\\n t += 1 / fps\\n i += 1\\n\\n if i % progress_interval == 0:\\n print(f\\\"\\\\rProcessed up to time {t:0.2f} of {duration}. {t/duration:0.1%} complete.\\\", end='')\",\n \"def update_fps(self, fps):\\n self.fps_history.append(fps)\\n if len(self.fps_history) > FPS_AVERAGES:\\n self.fps_history.pop(0)\\n\\n self.fps_estimate = np.mean(self.fps_history)\\n return self.fps_estimate\",\n \"def set_refresh_rate(self, refresh_rate : int) -> None:\\n if self.stdscr:\\n self.stdscr.timeout(int(1000 / refresh_rate))\",\n \"def bspb_frameCounter():\\n curTime = int(pm.currentTime())\\n maxTime = int(pm.playbackOptions(q=True, maxTime=True))\\n return '{0} / {1}'.format(curTime, maxTime)\",\n \"def testConfigG(self):\\n assert type(self.config['maxfps']) == int\",\n \"def gif(filename, array, fps=10, scale=1.0):\\n # ensure that the file has the .gif extension\\n filename = filename + '.gif'\\n\\n # copy into the color dimension if the images are black and white\\n if array.ndim == 3:\\n array = array[..., np.newaxis] * np.ones(3)\\n\\n # make the moviepy clip\\n clip = ImageSequenceClip(list(array), fps=fps).resize(scale)\\n clip.write_gif(filename, fps=fps)\\n return True\",\n \"def set_speed(self, speed):\\n self._set_sub_text('speed', text=str(speed))\\n return self\",\n \"def get_video_frame_rate(filename):\\n clip = VideoFileClip(filename)\\n frame_rate = clip.fps\\n clip.close()\\n return frame_rate\",\n \"def set_speed(self, speed=0):\\n speed = clamp(speed)\\n self._state.speed = speed\\n self.send_command(Command.SET_SPEED, [int(speed)])\",\n \"def animate(self, save_path=None):\\n interval = 100 # 1 frame per interval ms\\n frames = int(20 * len(self.experienced_states_kancks_paths) / self.frame_skip) # times to call updatefig\\n blit = True # acceralate computation\\n ani = animation.FuncAnimation(self.fig, self.updateifig, frames=frames,\\n interval=interval, blit=blit)\\n if save_path is not None:\\n ani.save(os.path.join(save_path, 'anim.mp4'), writer='ffmpeg')\\n else:\\n plt.show()\",\n \"def setFloatValue(self, *args):\\n return _libsbml.ConversionOption_setFloatValue(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74496573","0.69945496","0.6775548","0.6714409","0.62625706","0.6213025","0.59868544","0.5918831","0.5851581","0.5825714","0.5825714","0.5749928","0.5744896","0.5659933","0.5629519","0.56099874","0.5604374","0.5597134","0.55247176","0.550153","0.54935694","0.5469354","0.5440254","0.5420304","0.5401796","0.5396541","0.5345666","0.5329834","0.5320907","0.5294245","0.5287813","0.5225325","0.5217072","0.52167284","0.51430225","0.51238155","0.5122546","0.51103365","0.5098196","0.50953716","0.50800586","0.50623703","0.5056589","0.5049285","0.5020985","0.5016865","0.495351","0.495351","0.49532914","0.49523848","0.49397716","0.49308756","0.49297577","0.48726347","0.4869415","0.48688394","0.48677692","0.4850325","0.4848853","0.4844595","0.48273346","0.48249546","0.48247063","0.48239422","0.48210105","0.48142117","0.48028588","0.48011974","0.47902647","0.47863582","0.47852355","0.47734883","0.47727904","0.4772159","0.47678646","0.47669044","0.47551495","0.47435427","0.47309843","0.47215763","0.47148323","0.4710258","0.4705902","0.46930265","0.46918172","0.4689475","0.46624687","0.4654918","0.4653389","0.46388462","0.46377236","0.4626578","0.46248484","0.46244156","0.4623639","0.46227798","0.46193328","0.46158916","0.4602272","0.4601336"],"string":"[\n \"0.74496573\",\n \"0.69945496\",\n \"0.6775548\",\n \"0.6714409\",\n \"0.62625706\",\n \"0.6213025\",\n \"0.59868544\",\n \"0.5918831\",\n \"0.5851581\",\n \"0.5825714\",\n \"0.5825714\",\n \"0.5749928\",\n \"0.5744896\",\n \"0.5659933\",\n \"0.5629519\",\n \"0.56099874\",\n \"0.5604374\",\n \"0.5597134\",\n \"0.55247176\",\n \"0.550153\",\n \"0.54935694\",\n \"0.5469354\",\n \"0.5440254\",\n \"0.5420304\",\n \"0.5401796\",\n \"0.5396541\",\n \"0.5345666\",\n \"0.5329834\",\n \"0.5320907\",\n \"0.5294245\",\n \"0.5287813\",\n \"0.5225325\",\n \"0.5217072\",\n \"0.52167284\",\n \"0.51430225\",\n \"0.51238155\",\n \"0.5122546\",\n \"0.51103365\",\n \"0.5098196\",\n \"0.50953716\",\n \"0.50800586\",\n \"0.50623703\",\n \"0.5056589\",\n \"0.5049285\",\n \"0.5020985\",\n \"0.5016865\",\n \"0.495351\",\n \"0.495351\",\n \"0.49532914\",\n \"0.49523848\",\n \"0.49397716\",\n \"0.49308756\",\n \"0.49297577\",\n \"0.48726347\",\n \"0.4869415\",\n \"0.48688394\",\n \"0.48677692\",\n \"0.4850325\",\n \"0.4848853\",\n \"0.4844595\",\n \"0.48273346\",\n \"0.48249546\",\n \"0.48247063\",\n \"0.48239422\",\n \"0.48210105\",\n \"0.48142117\",\n \"0.48028588\",\n \"0.48011974\",\n \"0.47902647\",\n \"0.47863582\",\n \"0.47852355\",\n \"0.47734883\",\n \"0.47727904\",\n \"0.4772159\",\n \"0.47678646\",\n \"0.47669044\",\n \"0.47551495\",\n \"0.47435427\",\n \"0.47309843\",\n \"0.47215763\",\n \"0.47148323\",\n \"0.4710258\",\n \"0.4705902\",\n \"0.46930265\",\n \"0.46918172\",\n \"0.4689475\",\n \"0.46624687\",\n \"0.4654918\",\n \"0.4653389\",\n \"0.46388462\",\n \"0.46377236\",\n \"0.4626578\",\n \"0.46248484\",\n \"0.46244156\",\n \"0.4623639\",\n \"0.46227798\",\n \"0.46193328\",\n \"0.46158916\",\n \"0.4602272\",\n \"0.4601336\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.85410434"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76572,"cells":{"query":{"kind":"string","value":"Gets the color_depth of this GIFOutput. Amount of colors in palette"},"document":{"kind":"string","value":"def color_depth(self):\n return self._color_depth"},"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_num_explored(self):\n return self.__num_explored","def queryNumberOfColors(self):\n self._numColorsInUse = \\\n self._readInt('How many colors are available', 2, len(self._palette))\n return self._numColorsInUse","def num_depth(self):\n return len(self._sizes) + len(self._ratios) - 1","def GetDepth(*args, **kwargs):\n return _gdi_.Bitmap_GetDepth(*args, **kwargs)","def depth(self):\n return _libsbml.Dimensions_depth(self)","def depth(self):\n \n return self._depth","def num_depth(self):\n if self._index == 0:\n return len(self._ratios)\n else:\n return len(self._sizes) + len(self._ratios) - 1","def depth(self) -> int:\n return self.__depth","def getDepth(self):\n return _libsbml.Dimensions_getDepth(self)","def depth(self):\n if self.size == 0:\n return 0\n return int(math.log(self.size, 2)) + 1","def depth_percent(self):\n return self.container['depth_percent']","def depth(self):\n return self._max_depth","def depth_color(depth):\n if depth < 20:\n return 'g'\n if depth < 40:\n return 'y'\n return 'r'","def GetDepth(*args, **kwargs):\n return _gdi_.DC_GetDepth(*args, **kwargs)","def depths(self):\n return self._origin.depth","def depths(self):\n return self._origin.depth","def getDepth(depth: str) -> int:\n return {\n CommonPrefs.DEPTH_8: 8,\n CommonPrefs.DEPTH_16: 16,\n CommonPrefs.DEPTH_24: 24,\n CommonPrefs.DEPTH_32: 32,\n }.get(depth, 24)","def bit_depth(self, ch):\n ch = ct.c_int(ch)\n depth = ct.c_uint()\n self.lib.GetBitDepth(ch, ct.pointer(depth))\n return depth.value","def obtain_depth(self):\n self.z_buffer = image(self.image_plane.width, self.image_plane.height)\n for j in range(self.image_plane.height):\n for i in range(self.image_plane.width):\n single_point = None\n for ray_tracing in self.ray_tracer:\n ray_tracing.ray_direction(i, j)\n ray_tracing.sphere_to_ray()\n ray_tracing.ray_sphere_intersection()\n ray_tracing.hit_pos()\n hit_point = ray_tracing.getHit()\n\n if single_point is None:\n single_point = hit_point\n elif single_point is not None and single_point.z > hit_point.z:\n single_point = hit_point\n self.z_buffer.setColor(single_point, i, j)","def stride_depth(self):\n\t\treturn self.strides_shape_param('D')","def get_default_color_depth(self) -> ColorDepth:\n if self.default_color_depth is not None:\n return self.default_color_depth\n\n return ColorDepth.DEPTH_4_BIT","def get_depth_shape(self):\n width = -1\n height = -1\n for (serial, device) in self._enabled_devices.items():\n for stream in device.pipeline_profile.get_streams():\n if (rs.stream.depth == stream.stream_type()):\n width = stream.as_video_stream_profile().width()\n height = stream.as_video_stream_profile().height()\n return width, height","def depth(self):\n ch = self.children\n return 0 if not ch else 1 + max([c.depth for c in ch])","def axis(self):\n return len(self._colors)","def depth(state):\n current_depth = 0\n for i in range(0, len(state.board)):\n for j in range(0, len(state.board[0])):\n if state.board[i][j] == '_':\n current_depth += 1\n return current_depth","def depth(self):\n return max(n.depth for n in self.iternodes())","def GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()","def shadeToDepth(color):\n minDistance = 0.7\n maxDistance = 20\n maxColor = 255\n color = np.average(color, axis=None)\n # depth = mx + b\n # m = (minDistance - maxDistance)/maxColor\n # x = color\n # b = maxDistance\n m = (maxDistance - minDistance)/maxColor\n x = color\n b = minDistance\n return m * x + b","def get_colors(self, maxcolors=None):\n if maxcolors:\n return self.image.getcolors(maxcolors)\n return self.image.getcolors(self.width*self.height)","def getDepth(self):\n return _libsbml.BoundingBox_getDepth(self)","def getcolors(self, maxcolors=256):\r\n\r\n if self._mode in (\"1\", \"L\", \"P\"):\r\n h = self._instance.histogram()\r\n out = []\r\n for i in range(256):\r\n if h[i]:\r\n out.append((h[i], i))\r\n if len(out) > maxcolors:\r\n return None\r\n return out\r\n uni, counts = self._getcolors()\r\n if c>maxcolors: return None\r\n colors = []\r\n for l in range(len(counts)):\r\n colors.append((counts[l], l))\r\n return colors","def GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()","def layers_sizes(self):\n return iter([self.delta_h*l for l in range(int(self.h/self.delta_h)-1)])","def getNoiseCancellationDepth(self, channel, group, unitCode=0):\n resp = self.XAPCommand('NCD', channel, group, unitCode=unitCode)\n return int(resp)","def get_max_depth(self):\n return self.MAX_DEPTH","def depth(x):\n return max(int(x * depth_multiplier), 8)","def depth(self):\n return 0","def _tree_depth(self):\n return self._flat_data._tree_depth()","def getPixelColor(self, n):\n self._logger.debug(\"getPixelColor\")","def itkRGBAPixelF_GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()","def itkRGBAPixelUS_GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()","def num_frames(self):\n return self._first_rgb.shape[1]","def get_well_depth_image(self):\n rampTime = self.result['information']['exposure_specification']['saturation_time']\n wellFrac = rampTime * self.result['2d']['detector'] / self.fullWell\n \n return wellFrac","def max_depth(self) -> int:\n return pulumi.get(self, \"max_depth\")","def numPixels(self):\n\t\treturn self.size","def numPixels(self):\n\t\treturn self.size","def split_necessity(self):\n return max(self._color_var_rel) * self.n_pix\n # return reduce(int.__mul__, (l-u for u,l in self.bounds)) * self.n_pix","def getDepth(self):\n return self.movies.depth","def getDepth(self):\n return self.movies.depth","def num_channels_per_output(cls) -> list[tuple[int, ...]]:\n return [\n (16, 24, 40, 112, 320),\n (16, 24, 40, 112, 320),\n (16, 24, 48, 120, 352),\n (24, 32, 48, 136, 384),\n (24, 32, 56, 160, 448),\n (24, 40, 64, 176, 512),\n (32, 40, 72, 200, 576),\n (32, 48, 80, 224, 640),\n (32, 56, 88, 248, 704),\n (72, 104, 176, 480, 1376),\n ]","def critical_depth(self):\n crit_depth = math.pow((self.flow**2 /\n (self.width ** 2 * Channel.g)), (1/3))\n return crit_depth","def depth(self):\n raise NotImplementedError()","def GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()","def _get_depth(self, data): \r\n\r\n data = data.astype(np.float32)\r\n\r\n normalized = np.dot(data, [65536.0, 256.0, 1.0]) \r\n normalized /= (256 * 256 * 256 - 1)\r\n in_meters = 1000 * normalized\r\n\r\n return in_meters","def kernel_depth(self):\n\t\treturn self.kernel_shape_param('D')","def read_png_depth(file):\n depth_png = np.array(load_image(file), dtype=int)\n\n depth = depth_png.astype(np.float) / 1000.\n # assert (np.max(depth_png) > 1000.), 'Wrong .png depth file'\n # if (np.max(depth_png) > 1000.):\n # depth = depth_png.astype(np.float) / 1000.\n # else:\n # depth = depth_png.astype(np.float)\n depth[depth_png == 0] = -1.\n return np.expand_dims(depth, axis=2)","def padding_depth(self):\n\t\treturn self.paddings_shape_param('D')","def depth(self):\n L, R = 0,0\n if self.left:\n L = self.left.depth()\n if self.right:\n R = self.right.depth()\n\n return 1 + max(L, R)","def get_caravan_depth(self):\n return self.caravan_depth","def get_recursion_depth(self):\n str_depth_input = self.entries[\"ent_recursion_depth\"].get()\n if str_depth_input == '':\n return None # default of fractal class while drawing in None\n # draws the base curve instead\n return int(str_depth_input)","def depth(self) -> int:\n if len(self.children) == 0:\n return 0\n\n # Regresar la altura máxima de sus hijos más uno\n return max([n.depth() for n in self.children]) + 1","def numPixels(self):\n self._logger.debug(\"numPixels\")\n return self.count","def getShadeMap(img):\n return np.bincount(img.astype(int).flat, minlength=256)","def color_column(self):\n return 8","def Nlevels(self):\n return self._nlevels","def get_n_channels(self): \n return self.n_out_channels","def ColorizeDepthFrame(self):\n self.DepthFrameHSV[..., 0] = self.DepthFrameRaw\n self.DepthFrameHSV[..., 1] = 0x9F\n self.DepthFrameHSV[..., 2] = 0xFF\n self.DepthFrameRGB = cv2.cvtColor(\n self.DepthFrameHSV, cv2.COLOR_HSV2RGB)","def color_depth(self, color_depth):\n\n self._color_depth = color_depth","def _read_depth(self):\n # s = openni2.wait_for_any_stream([self.depth_stream], timeout)\n # if not s:\n # return None\n # read raw uint16 buffer\n im_arr = self.depth_stream.read_frame()\n raw_buf = im_arr.get_buffer_as_uint16()\n depth_im = np.ctypeslib.as_array(raw_buf).reshape(\n (self.DEPTH_IM_HEIGHT, self.DEPTH_IM_WIDTH))\n depth_im = depth_im.astype('float64') / 1000 # 把毫米的单位转换到米\n # TODO: 不是很清楚为什么要翻转图像\n if self.flip_images:\n # 上下翻转图像\n depth_im = np.flipud(depth_im)\n else:\n # 左右翻转图像\n depth_im = np.fliplr(depth_im)\n return depth_im","def dim(color):\n return tuple(_gamut(i // 2) for i in color)","def depth(self):\n return len(self.topology)","def colors(self):\r\n\t\treturn self._colors","def make_palette(self, color_count):\n palette = []\n palette_index = 0\n leaf_count = len(self.get_leaves())\n # reduce nodes\n # up to 8 leaves can be reduced here and the palette will have\n # only 248 colors (in worst case) instead of expected 256 colors\n for level in range(OctreeQuantizer.MAX_DEPTH - 1, -1, -1):\n if self.levels[level]:\n for node in self.levels[level]:\n leaf_count -= node.remove_leaves()\n if leaf_count <= color_count:\n break\n if leaf_count <= color_count:\n break\n self.levels[level] = []\n # build palette\n for node in self.get_leaves():\n if palette_index >= color_count:\n break\n if node.is_leaf():\n palette.append(node.get_color())\n node.palette_index = palette_index\n palette_index += 1\n return palette","def num_faces(self):\n return self._top_exp.number_of_faces()","def depth(self, u):\n return self._ll_tree.depth(u)","def luminance(self):\n \n return (self.r + self.g + self.b) // 3","def depth(self, p):\n if self._depths is None:\n return None\n return self._depths[p.index()]","def n_z(self, level):\n resolution = self.resolution(level)\n return (self.z_extent // resolution + 63) // 64","def depth(self):\n left_depth = self.left.depth() if self.left is not None else 0\n right_depth = self.right.depth() if self.right is not None else 0\n return max(left_depth, right_depth) + 1","def itkRGBAPixelUC_GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()","def get_object_depth(self):\n self.object_depth = self.get_depth_milli_metres()\n self.object_depth[self.non_object_mask] = 0\n return self.object_depth","def grey(self):\n return sum((self.value(0), self.value(1), self.value(2)))/3","def depr_depth_images(self):\n if not hasattr(self, '_depr_depth_images'):\n depth_images = self._archive['gaps_depth']\n self._depr_depth_images = depth_images.reshape([1, 20, 224, 224, 1])\n return self._depr_depth_images","def depthControl(self):\n if self.__cursor <= self.__stop:\n return 1\n elif self.__cursor == self.__stop + 1:\n return 2\n elif self.__cursor > self.__stop + 1:\n return 3","def get_depth(depth, calibration_extrinsics, intrinsics_color,\n intrinsics_depth_inv):\n img_height, img_width = depth.shape[0], depth.shape[1]\n depth_ = np.zeros_like(depth)\n x = np.linspace(0, img_width-1, img_width)\n y = np.linspace(0, img_height-1, img_height)\n xx, yy = np.meshgrid(x, y)\n xx = np.reshape(xx, (1, -1))\n yy = np.reshape(yy, (1, -1))\n ones = np.ones_like(xx)\n pcoord_depth = np.concatenate((xx, yy, ones), axis=0)\n depth = np.reshape(depth, (1, img_height*img_width))\n ccoord_depth = np.dot(intrinsics_depth_inv, pcoord_depth) * depth\n ccoord_depth[1,:] = - ccoord_depth[1,:]\n ccoord_depth[2,:] = - ccoord_depth[2,:]\n ccoord_depth = np.concatenate((ccoord_depth, ones), axis=0)\n ccoord_color = np.dot(calibration_extrinsics, ccoord_depth)\n ccoord_color = ccoord_color[0:3,:]\n ccoord_color[1,:] = - ccoord_color[1,:]\n ccoord_color[2,:] = depth\n\n pcoord_color = np.dot(intrinsics_color, ccoord_color)\n pcoord_color = pcoord_color[:,pcoord_color[2,:]!=0]\n pcoord_color[0,:] = pcoord_color[0,:]/pcoord_color[2,:]+0.5\n pcoord_color[0,:] = pcoord_color[0,:].astype(int)\n pcoord_color[1,:] = pcoord_color[1,:]/pcoord_color[2,:]+0.5\n pcoord_color[1,:] = pcoord_color[1,:].astype(int)\n pcoord_color = pcoord_color[:,pcoord_color[0,:]>=0]\n pcoord_color = pcoord_color[:,pcoord_color[1,:]>=0]\n pcoord_color = pcoord_color[:,pcoord_color[0,:]<img_width]\n pcoord_color = pcoord_color[:,pcoord_color[1,:]<img_height]\n\n depth_[pcoord_color[1,:].astype(int),\n pcoord_color[0,:].astype(int)] = pcoord_color[2,:]\n return depth_","def DEPTH(frame):\n\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\n\tframe.image.copy_bits( depth.ctypes.data )\n\tcv2.imshow( 'VideoDEPTH', depth )","def skin_depth(self,freq):\n sigma = self.conductivity\n delta_s = np.sqrt(2/(2*np.pi*freq*self.mu*sigma))\n return delta_s","def countDiff(self, color):\n count = 0\n for y in range(self.n):\n for x in range(self.n):\n if self[x][y]==color:\n count += 1\n if self[x][y]==-color:\n count -= 1\n return count","def n_levels(self):\n return len(self.scales)","def get_depth_milli_metres(self):\n self.depth = (self.get_depth_metres() * 1000).astype(np.float32)\n self.full_depth = copy.copy(self.depth)\n return self.depth","def norm(self):\n return self._color_mapper","def distict_color_count(img):\n return Counter([tuple(colors) for i in img for colors in i])","def distict_color_count(img):\n return Counter([tuple(colors) for i in img for colors in i])","def n_channels(self):\n return self._n_channels","def nlevels(self) -> int:\n return len(self._levels)","def convertDepthFrame(self):\n try:\n \"\"\" \n Convert Depth frame to rudimentary colormap\n \"\"\"\n self.DepthHSV[...,0] = self.currentDepthFrame\n self.DepthHSV[...,1] = 0x9F\n self.DepthHSV[...,2] = 0xFF\n self.DepthCM = cv2.cvtColor(self.DepthHSV,cv2.COLOR_HSV2RGB)\n cv2.drawContours(self.DepthCM,self.block_contours,-1,(0,0,0),3)\n cv2.drawContours(self.DepthCM,self.block_contours_2,-1,(0,0,0),3)\n cv2.drawContours(self.DepthCM,self.block_contours_3,-1,(0,0,0),3)\n\n img = QImage(self.DepthCM,\n self.DepthCM.shape[1],\n self.DepthCM.shape[0],\n QImage.Format_RGB888\n )\n return img\n except:\n return None","def get_max_depth_val():\n data = SUNRGBDTrainDataset(True)\n return max([data[0][i][-1].flatten().item() for i in range(len(data))])","def getColor(self):\n\n return self.pktColor","def get_colors(self):\n x = np.linspace(0, 1, self.length)\n y = x**self.gamma\n\n value = np.linspace(0, 1, len(self.colors))\n r = np.interp(y, value, self.colors[:,0])\n g = np.interp(y, value, self.colors[:,1])\n b = np.interp(y, value, self.colors[:,2])\n\n return np.dstack((r, g, b)).reshape(len(r), 3).astype(np.uint8)","def get_height(self):\n height = 0\n for layer, ldata in self.conf['Layers'].items():\n layer_t = ldata['params']['thickness']\n height += layer_t\n return height"],"string":"[\n \"def get_num_explored(self):\\n return self.__num_explored\",\n \"def queryNumberOfColors(self):\\n self._numColorsInUse = \\\\\\n self._readInt('How many colors are available', 2, len(self._palette))\\n return self._numColorsInUse\",\n \"def num_depth(self):\\n return len(self._sizes) + len(self._ratios) - 1\",\n \"def GetDepth(*args, **kwargs):\\n return _gdi_.Bitmap_GetDepth(*args, **kwargs)\",\n \"def depth(self):\\n return _libsbml.Dimensions_depth(self)\",\n \"def depth(self):\\n \\n return self._depth\",\n \"def num_depth(self):\\n if self._index == 0:\\n return len(self._ratios)\\n else:\\n return len(self._sizes) + len(self._ratios) - 1\",\n \"def depth(self) -> int:\\n return self.__depth\",\n \"def getDepth(self):\\n return _libsbml.Dimensions_getDepth(self)\",\n \"def depth(self):\\n if self.size == 0:\\n return 0\\n return int(math.log(self.size, 2)) + 1\",\n \"def depth_percent(self):\\n return self.container['depth_percent']\",\n \"def depth(self):\\n return self._max_depth\",\n \"def depth_color(depth):\\n if depth < 20:\\n return 'g'\\n if depth < 40:\\n return 'y'\\n return 'r'\",\n \"def GetDepth(*args, **kwargs):\\n return _gdi_.DC_GetDepth(*args, **kwargs)\",\n \"def depths(self):\\n return self._origin.depth\",\n \"def depths(self):\\n return self._origin.depth\",\n \"def getDepth(depth: str) -> int:\\n return {\\n CommonPrefs.DEPTH_8: 8,\\n CommonPrefs.DEPTH_16: 16,\\n CommonPrefs.DEPTH_24: 24,\\n CommonPrefs.DEPTH_32: 32,\\n }.get(depth, 24)\",\n \"def bit_depth(self, ch):\\n ch = ct.c_int(ch)\\n depth = ct.c_uint()\\n self.lib.GetBitDepth(ch, ct.pointer(depth))\\n return depth.value\",\n \"def obtain_depth(self):\\n self.z_buffer = image(self.image_plane.width, self.image_plane.height)\\n for j in range(self.image_plane.height):\\n for i in range(self.image_plane.width):\\n single_point = None\\n for ray_tracing in self.ray_tracer:\\n ray_tracing.ray_direction(i, j)\\n ray_tracing.sphere_to_ray()\\n ray_tracing.ray_sphere_intersection()\\n ray_tracing.hit_pos()\\n hit_point = ray_tracing.getHit()\\n\\n if single_point is None:\\n single_point = hit_point\\n elif single_point is not None and single_point.z > hit_point.z:\\n single_point = hit_point\\n self.z_buffer.setColor(single_point, i, j)\",\n \"def stride_depth(self):\\n\\t\\treturn self.strides_shape_param('D')\",\n \"def get_default_color_depth(self) -> ColorDepth:\\n if self.default_color_depth is not None:\\n return self.default_color_depth\\n\\n return ColorDepth.DEPTH_4_BIT\",\n \"def get_depth_shape(self):\\n width = -1\\n height = -1\\n for (serial, device) in self._enabled_devices.items():\\n for stream in device.pipeline_profile.get_streams():\\n if (rs.stream.depth == stream.stream_type()):\\n width = stream.as_video_stream_profile().width()\\n height = stream.as_video_stream_profile().height()\\n return width, height\",\n \"def depth(self):\\n ch = self.children\\n return 0 if not ch else 1 + max([c.depth for c in ch])\",\n \"def axis(self):\\n return len(self._colors)\",\n \"def depth(state):\\n current_depth = 0\\n for i in range(0, len(state.board)):\\n for j in range(0, len(state.board[0])):\\n if state.board[i][j] == '_':\\n current_depth += 1\\n return current_depth\",\n \"def depth(self):\\n return max(n.depth for n in self.iternodes())\",\n \"def GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()\",\n \"def shadeToDepth(color):\\n minDistance = 0.7\\n maxDistance = 20\\n maxColor = 255\\n color = np.average(color, axis=None)\\n # depth = mx + b\\n # m = (minDistance - maxDistance)/maxColor\\n # x = color\\n # b = maxDistance\\n m = (maxDistance - minDistance)/maxColor\\n x = color\\n b = minDistance\\n return m * x + b\",\n \"def get_colors(self, maxcolors=None):\\n if maxcolors:\\n return self.image.getcolors(maxcolors)\\n return self.image.getcolors(self.width*self.height)\",\n \"def getDepth(self):\\n return _libsbml.BoundingBox_getDepth(self)\",\n \"def getcolors(self, maxcolors=256):\\r\\n\\r\\n if self._mode in (\\\"1\\\", \\\"L\\\", \\\"P\\\"):\\r\\n h = self._instance.histogram()\\r\\n out = []\\r\\n for i in range(256):\\r\\n if h[i]:\\r\\n out.append((h[i], i))\\r\\n if len(out) > maxcolors:\\r\\n return None\\r\\n return out\\r\\n uni, counts = self._getcolors()\\r\\n if c>maxcolors: return None\\r\\n colors = []\\r\\n for l in range(len(counts)):\\r\\n colors.append((counts[l], l))\\r\\n return colors\",\n \"def GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()\",\n \"def layers_sizes(self):\\n return iter([self.delta_h*l for l in range(int(self.h/self.delta_h)-1)])\",\n \"def getNoiseCancellationDepth(self, channel, group, unitCode=0):\\n resp = self.XAPCommand('NCD', channel, group, unitCode=unitCode)\\n return int(resp)\",\n \"def get_max_depth(self):\\n return self.MAX_DEPTH\",\n \"def depth(x):\\n return max(int(x * depth_multiplier), 8)\",\n \"def depth(self):\\n return 0\",\n \"def _tree_depth(self):\\n return self._flat_data._tree_depth()\",\n \"def getPixelColor(self, n):\\n self._logger.debug(\\\"getPixelColor\\\")\",\n \"def itkRGBAPixelF_GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()\",\n \"def itkRGBAPixelUS_GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()\",\n \"def num_frames(self):\\n return self._first_rgb.shape[1]\",\n \"def get_well_depth_image(self):\\n rampTime = self.result['information']['exposure_specification']['saturation_time']\\n wellFrac = rampTime * self.result['2d']['detector'] / self.fullWell\\n \\n return wellFrac\",\n \"def max_depth(self) -> int:\\n return pulumi.get(self, \\\"max_depth\\\")\",\n \"def numPixels(self):\\n\\t\\treturn self.size\",\n \"def numPixels(self):\\n\\t\\treturn self.size\",\n \"def split_necessity(self):\\n return max(self._color_var_rel) * self.n_pix\\n # return reduce(int.__mul__, (l-u for u,l in self.bounds)) * self.n_pix\",\n \"def getDepth(self):\\n return self.movies.depth\",\n \"def getDepth(self):\\n return self.movies.depth\",\n \"def num_channels_per_output(cls) -> list[tuple[int, ...]]:\\n return [\\n (16, 24, 40, 112, 320),\\n (16, 24, 40, 112, 320),\\n (16, 24, 48, 120, 352),\\n (24, 32, 48, 136, 384),\\n (24, 32, 56, 160, 448),\\n (24, 40, 64, 176, 512),\\n (32, 40, 72, 200, 576),\\n (32, 48, 80, 224, 640),\\n (32, 56, 88, 248, 704),\\n (72, 104, 176, 480, 1376),\\n ]\",\n \"def critical_depth(self):\\n crit_depth = math.pow((self.flow**2 /\\n (self.width ** 2 * Channel.g)), (1/3))\\n return crit_depth\",\n \"def depth(self):\\n raise NotImplementedError()\",\n \"def GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()\",\n \"def _get_depth(self, data): \\r\\n\\r\\n data = data.astype(np.float32)\\r\\n\\r\\n normalized = np.dot(data, [65536.0, 256.0, 1.0]) \\r\\n normalized /= (256 * 256 * 256 - 1)\\r\\n in_meters = 1000 * normalized\\r\\n\\r\\n return in_meters\",\n \"def kernel_depth(self):\\n\\t\\treturn self.kernel_shape_param('D')\",\n \"def read_png_depth(file):\\n depth_png = np.array(load_image(file), dtype=int)\\n\\n depth = depth_png.astype(np.float) / 1000.\\n # assert (np.max(depth_png) > 1000.), 'Wrong .png depth file'\\n # if (np.max(depth_png) > 1000.):\\n # depth = depth_png.astype(np.float) / 1000.\\n # else:\\n # depth = depth_png.astype(np.float)\\n depth[depth_png == 0] = -1.\\n return np.expand_dims(depth, axis=2)\",\n \"def padding_depth(self):\\n\\t\\treturn self.paddings_shape_param('D')\",\n \"def depth(self):\\n L, R = 0,0\\n if self.left:\\n L = self.left.depth()\\n if self.right:\\n R = self.right.depth()\\n\\n return 1 + max(L, R)\",\n \"def get_caravan_depth(self):\\n return self.caravan_depth\",\n \"def get_recursion_depth(self):\\n str_depth_input = self.entries[\\\"ent_recursion_depth\\\"].get()\\n if str_depth_input == '':\\n return None # default of fractal class while drawing in None\\n # draws the base curve instead\\n return int(str_depth_input)\",\n \"def depth(self) -> int:\\n if len(self.children) == 0:\\n return 0\\n\\n # Regresar la altura máxima de sus hijos más uno\\n return max([n.depth() for n in self.children]) + 1\",\n \"def numPixels(self):\\n self._logger.debug(\\\"numPixels\\\")\\n return self.count\",\n \"def getShadeMap(img):\\n return np.bincount(img.astype(int).flat, minlength=256)\",\n \"def color_column(self):\\n return 8\",\n \"def Nlevels(self):\\n return self._nlevels\",\n \"def get_n_channels(self): \\n return self.n_out_channels\",\n \"def ColorizeDepthFrame(self):\\n self.DepthFrameHSV[..., 0] = self.DepthFrameRaw\\n self.DepthFrameHSV[..., 1] = 0x9F\\n self.DepthFrameHSV[..., 2] = 0xFF\\n self.DepthFrameRGB = cv2.cvtColor(\\n self.DepthFrameHSV, cv2.COLOR_HSV2RGB)\",\n \"def color_depth(self, color_depth):\\n\\n self._color_depth = color_depth\",\n \"def _read_depth(self):\\n # s = openni2.wait_for_any_stream([self.depth_stream], timeout)\\n # if not s:\\n # return None\\n # read raw uint16 buffer\\n im_arr = self.depth_stream.read_frame()\\n raw_buf = im_arr.get_buffer_as_uint16()\\n depth_im = np.ctypeslib.as_array(raw_buf).reshape(\\n (self.DEPTH_IM_HEIGHT, self.DEPTH_IM_WIDTH))\\n depth_im = depth_im.astype('float64') / 1000 # 把毫米的单位转换到米\\n # TODO: 不是很清楚为什么要翻转图像\\n if self.flip_images:\\n # 上下翻转图像\\n depth_im = np.flipud(depth_im)\\n else:\\n # 左右翻转图像\\n depth_im = np.fliplr(depth_im)\\n return depth_im\",\n \"def dim(color):\\n return tuple(_gamut(i // 2) for i in color)\",\n \"def depth(self):\\n return len(self.topology)\",\n \"def colors(self):\\r\\n\\t\\treturn self._colors\",\n \"def make_palette(self, color_count):\\n palette = []\\n palette_index = 0\\n leaf_count = len(self.get_leaves())\\n # reduce nodes\\n # up to 8 leaves can be reduced here and the palette will have\\n # only 248 colors (in worst case) instead of expected 256 colors\\n for level in range(OctreeQuantizer.MAX_DEPTH - 1, -1, -1):\\n if self.levels[level]:\\n for node in self.levels[level]:\\n leaf_count -= node.remove_leaves()\\n if leaf_count <= color_count:\\n break\\n if leaf_count <= color_count:\\n break\\n self.levels[level] = []\\n # build palette\\n for node in self.get_leaves():\\n if palette_index >= color_count:\\n break\\n if node.is_leaf():\\n palette.append(node.get_color())\\n node.palette_index = palette_index\\n palette_index += 1\\n return palette\",\n \"def num_faces(self):\\n return self._top_exp.number_of_faces()\",\n \"def depth(self, u):\\n return self._ll_tree.depth(u)\",\n \"def luminance(self):\\n \\n return (self.r + self.g + self.b) // 3\",\n \"def depth(self, p):\\n if self._depths is None:\\n return None\\n return self._depths[p.index()]\",\n \"def n_z(self, level):\\n resolution = self.resolution(level)\\n return (self.z_extent // resolution + 63) // 64\",\n \"def depth(self):\\n left_depth = self.left.depth() if self.left is not None else 0\\n right_depth = self.right.depth() if self.right is not None else 0\\n return max(left_depth, right_depth) + 1\",\n \"def itkRGBAPixelUC_GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()\",\n \"def get_object_depth(self):\\n self.object_depth = self.get_depth_milli_metres()\\n self.object_depth[self.non_object_mask] = 0\\n return self.object_depth\",\n \"def grey(self):\\n return sum((self.value(0), self.value(1), self.value(2)))/3\",\n \"def depr_depth_images(self):\\n if not hasattr(self, '_depr_depth_images'):\\n depth_images = self._archive['gaps_depth']\\n self._depr_depth_images = depth_images.reshape([1, 20, 224, 224, 1])\\n return self._depr_depth_images\",\n \"def depthControl(self):\\n if self.__cursor <= self.__stop:\\n return 1\\n elif self.__cursor == self.__stop + 1:\\n return 2\\n elif self.__cursor > self.__stop + 1:\\n return 3\",\n \"def get_depth(depth, calibration_extrinsics, intrinsics_color,\\n intrinsics_depth_inv):\\n img_height, img_width = depth.shape[0], depth.shape[1]\\n depth_ = np.zeros_like(depth)\\n x = np.linspace(0, img_width-1, img_width)\\n y = np.linspace(0, img_height-1, img_height)\\n xx, yy = np.meshgrid(x, y)\\n xx = np.reshape(xx, (1, -1))\\n yy = np.reshape(yy, (1, -1))\\n ones = np.ones_like(xx)\\n pcoord_depth = np.concatenate((xx, yy, ones), axis=0)\\n depth = np.reshape(depth, (1, img_height*img_width))\\n ccoord_depth = np.dot(intrinsics_depth_inv, pcoord_depth) * depth\\n ccoord_depth[1,:] = - ccoord_depth[1,:]\\n ccoord_depth[2,:] = - ccoord_depth[2,:]\\n ccoord_depth = np.concatenate((ccoord_depth, ones), axis=0)\\n ccoord_color = np.dot(calibration_extrinsics, ccoord_depth)\\n ccoord_color = ccoord_color[0:3,:]\\n ccoord_color[1,:] = - ccoord_color[1,:]\\n ccoord_color[2,:] = depth\\n\\n pcoord_color = np.dot(intrinsics_color, ccoord_color)\\n pcoord_color = pcoord_color[:,pcoord_color[2,:]!=0]\\n pcoord_color[0,:] = pcoord_color[0,:]/pcoord_color[2,:]+0.5\\n pcoord_color[0,:] = pcoord_color[0,:].astype(int)\\n pcoord_color[1,:] = pcoord_color[1,:]/pcoord_color[2,:]+0.5\\n pcoord_color[1,:] = pcoord_color[1,:].astype(int)\\n pcoord_color = pcoord_color[:,pcoord_color[0,:]>=0]\\n pcoord_color = pcoord_color[:,pcoord_color[1,:]>=0]\\n pcoord_color = pcoord_color[:,pcoord_color[0,:]<img_width]\\n pcoord_color = pcoord_color[:,pcoord_color[1,:]<img_height]\\n\\n depth_[pcoord_color[1,:].astype(int),\\n pcoord_color[0,:].astype(int)] = pcoord_color[2,:]\\n return depth_\",\n \"def DEPTH(frame):\\n\\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\\n\\tframe.image.copy_bits( depth.ctypes.data )\\n\\tcv2.imshow( 'VideoDEPTH', depth )\",\n \"def skin_depth(self,freq):\\n sigma = self.conductivity\\n delta_s = np.sqrt(2/(2*np.pi*freq*self.mu*sigma))\\n return delta_s\",\n \"def countDiff(self, color):\\n count = 0\\n for y in range(self.n):\\n for x in range(self.n):\\n if self[x][y]==color:\\n count += 1\\n if self[x][y]==-color:\\n count -= 1\\n return count\",\n \"def n_levels(self):\\n return len(self.scales)\",\n \"def get_depth_milli_metres(self):\\n self.depth = (self.get_depth_metres() * 1000).astype(np.float32)\\n self.full_depth = copy.copy(self.depth)\\n return self.depth\",\n \"def norm(self):\\n return self._color_mapper\",\n \"def distict_color_count(img):\\n return Counter([tuple(colors) for i in img for colors in i])\",\n \"def distict_color_count(img):\\n return Counter([tuple(colors) for i in img for colors in i])\",\n \"def n_channels(self):\\n return self._n_channels\",\n \"def nlevels(self) -> int:\\n return len(self._levels)\",\n \"def convertDepthFrame(self):\\n try:\\n \\\"\\\"\\\" \\n Convert Depth frame to rudimentary colormap\\n \\\"\\\"\\\"\\n self.DepthHSV[...,0] = self.currentDepthFrame\\n self.DepthHSV[...,1] = 0x9F\\n self.DepthHSV[...,2] = 0xFF\\n self.DepthCM = cv2.cvtColor(self.DepthHSV,cv2.COLOR_HSV2RGB)\\n cv2.drawContours(self.DepthCM,self.block_contours,-1,(0,0,0),3)\\n cv2.drawContours(self.DepthCM,self.block_contours_2,-1,(0,0,0),3)\\n cv2.drawContours(self.DepthCM,self.block_contours_3,-1,(0,0,0),3)\\n\\n img = QImage(self.DepthCM,\\n self.DepthCM.shape[1],\\n self.DepthCM.shape[0],\\n QImage.Format_RGB888\\n )\\n return img\\n except:\\n return None\",\n \"def get_max_depth_val():\\n data = SUNRGBDTrainDataset(True)\\n return max([data[0][i][-1].flatten().item() for i in range(len(data))])\",\n \"def getColor(self):\\n\\n return self.pktColor\",\n \"def get_colors(self):\\n x = np.linspace(0, 1, self.length)\\n y = x**self.gamma\\n\\n value = np.linspace(0, 1, len(self.colors))\\n r = np.interp(y, value, self.colors[:,0])\\n g = np.interp(y, value, self.colors[:,1])\\n b = np.interp(y, value, self.colors[:,2])\\n\\n return np.dstack((r, g, b)).reshape(len(r), 3).astype(np.uint8)\",\n \"def get_height(self):\\n height = 0\\n for layer, ldata in self.conf['Layers'].items():\\n layer_t = ldata['params']['thickness']\\n height += layer_t\\n return height\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68169844","0.65945107","0.65047747","0.64739394","0.6416106","0.6415538","0.6361293","0.63216704","0.6281688","0.62379676","0.622544","0.61876786","0.6183844","0.6128096","0.60531795","0.60531795","0.60180753","0.592283","0.5902543","0.5848112","0.5841671","0.58196205","0.5814486","0.58069426","0.5798566","0.5759646","0.5759019","0.57304585","0.5716417","0.5710291","0.5705755","0.5702082","0.5697838","0.56915265","0.5673882","0.56424004","0.5636857","0.56195587","0.560792","0.55782276","0.5572664","0.55688846","0.5567217","0.5558436","0.555681","0.555681","0.5553794","0.5553772","0.5553772","0.5539558","0.5516718","0.55152583","0.5503125","0.5495938","0.5493026","0.5482311","0.5480434","0.547964","0.5478057","0.5476031","0.5471836","0.5460237","0.5459146","0.5451833","0.545001","0.543435","0.5426605","0.5412466","0.54105633","0.54102933","0.54093206","0.5405803","0.54018134","0.5392401","0.5389128","0.53719956","0.5371162","0.5367965","0.5364283","0.53568554","0.53474283","0.53449374","0.5344042","0.5342988","0.5331986","0.53286624","0.5311841","0.5310253","0.5305292","0.530343","0.53004014","0.5300367","0.5300367","0.5290333","0.5285779","0.5279635","0.5275295","0.5274022","0.5269006","0.5267269"],"string":"[\n \"0.68169844\",\n \"0.65945107\",\n \"0.65047747\",\n \"0.64739394\",\n \"0.6416106\",\n \"0.6415538\",\n \"0.6361293\",\n \"0.63216704\",\n \"0.6281688\",\n \"0.62379676\",\n \"0.622544\",\n \"0.61876786\",\n \"0.6183844\",\n \"0.6128096\",\n \"0.60531795\",\n \"0.60531795\",\n \"0.60180753\",\n \"0.592283\",\n \"0.5902543\",\n \"0.5848112\",\n \"0.5841671\",\n \"0.58196205\",\n \"0.5814486\",\n \"0.58069426\",\n \"0.5798566\",\n \"0.5759646\",\n \"0.5759019\",\n \"0.57304585\",\n \"0.5716417\",\n \"0.5710291\",\n \"0.5705755\",\n \"0.5702082\",\n \"0.5697838\",\n \"0.56915265\",\n \"0.5673882\",\n \"0.56424004\",\n \"0.5636857\",\n \"0.56195587\",\n \"0.560792\",\n \"0.55782276\",\n \"0.5572664\",\n \"0.55688846\",\n \"0.5567217\",\n \"0.5558436\",\n \"0.555681\",\n \"0.555681\",\n \"0.5553794\",\n \"0.5553772\",\n \"0.5553772\",\n \"0.5539558\",\n \"0.5516718\",\n \"0.55152583\",\n \"0.5503125\",\n \"0.5495938\",\n \"0.5493026\",\n \"0.5482311\",\n \"0.5480434\",\n \"0.547964\",\n \"0.5478057\",\n \"0.5476031\",\n \"0.5471836\",\n \"0.5460237\",\n \"0.5459146\",\n \"0.5451833\",\n \"0.545001\",\n \"0.543435\",\n \"0.5426605\",\n \"0.5412466\",\n \"0.54105633\",\n \"0.54102933\",\n \"0.54093206\",\n \"0.5405803\",\n \"0.54018134\",\n \"0.5392401\",\n \"0.5389128\",\n \"0.53719956\",\n \"0.5371162\",\n \"0.5367965\",\n \"0.5364283\",\n \"0.53568554\",\n \"0.53474283\",\n \"0.53449374\",\n \"0.5344042\",\n \"0.5342988\",\n \"0.5331986\",\n \"0.53286624\",\n \"0.5311841\",\n \"0.5310253\",\n \"0.5305292\",\n \"0.530343\",\n \"0.53004014\",\n \"0.5300367\",\n \"0.5300367\",\n \"0.5290333\",\n \"0.5285779\",\n \"0.5279635\",\n \"0.5275295\",\n \"0.5274022\",\n \"0.5269006\",\n \"0.5267269\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8169639"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76573,"cells":{"query":{"kind":"string","value":"Sets the color_depth of this GIFOutput. Amount of colors in palette"},"document":{"kind":"string","value":"def color_depth(self, color_depth):\n\n self._color_depth = color_depth"},"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 SetDepth(*args, **kwargs):\n return _gdi_.Bitmap_SetDepth(*args, **kwargs)","def set_depth(self, depth):\n self._depth = depth\n if self._scaled_image_coordinates is None:\n self._initialise()\n else:\n self._update_depth()","def color_depth(self):\n return self._color_depth","def ColorizeDepthFrame(self):\n self.DepthFrameHSV[..., 0] = self.DepthFrameRaw\n self.DepthFrameHSV[..., 1] = 0x9F\n self.DepthFrameHSV[..., 2] = 0xFF\n self.DepthFrameRGB = cv2.cvtColor(\n self.DepthFrameHSV, cv2.COLOR_HSV2RGB)","def set_depth(self, d):\r\n self.depth = d","def set_depth(self, z):\r\n self.z = z\r\n self._update_rect()","def setDepth(self, *args):\n return _CompuCell.Potts3D_setDepth(self, *args)","def depth_color(depth):\n if depth < 20:\n return 'g'\n if depth < 40:\n return 'y'\n return 'r'","def setChrDepths(self, cd):\n self.chr_depth = cd","def setDepth(self, *args):\n return _libsbml.Dimensions_setDepth(self, *args)","def set_depth(self, new_depth):\n self.caravan_depth = new_depth","def changeConvolutionalDepth(self,depth):\n self.conv_depth = depth","def updatePageDepthColor(self, newVal):\n self.depthSelections[self.val].set_facecolor(self.nonSelectedDepthColor)\n self.depthSelections[newVal].set_facecolor(self.selectedDepthColor)","def setPixelColor(self, n, color):\n self._logger.debug(\"setPixelColor\")","def depth(self, new_depth):\n \n # Check a type of 'new_depth' parametr \n if not isinstance(new_depth, (int, long)):\n raise TypeError('int or long type expected')\n self._depth = new_depth","def set_depth(node, depth):\n setattr(node[0], \"depth\", depth)","def _set_curr_depth(self, curr_depth):\n self.curr_depth = curr_depth.fluid_pressure","def updateDepthBlendWeights(percent):\n global depthWeight\n depthWeight = float(percent)/100.0","def setNoiseCancellationDepth(self, channel, group, depth, unitCode=0):\n resp = self.XAPCommand('NCD', channel, group, depth, unitCode=unitCode)\n return int(resp)","def increment_depth(self):\r\n self.depth = self.depth + 1","def bit_depth(self, value):\n self._bit_depth = value\n self._max_DN = (2 ** self.bit_depth) - 1","def bit_depth(self, value):\n self._bit_depth = value\n self._max_DN = (2 ** self.bit_depth) - 1","def setColourLevels(self):\n minsg = np.min(self.sg)\n maxsg = np.max(self.sg)\n brightness = self.brightnessSlider.value()\n contrast = self.contrastSlider.value()\n colourStart = (brightness / 100.0 * contrast / 100.0) * (maxsg - minsg) + minsg\n colourEnd = (maxsg - minsg) * (1.0 - contrast / 100.0) + colourStart\n for btn in self.picbuttons:\n btn.stopPlayback()\n btn.setImage(self.lut, colourStart, colourEnd, False)\n btn.update()","def depth_percent(self, depth_percent):\n\n self.container['depth_percent'] = depth_percent","def log_depth(self, *args, **kwargs):\n def log(prefix_idx, batch, output):\n self._metrics.update(log_rgb('rgb', prefix_idx, batch))\n self._metrics.update(log_inv_depth('inv_depth', prefix_idx, output))\n if 'depth' in batch:\n self._metrics.update(log_depth('depth', prefix_idx, batch))\n self.log_images(log, *args, **kwargs)","def setDepth(self, *args):\n return _libsbml.BoundingBox_setDepth(self, *args)","def setColors(self):\n #productive\n profprint()\n self.color= [[0,0,0] for i in range(205)]\n self.color255= self.setColors255()\n for i in range(205):\n for j in range(3):\n self.color[i][j] = self.color255[i][j]/float(255)\n\n return self.color","def make_palette(self, color_count):\n palette = []\n palette_index = 0\n leaf_count = len(self.get_leaves())\n # reduce nodes\n # up to 8 leaves can be reduced here and the palette will have\n # only 248 colors (in worst case) instead of expected 256 colors\n for level in range(OctreeQuantizer.MAX_DEPTH - 1, -1, -1):\n if self.levels[level]:\n for node in self.levels[level]:\n leaf_count -= node.remove_leaves()\n if leaf_count <= color_count:\n break\n if leaf_count <= color_count:\n break\n self.levels[level] = []\n # build palette\n for node in self.get_leaves():\n if palette_index >= color_count:\n break\n if node.is_leaf():\n palette.append(node.get_color())\n node.palette_index = palette_index\n palette_index += 1\n return palette","def AMdepth(depthPerc=100,channel=1):\r\n inst.write(\":AM%i:DEPT %iPCT\" %(channel,depthPerc))","def setPixelColor(self, n, color):\n\t\t#print \"pxl %s = %s\" % (n, color)\n\t\tif isinstance(n, slice):\n\t\t\tself.leds[n] = [color]*len(self.leds[n])\n\t\telse:\n\t\t\tif n >= 0 or n <= self.size:\n\t\t\t\tself.leds[n] = color\n\t\t#pprint(self.leds)","def _update_color(self):\n self._vertex_list.colors[:] = self._rgba * self._num_verts","def setColorResolution(width=1,height=1):\n dislin.setres(width,height)","def setColors(self):\r\n # productive\r\n profprint()\r\n self.color = [[0, 0, 0] for i in range(MAXCOL)]\r\n self.color255 = self.setColors255()\r\n for i in range(MAXCOL):\r\n for j in range(3):\r\n self.color[i][j] = self.color255[i][j] / float(255)\r\n\r\n return self.color","def set_color(self, value):\n _lib.caca_set_dither_color.argtypes = [_Dither, ctypes.c_char_p]\n _lib.caca_set_dither_color.restype = ctypes.c_int\n\n return _lib.caca_set_dither_color(self, value)","def add_color(self, color, level, parent):\n if level >= OctreeQuantizer.MAX_DEPTH:\n self.color.red += color.red\n self.color.green += color.green\n self.color.blue += color.blue\n self.pixel_count += 1\n return\n index = self.get_color_index_for_level(color, level)\n if not self.children[index]:\n self.children[index] = OctreeNode(level, parent)\n self.children[index].add_color(color, level + 1, parent)","def _update_color(self, color):\n self.color = color","def show_rgbd(self):\n while self.depth_data is None:\n pass\n\n while not rospy.is_shutdown():\n rospy.Rate(10).sleep()\n d = self.depth_data * self.cam.DEPTH_UNIT\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\n dc = np.concatenate((d, self.rgb_data), axis=1)\n cv2.imshow('RGB & Depth Image', dc)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n cv2.destroyAllWindows()","def refresh_color(self):\n self.color = max(0, int(math.sqrt(self.vx ** 2\n + self.vy ** 2)) + 100)","def on_depth_image(self, depth_image):\n depth_image = depth_image.copy()\n mask = np.where(self.depth != 0)\n depth_image[mask] = self.depth[mask]\n return depth_image","def set_color(group, color, pct=1):\n for l, v in zip(group, color):\n l.brightness_pct = v * pct","def update_color(self):\r\n \r\n \r\n colorset = self.colorset\r\n \r\n self.grfx[0].colorset = colorset\r\n pass","def vis_depth_map(\n img_rgb: NDArrayByte,\n depth_map: NDArrayFloat,\n interp_depth_map: bool,\n num_dilation_iters: int = 10,\n) -> None:\n if not interp_depth_map:\n # fix the zero values?\n depth_map[depth_map == 0] = np.finfo(np.float32).max\n\n # purely for visualization\n depth_map = cv2.dilate(\n depth_map,\n kernel=np.ones((2, 2), np.uint8),\n iterations=num_dilation_iters,\n )\n\n # prevent too dark in the foreground, clip far away\n depth_map = np.clip(depth_map, 0, 50)\n\n plt.subplot(1, 2, 1)\n plt.imshow(img_rgb)\n plt.subplot(1, 2, 2)\n plt.imshow((depth_map * 3).astype(np.uint8), cmap=\"inferno\")","def setPixelColorRGB(self, n, red, green, blue, white=0):\n self._logger.debug(\"setPixelColorRGB\")","def loadDepthFrame(self):\n self.DepthFrameRaw = cv2.imread(\n script_path + \"/data/raw_depth.png\", 0).astype(np.uint16)","def startColorLoop():\n b.set_group(1, 'on', True)\n b.set_group(1, 'bri', 254)\n b.set_group(1, 'hue', 255)\n b.set_group(1, 'sat', 255)\n b.set_group(1, 'effect', 'colorloop')","def convertDepthFrame(self):\n try:\n \"\"\" \n Convert Depth frame to rudimentary colormap\n \"\"\"\n self.DepthHSV[...,0] = self.currentDepthFrame\n self.DepthHSV[...,1] = 0x9F\n self.DepthHSV[...,2] = 0xFF\n self.DepthCM = cv2.cvtColor(self.DepthHSV,cv2.COLOR_HSV2RGB)\n cv2.drawContours(self.DepthCM,self.block_contours,-1,(0,0,0),3)\n cv2.drawContours(self.DepthCM,self.block_contours_2,-1,(0,0,0),3)\n cv2.drawContours(self.DepthCM,self.block_contours_3,-1,(0,0,0),3)\n\n img = QImage(self.DepthCM,\n self.DepthCM.shape[1],\n self.DepthCM.shape[0],\n QImage.Format_RGB888\n )\n return img\n except:\n return None","def set_color(self, color):\n pass","def run(palette='hsv', num_vals=12):\n fout_png = 'colors_{P}_{N}.png'.format(P=palette, N=num_vals)\n _, axis = plt.subplots(1, 1, figsize=(6, 6))\n colobj = MplColorHelper(palette, 0, num_vals-1)\n colors = [colobj.get_hexstr(yval) for yval in range(num_vals)]\n plt_color_text(colors)\n for idx, color in enumerate(reversed(colors)):\n print('{N:2} {COLOR}'.format(N=idx, COLOR=color))\n axis.set_title('{N} Discrete Colors from {MAP}'.format(N=num_vals, MAP=palette))\n plt.show()\n plt.savefig(fout_png)\n print(' WROTE: {PNG}'.format(PNG=fout_png))","def obtain_depth(self):\n self.z_buffer = image(self.image_plane.width, self.image_plane.height)\n for j in range(self.image_plane.height):\n for i in range(self.image_plane.width):\n single_point = None\n for ray_tracing in self.ray_tracer:\n ray_tracing.ray_direction(i, j)\n ray_tracing.sphere_to_ray()\n ray_tracing.ray_sphere_intersection()\n ray_tracing.hit_pos()\n hit_point = ray_tracing.getHit()\n\n if single_point is None:\n single_point = hit_point\n elif single_point is not None and single_point.z > hit_point.z:\n single_point = hit_point\n self.z_buffer.setColor(single_point, i, j)","def _update_color(self, *args):\n\n if self._variable and 'w' in self._mode and not self._dnd_started:\n self._internal_color_change = True\n self.color_var.set(self._variable)","def update_depths(self, fixed=True, r=2):\n\n n_images = len(self.images)\n # faster if we batch multiple depth updates together\n\n inds = self.keyframe_inds\n if fixed and len(self.keyframe_inds) > 1:\n inds = inds[1:]\n\n for keyframe_index in inds:\n adj_list = [keyframe_index]\n for j in range(keyframe_index - r, keyframe_index + r + 1):\n if keyframe_index != j:\n j = min(max(j, 0), n_images)\n adj_list.append(j)\n\n images = np.stack([self.images[i] for i in adj_list], axis=0)\n poses = np.stack([self.poses[i] for i in adj_list], axis=0)\n\n feed_dict = {\n self.images_placeholder: images,\n self.poses_placeholder: poses,\n self.intrinsics_placeholder: self.intrinsics,\n }\n\n keyframe_depth = self.sess.run(self.outputs['depths'], feed_dict=feed_dict)\n self.depths[keyframe_index] = keyframe_depth[0]","def set_color(self, color):\n\t\tpass","def rgb(self, value):\n\n self._variable = value\n self._update()","def changeColor(self):\n self.layer.new_colormap()","def color(self, value: tuple) -> None:\n if value in Color.PALETTE:\n self._color = value","def set_pattern(colors=('green', 'blue', 'red')): # (10)\n for i in range(0, int(ceil(float(NUM_LEDS)/float(len(colors))))):\n for color in colors:\n push_color(color)","def setLeds(number: int, red: int, green: int, blue: int):\n pass","def assign_color(self,tank):\n tank.color = self.color_queue.popleft()","def getDepth(depth: str) -> int:\n return {\n CommonPrefs.DEPTH_8: 8,\n CommonPrefs.DEPTH_16: 16,\n CommonPrefs.DEPTH_24: 24,\n CommonPrefs.DEPTH_32: 32,\n }.get(depth, 24)","def set_layer(self, n):\n self.layernum = n\n self.update()","def fill_color(self, _col):\n for x in xrange(0, self.__resolution[0], 1):\n for y in xrange(0, self.__resolution[1], 1):\n self.__framebuffer[(x, y)] = _col","def num_depth(self):\n return len(self._sizes) + len(self._ratios) - 1","def setPixelColorRGB(self, n, red, green, blue):\n\t\tself.setPixelColor(n, Color(red, green, blue))","def setPageFill(ncolor):\n dislin.pagfll(ncolor)","def colorFrame(self, _color):\n\t\tif self.frame:\n\t\t\tfor nr, i in enumerate(self.frame):\n\t\t\t\tself.frame[nr][1] = _color","def colorFrame(self, _color):\n\t\tif self.frame:\n\t\t\tfor nr, i in enumerate(self.frame):\n\t\t\t\tself.frame[nr][1] = _color","def load_colors(self):\n self.color_queue = deque(range(10))","def color(self, color):\n\n self.container['color'] = color","def _set_color_mode(self, mode):\n self._write(ST7789_COLMOD, bytes([mode & 0x77]))","def svn_info_t_depth_set(svn_info_t_self, svn_depth_t_depth): # real signature unknown; restored from __doc__\n pass","def setColor(self,value):\n\t\tself.politics = value if(type(value) is int)else int(value[1:],16)\n\t\tself.canvas.itemconfig('node_'+self.identifier,fill=self.toRGB())","def num_depth(self):\n if self._index == 0:\n return len(self._ratios)\n else:\n return len(self._sizes) + len(self._ratios) - 1","def setColor(pnj, color):\r\n\r\n assert isinstance(color, (int, tuple, str))\r\n pnj[\"color\"] = color","def get_num_explored(self):\n return self.__num_explored","def set_palette(self, red, green, blue, alpha):\n raise DitherError(\"Not implemented\")","def depth(self) -> int:\n return self.__depth","def changeColor( self ):\n\t\t\n\t\tx, y = self.position.xy\n\t\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))","def depth(x):\n return max(int(x * depth_multiplier), 8)","def __init__(self,\n levels=1,\n palette=None,\n *args, **kwargs):\n super().__init__(*args, **kwargs)\n if palette is None:\n try:\n palette = self.scanner.palette\n except AttributeError:\n palette = default_palette(8, 4, 8)\n elif len(palette) == 3:\n palette = default_palette(*palette)\n self.palette = palette\n self.levels = levels","def convertDepthFrame(self):\n try:\n\n \"\"\" \n Convert Depth frame to rudimentary colormap\n \"\"\"\n self.DepthHSV[...,0] = self.currentDepthFrame\n self.DepthHSV[...,1] = 0x9F\n self.DepthHSV[...,2] = 0xFF\n self.DepthCM = cv2.cvtColor(self.DepthHSV,cv2.COLOR_HSV2RGB)\n cv2.drawContours(self.DepthCM,self.block_contours,-1,(0,0,0),3)\n\n img = QImage(self.DepthCM,\n self.DepthCM.shape[1],\n self.DepthCM.shape[0],\n QImage.Format_RGB888\n )\n return img\n except:\n return None","def DEPTH(frame):\n\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\n\tframe.image.copy_bits( depth.ctypes.data )\n\tcv2.imshow( 'VideoDEPTH', depth )","def depth_callback(self, data):\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\"passthrough\")\n self.depth_mutex.acquire()\n self.depth_image = cv_image\n self.depth_mutex.release()","def set_color(self, color):\n self.color = color","def add_depth(self, px, py, d):\n if self.circular:\n iy, ix = np.where(\n create_circular_mask(\n self.height, self.width, py, px, radius=50))\n idices = ix + iy * self.width\n for idx in idices:\n self._depth_buffer[idx].append(d)\n else:\n idx = px + py * self.width\n self._depth[idx] = d","def update(self):\n super().update()\n time_since_start = self.time_since_start() \n curr_mod = time_since_start%self.game.time_cycle_secs\n grade = abs(curr_mod - self.game.time_cycle_secs/2) / (self.game.time_cycle_secs/2)\n color_value = grade*(255-self.game.max_darkness) + self.game.max_darkness\n for sprite in self.all_sprites:\n sprite.color = (color_value, color_value, color_value)","def set_color(self, new_color):\n self.color = new_color","def setColors255(self):\n #productive\n profprint()\n self.color255= [[0,0,0] for i in range(205)]\n self.color255[0]=[221,108,158]\n self.color255[1]=[128,174,128]\n self.color255[2]=[241,214,145]\n self.color255[3]=[177,122,101]\n self.color255[4]=[111,184,210]\n self.color255[5]=[216,101,79]\n self.color255[6]=[221,130,101]\n self.color255[7]=[144,238,144]\n self.color255[8]=[192,104,88]\n self.color255[9]=[220,245,20]\n self.color255[10]=[78,63,0]\n self.color255[11]=[255,250,220]\n self.color255[12]=[230,220,70]\n self.color255[13]=[200,200,235]\n self.color255[14]=[250,250,210]\n self.color255[15]=[244,214,49]\n self.color255[16]=[0,151,206]\n self.color255[17]=[183,156,220]\n self.color255[18]=[183,214,211]\n self.color255[19]=[152,189,207]\n self.color255[20]=[178,212,242]\n self.color255[21]=[68,172,100]\n self.color255[22]=[111,197,131]\n self.color255[23]=[85,188,255]\n self.color255[24]=[0,145,30]\n self.color255[25]=[214,230,130]\n self.color255[26]=[218,255,255]\n self.color255[27]=[170,250,250]\n self.color255[28]=[140,224,228]\n self.color255[29]=[188,65,28]\n self.color255[30]=[216,191,216]\n self.color255[31]=[145,60,66]\n self.color255[32]=[150,98,83]\n self.color255[33]=[250,250,225]\n self.color255[34]=[200,200,215]\n self.color255[35]=[68,131,98]\n self.color255[36]=[83,146,164]\n self.color255[37]=[162,115,105]\n self.color255[38]=[141,93,137]\n self.color255[39]=[182,166,110]\n self.color255[40]=[188,135,166]\n self.color255[41]=[154,150,201]\n self.color255[42]=[177,140,190]\n self.color255[43]=[30,111,85]\n self.color255[44]=[210,157,166]\n self.color255[45]=[48,129,126]\n self.color255[46]=[98,153,112]\n self.color255[47]=[69,110,53]\n self.color255[48]=[166,113,137]\n self.color255[49]=[122,101,38]\n self.color255[50]=[253,135,192]\n self.color255[51]=[145,92,109]\n self.color255[52]=[46,101,131]\n self.color255[53]=[0,108,112]\n self.color255[54]=[127,150,88]\n self.color255[55]=[159,116,163]\n self.color255[56]=[125,102,154]\n self.color255[57]=[106,174,155]\n self.color255[58]=[154,146,83]\n self.color255[59]=[126,126,55]\n self.color255[60]=[201,160,133]\n self.color255[61]=[78,152,141]\n self.color255[62]=[174,140,103]\n self.color255[63]=[139,126,177]\n self.color255[64]=[148,120,72]\n self.color255[65]=[186,135,135]\n self.color255[66]=[99,106,24]\n self.color255[67]=[156,171,108]\n self.color255[68]=[64,123,147]\n self.color255[69]=[138,95,74]\n self.color255[70]=[97,113,158]\n self.color255[71]=[126,161,197]\n self.color255[72]=[194,195,164]\n self.color255[73]=[88,106,215]\n self.color255[74]=[82,174,128]\n self.color255[75]=[57,157,110]\n self.color255[76]=[60,143,83]\n self.color255[77]=[92,162,109]\n self.color255[78]=[255,244,209]\n self.color255[79]=[201,121,77]\n self.color255[80]=[70,163,117]\n self.color255[81]=[188,91,95]\n self.color255[82]=[166,84,94]\n self.color255[83]=[182,105,107]\n self.color255[84]=[229,147,118]\n self.color255[85]=[174,122,90]\n self.color255[86]=[201,112,73]\n self.color255[87]=[194,142,0]\n self.color255[88]=[241,213,144]\n self.color255[89]=[203,179,77]\n self.color255[90]=[229,204,109]\n self.color255[91]=[255,243,152]\n self.color255[92]=[209,185,85]\n self.color255[93]=[248,223,131]\n self.color255[94]=[255,230,138]\n self.color255[95]=[196,172,68]\n self.color255[96]=[255,255,167]\n self.color255[97]=[255,250,160]\n self.color255[98]=[255,237,145]\n self.color255[99]=[242,217,123]\n self.color255[100]=[222,198,101]\n self.color255[101]=[213,124,109]\n self.color255[102]=[184,105,108]\n self.color255[103]=[150,208,243]\n self.color255[104]=[62,162,114]\n self.color255[105]=[242,206,142]\n self.color255[106]=[250,210,139]\n self.color255[107]=[255,255,207]\n self.color255[108]=[182,228,255]\n self.color255[109]=[175,216,244]\n self.color255[110]=[197,165,145]\n self.color255[111]=[172,138,115]\n self.color255[112]=[202,164,140]\n self.color255[113]=[224,186,162]\n self.color255[114]=[255,245,217]\n self.color255[115]=[206,110,84]\n self.color255[116]=[210,115,89]\n self.color255[117]=[203,108,81]\n self.color255[118]=[233,138,112]\n self.color255[119]=[195,100,73]\n self.color255[120]=[181,85,57]\n self.color255[121]=[152,55,13]\n self.color255[122]=[159,63,27]\n self.color255[123]=[166,70,38]\n self.color255[124]=[218,123,97]\n self.color255[125]=[225,130,104]\n self.color255[126]=[224,97,76]\n self.color255[127]=[184,122,154]\n self.color255[128]=[211,171,143]\n self.color255[129]=[47,150,103]\n self.color255[130]=[173,121,88]\n self.color255[131]=[188,95,76]\n self.color255[132]=[255,239,172]\n self.color255[133]=[226,202,134]\n self.color255[134]=[253,232,158]\n self.color255[135]=[244,217,154]\n self.color255[136]=[205,179,108]\n self.color255[137]=[186,124,161]\n self.color255[138]=[255,255,220]\n self.color255[139]=[234,234,194]\n self.color255[140]=[204,142,178]\n self.color255[141]=[180,119,153]\n self.color255[142]=[216,132,105]\n self.color255[143]=[255,253,229]\n self.color255[144]=[205,167,142]\n self.color255[145]=[204,168,143]\n self.color255[146]=[255,224,199]\n self.color255[147]=[139,150,98]\n self.color255[148]=[249,180,111]\n self.color255[149]=[157,108,162]\n self.color255[150]=[203,136,116]\n self.color255[151]=[185,102,83]\n self.color255[152]=[247,182,164]\n self.color255[153]=[222,154,132]\n self.color255[154]=[124,186,223]\n self.color255[155]=[249,186,150]\n self.color255[156]=[244,170,147]\n self.color255[157]=[255,181,158]\n self.color255[158]=[255,190,165]\n self.color255[159]=[227,153,130]\n self.color255[160]=[213,141,113]\n self.color255[161]=[193,123,103]\n self.color255[162]=[216,146,127]\n self.color255[163]=[230,158,140]\n self.color255[164]=[245,172,147]\n self.color255[165]=[241,172,151]\n self.color255[166]=[177,124,92]\n self.color255[167]=[171,85,68]\n self.color255[168]=[217,198,131]\n self.color255[169]=[212,188,102]\n self.color255[170]=[185,135,134]\n self.color255[171]=[198,175,125]\n self.color255[172]=[194,98,79]\n self.color255[173]=[255,238,170]\n self.color255[174]=[206,111,93]\n self.color255[175]=[216,186,0]\n self.color255[176]=[255,226,77]\n self.color255[177]=[255,243,106]\n self.color255[178]=[255,234,92]\n self.color255[179]=[240,210,35]\n self.color255[180]=[224,194,0]\n self.color255[181]=[213,99,79]\n self.color255[182]=[217,102,81]\n self.color255[183]=[0,147,202]\n self.color255[184]=[0,122,171]\n self.color255[185]=[186,77,64]\n self.color255[186]=[240,255,30]\n self.color255[187]=[185,232,61]\n self.color255[188]=[0,226,255]\n self.color255[189]=[251,159,255]\n self.color255[190]=[230,169,29]\n self.color255[191]=[0,194,113]\n self.color255[192]=[104,160,249]\n self.color255[193]=[221,108,158]\n self.color255[194]=[137,142,0]\n self.color255[195]=[230,70,0]\n self.color255[196]=[0,147,0]\n self.color255[197]=[0,147,248]\n self.color255[198]=[231,0,206]\n self.color255[199]=[129,78,0]\n self.color255[200]=[0,116,0]\n self.color255[201]=[0,0,255]\n self.color255[202]=[157,0,0]\n self.color255[203]=[100,100,130]\n self.color255[204]=[205,205,100]\n \n return self.color255","def update_color(self):\n self.plot(update_traces=False, update_waveforms=True)","def depth(self):\n \n return self._depth","def setColor(self, color):\n for patch in self._patches:\n patch.setColor(color)","def set_color(self):\n self.image[self.x, self.y] = self.color\n if self.diffusion:\n r = g = b = 0\n for i in range(self.convolution_matrix.shape[0]):\n for j in range(self.convolution_matrix.shape[1]):\n r = g = b = 0\n for k in range(self.convolution_matrix.shape[0]):\n for l in range(self.convolution_matrix.shape[1]):\n m = (self.x + i + k - 2 + self.image.shape[0]) % self.image.shape[0]\n n = (self.y + j + l - 2 + self.image.shape[1]) % self.image.shape[1]\n r += self.convolution_matrix[k][l] * self.image[m, n][2]\n g += self.convolution_matrix[k][l] * self.image[m, n][1]\n b += self.convolution_matrix[k][l] * self.image[m, n][0]\n self.image[self.x, self.y] = (b, g, r)","def setColorIndex(idx):\n dislin.setclr(idx)","def shadeToDepth(color):\n minDistance = 0.7\n maxDistance = 20\n maxColor = 255\n color = np.average(color, axis=None)\n # depth = mx + b\n # m = (minDistance - maxDistance)/maxColor\n # x = color\n # b = maxDistance\n m = (maxDistance - minDistance)/maxColor\n x = color\n b = minDistance\n return m * x + b","def _set_z_size(self):\n self._level_gen.size = (self._level_gen.size[X],\n self._level_gen.size[Y],\n self._level_size_z_spinbox.value())\n self._refresh_view()","def draw_color_bar(frame):\n depth = 35\n cv2.rectangle(frame, (0,0), (72,depth - 1), (0,0,0), 2) # white/eraser\n cv2.rectangle(frame, (72,0), (138,depth), (0,0,0), -1) # black\n cv2.rectangle(frame, (138,0), (204,depth), (122,78,32), -1) # brown\n cv2.rectangle(frame, (204,0), (270,depth), (242,0,255), -1) # violet/purple\n cv2.rectangle(frame, (270,0), (336,depth), (0,0,255), -1) # blue\n cv2.rectangle(frame, (336,0), (402,depth), (63,255,0), -1) # green\n cv2.rectangle(frame, (402,0), (468,depth), (255,250,0), -1) # yellow\n cv2.rectangle(frame, (468,0), (534,depth), (255,174,0), -1) # orange\n cv2.rectangle(frame, (534,0), (600,depth), (255,0,0), -1) # red","def imshow(self, depth):\n layer = self.cube[depth]\n img = []\n for i in range(self.height):\n img.append([layer[i][j].value for j in range(self.width)])\n plt.imshow(img, cmap='gray')\n plt.show()","def get_default_color_depth(self) -> ColorDepth:\n if self.default_color_depth is not None:\n return self.default_color_depth\n\n return ColorDepth.DEPTH_4_BIT","def setColor(self, color):\n self.__color = color","def _set_number_of_levels(self, number_of_levels):\n if not number_of_levels & 1:\n number_of_levels -= 1\n logging.warning('Set number of levels to an odd number %r',\n number_of_levels)\n\n self._number_of_levels = number_of_levels\n self._compute_quantization_factor()","def set_color(self, color):\n self._color = color"],"string":"[\n \"def SetDepth(*args, **kwargs):\\n return _gdi_.Bitmap_SetDepth(*args, **kwargs)\",\n \"def set_depth(self, depth):\\n self._depth = depth\\n if self._scaled_image_coordinates is None:\\n self._initialise()\\n else:\\n self._update_depth()\",\n \"def color_depth(self):\\n return self._color_depth\",\n \"def ColorizeDepthFrame(self):\\n self.DepthFrameHSV[..., 0] = self.DepthFrameRaw\\n self.DepthFrameHSV[..., 1] = 0x9F\\n self.DepthFrameHSV[..., 2] = 0xFF\\n self.DepthFrameRGB = cv2.cvtColor(\\n self.DepthFrameHSV, cv2.COLOR_HSV2RGB)\",\n \"def set_depth(self, d):\\r\\n self.depth = d\",\n \"def set_depth(self, z):\\r\\n self.z = z\\r\\n self._update_rect()\",\n \"def setDepth(self, *args):\\n return _CompuCell.Potts3D_setDepth(self, *args)\",\n \"def depth_color(depth):\\n if depth < 20:\\n return 'g'\\n if depth < 40:\\n return 'y'\\n return 'r'\",\n \"def setChrDepths(self, cd):\\n self.chr_depth = cd\",\n \"def setDepth(self, *args):\\n return _libsbml.Dimensions_setDepth(self, *args)\",\n \"def set_depth(self, new_depth):\\n self.caravan_depth = new_depth\",\n \"def changeConvolutionalDepth(self,depth):\\n self.conv_depth = depth\",\n \"def updatePageDepthColor(self, newVal):\\n self.depthSelections[self.val].set_facecolor(self.nonSelectedDepthColor)\\n self.depthSelections[newVal].set_facecolor(self.selectedDepthColor)\",\n \"def setPixelColor(self, n, color):\\n self._logger.debug(\\\"setPixelColor\\\")\",\n \"def depth(self, new_depth):\\n \\n # Check a type of 'new_depth' parametr \\n if not isinstance(new_depth, (int, long)):\\n raise TypeError('int or long type expected')\\n self._depth = new_depth\",\n \"def set_depth(node, depth):\\n setattr(node[0], \\\"depth\\\", depth)\",\n \"def _set_curr_depth(self, curr_depth):\\n self.curr_depth = curr_depth.fluid_pressure\",\n \"def updateDepthBlendWeights(percent):\\n global depthWeight\\n depthWeight = float(percent)/100.0\",\n \"def setNoiseCancellationDepth(self, channel, group, depth, unitCode=0):\\n resp = self.XAPCommand('NCD', channel, group, depth, unitCode=unitCode)\\n return int(resp)\",\n \"def increment_depth(self):\\r\\n self.depth = self.depth + 1\",\n \"def bit_depth(self, value):\\n self._bit_depth = value\\n self._max_DN = (2 ** self.bit_depth) - 1\",\n \"def bit_depth(self, value):\\n self._bit_depth = value\\n self._max_DN = (2 ** self.bit_depth) - 1\",\n \"def setColourLevels(self):\\n minsg = np.min(self.sg)\\n maxsg = np.max(self.sg)\\n brightness = self.brightnessSlider.value()\\n contrast = self.contrastSlider.value()\\n colourStart = (brightness / 100.0 * contrast / 100.0) * (maxsg - minsg) + minsg\\n colourEnd = (maxsg - minsg) * (1.0 - contrast / 100.0) + colourStart\\n for btn in self.picbuttons:\\n btn.stopPlayback()\\n btn.setImage(self.lut, colourStart, colourEnd, False)\\n btn.update()\",\n \"def depth_percent(self, depth_percent):\\n\\n self.container['depth_percent'] = depth_percent\",\n \"def log_depth(self, *args, **kwargs):\\n def log(prefix_idx, batch, output):\\n self._metrics.update(log_rgb('rgb', prefix_idx, batch))\\n self._metrics.update(log_inv_depth('inv_depth', prefix_idx, output))\\n if 'depth' in batch:\\n self._metrics.update(log_depth('depth', prefix_idx, batch))\\n self.log_images(log, *args, **kwargs)\",\n \"def setDepth(self, *args):\\n return _libsbml.BoundingBox_setDepth(self, *args)\",\n \"def setColors(self):\\n #productive\\n profprint()\\n self.color= [[0,0,0] for i in range(205)]\\n self.color255= self.setColors255()\\n for i in range(205):\\n for j in range(3):\\n self.color[i][j] = self.color255[i][j]/float(255)\\n\\n return self.color\",\n \"def make_palette(self, color_count):\\n palette = []\\n palette_index = 0\\n leaf_count = len(self.get_leaves())\\n # reduce nodes\\n # up to 8 leaves can be reduced here and the palette will have\\n # only 248 colors (in worst case) instead of expected 256 colors\\n for level in range(OctreeQuantizer.MAX_DEPTH - 1, -1, -1):\\n if self.levels[level]:\\n for node in self.levels[level]:\\n leaf_count -= node.remove_leaves()\\n if leaf_count <= color_count:\\n break\\n if leaf_count <= color_count:\\n break\\n self.levels[level] = []\\n # build palette\\n for node in self.get_leaves():\\n if palette_index >= color_count:\\n break\\n if node.is_leaf():\\n palette.append(node.get_color())\\n node.palette_index = palette_index\\n palette_index += 1\\n return palette\",\n \"def AMdepth(depthPerc=100,channel=1):\\r\\n inst.write(\\\":AM%i:DEPT %iPCT\\\" %(channel,depthPerc))\",\n \"def setPixelColor(self, n, color):\\n\\t\\t#print \\\"pxl %s = %s\\\" % (n, color)\\n\\t\\tif isinstance(n, slice):\\n\\t\\t\\tself.leds[n] = [color]*len(self.leds[n])\\n\\t\\telse:\\n\\t\\t\\tif n >= 0 or n <= self.size:\\n\\t\\t\\t\\tself.leds[n] = color\\n\\t\\t#pprint(self.leds)\",\n \"def _update_color(self):\\n self._vertex_list.colors[:] = self._rgba * self._num_verts\",\n \"def setColorResolution(width=1,height=1):\\n dislin.setres(width,height)\",\n \"def setColors(self):\\r\\n # productive\\r\\n profprint()\\r\\n self.color = [[0, 0, 0] for i in range(MAXCOL)]\\r\\n self.color255 = self.setColors255()\\r\\n for i in range(MAXCOL):\\r\\n for j in range(3):\\r\\n self.color[i][j] = self.color255[i][j] / float(255)\\r\\n\\r\\n return self.color\",\n \"def set_color(self, value):\\n _lib.caca_set_dither_color.argtypes = [_Dither, ctypes.c_char_p]\\n _lib.caca_set_dither_color.restype = ctypes.c_int\\n\\n return _lib.caca_set_dither_color(self, value)\",\n \"def add_color(self, color, level, parent):\\n if level >= OctreeQuantizer.MAX_DEPTH:\\n self.color.red += color.red\\n self.color.green += color.green\\n self.color.blue += color.blue\\n self.pixel_count += 1\\n return\\n index = self.get_color_index_for_level(color, level)\\n if not self.children[index]:\\n self.children[index] = OctreeNode(level, parent)\\n self.children[index].add_color(color, level + 1, parent)\",\n \"def _update_color(self, color):\\n self.color = color\",\n \"def show_rgbd(self):\\n while self.depth_data is None:\\n pass\\n\\n while not rospy.is_shutdown():\\n rospy.Rate(10).sleep()\\n d = self.depth_data * self.cam.DEPTH_UNIT\\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\\n dc = np.concatenate((d, self.rgb_data), axis=1)\\n cv2.imshow('RGB & Depth Image', dc)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n cv2.destroyAllWindows()\",\n \"def refresh_color(self):\\n self.color = max(0, int(math.sqrt(self.vx ** 2\\n + self.vy ** 2)) + 100)\",\n \"def on_depth_image(self, depth_image):\\n depth_image = depth_image.copy()\\n mask = np.where(self.depth != 0)\\n depth_image[mask] = self.depth[mask]\\n return depth_image\",\n \"def set_color(group, color, pct=1):\\n for l, v in zip(group, color):\\n l.brightness_pct = v * pct\",\n \"def update_color(self):\\r\\n \\r\\n \\r\\n colorset = self.colorset\\r\\n \\r\\n self.grfx[0].colorset = colorset\\r\\n pass\",\n \"def vis_depth_map(\\n img_rgb: NDArrayByte,\\n depth_map: NDArrayFloat,\\n interp_depth_map: bool,\\n num_dilation_iters: int = 10,\\n) -> None:\\n if not interp_depth_map:\\n # fix the zero values?\\n depth_map[depth_map == 0] = np.finfo(np.float32).max\\n\\n # purely for visualization\\n depth_map = cv2.dilate(\\n depth_map,\\n kernel=np.ones((2, 2), np.uint8),\\n iterations=num_dilation_iters,\\n )\\n\\n # prevent too dark in the foreground, clip far away\\n depth_map = np.clip(depth_map, 0, 50)\\n\\n plt.subplot(1, 2, 1)\\n plt.imshow(img_rgb)\\n plt.subplot(1, 2, 2)\\n plt.imshow((depth_map * 3).astype(np.uint8), cmap=\\\"inferno\\\")\",\n \"def setPixelColorRGB(self, n, red, green, blue, white=0):\\n self._logger.debug(\\\"setPixelColorRGB\\\")\",\n \"def loadDepthFrame(self):\\n self.DepthFrameRaw = cv2.imread(\\n script_path + \\\"/data/raw_depth.png\\\", 0).astype(np.uint16)\",\n \"def startColorLoop():\\n b.set_group(1, 'on', True)\\n b.set_group(1, 'bri', 254)\\n b.set_group(1, 'hue', 255)\\n b.set_group(1, 'sat', 255)\\n b.set_group(1, 'effect', 'colorloop')\",\n \"def convertDepthFrame(self):\\n try:\\n \\\"\\\"\\\" \\n Convert Depth frame to rudimentary colormap\\n \\\"\\\"\\\"\\n self.DepthHSV[...,0] = self.currentDepthFrame\\n self.DepthHSV[...,1] = 0x9F\\n self.DepthHSV[...,2] = 0xFF\\n self.DepthCM = cv2.cvtColor(self.DepthHSV,cv2.COLOR_HSV2RGB)\\n cv2.drawContours(self.DepthCM,self.block_contours,-1,(0,0,0),3)\\n cv2.drawContours(self.DepthCM,self.block_contours_2,-1,(0,0,0),3)\\n cv2.drawContours(self.DepthCM,self.block_contours_3,-1,(0,0,0),3)\\n\\n img = QImage(self.DepthCM,\\n self.DepthCM.shape[1],\\n self.DepthCM.shape[0],\\n QImage.Format_RGB888\\n )\\n return img\\n except:\\n return None\",\n \"def set_color(self, color):\\n pass\",\n \"def run(palette='hsv', num_vals=12):\\n fout_png = 'colors_{P}_{N}.png'.format(P=palette, N=num_vals)\\n _, axis = plt.subplots(1, 1, figsize=(6, 6))\\n colobj = MplColorHelper(palette, 0, num_vals-1)\\n colors = [colobj.get_hexstr(yval) for yval in range(num_vals)]\\n plt_color_text(colors)\\n for idx, color in enumerate(reversed(colors)):\\n print('{N:2} {COLOR}'.format(N=idx, COLOR=color))\\n axis.set_title('{N} Discrete Colors from {MAP}'.format(N=num_vals, MAP=palette))\\n plt.show()\\n plt.savefig(fout_png)\\n print(' WROTE: {PNG}'.format(PNG=fout_png))\",\n \"def obtain_depth(self):\\n self.z_buffer = image(self.image_plane.width, self.image_plane.height)\\n for j in range(self.image_plane.height):\\n for i in range(self.image_plane.width):\\n single_point = None\\n for ray_tracing in self.ray_tracer:\\n ray_tracing.ray_direction(i, j)\\n ray_tracing.sphere_to_ray()\\n ray_tracing.ray_sphere_intersection()\\n ray_tracing.hit_pos()\\n hit_point = ray_tracing.getHit()\\n\\n if single_point is None:\\n single_point = hit_point\\n elif single_point is not None and single_point.z > hit_point.z:\\n single_point = hit_point\\n self.z_buffer.setColor(single_point, i, j)\",\n \"def _update_color(self, *args):\\n\\n if self._variable and 'w' in self._mode and not self._dnd_started:\\n self._internal_color_change = True\\n self.color_var.set(self._variable)\",\n \"def update_depths(self, fixed=True, r=2):\\n\\n n_images = len(self.images)\\n # faster if we batch multiple depth updates together\\n\\n inds = self.keyframe_inds\\n if fixed and len(self.keyframe_inds) > 1:\\n inds = inds[1:]\\n\\n for keyframe_index in inds:\\n adj_list = [keyframe_index]\\n for j in range(keyframe_index - r, keyframe_index + r + 1):\\n if keyframe_index != j:\\n j = min(max(j, 0), n_images)\\n adj_list.append(j)\\n\\n images = np.stack([self.images[i] for i in adj_list], axis=0)\\n poses = np.stack([self.poses[i] for i in adj_list], axis=0)\\n\\n feed_dict = {\\n self.images_placeholder: images,\\n self.poses_placeholder: poses,\\n self.intrinsics_placeholder: self.intrinsics,\\n }\\n\\n keyframe_depth = self.sess.run(self.outputs['depths'], feed_dict=feed_dict)\\n self.depths[keyframe_index] = keyframe_depth[0]\",\n \"def set_color(self, color):\\n\\t\\tpass\",\n \"def rgb(self, value):\\n\\n self._variable = value\\n self._update()\",\n \"def changeColor(self):\\n self.layer.new_colormap()\",\n \"def color(self, value: tuple) -> None:\\n if value in Color.PALETTE:\\n self._color = value\",\n \"def set_pattern(colors=('green', 'blue', 'red')): # (10)\\n for i in range(0, int(ceil(float(NUM_LEDS)/float(len(colors))))):\\n for color in colors:\\n push_color(color)\",\n \"def setLeds(number: int, red: int, green: int, blue: int):\\n pass\",\n \"def assign_color(self,tank):\\n tank.color = self.color_queue.popleft()\",\n \"def getDepth(depth: str) -> int:\\n return {\\n CommonPrefs.DEPTH_8: 8,\\n CommonPrefs.DEPTH_16: 16,\\n CommonPrefs.DEPTH_24: 24,\\n CommonPrefs.DEPTH_32: 32,\\n }.get(depth, 24)\",\n \"def set_layer(self, n):\\n self.layernum = n\\n self.update()\",\n \"def fill_color(self, _col):\\n for x in xrange(0, self.__resolution[0], 1):\\n for y in xrange(0, self.__resolution[1], 1):\\n self.__framebuffer[(x, y)] = _col\",\n \"def num_depth(self):\\n return len(self._sizes) + len(self._ratios) - 1\",\n \"def setPixelColorRGB(self, n, red, green, blue):\\n\\t\\tself.setPixelColor(n, Color(red, green, blue))\",\n \"def setPageFill(ncolor):\\n dislin.pagfll(ncolor)\",\n \"def colorFrame(self, _color):\\n\\t\\tif self.frame:\\n\\t\\t\\tfor nr, i in enumerate(self.frame):\\n\\t\\t\\t\\tself.frame[nr][1] = _color\",\n \"def colorFrame(self, _color):\\n\\t\\tif self.frame:\\n\\t\\t\\tfor nr, i in enumerate(self.frame):\\n\\t\\t\\t\\tself.frame[nr][1] = _color\",\n \"def load_colors(self):\\n self.color_queue = deque(range(10))\",\n \"def color(self, color):\\n\\n self.container['color'] = color\",\n \"def _set_color_mode(self, mode):\\n self._write(ST7789_COLMOD, bytes([mode & 0x77]))\",\n \"def svn_info_t_depth_set(svn_info_t_self, svn_depth_t_depth): # real signature unknown; restored from __doc__\\n pass\",\n \"def setColor(self,value):\\n\\t\\tself.politics = value if(type(value) is int)else int(value[1:],16)\\n\\t\\tself.canvas.itemconfig('node_'+self.identifier,fill=self.toRGB())\",\n \"def num_depth(self):\\n if self._index == 0:\\n return len(self._ratios)\\n else:\\n return len(self._sizes) + len(self._ratios) - 1\",\n \"def setColor(pnj, color):\\r\\n\\r\\n assert isinstance(color, (int, tuple, str))\\r\\n pnj[\\\"color\\\"] = color\",\n \"def get_num_explored(self):\\n return self.__num_explored\",\n \"def set_palette(self, red, green, blue, alpha):\\n raise DitherError(\\\"Not implemented\\\")\",\n \"def depth(self) -> int:\\n return self.__depth\",\n \"def changeColor( self ):\\n\\t\\t\\n\\t\\tx, y = self.position.xy\\n\\t\\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))\",\n \"def depth(x):\\n return max(int(x * depth_multiplier), 8)\",\n \"def __init__(self,\\n levels=1,\\n palette=None,\\n *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n if palette is None:\\n try:\\n palette = self.scanner.palette\\n except AttributeError:\\n palette = default_palette(8, 4, 8)\\n elif len(palette) == 3:\\n palette = default_palette(*palette)\\n self.palette = palette\\n self.levels = levels\",\n \"def convertDepthFrame(self):\\n try:\\n\\n \\\"\\\"\\\" \\n Convert Depth frame to rudimentary colormap\\n \\\"\\\"\\\"\\n self.DepthHSV[...,0] = self.currentDepthFrame\\n self.DepthHSV[...,1] = 0x9F\\n self.DepthHSV[...,2] = 0xFF\\n self.DepthCM = cv2.cvtColor(self.DepthHSV,cv2.COLOR_HSV2RGB)\\n cv2.drawContours(self.DepthCM,self.block_contours,-1,(0,0,0),3)\\n\\n img = QImage(self.DepthCM,\\n self.DepthCM.shape[1],\\n self.DepthCM.shape[0],\\n QImage.Format_RGB888\\n )\\n return img\\n except:\\n return None\",\n \"def DEPTH(frame):\\n\\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\\n\\tframe.image.copy_bits( depth.ctypes.data )\\n\\tcv2.imshow( 'VideoDEPTH', depth )\",\n \"def depth_callback(self, data):\\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\\\"passthrough\\\")\\n self.depth_mutex.acquire()\\n self.depth_image = cv_image\\n self.depth_mutex.release()\",\n \"def set_color(self, color):\\n self.color = color\",\n \"def add_depth(self, px, py, d):\\n if self.circular:\\n iy, ix = np.where(\\n create_circular_mask(\\n self.height, self.width, py, px, radius=50))\\n idices = ix + iy * self.width\\n for idx in idices:\\n self._depth_buffer[idx].append(d)\\n else:\\n idx = px + py * self.width\\n self._depth[idx] = d\",\n \"def update(self):\\n super().update()\\n time_since_start = self.time_since_start() \\n curr_mod = time_since_start%self.game.time_cycle_secs\\n grade = abs(curr_mod - self.game.time_cycle_secs/2) / (self.game.time_cycle_secs/2)\\n color_value = grade*(255-self.game.max_darkness) + self.game.max_darkness\\n for sprite in self.all_sprites:\\n sprite.color = (color_value, color_value, color_value)\",\n \"def set_color(self, new_color):\\n self.color = new_color\",\n \"def setColors255(self):\\n #productive\\n profprint()\\n self.color255= [[0,0,0] for i in range(205)]\\n self.color255[0]=[221,108,158]\\n self.color255[1]=[128,174,128]\\n self.color255[2]=[241,214,145]\\n self.color255[3]=[177,122,101]\\n self.color255[4]=[111,184,210]\\n self.color255[5]=[216,101,79]\\n self.color255[6]=[221,130,101]\\n self.color255[7]=[144,238,144]\\n self.color255[8]=[192,104,88]\\n self.color255[9]=[220,245,20]\\n self.color255[10]=[78,63,0]\\n self.color255[11]=[255,250,220]\\n self.color255[12]=[230,220,70]\\n self.color255[13]=[200,200,235]\\n self.color255[14]=[250,250,210]\\n self.color255[15]=[244,214,49]\\n self.color255[16]=[0,151,206]\\n self.color255[17]=[183,156,220]\\n self.color255[18]=[183,214,211]\\n self.color255[19]=[152,189,207]\\n self.color255[20]=[178,212,242]\\n self.color255[21]=[68,172,100]\\n self.color255[22]=[111,197,131]\\n self.color255[23]=[85,188,255]\\n self.color255[24]=[0,145,30]\\n self.color255[25]=[214,230,130]\\n self.color255[26]=[218,255,255]\\n self.color255[27]=[170,250,250]\\n self.color255[28]=[140,224,228]\\n self.color255[29]=[188,65,28]\\n self.color255[30]=[216,191,216]\\n self.color255[31]=[145,60,66]\\n self.color255[32]=[150,98,83]\\n self.color255[33]=[250,250,225]\\n self.color255[34]=[200,200,215]\\n self.color255[35]=[68,131,98]\\n self.color255[36]=[83,146,164]\\n self.color255[37]=[162,115,105]\\n self.color255[38]=[141,93,137]\\n self.color255[39]=[182,166,110]\\n self.color255[40]=[188,135,166]\\n self.color255[41]=[154,150,201]\\n self.color255[42]=[177,140,190]\\n self.color255[43]=[30,111,85]\\n self.color255[44]=[210,157,166]\\n self.color255[45]=[48,129,126]\\n self.color255[46]=[98,153,112]\\n self.color255[47]=[69,110,53]\\n self.color255[48]=[166,113,137]\\n self.color255[49]=[122,101,38]\\n self.color255[50]=[253,135,192]\\n self.color255[51]=[145,92,109]\\n self.color255[52]=[46,101,131]\\n self.color255[53]=[0,108,112]\\n self.color255[54]=[127,150,88]\\n self.color255[55]=[159,116,163]\\n self.color255[56]=[125,102,154]\\n self.color255[57]=[106,174,155]\\n self.color255[58]=[154,146,83]\\n self.color255[59]=[126,126,55]\\n self.color255[60]=[201,160,133]\\n self.color255[61]=[78,152,141]\\n self.color255[62]=[174,140,103]\\n self.color255[63]=[139,126,177]\\n self.color255[64]=[148,120,72]\\n self.color255[65]=[186,135,135]\\n self.color255[66]=[99,106,24]\\n self.color255[67]=[156,171,108]\\n self.color255[68]=[64,123,147]\\n self.color255[69]=[138,95,74]\\n self.color255[70]=[97,113,158]\\n self.color255[71]=[126,161,197]\\n self.color255[72]=[194,195,164]\\n self.color255[73]=[88,106,215]\\n self.color255[74]=[82,174,128]\\n self.color255[75]=[57,157,110]\\n self.color255[76]=[60,143,83]\\n self.color255[77]=[92,162,109]\\n self.color255[78]=[255,244,209]\\n self.color255[79]=[201,121,77]\\n self.color255[80]=[70,163,117]\\n self.color255[81]=[188,91,95]\\n self.color255[82]=[166,84,94]\\n self.color255[83]=[182,105,107]\\n self.color255[84]=[229,147,118]\\n self.color255[85]=[174,122,90]\\n self.color255[86]=[201,112,73]\\n self.color255[87]=[194,142,0]\\n self.color255[88]=[241,213,144]\\n self.color255[89]=[203,179,77]\\n self.color255[90]=[229,204,109]\\n self.color255[91]=[255,243,152]\\n self.color255[92]=[209,185,85]\\n self.color255[93]=[248,223,131]\\n self.color255[94]=[255,230,138]\\n self.color255[95]=[196,172,68]\\n self.color255[96]=[255,255,167]\\n self.color255[97]=[255,250,160]\\n self.color255[98]=[255,237,145]\\n self.color255[99]=[242,217,123]\\n self.color255[100]=[222,198,101]\\n self.color255[101]=[213,124,109]\\n self.color255[102]=[184,105,108]\\n self.color255[103]=[150,208,243]\\n self.color255[104]=[62,162,114]\\n self.color255[105]=[242,206,142]\\n self.color255[106]=[250,210,139]\\n self.color255[107]=[255,255,207]\\n self.color255[108]=[182,228,255]\\n self.color255[109]=[175,216,244]\\n self.color255[110]=[197,165,145]\\n self.color255[111]=[172,138,115]\\n self.color255[112]=[202,164,140]\\n self.color255[113]=[224,186,162]\\n self.color255[114]=[255,245,217]\\n self.color255[115]=[206,110,84]\\n self.color255[116]=[210,115,89]\\n self.color255[117]=[203,108,81]\\n self.color255[118]=[233,138,112]\\n self.color255[119]=[195,100,73]\\n self.color255[120]=[181,85,57]\\n self.color255[121]=[152,55,13]\\n self.color255[122]=[159,63,27]\\n self.color255[123]=[166,70,38]\\n self.color255[124]=[218,123,97]\\n self.color255[125]=[225,130,104]\\n self.color255[126]=[224,97,76]\\n self.color255[127]=[184,122,154]\\n self.color255[128]=[211,171,143]\\n self.color255[129]=[47,150,103]\\n self.color255[130]=[173,121,88]\\n self.color255[131]=[188,95,76]\\n self.color255[132]=[255,239,172]\\n self.color255[133]=[226,202,134]\\n self.color255[134]=[253,232,158]\\n self.color255[135]=[244,217,154]\\n self.color255[136]=[205,179,108]\\n self.color255[137]=[186,124,161]\\n self.color255[138]=[255,255,220]\\n self.color255[139]=[234,234,194]\\n self.color255[140]=[204,142,178]\\n self.color255[141]=[180,119,153]\\n self.color255[142]=[216,132,105]\\n self.color255[143]=[255,253,229]\\n self.color255[144]=[205,167,142]\\n self.color255[145]=[204,168,143]\\n self.color255[146]=[255,224,199]\\n self.color255[147]=[139,150,98]\\n self.color255[148]=[249,180,111]\\n self.color255[149]=[157,108,162]\\n self.color255[150]=[203,136,116]\\n self.color255[151]=[185,102,83]\\n self.color255[152]=[247,182,164]\\n self.color255[153]=[222,154,132]\\n self.color255[154]=[124,186,223]\\n self.color255[155]=[249,186,150]\\n self.color255[156]=[244,170,147]\\n self.color255[157]=[255,181,158]\\n self.color255[158]=[255,190,165]\\n self.color255[159]=[227,153,130]\\n self.color255[160]=[213,141,113]\\n self.color255[161]=[193,123,103]\\n self.color255[162]=[216,146,127]\\n self.color255[163]=[230,158,140]\\n self.color255[164]=[245,172,147]\\n self.color255[165]=[241,172,151]\\n self.color255[166]=[177,124,92]\\n self.color255[167]=[171,85,68]\\n self.color255[168]=[217,198,131]\\n self.color255[169]=[212,188,102]\\n self.color255[170]=[185,135,134]\\n self.color255[171]=[198,175,125]\\n self.color255[172]=[194,98,79]\\n self.color255[173]=[255,238,170]\\n self.color255[174]=[206,111,93]\\n self.color255[175]=[216,186,0]\\n self.color255[176]=[255,226,77]\\n self.color255[177]=[255,243,106]\\n self.color255[178]=[255,234,92]\\n self.color255[179]=[240,210,35]\\n self.color255[180]=[224,194,0]\\n self.color255[181]=[213,99,79]\\n self.color255[182]=[217,102,81]\\n self.color255[183]=[0,147,202]\\n self.color255[184]=[0,122,171]\\n self.color255[185]=[186,77,64]\\n self.color255[186]=[240,255,30]\\n self.color255[187]=[185,232,61]\\n self.color255[188]=[0,226,255]\\n self.color255[189]=[251,159,255]\\n self.color255[190]=[230,169,29]\\n self.color255[191]=[0,194,113]\\n self.color255[192]=[104,160,249]\\n self.color255[193]=[221,108,158]\\n self.color255[194]=[137,142,0]\\n self.color255[195]=[230,70,0]\\n self.color255[196]=[0,147,0]\\n self.color255[197]=[0,147,248]\\n self.color255[198]=[231,0,206]\\n self.color255[199]=[129,78,0]\\n self.color255[200]=[0,116,0]\\n self.color255[201]=[0,0,255]\\n self.color255[202]=[157,0,0]\\n self.color255[203]=[100,100,130]\\n self.color255[204]=[205,205,100]\\n \\n return self.color255\",\n \"def update_color(self):\\n self.plot(update_traces=False, update_waveforms=True)\",\n \"def depth(self):\\n \\n return self._depth\",\n \"def setColor(self, color):\\n for patch in self._patches:\\n patch.setColor(color)\",\n \"def set_color(self):\\n self.image[self.x, self.y] = self.color\\n if self.diffusion:\\n r = g = b = 0\\n for i in range(self.convolution_matrix.shape[0]):\\n for j in range(self.convolution_matrix.shape[1]):\\n r = g = b = 0\\n for k in range(self.convolution_matrix.shape[0]):\\n for l in range(self.convolution_matrix.shape[1]):\\n m = (self.x + i + k - 2 + self.image.shape[0]) % self.image.shape[0]\\n n = (self.y + j + l - 2 + self.image.shape[1]) % self.image.shape[1]\\n r += self.convolution_matrix[k][l] * self.image[m, n][2]\\n g += self.convolution_matrix[k][l] * self.image[m, n][1]\\n b += self.convolution_matrix[k][l] * self.image[m, n][0]\\n self.image[self.x, self.y] = (b, g, r)\",\n \"def setColorIndex(idx):\\n dislin.setclr(idx)\",\n \"def shadeToDepth(color):\\n minDistance = 0.7\\n maxDistance = 20\\n maxColor = 255\\n color = np.average(color, axis=None)\\n # depth = mx + b\\n # m = (minDistance - maxDistance)/maxColor\\n # x = color\\n # b = maxDistance\\n m = (maxDistance - minDistance)/maxColor\\n x = color\\n b = minDistance\\n return m * x + b\",\n \"def _set_z_size(self):\\n self._level_gen.size = (self._level_gen.size[X],\\n self._level_gen.size[Y],\\n self._level_size_z_spinbox.value())\\n self._refresh_view()\",\n \"def draw_color_bar(frame):\\n depth = 35\\n cv2.rectangle(frame, (0,0), (72,depth - 1), (0,0,0), 2) # white/eraser\\n cv2.rectangle(frame, (72,0), (138,depth), (0,0,0), -1) # black\\n cv2.rectangle(frame, (138,0), (204,depth), (122,78,32), -1) # brown\\n cv2.rectangle(frame, (204,0), (270,depth), (242,0,255), -1) # violet/purple\\n cv2.rectangle(frame, (270,0), (336,depth), (0,0,255), -1) # blue\\n cv2.rectangle(frame, (336,0), (402,depth), (63,255,0), -1) # green\\n cv2.rectangle(frame, (402,0), (468,depth), (255,250,0), -1) # yellow\\n cv2.rectangle(frame, (468,0), (534,depth), (255,174,0), -1) # orange\\n cv2.rectangle(frame, (534,0), (600,depth), (255,0,0), -1) # red\",\n \"def imshow(self, depth):\\n layer = self.cube[depth]\\n img = []\\n for i in range(self.height):\\n img.append([layer[i][j].value for j in range(self.width)])\\n plt.imshow(img, cmap='gray')\\n plt.show()\",\n \"def get_default_color_depth(self) -> ColorDepth:\\n if self.default_color_depth is not None:\\n return self.default_color_depth\\n\\n return ColorDepth.DEPTH_4_BIT\",\n \"def setColor(self, color):\\n self.__color = color\",\n \"def _set_number_of_levels(self, number_of_levels):\\n if not number_of_levels & 1:\\n number_of_levels -= 1\\n logging.warning('Set number of levels to an odd number %r',\\n number_of_levels)\\n\\n self._number_of_levels = number_of_levels\\n self._compute_quantization_factor()\",\n \"def set_color(self, color):\\n self._color = color\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6401659","0.6380821","0.6300926","0.62612724","0.5997467","0.5974511","0.5967667","0.5931414","0.5931148","0.59209645","0.58476746","0.58119255","0.57820714","0.57815474","0.5667481","0.5611237","0.5600413","0.5562935","0.5406338","0.53640157","0.53597665","0.53597665","0.5350042","0.5335973","0.53140414","0.5284104","0.52814204","0.5249606","0.5239207","0.5229915","0.5222692","0.51694655","0.5109942","0.50780934","0.5076891","0.5071835","0.5061351","0.50467503","0.5035525","0.5031293","0.50302815","0.502836","0.5026987","0.5024536","0.49769711","0.49681365","0.4965505","0.49637818","0.496157","0.49495924","0.49402502","0.49269304","0.49176317","0.49110934","0.49090248","0.49086672","0.4887781","0.48809677","0.48802027","0.48795006","0.4872442","0.48670775","0.48538923","0.4837635","0.48252088","0.48252088","0.4823579","0.48163807","0.48159724","0.4813156","0.47874945","0.47678047","0.47667173","0.47657296","0.4764594","0.47630015","0.47625026","0.47485983","0.4744411","0.47418132","0.47351393","0.4730505","0.47269025","0.47143507","0.4707302","0.47035414","0.46992138","0.4694911","0.46897736","0.4683969","0.46819365","0.46807313","0.4676377","0.46758133","0.46751463","0.4670986","0.467085","0.4659779","0.46594992","0.4653496"],"string":"[\n \"0.6401659\",\n \"0.6380821\",\n \"0.6300926\",\n \"0.62612724\",\n \"0.5997467\",\n \"0.5974511\",\n \"0.5967667\",\n \"0.5931414\",\n \"0.5931148\",\n \"0.59209645\",\n \"0.58476746\",\n \"0.58119255\",\n \"0.57820714\",\n \"0.57815474\",\n \"0.5667481\",\n \"0.5611237\",\n \"0.5600413\",\n \"0.5562935\",\n \"0.5406338\",\n \"0.53640157\",\n \"0.53597665\",\n \"0.53597665\",\n \"0.5350042\",\n \"0.5335973\",\n \"0.53140414\",\n \"0.5284104\",\n \"0.52814204\",\n \"0.5249606\",\n \"0.5239207\",\n \"0.5229915\",\n \"0.5222692\",\n \"0.51694655\",\n \"0.5109942\",\n \"0.50780934\",\n \"0.5076891\",\n \"0.5071835\",\n \"0.5061351\",\n \"0.50467503\",\n \"0.5035525\",\n \"0.5031293\",\n \"0.50302815\",\n \"0.502836\",\n \"0.5026987\",\n \"0.5024536\",\n \"0.49769711\",\n \"0.49681365\",\n \"0.4965505\",\n \"0.49637818\",\n \"0.496157\",\n \"0.49495924\",\n \"0.49402502\",\n \"0.49269304\",\n \"0.49176317\",\n \"0.49110934\",\n \"0.49090248\",\n \"0.49086672\",\n \"0.4887781\",\n \"0.48809677\",\n \"0.48802027\",\n \"0.48795006\",\n \"0.4872442\",\n \"0.48670775\",\n \"0.48538923\",\n \"0.4837635\",\n \"0.48252088\",\n \"0.48252088\",\n \"0.4823579\",\n \"0.48163807\",\n \"0.48159724\",\n \"0.4813156\",\n \"0.47874945\",\n \"0.47678047\",\n \"0.47667173\",\n \"0.47657296\",\n \"0.4764594\",\n \"0.47630015\",\n \"0.47625026\",\n \"0.47485983\",\n \"0.4744411\",\n \"0.47418132\",\n \"0.47351393\",\n \"0.4730505\",\n \"0.47269025\",\n \"0.47143507\",\n \"0.4707302\",\n \"0.47035414\",\n \"0.46992138\",\n \"0.4694911\",\n \"0.46897736\",\n \"0.4683969\",\n \"0.46819365\",\n \"0.46807313\",\n \"0.4676377\",\n \"0.46758133\",\n \"0.46751463\",\n \"0.4670986\",\n \"0.467085\",\n \"0.4659779\",\n \"0.46594992\",\n \"0.4653496\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.756508"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76574,"cells":{"query":{"kind":"string","value":"Gets the gif_loop of this GIFOutput. If to loop the GIF. 1 is no loop, 0 is infinite loops, and other numbers are number of loops."},"document":{"kind":"string","value":"def gif_loop(self):\n return self._gif_loop"},"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 gif_loop(self, gif_loop):\n if gif_loop is not None and gif_loop < -1:\n raise ValueError(\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\")\n\n self._gif_loop = gif_loop","def get_loop(self):\n\n log(\"Getting loop for {} at {}\".format(self._location, self._t0))\n loop = io.BytesIO()\n try:\n frames = self.get_frames()\n if frames is None:\n raise\n log(\"Got {} frames for {} at {}\".format(\n len(frames),\n self._location,\n self._t0\n ))\n frames[0].save(\n loop,\n append_images=frames[1:],\n duration=500,\n format='GIF',\n loop=0,\n save_all=True,\n )\n except:\n log(\"Got NO frames for {} at {}\".format(self._location, self._t0))\n self._pilimg.new('RGB', (340, 370)).save(loop, format='GIF')\n if self._outfn:\n outdir = os.path.dirname(self._outfn)\n if not os.path.isdir(outdir):\n try:\n os.makedirs(outdir)\n except:\n log_error(\"Could not create directory {}\".format(outdir))\n try:\n with open(self._outfn, 'wb') as f:\n f.write(loop.getvalue())\n except:\n log_error(\"Could not write image to {}\".format(self._outfn))\n return loop.getvalue()","def get_loop(self) -> bool:\n return self._select_interface(self._rc_get_loop, self._http_get_loop)","def loop(self):\n\n return self._loop","def while_loop(self):\n if self._loop is None:\n self._loop = self._while_loop()\n return self._loop\n return self._loop","def gif(self):\n\n if self._gif is None:\n\n url = self.url.replace('f=fits', 'f=gif')\n\n try:\n url_data = urllib.request.urlopen(url)\n except urllib.request.URLError as ee:\n raise ValueError(f'cannot open URL for these parameters: {ee}')\n\n data = url_data.read()\n\n image = PIL.Image.open(io.BytesIO(data))\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\n\n self._gif = image\n\n return self._gif","def enable_loop(self):\n loop = (self._loop_mode is LoopMode.Wrap)\n return loop","def loop_type(graph = None):\n\tbreakpoints = 0\n\tfor edge in nx.generate_edgelist(graph):\n\t\tif ('breakpoint' in edge):\n\t\t\tbreakpoints += 1\n\n\tif breakpoints == 1:\n\t\tif is_loop(graph = graph):\n\t\t\treturn 'hairpinloop'\n\t\telse:\n\t\t\treturn 'dangling_end'\n\n\tif is_loop(graph = graph):\n\t\tif breakpoints == 2:\n\t\t\treturn multiloop_type(graph = graph)\n\t\telif breakpoints == 3:\n\t\t\treturn 'multiloop3'\n\t\telif breakpoints == 4:\n\t\t\treturn 'multiloop4'\n\t\telif breakpoints == 5:\n\t\t\treturn 'multiloop5'\n\treturn 'NA'","def __loop(self):\n if self.loops is \"inf\":\n self.play()\n else:\n if self.loops > self.current_loop:\n self.current_loop += 1\n self.play()\n else:\n self.stop()","def get_loop(logger):\n try:\n SerialAsyncLoop.mutex.acquire()\n if SerialAsyncLoop.count == 0:\n SerialAsyncLoop(logger)\n SerialAsyncLoop.count += 1\n if logger:\n logger.info(f\"SerialAsyncLoop instance count: {SerialAsyncLoop.count}\")\n return SerialAsyncLoop._loop\n except Exception as e:\n raise\n finally:\n SerialAsyncLoop.mutex.release()","def loop(self):\n return self.caller.location.ndb.event_line_loop","def loop(self):\r\n if self.delay_count >= self.delay:\r\n if self.loop_alt == 0:\r\n self.frame_index += 1\r\n elif self.loop_alt == 1:\r\n if self.loop_down and self.frame_index > 0:\r\n self.frame_index -= 1\r\n else:\r\n self.frame_index += 1\r\n self.loop_down = False\r\n if self.frame_index >= len(self.frames): # Repeat frames\r\n if self.loop_alt == 0:\r\n self.frame_index = 0\r\n elif self.loop_alt == 1:\r\n self.loop_down = True\r\n self.frame_index -= 2\r\n\r\n self.image = self.frames[self.frame_index]\r\n self.delay_count = 0\r\n else:\r\n self.delay_count += 1","def get_loopstate():\n return grovepi.digitalRead(LOOP)","def getImage(self):\n\n\t\t\t_frame = str(self._frame)\n\t\t\tself._counter += 1\n\t\t\tif self._counter >= 10/ANIMATION_SPEED:\n\t\t\t\tself._frame += 1\n\t\t\t\tself._counter = 0\n\n\t\t\tif self.images[self.getState()][self.getDirection()][str(self._frame)] == {}:\n\t\t\t\tself._frame = 0\n\n\t\t\treturn self.images[self.getState()][self.getDirection()][_frame]","def loop(self, loop: bool=None):\n self._select_interface(self._rc_loop, self._http_loop, loop)","def loop():\n global loop_idx\n sys.stdout.write('loop index %d/%d\\r\\n' % (loop_idx, _LOOPS))\n time.sleep(0.5)\n loop_idx += 1\n return loop_idx > _LOOPS","def first_loop_play_count(self) -> int:\n return self.__first_loop_play_count","def get_gif_key(self):\n key = self.bot_data_file[\"apiKeys\"][\"gif\"]\n if self.check_empty_key(key):\n return key\n else:\n print(\"ERROR GETTING THE GIF KEY (get yours from http://api.giphy.com/) - ABORTING\")\n quit(1)","def config_loop(self):\n loop_label = ['Loop OFF', 'Loop ON']\n group = self.make_ui_group(False, loop_label[self.loop])\n orig_loop = self.loop\n\n while True:\n action_left, action_right = (self.button_left.action(),\n self.button_right.action())\n if action_left is RichButton.HOLD:\n return self.loop is not orig_loop, False # Resume config\n if action_right is RichButton.HOLD:\n return self.loop is not orig_loop, True # Resume paint\n if RichButton.TAP in {action_left, action_right}:\n self.loop = not self.loop\n group.pop()\n group.append(centered_label(loop_label[self.loop], 40, 3))","async def gif(self, ctx: discord.ext.commands.Context, *args):\n print(\"-------------------------\")\n message_channel: discord.abc.Messageable = ctx.message.channel\n currentgifkey = self.botVariables.get_gif_key()\n print(\"GifRequest:Arguments:\" + str(len(args)))\n tag = \"\"\n if len(args) == 0: # request a random gif\n print(\"Gif Request with No arguments\")\n url = \"http://api.giphy.com/v1/gifs/random?api_key=\" + currentgifkey\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as resp:\n r = await resp.json()\n if 'data' in r:\n await message_channel.send(r['data']['url'])\n elif 'message' in r:\n await message_channel.send(\"An error occurred:\" + r['message'])\n else: # request a gif with tags\n for x in range(0, len(args)):\n tag = tag + args[x]\n if x != (len(args) - 1):\n tag += \" \"\n tag = urllib.parse.quote(tag)\n url = \"http://api.giphy.com/v1/gifs/random?api_key=\" + currentgifkey + \"&tag=\" + tag\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as resp:\n r = await resp.json()\n print(\"GifRequest:Gif Found\")\n if (len(r['data'])) == 0:\n await message_channel.send(\"No GIF found with those tags :frowning: \")\n else:\n if 'data' in r:\n await message_channel.send(r['data']['url'])\n elif 'message' in r:\n await message_channel.send(\"An error occurred:\" + r['message'])\n print(\"-------------------------\")","def first_loop_type(self) -> int:\n return self.__first_loop_type","def gif_fps(self):\n return self._gif_fps","def get_repeat(self) -> bool:\n return self._select_interface(self._rc_get_repeat,\n self._http_get_repeat)","async def loop(self, ctx: commands.Context) -> Optional[bool]:\n\n self.queue[ctx.guild.id].loop = (\n Loops.LOOP if self.queue[ctx.guild.id].loop != Loops.LOOP else Loops.NO_LOOP\n )\n return self.queue[ctx.guild.id].loop == Loops.LOOP","def ios_test_loop(self) -> Optional[pulumi.Input['IosTestLoopArgs']]:\n return pulumi.get(self, \"ios_test_loop\")","def infinite_loop():\n return True","def get_frame_rate(gif=''):\n\n # identify -format \"Frame %s: %Tcs\\n\" ~/test.gif - frame life in centiseconds - how very odd.\n frame_rate_str = subprocess.check_output([\n 'identify',\n '-format',\n '%T\\n',\n gif\n ])\n # If we failed to get a frame lifetime from imagemagick...\n if len(frame_rate_str) <= 0:\n frame_rate = str(FRAME_RATE)\n else:\n # Get gif's lifetime...\n frame_rate_list = frame_rate_str.split('\\n')\n frame_rate_list = [int(n) for n in frame_rate_list if n]\n lifetime = float(sum(frame_rate_list)) / 100\n\n # print \"gif lifetime is \" + str(lifetime) + \"s\"\n # Determine average frames per second\n frame_rate = str(len(frame_rate_list) / lifetime)\n if float(frame_rate) <= 0.0:\n frame_rate = FRAME_RATE\n\n return frame_rate","def watch_loop(self):\n # Double threaded function that allows to stop the loop mid execution\n def repeatIt():\n # reset UI and flag before starting loop\n self.resetLabels()\n self.reset_scrollbar()\n # enable stop button\n self.btnStop.config(state=\"normal\")\n # disable button while loop is running\n self.btnStart.config(state=\"disabled\")\n self.txtLoop.config(state=\"disabled\", textvariable=self.loopCounterUI)\n self.labelLoop.config(text=\"Loop Count: \")\n\n while self.loopCount.get() > 0:\n # move scrollbar to bottom\n self.testCanvas.yview_moveto(0)\n # count the loop\n self.loopCounterUI.set(self.loopCounterUI.get() + 1)\n\n # Run the test cases\n self.runThis()\n\n # Below are just to reset the UI\n if not self.stopLoop:\n print(\"loop not stopped so proceed\")\n # let user know script is stopping\n x = Label(\n self.testFrame, text=f'End of Loop',\n background=self.bgChooser(),\n foreground=\"#630984\",\n font=self.boldFont)\n x.pack(fill=X)\n # flag gor BG and labels\n self.bgCounter += 1\n self.LabelLists.append(x)\n # allow window to catch up\n self.tkRoot.update()\n self.update_scrollbar()\n else:\n print(\"loop has been stopped so not gonna print End of Loop\")\n\n # pause before restarting loop\n self.loopCount.set(self.loopCount.get()-1)\n time.sleep(1)\n\n # disable stop button\n self.btnStop.config(state=\"disabled\")\n # re-enable button after loop is done\n self.btnStart.config(state=\"normal\")\n self.txtLoop.config(state=\"normal\", textvariable=self.loopCount)\n self.labelLoop.config(text=\"Enter Loop Count: \")\n # self.testCanvas.yview_moveto(0)\n # Let user know the script is done\n if not self.stopLoop:\n # loop did not stopped\n x = Label(\n self.testFrame, text=f'Test is done!',\n background=self.bgChooser(),\n foreground=\"#057224\",\n font=self.boldFont)\n x.pack(fill=X)\n self.bgCounter += 1\n else:\n x = Label(\n self.testFrame, text=f'Test stopped!',\n background=self.bgChooser(),\n foreground=\"#057224\",\n font=self.boldFont)\n x.pack(fill=X)\n self.bgCounter += 1\n self.btnStart.config(state=\"normal\")\n self.txtLoop.config(state=\"normal\", textvariable=self.loopCount)\n self.labelLoop.config(text=\"Enter Loop count: \")\n self.loopCount.set(50000)\n self.LabelLists.append(x)\n # allow window to catch up\n self.tkRoot.update()\n self.update_scrollbar()\n thread = threading.Thread(target=repeatIt)\n thread.start()","def animated_gif(folder_with_images, gif_filename, loop_duration, size):\r\n\r\n\tos.chdir(folder_with_images) # changes directory to the folder with the images\r\n\r\n\tpng_files = []\r\n\r\n\t# get list of png files in folder\r\n\tfor fn in os.listdir(folder_with_images):\r\n\t\tif fn.endswith('.png'):\r\n\t\t\tpng_files.append(fn)\r\n\r\n\tsort_nicely(png_files)\r\n\r\n\tprint(png_files)\r\n\r\n\t# number of png_files\r\n\tnum_pngs = len(png_files)\r\n\tpng_time = float(loop_duration)/ float(num_pngs)\r\n\r\n\timages = [Image.open(fn) for fn in png_files]\r\n\tdim = (size, size) # change sizes for the image file dimension\r\n\t#for im in images:\r\n\t#\tim.thumbnail(dim, Image.ANTIALIAS)\r\n\r\n\toutput_file = os.path.join(folder_with_images, gif_filename) # path for output file\r\n\twriteGif(output_file, images, png_time) # writes out GIF\r","def gif(self, delay=20, savefile=None, iterations=0, show_path=False,\n use_ffmpeg=False):\n from sage.misc.sage_ostools import have_program\n have_convert = have_program('convert')\n have_ffmpeg = self._have_ffmpeg()\n if use_ffmpeg or not have_convert:\n if have_ffmpeg:\n self.ffmpeg(savefile=savefile, show_path=show_path,\n output_format='.gif', delay=delay,\n iterations=iterations)\n else:\n if not have_convert:\n msg = \"\"\"\nError: Neither ImageMagick nor ffmpeg appears to be installed. Saving an\nanimation to a GIF file or displaying an animation requires one of these\npackages, so please install one of them and try again.\n\nSee www.imagemagick.org and www.ffmpeg.org for more information.\"\"\"\n else:\n msg = \"\"\"\nError: ffmpeg does not appear to be installed. Download it from\nwww.ffmpeg.org, or use 'convert' to produce gifs instead.\"\"\"\n raise OSError(msg)\n else:\n if not savefile:\n savefile = graphics_filename(ext='.gif')\n if not savefile.endswith('.gif'):\n savefile += '.gif'\n savefile = os.path.abspath(savefile)\n d = self.png()\n cmd = ( 'cd \"%s\"; sage-native-execute convert -dispose Background '\n '-delay %s -loop %s *.png \"%s\"' ) % ( d, int(delay),\n int(iterations), savefile )\n from subprocess import check_call, CalledProcessError\n try:\n check_call(cmd, shell=True)\n if show_path:\n print(\"Animation saved to file %s.\" % savefile)\n except (CalledProcessError, OSError):\n msg = \"\"\"\nError: Cannot generate GIF animation. Verify that convert\n(ImageMagick) or ffmpeg is installed, and that the objects passed to\nthe animate command can be saved in PNG image format.\n\nSee www.imagemagick.org and www.ffmpeg.org for more information.\"\"\"\n raise OSError(msg)","def first_loop_end(self) -> int:\n return self.__first_loop_end","def repeat(self):\n return self._get('repeat')","def multiloop_type(graph = None):\n\tg = graph.copy()\n\tbreakpoint_nodes = []\n\tfor edge in g.edges(data=True):\n\t\tid1 ,id2 , data = edge\n\t\tif g.edge[id1][id2]['label']== '$':\n\t\t\tif not id1 in breakpoint_nodes:\n\t\t\t\tbreakpoint_nodes.append(id1)\n\t\t\tif not id2 in breakpoint_nodes:\n\t\t\t\tbreakpoint_nodes.append(id2)\n\tfor node in breakpoint_nodes:\n\t\tg.remove_node(node)\n\tif nx.number_connected_components(g) ==1:\n\t\treturn 'bulge'\n\telse:\n\t\treturn 'internal_loop'","def iteration(self):\n return self._iteration","def iteration(self):\n return self._iteration","def iteration(self):\n return self._iteration","def iteration(self):\n return self._iteration","def get_gif_uri(kanji):\n fileName = kanji.encode(\"unicode-escape\").decode(\"utf-8\").replace(\"\\\\u\", '') + '.gif'\n animationUri = f'https://raw.githubusercontent.com/mistval/kanji_images/master/gifs/{fileName}'\n return animationUri","def loop_running(self):\r\n if self.is_running:\r\n if self.first_time:\r\n self.time = time.time()\r\n self.first_time = False\r\n else:\r\n self._loop_end() # Finish the previous loop.\r\n self._loop_begin()\r\n else:\r\n self._loop_end()\r\n self.destroy()\r\n\r\n return self.is_running","def is_loop(*args):\n return _ida_hexrays.is_loop(*args)","def write_loop_text(self):\n\t\tself.write_components['loop'] = \"\"\"loop( ({sets})$({cond}), {loop})\n\t\t\"\"\".format( sets = ', '.join(self.shock_gm.database[self.loop_name].names),\n\t\t\t\t\tcond = self.shock_gm.database.get(self.loop_name).to_str,\n\t\t\t\t\tloop = self.loop_text)\n\t\treturn self.write_components['loop']","def get_iteration(self):\n return self.iteration","def bottle_song_while(num):\n pass","def start_frame(self):\n\n # Check whether we're supposed to make a frame on this iteration:\n if self.frame_count % self.stride != 0:\n return\n\n # Check whether we're already making a frame. \n if self.in_scope:\n print(\"The Gif object for {} has encountered 'start_frame' twice\\\n without an intervening 'end_frame'\".format(self.filename))\n raise SyntaxError\n\n # Construct a new figure\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\n self.current_frame = fig\n\n # Set the \"in_scope\" member True\n self.in_scope = True\n\n return self.current_frame","async def queueloop(self, ctx: commands.Context) -> Optional[bool]:\n\n queue = self.queue[ctx.guild.id]\n\n queue.loop = (\n Loops.QUEUE_LOOP\n if self.queue[ctx.guild.id].loop != Loops.QUEUE_LOOP\n else Loops.NO_LOOP\n )\n\n if queue.loop == Loops.QUEUE_LOOP:\n queue.queue_loop_start = queue.pos\n\n return queue.loop == Loops.QUEUE_LOOP","def _get_loop(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Optional[asyncio.AbstractEventLoop]:\n if callable(self.loop_getter):\n if self.loop_getter_need_context:\n return self.loop_getter(*args, **kwargs) # pylint: disable=not-callable\n return self.loop_getter() # pylint: disable=not-callable\n return self.loop_getter","def repeat(self):\n return self._repeat","def ios_test_loop(self) -> 'outputs.IosTestLoopResponse':\n return pulumi.get(self, \"ios_test_loop\")","def loopcount(self):\n return len(self.loopindices)","def read_gif(self, filename):\n blocks = {}\n with open(os.path.join(self.template_dir, filename), 'rb') as gif_fd:\n blocks['header'] = gif_fd.read(6)\n assert blocks['header'] in (b'GIF87a', b'GIF89a')\n blocks['lcd'] = gif_fd.read(7) # logical screen descriptor\n assert blocks['lcd'].endswith(b'\\xe3\\x10\\x00') # gct of 16 colours\n blocks['gct'] = gif_fd.read(16 * 3) # global colour table\n blocks['img_descriptor'] = gif_fd.read(10) # image descriptor\n assert blocks['img_descriptor'][0] == 0x2c\n assert blocks['img_descriptor'][9] == 0\n # img data\n blocks['img_data'] = gif_fd.read(1) # LZW min code size\n while True: # img data sub-blocks\n blocks['img_data'] += gif_fd.read(1) # sub-block data size\n if blocks['img_data'][-1] == 0:\n break # final sub-block (size 0)\n blocks['img_data'] += gif_fd.read(blocks['img_data'][-1])\n assert gif_fd.read(1) == b'\\x3b' # trailer\n return blocks","async def _loop(self, ctx: commands.Context):\n\n if not ctx.voice_state.is_playing:\n return await ctx.send('Nothing being played at the moment.')\n\n # Inverse boolean value to loop and unloop.\n ctx.voice_state.loop = not ctx.voice_state.loop\n await ctx.message.add_reaction('✅')","async def _loop(self, ctx: commands.Context):\n\n if not ctx.voice_state.is_playing:\n return await ctx.send('Nothing being played at the moment.')\n\n # Inverse boolean value to loop and unloop.\n ctx.voice_state.loop = not ctx.voice_state.loop\n await ctx.message.add_reaction('✅')","def get_gif(self, tag: Text) -> Optional[Text]:\r\n if tag == \"all\":\r\n matches = self.elements\r\n else:\r\n sub_tags = tag.split(\"+\")\r\n matches = [e for e in self.elements if all(t in e.tags for t in sub_tags)]\r\n return random.choice(matches).url if matches else None","def first_loop_fraction(self) -> int:\n return self.__first_loop_fraction","def getInstance():\n if GameLoop.__instance==None:\n GameLoop()\n return GameLoop.__instance","def animated_gif(file):\n\n\timport os.path\n\timport Image\n\tfrom conf import *\n\tfrom util_errors import gen_error\n\tANIMGIF_TAGID = 2\n\n\tfilepath = os.path.join(PROBATION_DIR, file[\"filename\"])\n\ttry:\n\t\timg = Image.open(filepath)\n\t\ttry:\n\t\t\timg.seek(1)\n\t\texcept:\n\t\t\tpass\n\t\telse:\n\t\t\tdel(img)\n\t\t\treturn [ANIMGIF_TAGID]\n\texcept Exception, data:\n\t\tgen_error('GENERIC', \"File couldn't be operated on, check perms -- \" + str(data))\n\n\tdel(img)\n\treturn []","def get_frames(gif: Image.Image) -> List[Image.Image]:\n last_frame = None\n all_frames = []\n i = 0\n try:\n while True:\n gif.seek(i)\n new_frame = gif.convert('RGBA')\n if last_frame is not None and gif.disposal_method == 1:\n updated = new_frame.crop(gif.dispose_extent)\n last_frame.paste(updated, gif.dispose_extent, updated)\n new_frame = last_frame\n else:\n last_frame = new_frame\n\n # do resizing on new_frame here...\n\n all_frames.append(new_frame.copy())\n i += 1\n except EOFError:\n gif.seek(0)\n\n return all_frames","def _get_repeat_times(self):\n # The passed arg on_repeat is used to check that.\n\n # The arg passes 1 in case the --repeat flag is not passed\n # which means we simply need to loop for once.\n\n # The arg passes None in case the --repeat flag is passed but\n # without a value. In this case, we need to make sure the song goes\n # on an infinite loop. Though, in our case, we will make the loop run\n # for a really large value like 1000\n\n # The arg passes the number of times the loop is supposed the run in\n # case the value is passed by the user.\n\n if self.on_repeat == 1:\n return 1\n elif self.on_repeat is None:\n logger.info(\"Repeating indefinitely\")\n return 5000\n else:\n logger.info(\n \"Repeating {} {}\".format(\n self.on_repeat, \"time\" if self.on_repeat == 1 else \"times\"\n )\n )\n return self.on_repeat","def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\n\n self._gif_fps = None\n self._color_depth = None\n self._gif_loop = None\n self._height = None\n self._start = None\n self._duration = None\n self._suffix = None\n self._overlay = None\n self._overlay_alignment = None\n self._overlay_scale = None\n self._label = None\n self.discriminator = None\n\n if gif_fps is not None:\n self.gif_fps = gif_fps\n if color_depth is not None:\n self.color_depth = color_depth\n if gif_loop is not None:\n self.gif_loop = gif_loop\n self.height = height\n self.start = start\n if duration is not None:\n self.duration = duration\n if suffix is not None:\n self.suffix = suffix\n if overlay is not None:\n self.overlay = overlay\n if overlay_alignment is not None:\n self.overlay_alignment = overlay_alignment\n if overlay_scale is not None:\n self.overlay_scale = overlay_scale\n if label is not None:\n self.label = label","def GetGifFrames(self, path):\n gif = imageio.mimread(path)\n return [\n (image.meta[\"duration\"], cv2.resize(\n cv2.cvtColor(image, cv2.COLOR_RGB2BGR), (64, 64))\n ) for image in gif\n ]","def has_loop(self) -> bool:\n try:\n list(self)\n return False\n except ContainsLoopError:\n return True","def get_first_playable_flag(self, direction):\n return next((f for f in xrange(1, 10) if self.is_flag_playable(f - 1, direction)), None)","def android_test_loop(self) -> Optional[pulumi.Input['AndroidTestLoopArgs']]:\n return pulumi.get(self, \"android_test_loop\")","def _set_loop(tik_instance, num_core, max_core, total_dim):\n core_loop = tik_instance.Scalar(\"uint64\")\n\n with tik_instance.if_scope(num_core < total_dim % AICORE_NUM):\n core_loop.set_as(_ceil_div(total_dim, max_core))\n with tik_instance.else_scope():\n core_loop.set_as(total_dim // max_core)\n\n return core_loop","def _while_loop(self):\n bind_map = {}\n wl = set_span(tvm.relay.var(\"while_loop\"), self._loop_name)\n sb = tvm.relay.scope_builder.ScopeBuilder()\n\n lv_list = []\n expr_list = []\n extra_vars = []\n\n for i, lv in enumerate(self.loop_vars):\n if self._loop_name not in self._lvar2expr:\n self._lvar2expr[self._loop_name] = {}\n\n # Handle the case when loop var is not properly lifted.\n # This can happen when loop var node name is set accidentally\n # beginning with loop name.\n if lv not in self._lvar2expr[self._loop_name]:\n var_name = f\"{self._loop_name}_loop_var_{i}\"\n var_type = _infer_type(lv, self._mod).checked_type\n loop_var = set_span(tvm.relay.var(var_name, type_annotation=var_type), var_name)\n self._lvar2expr[self._loop_name][loop_var] = lv\n bind_map[lv] = loop_var\n self.loop_vars[i] = loop_var\n lv = loop_var\n\n lv_list.append(lv)\n expr_list.append(self._lvar2expr[self._loop_name][lv])\n\n if bind_map:\n self.cond = rewrite_subgraph(self.cond, bind_map)\n self.body = [rewrite_subgraph(b, bind_map) for b in self.body]\n\n cond = set_span(tvm.relay.op.min(self.cond), self.cond.span)\n\n for lv, exp in self._lvar2expr[self._loop_name].items():\n if lv not in self.loop_vars:\n var_checker = VarChecker(lv)\n for bd in self.body + [cond]:\n var_checker.visit(bd)\n if var_checker.used:\n lv_list.append(lv)\n expr_list.append(exp)\n extra_vars.append(lv)\n break\n\n with sb.if_scope(cond):\n sb.ret(wl(*list(self.body + extra_vars)))\n with sb.else_scope():\n sb.ret(tvm.relay.Tuple(lv_list))\n\n loop_fn = tvm.relay.Function(lv_list, sb.get())\n sb = tvm.relay.scope_builder.ScopeBuilder()\n sb.let(wl, loop_fn)\n loop_ret = wl(*expr_list)\n\n sb.ret(loop_ret)\n ret = sb.get()\n return ret","def send_GIF():\n try:\n gif_icon = driver.find_element_by_xpath('//*[@data-tip=\"GIF\"]')\n gif_icon.click()\n wait(wait_time=10)\n gifs = driver.find_elements_by_class_name('giphy-gif')\n src = gifs[0].get_attribute('src')\n gif_ID = src[src.index('media/') + len('media/'):]\n gif_ID = gif_ID[:gif_ID.index('/')]\n gifs[0].click()\n wait()\n except Exception as e:\n return \"Error: \" + str(e)\n if verify_GIF_sent(gif_ID):\n return \"Success\"\n else:\n return \"Error: GIF wasn't sent\"","def current_event_loop(self):\n loop = current_loop.get()\n if loop is None:\n loop = super().get_event_loop()\n return loop","async def gif(self, ctx, *keywords):\n if keywords:\n keywords = \"+\".join(keywords)\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='sigh.. **`{}help gif`**'.format(self.config['prefix']),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\n return\n await self.bot.send_typing(ctx.message.channel)\n url = (\"http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}\"\n \"\".format(self.config['giphy-api-key'], keywords))\n\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as response:\n source = await response.json(encoding='utf8')\n\n source = json.dumps(source)\n result = json.loads(str(source))\n\n if response.status == 200:\n if result[\"data\"]:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format(''),\n colour=0xf20006)\n embed.set_image(url=result[\"data\"][\"image_original_url\"])\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['succes'])\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format('No results found.'),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['warning'])\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format('Error contacting the API'),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])","async def get_repeat(self) -> models.player.RepeatMode:\n repeat, _ = await self.get_play_mode()\n return repeat","def get_preview_gif_url(self, playback_id):\n return f'https://image.mux.com/{playback_id.id}/animated.gif?end=1'","def getLoop():\n return asyncio.get_event_loop_policy().get_event_loop()","def while_loop_op(op):\n return (control_flow_util.IsLoopSwitch(op) or\n control_flow_util.IsLoopMerge(op) or\n control_flow_util.IsLoopEnter(op) or\n control_flow_util.IsLoopExit(op) or\n TensorTracer.loop_cond_op(op) or\n op.type in ('RefNextIteration', 'NextIteration'))","def getAnimDone(self, task):\n if not self.actor.getCurrentAnim():\n self.isPlaying = False\n return task.done\n \n if self.actor.getCurrentFrame(self.animation) >= self.animConfig[self.animation]['end'] - 1:\n self.isPlaying = False\n if not self.loopAnimation:\n self.setAnim(self.animDefault, True)\n else:\n self.setAnim(self.loopAnimation, True)\n \n return task.done\n\n return task.cont","def GAME_LOOP():\n pass","def first_loop_start(self) -> int:\n return self.__first_loop_start","def get_status(self, vdef):\n _, status = self.loop_var_map[vdef]\n return status","async def return_gif_link(query: str) -> dict:\n best_match = extractOne(query.replace(\" \", \"_\"), os.listdir(gif_dir))\n if best_match[1] > 50:\n resp = {\n \"success\": True,\n \"query\": query,\n \"link\": f\"{gif_baseurl}/{best_match[0]}\",\n }\n else:\n resp = {\n \"success\": False,\n \"query\": query,\n \"reason\": \"Was not able to find an appropriate image\",\n }\n return resp","def loop(self) -> AbstractEventLoop:","def loop(self) -> AbstractEventLoop:","async def checkNewLoop(self):\n pass","def loop(self):\n raise NotImplementedError()","def postprocess(self, loop):\n return loop","def _get_gif_original_url(gif_dict):\n return gif_dict[\"images\"][\"original\"][\"url\"]","def get_current_pic(self):\n # Change the picture\n if clock() > self.next_frame:\n if self.exploding:\n if self.frame_num < self.num_of_explosion_frames:\n self.frame_num += 1\n else:\n self.away = True\n else:\n # Chose animation direction by the asteroid's horizontal direction\n self.frame_num += int(copysign(1, self.speed[0]+self.acceleration[0]))\n if self.frame_num >= self.num_of_images:\n self.frame_num = 0\n elif self.frame_num < 0:\n self.frame_num = self.num_of_images - 1\n self.next_frame = clock() + self.frame_time\n return self.current_image_set[self.frame_num]","def isPlaying(self):\n return self.getChannel().get_busy()","def _analyse_loop(\n self,\n statement: Union[ast.AsyncFor, ast.For, ast.While],\n *,\n next: CFNode,\n ) -> CFNode:\n # Node acting as target for the next iteration. We'll identify this\n # with the loop entry node, once that exists.\n dummy_node = self._dummy_node()\n with self._updated_context(break_=next, continue_=dummy_node):\n body_node = self._analyse_statements(statement.body, next=dummy_node)\n\n loop_node = self._ast_node(\n statement,\n enter=body_node,\n else_=self._analyse_statements(statement.orelse, next=next),\n error=self._raise,\n )\n\n self._graph.collapse_node(dummy_node, loop_node)\n return loop_node","def generate_gif(directory: (\"Folder name\", \"positional\"),\n image_format: ('Image format', 'positional') = '.png',\n print_file_names=False):\n import imageio\n from glob import glob\n from natsort import natsorted\n\n images = []\n # Create a list of file names in the specified directory\n filenames = glob(directory + '/*' + image_format)\n\n filenames = natsorted(filenames, key=lambda y: y.lower())\n # Sort the list 'filenames' using the traditional method.\n # Traditional method -\n # isolate the entire first number in the string, then sort by that number\n # If this step is not included,\n # files will be sorted like so: 0, 100, 110, 200, 3, 420, etc...\n\n if print_file_names: # For troubleshooting\n for i in filenames:\n print(i)\n\n for filename in filenames:\n images.append(imageio.imread(filename))\n # Append each file to the list that will become the gif\n\n imageio.mimsave(directory + '.gif', images)\n # Save the gif as the name of the directory\n # that the images were generated from\n return","def loop( self ):\n import gtk\n while self.count >= 1:\n log.debug( 'GTK loop restarting' )\n while gtk.events_pending():\n gtk.main_iteration()\n log.debug( 'GTK loop exiting' )\n try:\n del self.t_loop\n except AttributeError, err:\n pass","def getIteration(self): \n return self.iteration","def get_next(self):\n try:\n g = next(self.__gnext)\n except StopIteration:\n return None\n\n return g","def __nii4dtoGif(self, inputfile, tgGif, gifSpeed=30):\n gifId = self.__idGenerator()\n \n # Number of volumes in the 4D image\n vSize = mriutil.getNbDirectionsFromDWI(inputfile)\n vols = [gifId + '{0:04}'.format(i) for i in range(vSize)]\n \n # Spliting 4D image\n cmd = 'fslsplit ' + inputfile + ' ' + gifId + ' -t'\n self.launchCommand(cmd)\n \n # Extracting pngs from all volumes\n for vol in vols:\n self.__slicer(vol, None, vol + '.png')\n \n # Creating .gif\n cmd = 'convert '\n for vol in vols:\n cmd += '-delay ' + str(gifSpeed) + ' ' + vol + '.png '\n cmd += tgGif\n self.launchCommand(cmd)\n \n # Cleaning temp files\n cmd = 'rm ' + gifId + '*'\n self.launchCommand(cmd)","def get_repeat_mode(self):\n response = self.get(COMMAND_UIC, 'GetRepeatMode')\n\n return response['repeat']","def verify_GIF_sent(gif_ID):\n try:\n messages = driver.find_elements_by_class_name('m-messenger__message-content')\n gif = messages[-1].find_element_by_tag_name('img')\n src = gif.get_attribute('src')\n actual_gif_ID = src[src.index('media/') + len('media/'):]\n actual_gif_ID = actual_gif_ID[:actual_gif_ID.index('/')]\n #print(gif_ID)\n #print(actual_gif_ID)\n return gif_ID == actual_gif_ID\n except Exception as e:\n #print(str(e))\n return False","def get_flag(self):\n if self.flag is None:\n # Find the flag in the game objects list\n for obj in self.game_objects_list:\n if isinstance(obj, gameobjects.Flag):\n self.flag = obj\n break\n return self.flag","def next(self, iteration):\n\n gc3libs.log.info(\"Calling GdemoIteration.next(%d) ... \", iteration)\n\n last_application = self.tasks[iteration]\n\n f = open(os.path.join(last_application.output_dir,last_application.stdout))\n computed_value = int(f.read())\n f.close()\n\n if computed_value >= self.limit:\n self.execution.returncode = 0\n return Run.State.TERMINATED\n else:\n self.add(GdemoApplication(computed_value, self.increment, iteration+1))\n return Run.State.RUNNING","def image(self):\n if pygame.time.get_ticks() % 500 >= 250:\n return self._img_wingup\n else:\n return self._img_wingdown","def get_frame(self):\n\t\tframe = None\n\t\twhile not frame:","def _default_iteration(self, iteration: Optional[int], **kwargs) -> int:\n if iteration is None:\n return self.iteration_count(**kwargs)\n else:\n return iteration","def create_gifs(folder, time_per_image=0.1):\n # Retrieve images paths\n images_dict = defaultdict(list)\n folders_sorting_key = lambda s: int(s.split(\"_\")[-1])\n obs_folders = [f for f in os.listdir(folder) if f.split(\"_\")[0] == \"observations\"]\n obs_folders = sorted(obs_folders, key=folders_sorting_key)\n for obs_folder in obs_folders:\n for f in os.listdir(os.path.join(folder, obs_folder)):\n image_name = \"_\".join(f.split(\"_\")[:-1])\n images_dict[image_name].append(os.path.join(folder, obs_folder, f))\n # Create gifs\n for name in images_dict:\n target = os.path.join(folder, name + \".gif\")\n LungsLoader._create_gif(images_dict[name], target, time_per_image)","def stopGTK( ):\n if LOOP_TRACKER:\n LOOP_TRACKER.decrement()"],"string":"[\n \"def gif_loop(self, gif_loop):\\n if gif_loop is not None and gif_loop < -1:\\n raise ValueError(\\\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\\\")\\n\\n self._gif_loop = gif_loop\",\n \"def get_loop(self):\\n\\n log(\\\"Getting loop for {} at {}\\\".format(self._location, self._t0))\\n loop = io.BytesIO()\\n try:\\n frames = self.get_frames()\\n if frames is None:\\n raise\\n log(\\\"Got {} frames for {} at {}\\\".format(\\n len(frames),\\n self._location,\\n self._t0\\n ))\\n frames[0].save(\\n loop,\\n append_images=frames[1:],\\n duration=500,\\n format='GIF',\\n loop=0,\\n save_all=True,\\n )\\n except:\\n log(\\\"Got NO frames for {} at {}\\\".format(self._location, self._t0))\\n self._pilimg.new('RGB', (340, 370)).save(loop, format='GIF')\\n if self._outfn:\\n outdir = os.path.dirname(self._outfn)\\n if not os.path.isdir(outdir):\\n try:\\n os.makedirs(outdir)\\n except:\\n log_error(\\\"Could not create directory {}\\\".format(outdir))\\n try:\\n with open(self._outfn, 'wb') as f:\\n f.write(loop.getvalue())\\n except:\\n log_error(\\\"Could not write image to {}\\\".format(self._outfn))\\n return loop.getvalue()\",\n \"def get_loop(self) -> bool:\\n return self._select_interface(self._rc_get_loop, self._http_get_loop)\",\n \"def loop(self):\\n\\n return self._loop\",\n \"def while_loop(self):\\n if self._loop is None:\\n self._loop = self._while_loop()\\n return self._loop\\n return self._loop\",\n \"def gif(self):\\n\\n if self._gif is None:\\n\\n url = self.url.replace('f=fits', 'f=gif')\\n\\n try:\\n url_data = urllib.request.urlopen(url)\\n except urllib.request.URLError as ee:\\n raise ValueError(f'cannot open URL for these parameters: {ee}')\\n\\n data = url_data.read()\\n\\n image = PIL.Image.open(io.BytesIO(data))\\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\\n\\n self._gif = image\\n\\n return self._gif\",\n \"def enable_loop(self):\\n loop = (self._loop_mode is LoopMode.Wrap)\\n return loop\",\n \"def loop_type(graph = None):\\n\\tbreakpoints = 0\\n\\tfor edge in nx.generate_edgelist(graph):\\n\\t\\tif ('breakpoint' in edge):\\n\\t\\t\\tbreakpoints += 1\\n\\n\\tif breakpoints == 1:\\n\\t\\tif is_loop(graph = graph):\\n\\t\\t\\treturn 'hairpinloop'\\n\\t\\telse:\\n\\t\\t\\treturn 'dangling_end'\\n\\n\\tif is_loop(graph = graph):\\n\\t\\tif breakpoints == 2:\\n\\t\\t\\treturn multiloop_type(graph = graph)\\n\\t\\telif breakpoints == 3:\\n\\t\\t\\treturn 'multiloop3'\\n\\t\\telif breakpoints == 4:\\n\\t\\t\\treturn 'multiloop4'\\n\\t\\telif breakpoints == 5:\\n\\t\\t\\treturn 'multiloop5'\\n\\treturn 'NA'\",\n \"def __loop(self):\\n if self.loops is \\\"inf\\\":\\n self.play()\\n else:\\n if self.loops > self.current_loop:\\n self.current_loop += 1\\n self.play()\\n else:\\n self.stop()\",\n \"def get_loop(logger):\\n try:\\n SerialAsyncLoop.mutex.acquire()\\n if SerialAsyncLoop.count == 0:\\n SerialAsyncLoop(logger)\\n SerialAsyncLoop.count += 1\\n if logger:\\n logger.info(f\\\"SerialAsyncLoop instance count: {SerialAsyncLoop.count}\\\")\\n return SerialAsyncLoop._loop\\n except Exception as e:\\n raise\\n finally:\\n SerialAsyncLoop.mutex.release()\",\n \"def loop(self):\\n return self.caller.location.ndb.event_line_loop\",\n \"def loop(self):\\r\\n if self.delay_count >= self.delay:\\r\\n if self.loop_alt == 0:\\r\\n self.frame_index += 1\\r\\n elif self.loop_alt == 1:\\r\\n if self.loop_down and self.frame_index > 0:\\r\\n self.frame_index -= 1\\r\\n else:\\r\\n self.frame_index += 1\\r\\n self.loop_down = False\\r\\n if self.frame_index >= len(self.frames): # Repeat frames\\r\\n if self.loop_alt == 0:\\r\\n self.frame_index = 0\\r\\n elif self.loop_alt == 1:\\r\\n self.loop_down = True\\r\\n self.frame_index -= 2\\r\\n\\r\\n self.image = self.frames[self.frame_index]\\r\\n self.delay_count = 0\\r\\n else:\\r\\n self.delay_count += 1\",\n \"def get_loopstate():\\n return grovepi.digitalRead(LOOP)\",\n \"def getImage(self):\\n\\n\\t\\t\\t_frame = str(self._frame)\\n\\t\\t\\tself._counter += 1\\n\\t\\t\\tif self._counter >= 10/ANIMATION_SPEED:\\n\\t\\t\\t\\tself._frame += 1\\n\\t\\t\\t\\tself._counter = 0\\n\\n\\t\\t\\tif self.images[self.getState()][self.getDirection()][str(self._frame)] == {}:\\n\\t\\t\\t\\tself._frame = 0\\n\\n\\t\\t\\treturn self.images[self.getState()][self.getDirection()][_frame]\",\n \"def loop(self, loop: bool=None):\\n self._select_interface(self._rc_loop, self._http_loop, loop)\",\n \"def loop():\\n global loop_idx\\n sys.stdout.write('loop index %d/%d\\\\r\\\\n' % (loop_idx, _LOOPS))\\n time.sleep(0.5)\\n loop_idx += 1\\n return loop_idx > _LOOPS\",\n \"def first_loop_play_count(self) -> int:\\n return self.__first_loop_play_count\",\n \"def get_gif_key(self):\\n key = self.bot_data_file[\\\"apiKeys\\\"][\\\"gif\\\"]\\n if self.check_empty_key(key):\\n return key\\n else:\\n print(\\\"ERROR GETTING THE GIF KEY (get yours from http://api.giphy.com/) - ABORTING\\\")\\n quit(1)\",\n \"def config_loop(self):\\n loop_label = ['Loop OFF', 'Loop ON']\\n group = self.make_ui_group(False, loop_label[self.loop])\\n orig_loop = self.loop\\n\\n while True:\\n action_left, action_right = (self.button_left.action(),\\n self.button_right.action())\\n if action_left is RichButton.HOLD:\\n return self.loop is not orig_loop, False # Resume config\\n if action_right is RichButton.HOLD:\\n return self.loop is not orig_loop, True # Resume paint\\n if RichButton.TAP in {action_left, action_right}:\\n self.loop = not self.loop\\n group.pop()\\n group.append(centered_label(loop_label[self.loop], 40, 3))\",\n \"async def gif(self, ctx: discord.ext.commands.Context, *args):\\n print(\\\"-------------------------\\\")\\n message_channel: discord.abc.Messageable = ctx.message.channel\\n currentgifkey = self.botVariables.get_gif_key()\\n print(\\\"GifRequest:Arguments:\\\" + str(len(args)))\\n tag = \\\"\\\"\\n if len(args) == 0: # request a random gif\\n print(\\\"Gif Request with No arguments\\\")\\n url = \\\"http://api.giphy.com/v1/gifs/random?api_key=\\\" + currentgifkey\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as resp:\\n r = await resp.json()\\n if 'data' in r:\\n await message_channel.send(r['data']['url'])\\n elif 'message' in r:\\n await message_channel.send(\\\"An error occurred:\\\" + r['message'])\\n else: # request a gif with tags\\n for x in range(0, len(args)):\\n tag = tag + args[x]\\n if x != (len(args) - 1):\\n tag += \\\" \\\"\\n tag = urllib.parse.quote(tag)\\n url = \\\"http://api.giphy.com/v1/gifs/random?api_key=\\\" + currentgifkey + \\\"&tag=\\\" + tag\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as resp:\\n r = await resp.json()\\n print(\\\"GifRequest:Gif Found\\\")\\n if (len(r['data'])) == 0:\\n await message_channel.send(\\\"No GIF found with those tags :frowning: \\\")\\n else:\\n if 'data' in r:\\n await message_channel.send(r['data']['url'])\\n elif 'message' in r:\\n await message_channel.send(\\\"An error occurred:\\\" + r['message'])\\n print(\\\"-------------------------\\\")\",\n \"def first_loop_type(self) -> int:\\n return self.__first_loop_type\",\n \"def gif_fps(self):\\n return self._gif_fps\",\n \"def get_repeat(self) -> bool:\\n return self._select_interface(self._rc_get_repeat,\\n self._http_get_repeat)\",\n \"async def loop(self, ctx: commands.Context) -> Optional[bool]:\\n\\n self.queue[ctx.guild.id].loop = (\\n Loops.LOOP if self.queue[ctx.guild.id].loop != Loops.LOOP else Loops.NO_LOOP\\n )\\n return self.queue[ctx.guild.id].loop == Loops.LOOP\",\n \"def ios_test_loop(self) -> Optional[pulumi.Input['IosTestLoopArgs']]:\\n return pulumi.get(self, \\\"ios_test_loop\\\")\",\n \"def infinite_loop():\\n return True\",\n \"def get_frame_rate(gif=''):\\n\\n # identify -format \\\"Frame %s: %Tcs\\\\n\\\" ~/test.gif - frame life in centiseconds - how very odd.\\n frame_rate_str = subprocess.check_output([\\n 'identify',\\n '-format',\\n '%T\\\\n',\\n gif\\n ])\\n # If we failed to get a frame lifetime from imagemagick...\\n if len(frame_rate_str) <= 0:\\n frame_rate = str(FRAME_RATE)\\n else:\\n # Get gif's lifetime...\\n frame_rate_list = frame_rate_str.split('\\\\n')\\n frame_rate_list = [int(n) for n in frame_rate_list if n]\\n lifetime = float(sum(frame_rate_list)) / 100\\n\\n # print \\\"gif lifetime is \\\" + str(lifetime) + \\\"s\\\"\\n # Determine average frames per second\\n frame_rate = str(len(frame_rate_list) / lifetime)\\n if float(frame_rate) <= 0.0:\\n frame_rate = FRAME_RATE\\n\\n return frame_rate\",\n \"def watch_loop(self):\\n # Double threaded function that allows to stop the loop mid execution\\n def repeatIt():\\n # reset UI and flag before starting loop\\n self.resetLabels()\\n self.reset_scrollbar()\\n # enable stop button\\n self.btnStop.config(state=\\\"normal\\\")\\n # disable button while loop is running\\n self.btnStart.config(state=\\\"disabled\\\")\\n self.txtLoop.config(state=\\\"disabled\\\", textvariable=self.loopCounterUI)\\n self.labelLoop.config(text=\\\"Loop Count: \\\")\\n\\n while self.loopCount.get() > 0:\\n # move scrollbar to bottom\\n self.testCanvas.yview_moveto(0)\\n # count the loop\\n self.loopCounterUI.set(self.loopCounterUI.get() + 1)\\n\\n # Run the test cases\\n self.runThis()\\n\\n # Below are just to reset the UI\\n if not self.stopLoop:\\n print(\\\"loop not stopped so proceed\\\")\\n # let user know script is stopping\\n x = Label(\\n self.testFrame, text=f'End of Loop',\\n background=self.bgChooser(),\\n foreground=\\\"#630984\\\",\\n font=self.boldFont)\\n x.pack(fill=X)\\n # flag gor BG and labels\\n self.bgCounter += 1\\n self.LabelLists.append(x)\\n # allow window to catch up\\n self.tkRoot.update()\\n self.update_scrollbar()\\n else:\\n print(\\\"loop has been stopped so not gonna print End of Loop\\\")\\n\\n # pause before restarting loop\\n self.loopCount.set(self.loopCount.get()-1)\\n time.sleep(1)\\n\\n # disable stop button\\n self.btnStop.config(state=\\\"disabled\\\")\\n # re-enable button after loop is done\\n self.btnStart.config(state=\\\"normal\\\")\\n self.txtLoop.config(state=\\\"normal\\\", textvariable=self.loopCount)\\n self.labelLoop.config(text=\\\"Enter Loop Count: \\\")\\n # self.testCanvas.yview_moveto(0)\\n # Let user know the script is done\\n if not self.stopLoop:\\n # loop did not stopped\\n x = Label(\\n self.testFrame, text=f'Test is done!',\\n background=self.bgChooser(),\\n foreground=\\\"#057224\\\",\\n font=self.boldFont)\\n x.pack(fill=X)\\n self.bgCounter += 1\\n else:\\n x = Label(\\n self.testFrame, text=f'Test stopped!',\\n background=self.bgChooser(),\\n foreground=\\\"#057224\\\",\\n font=self.boldFont)\\n x.pack(fill=X)\\n self.bgCounter += 1\\n self.btnStart.config(state=\\\"normal\\\")\\n self.txtLoop.config(state=\\\"normal\\\", textvariable=self.loopCount)\\n self.labelLoop.config(text=\\\"Enter Loop count: \\\")\\n self.loopCount.set(50000)\\n self.LabelLists.append(x)\\n # allow window to catch up\\n self.tkRoot.update()\\n self.update_scrollbar()\\n thread = threading.Thread(target=repeatIt)\\n thread.start()\",\n \"def animated_gif(folder_with_images, gif_filename, loop_duration, size):\\r\\n\\r\\n\\tos.chdir(folder_with_images) # changes directory to the folder with the images\\r\\n\\r\\n\\tpng_files = []\\r\\n\\r\\n\\t# get list of png files in folder\\r\\n\\tfor fn in os.listdir(folder_with_images):\\r\\n\\t\\tif fn.endswith('.png'):\\r\\n\\t\\t\\tpng_files.append(fn)\\r\\n\\r\\n\\tsort_nicely(png_files)\\r\\n\\r\\n\\tprint(png_files)\\r\\n\\r\\n\\t# number of png_files\\r\\n\\tnum_pngs = len(png_files)\\r\\n\\tpng_time = float(loop_duration)/ float(num_pngs)\\r\\n\\r\\n\\timages = [Image.open(fn) for fn in png_files]\\r\\n\\tdim = (size, size) # change sizes for the image file dimension\\r\\n\\t#for im in images:\\r\\n\\t#\\tim.thumbnail(dim, Image.ANTIALIAS)\\r\\n\\r\\n\\toutput_file = os.path.join(folder_with_images, gif_filename) # path for output file\\r\\n\\twriteGif(output_file, images, png_time) # writes out GIF\\r\",\n \"def gif(self, delay=20, savefile=None, iterations=0, show_path=False,\\n use_ffmpeg=False):\\n from sage.misc.sage_ostools import have_program\\n have_convert = have_program('convert')\\n have_ffmpeg = self._have_ffmpeg()\\n if use_ffmpeg or not have_convert:\\n if have_ffmpeg:\\n self.ffmpeg(savefile=savefile, show_path=show_path,\\n output_format='.gif', delay=delay,\\n iterations=iterations)\\n else:\\n if not have_convert:\\n msg = \\\"\\\"\\\"\\nError: Neither ImageMagick nor ffmpeg appears to be installed. Saving an\\nanimation to a GIF file or displaying an animation requires one of these\\npackages, so please install one of them and try again.\\n\\nSee www.imagemagick.org and www.ffmpeg.org for more information.\\\"\\\"\\\"\\n else:\\n msg = \\\"\\\"\\\"\\nError: ffmpeg does not appear to be installed. Download it from\\nwww.ffmpeg.org, or use 'convert' to produce gifs instead.\\\"\\\"\\\"\\n raise OSError(msg)\\n else:\\n if not savefile:\\n savefile = graphics_filename(ext='.gif')\\n if not savefile.endswith('.gif'):\\n savefile += '.gif'\\n savefile = os.path.abspath(savefile)\\n d = self.png()\\n cmd = ( 'cd \\\"%s\\\"; sage-native-execute convert -dispose Background '\\n '-delay %s -loop %s *.png \\\"%s\\\"' ) % ( d, int(delay),\\n int(iterations), savefile )\\n from subprocess import check_call, CalledProcessError\\n try:\\n check_call(cmd, shell=True)\\n if show_path:\\n print(\\\"Animation saved to file %s.\\\" % savefile)\\n except (CalledProcessError, OSError):\\n msg = \\\"\\\"\\\"\\nError: Cannot generate GIF animation. Verify that convert\\n(ImageMagick) or ffmpeg is installed, and that the objects passed to\\nthe animate command can be saved in PNG image format.\\n\\nSee www.imagemagick.org and www.ffmpeg.org for more information.\\\"\\\"\\\"\\n raise OSError(msg)\",\n \"def first_loop_end(self) -> int:\\n return self.__first_loop_end\",\n \"def repeat(self):\\n return self._get('repeat')\",\n \"def multiloop_type(graph = None):\\n\\tg = graph.copy()\\n\\tbreakpoint_nodes = []\\n\\tfor edge in g.edges(data=True):\\n\\t\\tid1 ,id2 , data = edge\\n\\t\\tif g.edge[id1][id2]['label']== '$':\\n\\t\\t\\tif not id1 in breakpoint_nodes:\\n\\t\\t\\t\\tbreakpoint_nodes.append(id1)\\n\\t\\t\\tif not id2 in breakpoint_nodes:\\n\\t\\t\\t\\tbreakpoint_nodes.append(id2)\\n\\tfor node in breakpoint_nodes:\\n\\t\\tg.remove_node(node)\\n\\tif nx.number_connected_components(g) ==1:\\n\\t\\treturn 'bulge'\\n\\telse:\\n\\t\\treturn 'internal_loop'\",\n \"def iteration(self):\\n return self._iteration\",\n \"def iteration(self):\\n return self._iteration\",\n \"def iteration(self):\\n return self._iteration\",\n \"def iteration(self):\\n return self._iteration\",\n \"def get_gif_uri(kanji):\\n fileName = kanji.encode(\\\"unicode-escape\\\").decode(\\\"utf-8\\\").replace(\\\"\\\\\\\\u\\\", '') + '.gif'\\n animationUri = f'https://raw.githubusercontent.com/mistval/kanji_images/master/gifs/{fileName}'\\n return animationUri\",\n \"def loop_running(self):\\r\\n if self.is_running:\\r\\n if self.first_time:\\r\\n self.time = time.time()\\r\\n self.first_time = False\\r\\n else:\\r\\n self._loop_end() # Finish the previous loop.\\r\\n self._loop_begin()\\r\\n else:\\r\\n self._loop_end()\\r\\n self.destroy()\\r\\n\\r\\n return self.is_running\",\n \"def is_loop(*args):\\n return _ida_hexrays.is_loop(*args)\",\n \"def write_loop_text(self):\\n\\t\\tself.write_components['loop'] = \\\"\\\"\\\"loop( ({sets})$({cond}), {loop})\\n\\t\\t\\\"\\\"\\\".format( sets = ', '.join(self.shock_gm.database[self.loop_name].names),\\n\\t\\t\\t\\t\\tcond = self.shock_gm.database.get(self.loop_name).to_str,\\n\\t\\t\\t\\t\\tloop = self.loop_text)\\n\\t\\treturn self.write_components['loop']\",\n \"def get_iteration(self):\\n return self.iteration\",\n \"def bottle_song_while(num):\\n pass\",\n \"def start_frame(self):\\n\\n # Check whether we're supposed to make a frame on this iteration:\\n if self.frame_count % self.stride != 0:\\n return\\n\\n # Check whether we're already making a frame. \\n if self.in_scope:\\n print(\\\"The Gif object for {} has encountered 'start_frame' twice\\\\\\n without an intervening 'end_frame'\\\".format(self.filename))\\n raise SyntaxError\\n\\n # Construct a new figure\\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\\n self.current_frame = fig\\n\\n # Set the \\\"in_scope\\\" member True\\n self.in_scope = True\\n\\n return self.current_frame\",\n \"async def queueloop(self, ctx: commands.Context) -> Optional[bool]:\\n\\n queue = self.queue[ctx.guild.id]\\n\\n queue.loop = (\\n Loops.QUEUE_LOOP\\n if self.queue[ctx.guild.id].loop != Loops.QUEUE_LOOP\\n else Loops.NO_LOOP\\n )\\n\\n if queue.loop == Loops.QUEUE_LOOP:\\n queue.queue_loop_start = queue.pos\\n\\n return queue.loop == Loops.QUEUE_LOOP\",\n \"def _get_loop(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Optional[asyncio.AbstractEventLoop]:\\n if callable(self.loop_getter):\\n if self.loop_getter_need_context:\\n return self.loop_getter(*args, **kwargs) # pylint: disable=not-callable\\n return self.loop_getter() # pylint: disable=not-callable\\n return self.loop_getter\",\n \"def repeat(self):\\n return self._repeat\",\n \"def ios_test_loop(self) -> 'outputs.IosTestLoopResponse':\\n return pulumi.get(self, \\\"ios_test_loop\\\")\",\n \"def loopcount(self):\\n return len(self.loopindices)\",\n \"def read_gif(self, filename):\\n blocks = {}\\n with open(os.path.join(self.template_dir, filename), 'rb') as gif_fd:\\n blocks['header'] = gif_fd.read(6)\\n assert blocks['header'] in (b'GIF87a', b'GIF89a')\\n blocks['lcd'] = gif_fd.read(7) # logical screen descriptor\\n assert blocks['lcd'].endswith(b'\\\\xe3\\\\x10\\\\x00') # gct of 16 colours\\n blocks['gct'] = gif_fd.read(16 * 3) # global colour table\\n blocks['img_descriptor'] = gif_fd.read(10) # image descriptor\\n assert blocks['img_descriptor'][0] == 0x2c\\n assert blocks['img_descriptor'][9] == 0\\n # img data\\n blocks['img_data'] = gif_fd.read(1) # LZW min code size\\n while True: # img data sub-blocks\\n blocks['img_data'] += gif_fd.read(1) # sub-block data size\\n if blocks['img_data'][-1] == 0:\\n break # final sub-block (size 0)\\n blocks['img_data'] += gif_fd.read(blocks['img_data'][-1])\\n assert gif_fd.read(1) == b'\\\\x3b' # trailer\\n return blocks\",\n \"async def _loop(self, ctx: commands.Context):\\n\\n if not ctx.voice_state.is_playing:\\n return await ctx.send('Nothing being played at the moment.')\\n\\n # Inverse boolean value to loop and unloop.\\n ctx.voice_state.loop = not ctx.voice_state.loop\\n await ctx.message.add_reaction('✅')\",\n \"async def _loop(self, ctx: commands.Context):\\n\\n if not ctx.voice_state.is_playing:\\n return await ctx.send('Nothing being played at the moment.')\\n\\n # Inverse boolean value to loop and unloop.\\n ctx.voice_state.loop = not ctx.voice_state.loop\\n await ctx.message.add_reaction('✅')\",\n \"def get_gif(self, tag: Text) -> Optional[Text]:\\r\\n if tag == \\\"all\\\":\\r\\n matches = self.elements\\r\\n else:\\r\\n sub_tags = tag.split(\\\"+\\\")\\r\\n matches = [e for e in self.elements if all(t in e.tags for t in sub_tags)]\\r\\n return random.choice(matches).url if matches else None\",\n \"def first_loop_fraction(self) -> int:\\n return self.__first_loop_fraction\",\n \"def getInstance():\\n if GameLoop.__instance==None:\\n GameLoop()\\n return GameLoop.__instance\",\n \"def animated_gif(file):\\n\\n\\timport os.path\\n\\timport Image\\n\\tfrom conf import *\\n\\tfrom util_errors import gen_error\\n\\tANIMGIF_TAGID = 2\\n\\n\\tfilepath = os.path.join(PROBATION_DIR, file[\\\"filename\\\"])\\n\\ttry:\\n\\t\\timg = Image.open(filepath)\\n\\t\\ttry:\\n\\t\\t\\timg.seek(1)\\n\\t\\texcept:\\n\\t\\t\\tpass\\n\\t\\telse:\\n\\t\\t\\tdel(img)\\n\\t\\t\\treturn [ANIMGIF_TAGID]\\n\\texcept Exception, data:\\n\\t\\tgen_error('GENERIC', \\\"File couldn't be operated on, check perms -- \\\" + str(data))\\n\\n\\tdel(img)\\n\\treturn []\",\n \"def get_frames(gif: Image.Image) -> List[Image.Image]:\\n last_frame = None\\n all_frames = []\\n i = 0\\n try:\\n while True:\\n gif.seek(i)\\n new_frame = gif.convert('RGBA')\\n if last_frame is not None and gif.disposal_method == 1:\\n updated = new_frame.crop(gif.dispose_extent)\\n last_frame.paste(updated, gif.dispose_extent, updated)\\n new_frame = last_frame\\n else:\\n last_frame = new_frame\\n\\n # do resizing on new_frame here...\\n\\n all_frames.append(new_frame.copy())\\n i += 1\\n except EOFError:\\n gif.seek(0)\\n\\n return all_frames\",\n \"def _get_repeat_times(self):\\n # The passed arg on_repeat is used to check that.\\n\\n # The arg passes 1 in case the --repeat flag is not passed\\n # which means we simply need to loop for once.\\n\\n # The arg passes None in case the --repeat flag is passed but\\n # without a value. In this case, we need to make sure the song goes\\n # on an infinite loop. Though, in our case, we will make the loop run\\n # for a really large value like 1000\\n\\n # The arg passes the number of times the loop is supposed the run in\\n # case the value is passed by the user.\\n\\n if self.on_repeat == 1:\\n return 1\\n elif self.on_repeat is None:\\n logger.info(\\\"Repeating indefinitely\\\")\\n return 5000\\n else:\\n logger.info(\\n \\\"Repeating {} {}\\\".format(\\n self.on_repeat, \\\"time\\\" if self.on_repeat == 1 else \\\"times\\\"\\n )\\n )\\n return self.on_repeat\",\n \"def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\\n\\n self._gif_fps = None\\n self._color_depth = None\\n self._gif_loop = None\\n self._height = None\\n self._start = None\\n self._duration = None\\n self._suffix = None\\n self._overlay = None\\n self._overlay_alignment = None\\n self._overlay_scale = None\\n self._label = None\\n self.discriminator = None\\n\\n if gif_fps is not None:\\n self.gif_fps = gif_fps\\n if color_depth is not None:\\n self.color_depth = color_depth\\n if gif_loop is not None:\\n self.gif_loop = gif_loop\\n self.height = height\\n self.start = start\\n if duration is not None:\\n self.duration = duration\\n if suffix is not None:\\n self.suffix = suffix\\n if overlay is not None:\\n self.overlay = overlay\\n if overlay_alignment is not None:\\n self.overlay_alignment = overlay_alignment\\n if overlay_scale is not None:\\n self.overlay_scale = overlay_scale\\n if label is not None:\\n self.label = label\",\n \"def GetGifFrames(self, path):\\n gif = imageio.mimread(path)\\n return [\\n (image.meta[\\\"duration\\\"], cv2.resize(\\n cv2.cvtColor(image, cv2.COLOR_RGB2BGR), (64, 64))\\n ) for image in gif\\n ]\",\n \"def has_loop(self) -> bool:\\n try:\\n list(self)\\n return False\\n except ContainsLoopError:\\n return True\",\n \"def get_first_playable_flag(self, direction):\\n return next((f for f in xrange(1, 10) if self.is_flag_playable(f - 1, direction)), None)\",\n \"def android_test_loop(self) -> Optional[pulumi.Input['AndroidTestLoopArgs']]:\\n return pulumi.get(self, \\\"android_test_loop\\\")\",\n \"def _set_loop(tik_instance, num_core, max_core, total_dim):\\n core_loop = tik_instance.Scalar(\\\"uint64\\\")\\n\\n with tik_instance.if_scope(num_core < total_dim % AICORE_NUM):\\n core_loop.set_as(_ceil_div(total_dim, max_core))\\n with tik_instance.else_scope():\\n core_loop.set_as(total_dim // max_core)\\n\\n return core_loop\",\n \"def _while_loop(self):\\n bind_map = {}\\n wl = set_span(tvm.relay.var(\\\"while_loop\\\"), self._loop_name)\\n sb = tvm.relay.scope_builder.ScopeBuilder()\\n\\n lv_list = []\\n expr_list = []\\n extra_vars = []\\n\\n for i, lv in enumerate(self.loop_vars):\\n if self._loop_name not in self._lvar2expr:\\n self._lvar2expr[self._loop_name] = {}\\n\\n # Handle the case when loop var is not properly lifted.\\n # This can happen when loop var node name is set accidentally\\n # beginning with loop name.\\n if lv not in self._lvar2expr[self._loop_name]:\\n var_name = f\\\"{self._loop_name}_loop_var_{i}\\\"\\n var_type = _infer_type(lv, self._mod).checked_type\\n loop_var = set_span(tvm.relay.var(var_name, type_annotation=var_type), var_name)\\n self._lvar2expr[self._loop_name][loop_var] = lv\\n bind_map[lv] = loop_var\\n self.loop_vars[i] = loop_var\\n lv = loop_var\\n\\n lv_list.append(lv)\\n expr_list.append(self._lvar2expr[self._loop_name][lv])\\n\\n if bind_map:\\n self.cond = rewrite_subgraph(self.cond, bind_map)\\n self.body = [rewrite_subgraph(b, bind_map) for b in self.body]\\n\\n cond = set_span(tvm.relay.op.min(self.cond), self.cond.span)\\n\\n for lv, exp in self._lvar2expr[self._loop_name].items():\\n if lv not in self.loop_vars:\\n var_checker = VarChecker(lv)\\n for bd in self.body + [cond]:\\n var_checker.visit(bd)\\n if var_checker.used:\\n lv_list.append(lv)\\n expr_list.append(exp)\\n extra_vars.append(lv)\\n break\\n\\n with sb.if_scope(cond):\\n sb.ret(wl(*list(self.body + extra_vars)))\\n with sb.else_scope():\\n sb.ret(tvm.relay.Tuple(lv_list))\\n\\n loop_fn = tvm.relay.Function(lv_list, sb.get())\\n sb = tvm.relay.scope_builder.ScopeBuilder()\\n sb.let(wl, loop_fn)\\n loop_ret = wl(*expr_list)\\n\\n sb.ret(loop_ret)\\n ret = sb.get()\\n return ret\",\n \"def send_GIF():\\n try:\\n gif_icon = driver.find_element_by_xpath('//*[@data-tip=\\\"GIF\\\"]')\\n gif_icon.click()\\n wait(wait_time=10)\\n gifs = driver.find_elements_by_class_name('giphy-gif')\\n src = gifs[0].get_attribute('src')\\n gif_ID = src[src.index('media/') + len('media/'):]\\n gif_ID = gif_ID[:gif_ID.index('/')]\\n gifs[0].click()\\n wait()\\n except Exception as e:\\n return \\\"Error: \\\" + str(e)\\n if verify_GIF_sent(gif_ID):\\n return \\\"Success\\\"\\n else:\\n return \\\"Error: GIF wasn't sent\\\"\",\n \"def current_event_loop(self):\\n loop = current_loop.get()\\n if loop is None:\\n loop = super().get_event_loop()\\n return loop\",\n \"async def gif(self, ctx, *keywords):\\n if keywords:\\n keywords = \\\"+\\\".join(keywords)\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='sigh.. **`{}help gif`**'.format(self.config['prefix']),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\\n return\\n await self.bot.send_typing(ctx.message.channel)\\n url = (\\\"http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}\\\"\\n \\\"\\\".format(self.config['giphy-api-key'], keywords))\\n\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as response:\\n source = await response.json(encoding='utf8')\\n\\n source = json.dumps(source)\\n result = json.loads(str(source))\\n\\n if response.status == 200:\\n if result[\\\"data\\\"]:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format(''),\\n colour=0xf20006)\\n embed.set_image(url=result[\\\"data\\\"][\\\"image_original_url\\\"])\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['succes'])\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format('No results found.'),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['warning'])\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format('Error contacting the API'),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\",\n \"async def get_repeat(self) -> models.player.RepeatMode:\\n repeat, _ = await self.get_play_mode()\\n return repeat\",\n \"def get_preview_gif_url(self, playback_id):\\n return f'https://image.mux.com/{playback_id.id}/animated.gif?end=1'\",\n \"def getLoop():\\n return asyncio.get_event_loop_policy().get_event_loop()\",\n \"def while_loop_op(op):\\n return (control_flow_util.IsLoopSwitch(op) or\\n control_flow_util.IsLoopMerge(op) or\\n control_flow_util.IsLoopEnter(op) or\\n control_flow_util.IsLoopExit(op) or\\n TensorTracer.loop_cond_op(op) or\\n op.type in ('RefNextIteration', 'NextIteration'))\",\n \"def getAnimDone(self, task):\\n if not self.actor.getCurrentAnim():\\n self.isPlaying = False\\n return task.done\\n \\n if self.actor.getCurrentFrame(self.animation) >= self.animConfig[self.animation]['end'] - 1:\\n self.isPlaying = False\\n if not self.loopAnimation:\\n self.setAnim(self.animDefault, True)\\n else:\\n self.setAnim(self.loopAnimation, True)\\n \\n return task.done\\n\\n return task.cont\",\n \"def GAME_LOOP():\\n pass\",\n \"def first_loop_start(self) -> int:\\n return self.__first_loop_start\",\n \"def get_status(self, vdef):\\n _, status = self.loop_var_map[vdef]\\n return status\",\n \"async def return_gif_link(query: str) -> dict:\\n best_match = extractOne(query.replace(\\\" \\\", \\\"_\\\"), os.listdir(gif_dir))\\n if best_match[1] > 50:\\n resp = {\\n \\\"success\\\": True,\\n \\\"query\\\": query,\\n \\\"link\\\": f\\\"{gif_baseurl}/{best_match[0]}\\\",\\n }\\n else:\\n resp = {\\n \\\"success\\\": False,\\n \\\"query\\\": query,\\n \\\"reason\\\": \\\"Was not able to find an appropriate image\\\",\\n }\\n return resp\",\n \"def loop(self) -> AbstractEventLoop:\",\n \"def loop(self) -> AbstractEventLoop:\",\n \"async def checkNewLoop(self):\\n pass\",\n \"def loop(self):\\n raise NotImplementedError()\",\n \"def postprocess(self, loop):\\n return loop\",\n \"def _get_gif_original_url(gif_dict):\\n return gif_dict[\\\"images\\\"][\\\"original\\\"][\\\"url\\\"]\",\n \"def get_current_pic(self):\\n # Change the picture\\n if clock() > self.next_frame:\\n if self.exploding:\\n if self.frame_num < self.num_of_explosion_frames:\\n self.frame_num += 1\\n else:\\n self.away = True\\n else:\\n # Chose animation direction by the asteroid's horizontal direction\\n self.frame_num += int(copysign(1, self.speed[0]+self.acceleration[0]))\\n if self.frame_num >= self.num_of_images:\\n self.frame_num = 0\\n elif self.frame_num < 0:\\n self.frame_num = self.num_of_images - 1\\n self.next_frame = clock() + self.frame_time\\n return self.current_image_set[self.frame_num]\",\n \"def isPlaying(self):\\n return self.getChannel().get_busy()\",\n \"def _analyse_loop(\\n self,\\n statement: Union[ast.AsyncFor, ast.For, ast.While],\\n *,\\n next: CFNode,\\n ) -> CFNode:\\n # Node acting as target for the next iteration. We'll identify this\\n # with the loop entry node, once that exists.\\n dummy_node = self._dummy_node()\\n with self._updated_context(break_=next, continue_=dummy_node):\\n body_node = self._analyse_statements(statement.body, next=dummy_node)\\n\\n loop_node = self._ast_node(\\n statement,\\n enter=body_node,\\n else_=self._analyse_statements(statement.orelse, next=next),\\n error=self._raise,\\n )\\n\\n self._graph.collapse_node(dummy_node, loop_node)\\n return loop_node\",\n \"def generate_gif(directory: (\\\"Folder name\\\", \\\"positional\\\"),\\n image_format: ('Image format', 'positional') = '.png',\\n print_file_names=False):\\n import imageio\\n from glob import glob\\n from natsort import natsorted\\n\\n images = []\\n # Create a list of file names in the specified directory\\n filenames = glob(directory + '/*' + image_format)\\n\\n filenames = natsorted(filenames, key=lambda y: y.lower())\\n # Sort the list 'filenames' using the traditional method.\\n # Traditional method -\\n # isolate the entire first number in the string, then sort by that number\\n # If this step is not included,\\n # files will be sorted like so: 0, 100, 110, 200, 3, 420, etc...\\n\\n if print_file_names: # For troubleshooting\\n for i in filenames:\\n print(i)\\n\\n for filename in filenames:\\n images.append(imageio.imread(filename))\\n # Append each file to the list that will become the gif\\n\\n imageio.mimsave(directory + '.gif', images)\\n # Save the gif as the name of the directory\\n # that the images were generated from\\n return\",\n \"def loop( self ):\\n import gtk\\n while self.count >= 1:\\n log.debug( 'GTK loop restarting' )\\n while gtk.events_pending():\\n gtk.main_iteration()\\n log.debug( 'GTK loop exiting' )\\n try:\\n del self.t_loop\\n except AttributeError, err:\\n pass\",\n \"def getIteration(self): \\n return self.iteration\",\n \"def get_next(self):\\n try:\\n g = next(self.__gnext)\\n except StopIteration:\\n return None\\n\\n return g\",\n \"def __nii4dtoGif(self, inputfile, tgGif, gifSpeed=30):\\n gifId = self.__idGenerator()\\n \\n # Number of volumes in the 4D image\\n vSize = mriutil.getNbDirectionsFromDWI(inputfile)\\n vols = [gifId + '{0:04}'.format(i) for i in range(vSize)]\\n \\n # Spliting 4D image\\n cmd = 'fslsplit ' + inputfile + ' ' + gifId + ' -t'\\n self.launchCommand(cmd)\\n \\n # Extracting pngs from all volumes\\n for vol in vols:\\n self.__slicer(vol, None, vol + '.png')\\n \\n # Creating .gif\\n cmd = 'convert '\\n for vol in vols:\\n cmd += '-delay ' + str(gifSpeed) + ' ' + vol + '.png '\\n cmd += tgGif\\n self.launchCommand(cmd)\\n \\n # Cleaning temp files\\n cmd = 'rm ' + gifId + '*'\\n self.launchCommand(cmd)\",\n \"def get_repeat_mode(self):\\n response = self.get(COMMAND_UIC, 'GetRepeatMode')\\n\\n return response['repeat']\",\n \"def verify_GIF_sent(gif_ID):\\n try:\\n messages = driver.find_elements_by_class_name('m-messenger__message-content')\\n gif = messages[-1].find_element_by_tag_name('img')\\n src = gif.get_attribute('src')\\n actual_gif_ID = src[src.index('media/') + len('media/'):]\\n actual_gif_ID = actual_gif_ID[:actual_gif_ID.index('/')]\\n #print(gif_ID)\\n #print(actual_gif_ID)\\n return gif_ID == actual_gif_ID\\n except Exception as e:\\n #print(str(e))\\n return False\",\n \"def get_flag(self):\\n if self.flag is None:\\n # Find the flag in the game objects list\\n for obj in self.game_objects_list:\\n if isinstance(obj, gameobjects.Flag):\\n self.flag = obj\\n break\\n return self.flag\",\n \"def next(self, iteration):\\n\\n gc3libs.log.info(\\\"Calling GdemoIteration.next(%d) ... \\\", iteration)\\n\\n last_application = self.tasks[iteration]\\n\\n f = open(os.path.join(last_application.output_dir,last_application.stdout))\\n computed_value = int(f.read())\\n f.close()\\n\\n if computed_value >= self.limit:\\n self.execution.returncode = 0\\n return Run.State.TERMINATED\\n else:\\n self.add(GdemoApplication(computed_value, self.increment, iteration+1))\\n return Run.State.RUNNING\",\n \"def image(self):\\n if pygame.time.get_ticks() % 500 >= 250:\\n return self._img_wingup\\n else:\\n return self._img_wingdown\",\n \"def get_frame(self):\\n\\t\\tframe = None\\n\\t\\twhile not frame:\",\n \"def _default_iteration(self, iteration: Optional[int], **kwargs) -> int:\\n if iteration is None:\\n return self.iteration_count(**kwargs)\\n else:\\n return iteration\",\n \"def create_gifs(folder, time_per_image=0.1):\\n # Retrieve images paths\\n images_dict = defaultdict(list)\\n folders_sorting_key = lambda s: int(s.split(\\\"_\\\")[-1])\\n obs_folders = [f for f in os.listdir(folder) if f.split(\\\"_\\\")[0] == \\\"observations\\\"]\\n obs_folders = sorted(obs_folders, key=folders_sorting_key)\\n for obs_folder in obs_folders:\\n for f in os.listdir(os.path.join(folder, obs_folder)):\\n image_name = \\\"_\\\".join(f.split(\\\"_\\\")[:-1])\\n images_dict[image_name].append(os.path.join(folder, obs_folder, f))\\n # Create gifs\\n for name in images_dict:\\n target = os.path.join(folder, name + \\\".gif\\\")\\n LungsLoader._create_gif(images_dict[name], target, time_per_image)\",\n \"def stopGTK( ):\\n if LOOP_TRACKER:\\n LOOP_TRACKER.decrement()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6869839","0.6846498","0.622958","0.6160181","0.5945182","0.57386464","0.55551046","0.554464","0.53494954","0.5158095","0.5133926","0.5090462","0.50807434","0.5023866","0.5007544","0.4975262","0.49709076","0.49350947","0.4925683","0.4912694","0.48901445","0.4876861","0.48748952","0.48261687","0.47831246","0.47823098","0.4777519","0.47280332","0.47248992","0.47077528","0.46910676","0.46892598","0.46713853","0.4659751","0.4659751","0.4659751","0.4659751","0.46571532","0.4647425","0.464557","0.46060932","0.46002024","0.45938286","0.4593698","0.45845285","0.45519924","0.4550111","0.4495188","0.4483424","0.4480031","0.4474009","0.4474009","0.44675264","0.4466746","0.44652987","0.44593877","0.44590747","0.44587585","0.4447603","0.44441953","0.44194198","0.44152138","0.4400853","0.44006154","0.43944263","0.43824798","0.4382345","0.4374702","0.4374477","0.43734735","0.43718785","0.4370162","0.43585134","0.43485945","0.4343822","0.43431684","0.43410635","0.4339668","0.4339668","0.43376437","0.43376178","0.43349114","0.43275774","0.43244308","0.43226248","0.43099612","0.430218","0.42910215","0.4283921","0.42785367","0.42701596","0.42673257","0.42629883","0.42617053","0.42543733","0.42506006","0.4247948","0.42413607","0.4233617","0.42140666"],"string":"[\n \"0.6869839\",\n \"0.6846498\",\n \"0.622958\",\n \"0.6160181\",\n \"0.5945182\",\n \"0.57386464\",\n \"0.55551046\",\n \"0.554464\",\n \"0.53494954\",\n \"0.5158095\",\n \"0.5133926\",\n \"0.5090462\",\n \"0.50807434\",\n \"0.5023866\",\n \"0.5007544\",\n \"0.4975262\",\n \"0.49709076\",\n \"0.49350947\",\n \"0.4925683\",\n \"0.4912694\",\n \"0.48901445\",\n \"0.4876861\",\n \"0.48748952\",\n \"0.48261687\",\n \"0.47831246\",\n \"0.47823098\",\n \"0.4777519\",\n \"0.47280332\",\n \"0.47248992\",\n \"0.47077528\",\n \"0.46910676\",\n \"0.46892598\",\n \"0.46713853\",\n \"0.4659751\",\n \"0.4659751\",\n \"0.4659751\",\n \"0.4659751\",\n \"0.46571532\",\n \"0.4647425\",\n \"0.464557\",\n \"0.46060932\",\n \"0.46002024\",\n \"0.45938286\",\n \"0.4593698\",\n \"0.45845285\",\n \"0.45519924\",\n \"0.4550111\",\n \"0.4495188\",\n \"0.4483424\",\n \"0.4480031\",\n \"0.4474009\",\n \"0.4474009\",\n \"0.44675264\",\n \"0.4466746\",\n \"0.44652987\",\n \"0.44593877\",\n \"0.44590747\",\n \"0.44587585\",\n \"0.4447603\",\n \"0.44441953\",\n \"0.44194198\",\n \"0.44152138\",\n \"0.4400853\",\n \"0.44006154\",\n \"0.43944263\",\n \"0.43824798\",\n \"0.4382345\",\n \"0.4374702\",\n \"0.4374477\",\n \"0.43734735\",\n \"0.43718785\",\n \"0.4370162\",\n \"0.43585134\",\n \"0.43485945\",\n \"0.4343822\",\n \"0.43431684\",\n \"0.43410635\",\n \"0.4339668\",\n \"0.4339668\",\n \"0.43376437\",\n \"0.43376178\",\n \"0.43349114\",\n \"0.43275774\",\n \"0.43244308\",\n \"0.43226248\",\n \"0.43099612\",\n \"0.430218\",\n \"0.42910215\",\n \"0.4283921\",\n \"0.42785367\",\n \"0.42701596\",\n \"0.42673257\",\n \"0.42629883\",\n \"0.42617053\",\n \"0.42543733\",\n \"0.42506006\",\n \"0.4247948\",\n \"0.42413607\",\n \"0.4233617\",\n \"0.42140666\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8365495"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76575,"cells":{"query":{"kind":"string","value":"Sets the gif_loop of this GIFOutput. If to loop the GIF. 1 is no loop, 0 is infinite loops, and other numbers are number of loops."},"document":{"kind":"string","value":"def gif_loop(self, gif_loop):\n if gif_loop is not None and gif_loop < -1:\n raise ValueError(\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\")\n\n self._gif_loop = gif_loop"},"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 gif_loop(self):\n return self._gif_loop","def __loop(self):\n if self.loops is \"inf\":\n self.play()\n else:\n if self.loops > self.current_loop:\n self.current_loop += 1\n self.play()\n else:\n self.stop()","def loop(self):\r\n if self.delay_count >= self.delay:\r\n if self.loop_alt == 0:\r\n self.frame_index += 1\r\n elif self.loop_alt == 1:\r\n if self.loop_down and self.frame_index > 0:\r\n self.frame_index -= 1\r\n else:\r\n self.frame_index += 1\r\n self.loop_down = False\r\n if self.frame_index >= len(self.frames): # Repeat frames\r\n if self.loop_alt == 0:\r\n self.frame_index = 0\r\n elif self.loop_alt == 1:\r\n self.loop_down = True\r\n self.frame_index -= 2\r\n\r\n self.image = self.frames[self.frame_index]\r\n self.delay_count = 0\r\n else:\r\n self.delay_count += 1","def loop(self, loop: bool=None):\n self._select_interface(self._rc_loop, self._http_loop, loop)","def gif(self, delay=20, savefile=None, iterations=0, show_path=False,\n use_ffmpeg=False):\n from sage.misc.sage_ostools import have_program\n have_convert = have_program('convert')\n have_ffmpeg = self._have_ffmpeg()\n if use_ffmpeg or not have_convert:\n if have_ffmpeg:\n self.ffmpeg(savefile=savefile, show_path=show_path,\n output_format='.gif', delay=delay,\n iterations=iterations)\n else:\n if not have_convert:\n msg = \"\"\"\nError: Neither ImageMagick nor ffmpeg appears to be installed. Saving an\nanimation to a GIF file or displaying an animation requires one of these\npackages, so please install one of them and try again.\n\nSee www.imagemagick.org and www.ffmpeg.org for more information.\"\"\"\n else:\n msg = \"\"\"\nError: ffmpeg does not appear to be installed. Download it from\nwww.ffmpeg.org, or use 'convert' to produce gifs instead.\"\"\"\n raise OSError(msg)\n else:\n if not savefile:\n savefile = graphics_filename(ext='.gif')\n if not savefile.endswith('.gif'):\n savefile += '.gif'\n savefile = os.path.abspath(savefile)\n d = self.png()\n cmd = ( 'cd \"%s\"; sage-native-execute convert -dispose Background '\n '-delay %s -loop %s *.png \"%s\"' ) % ( d, int(delay),\n int(iterations), savefile )\n from subprocess import check_call, CalledProcessError\n try:\n check_call(cmd, shell=True)\n if show_path:\n print(\"Animation saved to file %s.\" % savefile)\n except (CalledProcessError, OSError):\n msg = \"\"\"\nError: Cannot generate GIF animation. Verify that convert\n(ImageMagick) or ffmpeg is installed, and that the objects passed to\nthe animate command can be saved in PNG image format.\n\nSee www.imagemagick.org and www.ffmpeg.org for more information.\"\"\"\n raise OSError(msg)","def animated_gif(folder_with_images, gif_filename, loop_duration, size):\r\n\r\n\tos.chdir(folder_with_images) # changes directory to the folder with the images\r\n\r\n\tpng_files = []\r\n\r\n\t# get list of png files in folder\r\n\tfor fn in os.listdir(folder_with_images):\r\n\t\tif fn.endswith('.png'):\r\n\t\t\tpng_files.append(fn)\r\n\r\n\tsort_nicely(png_files)\r\n\r\n\tprint(png_files)\r\n\r\n\t# number of png_files\r\n\tnum_pngs = len(png_files)\r\n\tpng_time = float(loop_duration)/ float(num_pngs)\r\n\r\n\timages = [Image.open(fn) for fn in png_files]\r\n\tdim = (size, size) # change sizes for the image file dimension\r\n\t#for im in images:\r\n\t#\tim.thumbnail(dim, Image.ANTIALIAS)\r\n\r\n\toutput_file = os.path.join(folder_with_images, gif_filename) # path for output file\r\n\twriteGif(output_file, images, png_time) # writes out GIF\r","def get_loop(self):\n\n log(\"Getting loop for {} at {}\".format(self._location, self._t0))\n loop = io.BytesIO()\n try:\n frames = self.get_frames()\n if frames is None:\n raise\n log(\"Got {} frames for {} at {}\".format(\n len(frames),\n self._location,\n self._t0\n ))\n frames[0].save(\n loop,\n append_images=frames[1:],\n duration=500,\n format='GIF',\n loop=0,\n save_all=True,\n )\n except:\n log(\"Got NO frames for {} at {}\".format(self._location, self._t0))\n self._pilimg.new('RGB', (340, 370)).save(loop, format='GIF')\n if self._outfn:\n outdir = os.path.dirname(self._outfn)\n if not os.path.isdir(outdir):\n try:\n os.makedirs(outdir)\n except:\n log_error(\"Could not create directory {}\".format(outdir))\n try:\n with open(self._outfn, 'wb') as f:\n f.write(loop.getvalue())\n except:\n log_error(\"Could not write image to {}\".format(self._outfn))\n return loop.getvalue()","def enable_loop(self):\n loop = (self._loop_mode is LoopMode.Wrap)\n return loop","def play_loop_mode(self, play_loop_mode):\n self._play_loop_mode = play_loop_mode","def gif(self):\n\n if self._gif is None:\n\n url = self.url.replace('f=fits', 'f=gif')\n\n try:\n url_data = urllib.request.urlopen(url)\n except urllib.request.URLError as ee:\n raise ValueError(f'cannot open URL for these parameters: {ee}')\n\n data = url_data.read()\n\n image = PIL.Image.open(io.BytesIO(data))\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\n\n self._gif = image\n\n return self._gif","def play(self, animation_idx=0, should_loop=False, loops=\"inf\"):\n self.should_loop = should_loop\n self.loops = loops\n self.current_loop = 0\n self.animation_idx = animation_idx\n self.current_playing_animation = self.animation_list[self.animation_idx]\n self.animation_list[self.animation_idx].reset()","def config_loop(self):\n loop_label = ['Loop OFF', 'Loop ON']\n group = self.make_ui_group(False, loop_label[self.loop])\n orig_loop = self.loop\n\n while True:\n action_left, action_right = (self.button_left.action(),\n self.button_right.action())\n if action_left is RichButton.HOLD:\n return self.loop is not orig_loop, False # Resume config\n if action_right is RichButton.HOLD:\n return self.loop is not orig_loop, True # Resume paint\n if RichButton.TAP in {action_left, action_right}:\n self.loop = not self.loop\n group.pop()\n group.append(centered_label(loop_label[self.loop], 40, 3))","def set_looping_interval(self, interval: float) -> None:\n \n self._looping_interval = interval","def loop(self):\n\n return self._loop","def watch_loop(self):\n # Double threaded function that allows to stop the loop mid execution\n def repeatIt():\n # reset UI and flag before starting loop\n self.resetLabels()\n self.reset_scrollbar()\n # enable stop button\n self.btnStop.config(state=\"normal\")\n # disable button while loop is running\n self.btnStart.config(state=\"disabled\")\n self.txtLoop.config(state=\"disabled\", textvariable=self.loopCounterUI)\n self.labelLoop.config(text=\"Loop Count: \")\n\n while self.loopCount.get() > 0:\n # move scrollbar to bottom\n self.testCanvas.yview_moveto(0)\n # count the loop\n self.loopCounterUI.set(self.loopCounterUI.get() + 1)\n\n # Run the test cases\n self.runThis()\n\n # Below are just to reset the UI\n if not self.stopLoop:\n print(\"loop not stopped so proceed\")\n # let user know script is stopping\n x = Label(\n self.testFrame, text=f'End of Loop',\n background=self.bgChooser(),\n foreground=\"#630984\",\n font=self.boldFont)\n x.pack(fill=X)\n # flag gor BG and labels\n self.bgCounter += 1\n self.LabelLists.append(x)\n # allow window to catch up\n self.tkRoot.update()\n self.update_scrollbar()\n else:\n print(\"loop has been stopped so not gonna print End of Loop\")\n\n # pause before restarting loop\n self.loopCount.set(self.loopCount.get()-1)\n time.sleep(1)\n\n # disable stop button\n self.btnStop.config(state=\"disabled\")\n # re-enable button after loop is done\n self.btnStart.config(state=\"normal\")\n self.txtLoop.config(state=\"normal\", textvariable=self.loopCount)\n self.labelLoop.config(text=\"Enter Loop Count: \")\n # self.testCanvas.yview_moveto(0)\n # Let user know the script is done\n if not self.stopLoop:\n # loop did not stopped\n x = Label(\n self.testFrame, text=f'Test is done!',\n background=self.bgChooser(),\n foreground=\"#057224\",\n font=self.boldFont)\n x.pack(fill=X)\n self.bgCounter += 1\n else:\n x = Label(\n self.testFrame, text=f'Test stopped!',\n background=self.bgChooser(),\n foreground=\"#057224\",\n font=self.boldFont)\n x.pack(fill=X)\n self.bgCounter += 1\n self.btnStart.config(state=\"normal\")\n self.txtLoop.config(state=\"normal\", textvariable=self.loopCount)\n self.labelLoop.config(text=\"Enter Loop count: \")\n self.loopCount.set(50000)\n self.LabelLists.append(x)\n # allow window to catch up\n self.tkRoot.update()\n self.update_scrollbar()\n thread = threading.Thread(target=repeatIt)\n thread.start()","def gif_fps(self, gif_fps):\n if gif_fps is not None and gif_fps > 30:\n raise ValueError(\"Invalid value for `gif_fps`, must be a value less than or equal to `30`\")\n\n self._gif_fps = gif_fps","def loop( self ):\n import gtk\n while self.count >= 1:\n log.debug( 'GTK loop restarting' )\n while gtk.events_pending():\n gtk.main_iteration()\n log.debug( 'GTK loop exiting' )\n try:\n del self.t_loop\n except AttributeError, err:\n pass","def write_gifs(self, clip, gifs_dir, **kwargs):\n for start, end, _, _ in self:\n name = \"%s/%08d_%08d.gif\" % (gifs_dir, 100 * start, 100 * end)\n clip.subclip(start, end).write_gif(name, **kwargs)","async def loop(self, ctx: commands.Context) -> Optional[bool]:\n\n self.queue[ctx.guild.id].loop = (\n Loops.LOOP if self.queue[ctx.guild.id].loop != Loops.LOOP else Loops.NO_LOOP\n )\n return self.queue[ctx.guild.id].loop == Loops.LOOP","async def _loop(self, ctx: commands.Context):\n\n if not ctx.voice_state.is_playing:\n raise commands.CommandError('Nothing being played at the moment.')\n\n # Inverse boolean value to loop and unloop.\n ctx.voice_state.loop = not ctx.voice_state.loop\n await ctx.message.add_reaction('✅')","async def _loop(self, ctx: commands.Context):\n\n if not ctx.voice_state.is_playing:\n return await ctx.send('Nothing being played at the moment.')\n\n # Inverse boolean value to loop and unloop.\n ctx.voice_state.loop = not ctx.voice_state.loop\n await ctx.message.add_reaction('✅')","async def _loop(self, ctx: commands.Context):\n\n if not ctx.voice_state.is_playing:\n return await ctx.send('Nothing being played at the moment.')\n\n # Inverse boolean value to loop and unloop.\n ctx.voice_state.loop = not ctx.voice_state.loop\n await ctx.message.add_reaction('✅')","async def gif(self, ctx: discord.ext.commands.Context, *args):\n print(\"-------------------------\")\n message_channel: discord.abc.Messageable = ctx.message.channel\n currentgifkey = self.botVariables.get_gif_key()\n print(\"GifRequest:Arguments:\" + str(len(args)))\n tag = \"\"\n if len(args) == 0: # request a random gif\n print(\"Gif Request with No arguments\")\n url = \"http://api.giphy.com/v1/gifs/random?api_key=\" + currentgifkey\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as resp:\n r = await resp.json()\n if 'data' in r:\n await message_channel.send(r['data']['url'])\n elif 'message' in r:\n await message_channel.send(\"An error occurred:\" + r['message'])\n else: # request a gif with tags\n for x in range(0, len(args)):\n tag = tag + args[x]\n if x != (len(args) - 1):\n tag += \" \"\n tag = urllib.parse.quote(tag)\n url = \"http://api.giphy.com/v1/gifs/random?api_key=\" + currentgifkey + \"&tag=\" + tag\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as resp:\n r = await resp.json()\n print(\"GifRequest:Gif Found\")\n if (len(r['data'])) == 0:\n await message_channel.send(\"No GIF found with those tags :frowning: \")\n else:\n if 'data' in r:\n await message_channel.send(r['data']['url'])\n elif 'message' in r:\n await message_channel.send(\"An error occurred:\" + r['message'])\n print(\"-------------------------\")","def change_loop_to(self, loop_name: Optional[Text]) -> None:\n if loop_name is not None:\n self.active_loop = {\n LOOP_NAME: loop_name,\n LOOP_INTERRUPTED: False,\n LOOP_REJECTED: False,\n TRIGGER_MESSAGE: self.get_latest_message().parse_data,\n }\n else:\n self.active_loop = {}","def loop_run(self, loops):\n self.loop_seek(self.num_loops + loops)","def loop(self):\n pass","def gif(filename, array, fps=10, scale=1.0):\n # ensure that the file has the .gif extension\n filename = filename + '.gif'\n\n # copy into the color dimension if the images are black and white\n if array.ndim == 3:\n array = array[..., np.newaxis] * np.ones(3)\n\n # make the moviepy clip\n clip = ImageSequenceClip(list(array), fps=fps).resize(scale)\n clip.write_gif(filename, fps=fps)\n return True","def compose_in_gif(images, output_file, delay):\n images[0].save(\n output_file, \n format='GIF', append_images=images[1:], \n save_all=True, duration=delay, loop=0,\n )","def get_loop(self) -> bool:\n return self._select_interface(self._rc_get_loop, self._http_get_loop)","def create_gifs(folder, time_per_image=0.1):\n # Retrieve images paths\n images_dict = defaultdict(list)\n folders_sorting_key = lambda s: int(s.split(\"_\")[-1])\n obs_folders = [f for f in os.listdir(folder) if f.split(\"_\")[0] == \"observations\"]\n obs_folders = sorted(obs_folders, key=folders_sorting_key)\n for obs_folder in obs_folders:\n for f in os.listdir(os.path.join(folder, obs_folder)):\n image_name = \"_\".join(f.split(\"_\")[:-1])\n images_dict[image_name].append(os.path.join(folder, obs_folder, f))\n # Create gifs\n for name in images_dict:\n target = os.path.join(folder, name + \".gif\")\n LungsLoader._create_gif(images_dict[name], target, time_per_image)","def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\n\n self._gif_fps = None\n self._color_depth = None\n self._gif_loop = None\n self._height = None\n self._start = None\n self._duration = None\n self._suffix = None\n self._overlay = None\n self._overlay_alignment = None\n self._overlay_scale = None\n self._label = None\n self.discriminator = None\n\n if gif_fps is not None:\n self.gif_fps = gif_fps\n if color_depth is not None:\n self.color_depth = color_depth\n if gif_loop is not None:\n self.gif_loop = gif_loop\n self.height = height\n self.start = start\n if duration is not None:\n self.duration = duration\n if suffix is not None:\n self.suffix = suffix\n if overlay is not None:\n self.overlay = overlay\n if overlay_alignment is not None:\n self.overlay_alignment = overlay_alignment\n if overlay_scale is not None:\n self.overlay_scale = overlay_scale\n if label is not None:\n self.label = label","def animate(directory,gifname,n_t,step=2,duration=0.2):\n\t# create list of filenames\n\tfnames = dir_fname(directory,\"*\")\n\t# create list of plots\n\timages=[] \n\tfor k in range(0,n_t):\n\t\tk = k*step\n\t\tprint('Mounting Im '+ str(k))\n\t\tFIG_NAME=fnames[k]\n\t\timages.append(imageio.imread(FIG_NAME)) # read\n\t# Now we can assemble the video\n\timageio.mimsave(gifname, images,duration=duration) # create gif\n\tprint('Animation'+gifname+'Ready')\n\treturn True","def loop(self):\n raise NotImplementedError()","def _change_loop_to(self, loop_name: Optional[Text]) -> None:\n if loop_name is not None:\n self.active_loop = {\n LOOP_NAME: loop_name,\n LOOP_INTERRUPTED: False,\n LOOP_REJECTED: False,\n TRIGGER_MESSAGE: self.get_latest_message().parse_data,\n }\n else:\n self.active_loop = {}","def while_loop(self):\n if self._loop is None:\n self._loop = self._while_loop()\n return self._loop\n return self._loop","def gif(self, num_games, slow_mult=2, delete_pics=True,\n kill_limit_per_game=1000):\n slow_mult = int(slow_mult)\n gif_name = \"gifs\\\\\"+self.name\n\n try:\n os.remove(gif_name+'.gif')\n except Exception:\n pass\n\n kill_limit = kill_limit_per_game * num_games\n\n c = 0\n e = 0\n while c < kill_limit and e < num_games:\n self.env.reset()\n game_over = False\n # get initial input\n input_t = self.env.observe()\n\n plt.imshow(self.env.draw_state(),\n interpolation='none', cmap='gray')\n plt.savefig(\"gifs\\\\%d.png\" % c)\n plt.close()\n c += 1\n while not game_over and c < kill_limit:\n input_tm1 = input_t\n\n # get next action\n q = self.model.predict(input_tm1)\n action = np.argmax(q[0])\n\n # apply action, get rewards and new state\n input_t, reward, game_over = self.env.act(action)\n\n plt.imshow(self.env.draw_state(),\n interpolation='none', cmap='gray')\n plt.savefig(\"gifs\\\\%d.png\" % c)\n plt.close()\n c += 1\n\n e += 1\n\n # Making a temporary gif and slowing it down seems to be the only way I\n # can make a slower gif. For some reason the command works in cmd but\n # not here so i guess I am stuck with fast gifs.\n \"\"\"\n call1 = ['ffmpeg', '-i', '%d.png', gif_name+'_temp.gif']\n subprocess.call(call1)\n call2 = ['ffmpeg', '-i', gif_name+'_temp.gif', '-filter:v',\n '\"setpts={}.0*PTS\"'.format(slow_mult), gif_name+'.gif']\n subprocess.call(call2, shell=True)\n # ffmpeg -i catch_small_model.gif -filter:v \"setpts=3.0*PTS\" catch_small_model_slow.gif\n print(call2)\n try:\n os.remove(gif_name+'_temp.gif')\n except Exception as e:\n print(e)\n \"\"\"\n subprocess.call(['ffmpeg', '-i', 'gifs\\\\%d.png', gif_name+'.gif'])\n\n if delete_pics:\n for i in range(c):\n try:\n os.remove(\"gifs\\\\%d.png\" % i)\n except Exception as e:\n print(e)","def toggle_loop(self):\n if not self.can_alter_line():\n return\n if self.loop:\n self.loop = None\n else:\n self.caller.location.ndb.event_line_loop = True\n self.msg(\"Line looping set to: %s\" % str(bool(self.loop)))","async def async_set_repeat(self, repeat):\n if not self._slave_mode:\n self._repeat = repeat\n if repeat == REPEAT_MODE_OFF:\n mode = '0'\n elif repeat == REPEAT_MODE_ALL:\n mode = '2' if self._shuffle else '3'\n elif repeat == REPEAT_MODE_ONE:\n mode = '1'\n value = await self.async_call_linkplay_httpapi(\"setPlayerCmd:loopmode:{0}\".format(mode), None)\n if value != \"OK\":\n _LOGGER.warning(\"Failed to change repeat mode. Device: %s, Got response: %s\", self.entity_id, value)\n else:\n await self._master.async_set_repeat(repeat)","def _set_loop(tik_instance, num_core, max_core, total_dim):\n core_loop = tik_instance.Scalar(\"uint64\")\n\n with tik_instance.if_scope(num_core < total_dim % AICORE_NUM):\n core_loop.set_as(_ceil_div(total_dim, max_core))\n with tik_instance.else_scope():\n core_loop.set_as(total_dim // max_core)\n\n return core_loop","def _set_loops(loop_data):\n # Initiate a loop column with 1 for each loop tag\n loop_data[u'loop'] = 0\n loop_data.ix[loop_data.text.str.contains(u'loop_'),u'loop'] = 1\n\n # Ensure the index is linear, but set it up so the original\n # index can be replaced\n old_columns = loop_data.columns\n loop_data = loop_data.reset_index(drop=False)\n index_column = list(set(loop_data.columns) - set(old_columns))\n \n # Get the difference between index positions of the loop tags\n loop_index = loop_data.ix[loop_data.loop==1].index\n loop_diff = loop_index[1:] - loop_index[:-1]\n\n # For nested loops, the difference \n depth = 0\n for idx,diff in zip(loop_index[:-1],loop_diff):\n if diff <= 2:\n depth += 1\n loop_data.ix[idx,u'loop'] += depth\n else:\n depth = 0\n \n \n # Reset the index\n loop_data.set_index(index_column, drop=True)\n if u'index' in loop_data.columns:\n loop_data = loop_data.drop([u'index'], axis = 1)\n \n return loop_data","def generate_gif(directory: (\"Folder name\", \"positional\"),\n image_format: ('Image format', 'positional') = '.png',\n print_file_names=False):\n import imageio\n from glob import glob\n from natsort import natsorted\n\n images = []\n # Create a list of file names in the specified directory\n filenames = glob(directory + '/*' + image_format)\n\n filenames = natsorted(filenames, key=lambda y: y.lower())\n # Sort the list 'filenames' using the traditional method.\n # Traditional method -\n # isolate the entire first number in the string, then sort by that number\n # If this step is not included,\n # files will be sorted like so: 0, 100, 110, 200, 3, 420, etc...\n\n if print_file_names: # For troubleshooting\n for i in filenames:\n print(i)\n\n for filename in filenames:\n images.append(imageio.imread(filename))\n # Append each file to the list that will become the gif\n\n imageio.mimsave(directory + '.gif', images)\n # Save the gif as the name of the directory\n # that the images were generated from\n return","def gif_generation(orig_label_path, bound_data_path):\n for sample in os.listdir(bound_data_path):\n if not sample.startswith('.') and osp.isdir(osp.join(bound_data_path, sample)):\n sample_path = osp.join(bound_data_path, sample)\n for artery in os.listdir(sample_path):\n orig_label_pick_path = osp.join(orig_label_path, sample, artery, 'data.pkl')\n bound_pick_path = osp.join(bound_data_path, sample, artery, 'data.pkl')\n\n # function to save result of each artery into gif\n save_gif_artery(orig_label_pick_path, bound_pick_path)","def GAME_LOOP():\n pass","def startColorLoop():\n b.set_group(1, 'on', True)\n b.set_group(1, 'bri', 254)\n b.set_group(1, 'hue', 255)\n b.set_group(1, 'sat', 255)\n b.set_group(1, 'effect', 'colorloop')","def loop():\n global loop_idx\n sys.stdout.write('loop index %d/%d\\r\\n' % (loop_idx, _LOOPS))\n time.sleep(0.5)\n loop_idx += 1\n return loop_idx > _LOOPS","def start_loop(self, loop):\n asyncio.set_event_loop(loop)\n loop.run_forever()","def game_loop(self):\n self.interface.game_loop(self)","def create_gif(base_folder):\n img_list = []\n search_path = glob.glob(os.path.join(base_folder, '*.png'))\n search_path.sort()\n for f in search_path:\n im = Image.open(f)\n img_list.append(im)\n save_file = os.path.join(base_folder, 'animated_gif.gif')\n img_list[0].save(save_file,\n save_all=True, append_images=img_list[1:], optimize=False, duration=180, loop=0)","def loop(self):\r\n while self.__running:\r\n self.__check_events()\r\n self.__render()\r\n self.__reset_variables()","def saveGIFBatch(directory, path, name=''):\n # for each frame in batch\n images = []\n for filename in directory:\n print(filename)\n images.append(imageio.imread(filename))\n\n name_gif = path + '/' + name + '.gif'\n imageio.mimsave(name_gif, images)","def write_loop_text(self):\n\t\tself.write_components['loop'] = \"\"\"loop( ({sets})$({cond}), {loop})\n\t\t\"\"\".format( sets = ', '.join(self.shock_gm.database[self.loop_name].names),\n\t\t\t\t\tcond = self.shock_gm.database.get(self.loop_name).to_str,\n\t\t\t\t\tloop = self.loop_text)\n\t\treturn self.write_components['loop']","def loop_type(graph = None):\n\tbreakpoints = 0\n\tfor edge in nx.generate_edgelist(graph):\n\t\tif ('breakpoint' in edge):\n\t\t\tbreakpoints += 1\n\n\tif breakpoints == 1:\n\t\tif is_loop(graph = graph):\n\t\t\treturn 'hairpinloop'\n\t\telse:\n\t\t\treturn 'dangling_end'\n\n\tif is_loop(graph = graph):\n\t\tif breakpoints == 2:\n\t\t\treturn multiloop_type(graph = graph)\n\t\telif breakpoints == 3:\n\t\t\treturn 'multiloop3'\n\t\telif breakpoints == 4:\n\t\t\treturn 'multiloop4'\n\t\telif breakpoints == 5:\n\t\t\treturn 'multiloop5'\n\treturn 'NA'","def convert_gif(path: str,\n gif_name: str = 'gif_name.gif',\n frame_limit: int = 100):\n video_path = glob(path + \"/*.mp4\")[-1]\n vidcap = cv2.VideoCapture(video_path)\n success, frame = vidcap.read()\n count = 0\n\n # extracting and saving video frames.\n while success:\n cv2.imwrite(f\"{path}/frame{count}.png\", frame) \n success, frame = vidcap.read()\n count += 1\n if count > frame_limit:\n break\n print(\"total frames:\", count)\n\n # generate animated GIF.\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\"/*.png\"))]\n img.save(fp=f\"{path}/{gif_name}\", format='GIF', append_images=imgs,\n save_all=True, duration=200, loop=0)\n \n # remove frames\n [os.remove(os.path.join(path, f)) for f in glob(path+\"/*.png\")]","def MULTIPLAYER_LOOP():\n pass","def iteration(self, iteration):\n self._iteration = iteration","def iteration(self, iteration):\n self._iteration = iteration","def iteration(self, iteration):\n self._iteration = iteration","def loop_stop(self):\n self._loop_state = LState.Stopping\n self.log_debug(\"Stopping loop\")","async def queueloop(self, ctx: commands.Context) -> Optional[bool]:\n\n queue = self.queue[ctx.guild.id]\n\n queue.loop = (\n Loops.QUEUE_LOOP\n if self.queue[ctx.guild.id].loop != Loops.QUEUE_LOOP\n else Loops.NO_LOOP\n )\n\n if queue.loop == Loops.QUEUE_LOOP:\n queue.queue_loop_start = queue.pos\n\n return queue.loop == Loops.QUEUE_LOOP","def loop_run(self):\n super(HasLoops, self).loop_run()\n for loop in getattr(self, \"_loops\", []):\n loop.loop_remove_from_parent = weak_method(self.remove_loop)\n loop.loop_run()","def make_gif(image_list, gif_name):\n if not gif_name.endswith(\".gif\"):\n gif_name += \".gif\"\n imageio.mimsave(gif_name, [imageio.imread(x) for x in image_list])","def create_gif():\n anim_file = 'sample/training.gif'\n\n with imageio.get_writer(anim_file, mode='I') as writer:\n filenames = glob.glob('sample/*.jpg')\n filenames = sorted(filenames, key=lambda filename: int(filename[11:-4]))\n for filename in filenames:\n image = imageio.imread(filename)\n writer.append_data(image)\n image = imageio.imread(filename)\n writer.append_data(image)","def loop(self):\r\n\r\n self._next_state = self._current_state","def loop(self,timeout=1):\n self.stream.loop(timeout)","def _run(self):\n while(self._loop):\n pass","def save_gif(frames):\n print(\"Saving gif images!\")\n for i in range(len(frames)):\n im_out_path = \"gif/gif_emilie_will_\" + str(i) + \".png\"\n plt.imsave(im_out_path, frames[i])","def graphics_loop(self, font):\n self.screen.blit(self.background, (0, 0))\n if not self.scroll:\n self.all_sprites.draw(self.screen)\n else:\n self.draw_onscreen()\n #display which step we're on\n if pygame.font:\n text = font.render(str(self.stepid), 1, (255, 255, 255))\n textpos = text.get_rect(centerx = int(\n (self.screen.get_width() * 0.5)))\n self.screen.blit(text, textpos)\n pygame.display.flip()\n #cap at x fps\n self.clock.tick(self.max_fps)","def setIdle(self, flag):\n if( flag ) :\n if( self.idleWork == -1) :\n self.idleWork = gobject.idle_add( self.idle_callback )\n else :\n if( self.idleWork != -1) :\n gobject.source_remove( self.idleWork )\n self.idleWork = -1","def send_GIF():\n try:\n gif_icon = driver.find_element_by_xpath('//*[@data-tip=\"GIF\"]')\n gif_icon.click()\n wait(wait_time=10)\n gifs = driver.find_elements_by_class_name('giphy-gif')\n src = gifs[0].get_attribute('src')\n gif_ID = src[src.index('media/') + len('media/'):]\n gif_ID = gif_ID[:gif_ID.index('/')]\n gifs[0].click()\n wait()\n except Exception as e:\n return \"Error: \" + str(e)\n if verify_GIF_sent(gif_ID):\n return \"Success\"\n else:\n return \"Error: GIF wasn't sent\"","def on_update(self, delta_time):\n self.time += 1\n if self.time <= 900:\n self.gif.update_animation()","def __nii4dtoGif(self, inputfile, tgGif, gifSpeed=30):\n gifId = self.__idGenerator()\n \n # Number of volumes in the 4D image\n vSize = mriutil.getNbDirectionsFromDWI(inputfile)\n vols = [gifId + '{0:04}'.format(i) for i in range(vSize)]\n \n # Spliting 4D image\n cmd = 'fslsplit ' + inputfile + ' ' + gifId + ' -t'\n self.launchCommand(cmd)\n \n # Extracting pngs from all volumes\n for vol in vols:\n self.__slicer(vol, None, vol + '.png')\n \n # Creating .gif\n cmd = 'convert '\n for vol in vols:\n cmd += '-delay ' + str(gifSpeed) + ' ' + vol + '.png '\n cmd += tgGif\n self.launchCommand(cmd)\n \n # Cleaning temp files\n cmd = 'rm ' + gifId + '*'\n self.launchCommand(cmd)","def postprocess(self, loop):\n return loop","def play_next_animation(self):\n if self.animation_idx < len(self.animation_list)-1:\n self.__next()\n elif self.should_loop:\n self.__loop()\n else:\n self.stop()","def infinite_loop():\n return True","def loop(self):\n self.screen.fill((0, 0, 0))\n self.clock.tick(FU_FRAME_RATE)\n self.level.update_loop(self.screen, self.clock)\n self.handle_events()","def set_tif(self, interface):\n if not ((1 << interface) & self.supported_tifs()):\n raise errors.JLinkException('Unsupported target interface: %s' % interface)\n\n # The return code here is actually *NOT* the previous set interface, it\n # is ``0`` on success, otherwise ``1``.\n res = self._dll.JLINKARM_TIF_Select(interface)\n if res != 0:\n return False\n\n self._tif = interface\n return True","def start(self):\n if self.__started:\n return\n\n self.__started = True\n GLib.timeout_add(GtkMainLoop.DEADLINE_GLIB, self.__ioloop_run)\n self.__gi_loop.run()","def stopGTK( ):\n if LOOP_TRACKER:\n LOOP_TRACKER.decrement()","def put_drawing_gif_async(self, request):\n HttpRequest = request.to_http_info(self.api_client.configuration)\n return self.__make_request_async(HttpRequest, 'PUT', 'file')","def __init__(self, loop=None):\n object.__setattr__(self, '_loop', loop or get_event_loop())","def make_gif(im_dir, out_file, pattern='*.png', fps=10):\n im_files = glob.glob(os.path.join(im_dir, pattern))\n if len(im_files) == 0:\n raise ValueError(f'No images found in {im_dir}!')\n \n writer = imageio.get_writer(out_file, mode='I', fps=fps)\n for im_file in im_files:\n im = imageio.imread(im_file)\n writer.append_data(im)\n writer.close()","def bottle_song_while(num):\n pass","def setOverlayRepeat(self, value):\n self.PDFreactorConfiguration.in1[\"overlayRepeat\"] = value","def setFlag(self):\n if self.inPlay and not self.shown:\n self.flag = not(self.flag)\n image_index = 11 if self.flag else 10\n self.configure(image = Tile.images[image_index])\n return 1 if self.flag else -1\n return 0","def start_frame(self):\n\n # Check whether we're supposed to make a frame on this iteration:\n if self.frame_count % self.stride != 0:\n return\n\n # Check whether we're already making a frame. \n if self.in_scope:\n print(\"The Gif object for {} has encountered 'start_frame' twice\\\n without an intervening 'end_frame'\".format(self.filename))\n raise SyntaxError\n\n # Construct a new figure\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\n self.current_frame = fig\n\n # Set the \"in_scope\" member True\n self.in_scope = True\n\n return self.current_frame","def display_frames_as_gif(frames, video_name):\n Writer = animation.writers['ffmpeg']\n writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)\n #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\n patch = plt.imshow(frames[0])\n plt.axis('off')\n\n def animate(i):\n patch.set_data(frames[i])\n\n anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\n# display(display_animation(anim, default_mode='loop'))\n anim.save(result_floder + '/' + video_name, writer=writer)","def loop_forever(self):\n self.running = True\n while self.running:\n time.sleep(0.1)","def writeGif(filename, images, duration=0.1, loops=0, dither=1):\n \n if PIL is None:\n raise RuntimeError(\"Need PIL to write animated gif files.\")\n \n AD = Image.ADAPTIVE\n images2 = []\n \n # convert to PIL\n for im in images:\n \n if isinstance(im,Image.Image):\n images2.append( im.convert('P', palette=AD, dither=dither) )\n \n elif np and isinstance(im, np.ndarray):\n if im.dtype == np.uint8:\n pass\n elif im.dtype in [np.float32, np.float64]:\n im = (im*255).astype(np.uint8)\n else:\n im = im.astype(np.uint8)\n # convert\n if len(im.shape)==3 and im.shape[2]==3:\n im = Image.fromarray(im,'RGB').convert('P', palette=AD, dither=dither)\n elif len(im.shape)==2:\n im = Image.fromarray(im,'L').convert('P', palette=AD, dither=dither)\n else:\n raise ValueError(\"Array has invalid shape to be an image.\")\n images2.append(im)\n \n else:\n raise ValueError(\"Unknown image type.\")\n \n # check duration\n if hasattr(duration, '__len__'):\n if len(duration) == len(images2):\n durations = [d for d in duration]\n else:\n raise ValueError(\"len(duration) doesn't match amount of images.\")\n else:\n durations = [duration for im in images2]\n \n \n # open file\n fp = open(filename, 'wb')\n \n # write\n try:\n n = _writeGifToFile(fp, images2, durations, loops)\n print n, 'frames written'\n finally:\n fp.close()","def main_loop(infr, max_loops=None, use_refresh=True):\n raise RuntimeError()\n infr.start_id_review(max_loops=max_loops, use_refresh=use_refresh)\n # To automatically run through the loop just exhaust the generator\n try:\n result = next(infr._gen)\n except StopIteration:\n pass\n assert result is None, 'need user interaction. cannot auto loop'\n infr._gen = None","def stop_updating_loop(self) -> None:\n if self.updating_loop is not None:\n self.updating_loop.cancel()","def end_frame(self, **kwargs):\n \n # Check whether we're supposed to make a frame on this iteration:\n if self.frame_count % self.stride != 0:\n self.frame_count += 1\n return\n\n # Check whether we're still making another frame\n if not self.in_scope: \n print(\"The Gif object for {} has encountered 'end_frame' twice\\\n without an intervening 'start_frame'\".format(self.filename))\n raise SyntaxError\n\n # Save the frame to the temporary directory\n count_width = str(int(math.log10(self.max_frames) + 1))\n label = \"{:0>\"+count_width+\"d}\"\n label = label.format(self.frame_count)\n file_path = \"{}_{}{}\".format(self.tmp_prefix, label, self.tmp_suffix)\n self.current_frame.savefig(file_path,**kwargs)\n\n # Close the figure\n plt.close(self.current_frame)\n \n # Update some relevant attributes\n self.current_frame = None\n self.in_scope = False\n self.frame_count += 1\n\n return","def setSeqElementLooping(self,SequenceIndex=1,Repeat=1,InfiniteLoop=0):#TODO implement stringonly\n\n if (InfiniteLoop==1):\n self.sendMessage(\"SEQuence:ELEMent\"+str(SequenceIndex)+\":LOOP:INFinite 1\")\n else:\n self.sendMessage(\"SEQuence:ELEMent\"+str(SequenceIndex)+\":LOOP:INFinite 0\")\n self.sendMessage(\"SEQuence:ELEMent\"+str(SequenceIndex)+\":LOOP:COUNt \"+str(Repeat))","def changeGun(self):\n self.currentGun += 1\n self.currentGun %= len(Laser.imgs)\n self.agent.actionCompleted()","def AnimFromPng(name, gif=True, fps=15):\n if(gif):\n imgconvert = \"convert \" + \"-delay \" + str(int(1000/fps))\n imgconvert += \" -dispose None \" + name + \"*.png -loop 0 \" + name + \".gif\"\n system(imgconvert)\n print imgconvert\n else:\n aviconvert = \"ffmpeg -i \" + name + \"%03d.png -b:v 2048k -r \" + str(fps) + \" \" + name + \".avi\"\n system(aviconvert)\n print aviconvert","async def gif(self, ctx, *keywords):\n if keywords:\n keywords = \"+\".join(keywords)\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='sigh.. **`{}help gif`**'.format(self.config['prefix']),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\n return\n await self.bot.send_typing(ctx.message.channel)\n url = (\"http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}\"\n \"\".format(self.config['giphy-api-key'], keywords))\n\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as response:\n source = await response.json(encoding='utf8')\n\n source = json.dumps(source)\n result = json.loads(str(source))\n\n if response.status == 200:\n if result[\"data\"]:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format(''),\n colour=0xf20006)\n embed.set_image(url=result[\"data\"][\"image_original_url\"])\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['succes'])\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format('No results found.'),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['warning'])\n else:\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\n description='{}'.format('Error contacting the API'),\n colour=0xf20006)\n last_message = await self.bot.say(embed=embed)\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])","def make_GIF(image_path: Union[Path, str]) -> None:\n import imageio\n from pygifsicle import optimize\n\n if isinstance(image_path, str):\n image_path = Path(image_path)\n\n image_dir = image_path.parent\n image_file = image_path.stem\n gif_path = image_dir / f\"{image_file}.gif\"\n gif_path = Path(\"./xxxx.gif\")\n with imageio.get_writer(gif_path, mode='I') as writer:\n img_files = sorted((img_file for img_file in image_dir.glob('*.png')))\n for img_file in img_files:\n writer.append_data(imageio.imread(img_file))\n print(f\"{len(img_files)} images loaded from {image_path}\")\n try:\n optimize(gif_path)\n except Exception:\n print(\"gifsicle not installed\")","def multiloop_type(graph = None):\n\tg = graph.copy()\n\tbreakpoint_nodes = []\n\tfor edge in g.edges(data=True):\n\t\tid1 ,id2 , data = edge\n\t\tif g.edge[id1][id2]['label']== '$':\n\t\t\tif not id1 in breakpoint_nodes:\n\t\t\t\tbreakpoint_nodes.append(id1)\n\t\t\tif not id2 in breakpoint_nodes:\n\t\t\t\tbreakpoint_nodes.append(id2)\n\tfor node in breakpoint_nodes:\n\t\tg.remove_node(node)\n\tif nx.number_connected_components(g) ==1:\n\t\treturn 'bulge'\n\telse:\n\t\treturn 'internal_loop'","def loop_forever(self):\n while self.running:\n time.sleep(0.01)","def loop(self):\n while True:\n delay_until_next = self.tick()\n if not delay_until_next:\n break\n self._sleep(delay_until_next)","def _handle_loop(self):\n pass"],"string":"[\n \"def gif_loop(self):\\n return self._gif_loop\",\n \"def __loop(self):\\n if self.loops is \\\"inf\\\":\\n self.play()\\n else:\\n if self.loops > self.current_loop:\\n self.current_loop += 1\\n self.play()\\n else:\\n self.stop()\",\n \"def loop(self):\\r\\n if self.delay_count >= self.delay:\\r\\n if self.loop_alt == 0:\\r\\n self.frame_index += 1\\r\\n elif self.loop_alt == 1:\\r\\n if self.loop_down and self.frame_index > 0:\\r\\n self.frame_index -= 1\\r\\n else:\\r\\n self.frame_index += 1\\r\\n self.loop_down = False\\r\\n if self.frame_index >= len(self.frames): # Repeat frames\\r\\n if self.loop_alt == 0:\\r\\n self.frame_index = 0\\r\\n elif self.loop_alt == 1:\\r\\n self.loop_down = True\\r\\n self.frame_index -= 2\\r\\n\\r\\n self.image = self.frames[self.frame_index]\\r\\n self.delay_count = 0\\r\\n else:\\r\\n self.delay_count += 1\",\n \"def loop(self, loop: bool=None):\\n self._select_interface(self._rc_loop, self._http_loop, loop)\",\n \"def gif(self, delay=20, savefile=None, iterations=0, show_path=False,\\n use_ffmpeg=False):\\n from sage.misc.sage_ostools import have_program\\n have_convert = have_program('convert')\\n have_ffmpeg = self._have_ffmpeg()\\n if use_ffmpeg or not have_convert:\\n if have_ffmpeg:\\n self.ffmpeg(savefile=savefile, show_path=show_path,\\n output_format='.gif', delay=delay,\\n iterations=iterations)\\n else:\\n if not have_convert:\\n msg = \\\"\\\"\\\"\\nError: Neither ImageMagick nor ffmpeg appears to be installed. Saving an\\nanimation to a GIF file or displaying an animation requires one of these\\npackages, so please install one of them and try again.\\n\\nSee www.imagemagick.org and www.ffmpeg.org for more information.\\\"\\\"\\\"\\n else:\\n msg = \\\"\\\"\\\"\\nError: ffmpeg does not appear to be installed. Download it from\\nwww.ffmpeg.org, or use 'convert' to produce gifs instead.\\\"\\\"\\\"\\n raise OSError(msg)\\n else:\\n if not savefile:\\n savefile = graphics_filename(ext='.gif')\\n if not savefile.endswith('.gif'):\\n savefile += '.gif'\\n savefile = os.path.abspath(savefile)\\n d = self.png()\\n cmd = ( 'cd \\\"%s\\\"; sage-native-execute convert -dispose Background '\\n '-delay %s -loop %s *.png \\\"%s\\\"' ) % ( d, int(delay),\\n int(iterations), savefile )\\n from subprocess import check_call, CalledProcessError\\n try:\\n check_call(cmd, shell=True)\\n if show_path:\\n print(\\\"Animation saved to file %s.\\\" % savefile)\\n except (CalledProcessError, OSError):\\n msg = \\\"\\\"\\\"\\nError: Cannot generate GIF animation. Verify that convert\\n(ImageMagick) or ffmpeg is installed, and that the objects passed to\\nthe animate command can be saved in PNG image format.\\n\\nSee www.imagemagick.org and www.ffmpeg.org for more information.\\\"\\\"\\\"\\n raise OSError(msg)\",\n \"def animated_gif(folder_with_images, gif_filename, loop_duration, size):\\r\\n\\r\\n\\tos.chdir(folder_with_images) # changes directory to the folder with the images\\r\\n\\r\\n\\tpng_files = []\\r\\n\\r\\n\\t# get list of png files in folder\\r\\n\\tfor fn in os.listdir(folder_with_images):\\r\\n\\t\\tif fn.endswith('.png'):\\r\\n\\t\\t\\tpng_files.append(fn)\\r\\n\\r\\n\\tsort_nicely(png_files)\\r\\n\\r\\n\\tprint(png_files)\\r\\n\\r\\n\\t# number of png_files\\r\\n\\tnum_pngs = len(png_files)\\r\\n\\tpng_time = float(loop_duration)/ float(num_pngs)\\r\\n\\r\\n\\timages = [Image.open(fn) for fn in png_files]\\r\\n\\tdim = (size, size) # change sizes for the image file dimension\\r\\n\\t#for im in images:\\r\\n\\t#\\tim.thumbnail(dim, Image.ANTIALIAS)\\r\\n\\r\\n\\toutput_file = os.path.join(folder_with_images, gif_filename) # path for output file\\r\\n\\twriteGif(output_file, images, png_time) # writes out GIF\\r\",\n \"def get_loop(self):\\n\\n log(\\\"Getting loop for {} at {}\\\".format(self._location, self._t0))\\n loop = io.BytesIO()\\n try:\\n frames = self.get_frames()\\n if frames is None:\\n raise\\n log(\\\"Got {} frames for {} at {}\\\".format(\\n len(frames),\\n self._location,\\n self._t0\\n ))\\n frames[0].save(\\n loop,\\n append_images=frames[1:],\\n duration=500,\\n format='GIF',\\n loop=0,\\n save_all=True,\\n )\\n except:\\n log(\\\"Got NO frames for {} at {}\\\".format(self._location, self._t0))\\n self._pilimg.new('RGB', (340, 370)).save(loop, format='GIF')\\n if self._outfn:\\n outdir = os.path.dirname(self._outfn)\\n if not os.path.isdir(outdir):\\n try:\\n os.makedirs(outdir)\\n except:\\n log_error(\\\"Could not create directory {}\\\".format(outdir))\\n try:\\n with open(self._outfn, 'wb') as f:\\n f.write(loop.getvalue())\\n except:\\n log_error(\\\"Could not write image to {}\\\".format(self._outfn))\\n return loop.getvalue()\",\n \"def enable_loop(self):\\n loop = (self._loop_mode is LoopMode.Wrap)\\n return loop\",\n \"def play_loop_mode(self, play_loop_mode):\\n self._play_loop_mode = play_loop_mode\",\n \"def gif(self):\\n\\n if self._gif is None:\\n\\n url = self.url.replace('f=fits', 'f=gif')\\n\\n try:\\n url_data = urllib.request.urlopen(url)\\n except urllib.request.URLError as ee:\\n raise ValueError(f'cannot open URL for these parameters: {ee}')\\n\\n data = url_data.read()\\n\\n image = PIL.Image.open(io.BytesIO(data))\\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\\n\\n self._gif = image\\n\\n return self._gif\",\n \"def play(self, animation_idx=0, should_loop=False, loops=\\\"inf\\\"):\\n self.should_loop = should_loop\\n self.loops = loops\\n self.current_loop = 0\\n self.animation_idx = animation_idx\\n self.current_playing_animation = self.animation_list[self.animation_idx]\\n self.animation_list[self.animation_idx].reset()\",\n \"def config_loop(self):\\n loop_label = ['Loop OFF', 'Loop ON']\\n group = self.make_ui_group(False, loop_label[self.loop])\\n orig_loop = self.loop\\n\\n while True:\\n action_left, action_right = (self.button_left.action(),\\n self.button_right.action())\\n if action_left is RichButton.HOLD:\\n return self.loop is not orig_loop, False # Resume config\\n if action_right is RichButton.HOLD:\\n return self.loop is not orig_loop, True # Resume paint\\n if RichButton.TAP in {action_left, action_right}:\\n self.loop = not self.loop\\n group.pop()\\n group.append(centered_label(loop_label[self.loop], 40, 3))\",\n \"def set_looping_interval(self, interval: float) -> None:\\n \\n self._looping_interval = interval\",\n \"def loop(self):\\n\\n return self._loop\",\n \"def watch_loop(self):\\n # Double threaded function that allows to stop the loop mid execution\\n def repeatIt():\\n # reset UI and flag before starting loop\\n self.resetLabels()\\n self.reset_scrollbar()\\n # enable stop button\\n self.btnStop.config(state=\\\"normal\\\")\\n # disable button while loop is running\\n self.btnStart.config(state=\\\"disabled\\\")\\n self.txtLoop.config(state=\\\"disabled\\\", textvariable=self.loopCounterUI)\\n self.labelLoop.config(text=\\\"Loop Count: \\\")\\n\\n while self.loopCount.get() > 0:\\n # move scrollbar to bottom\\n self.testCanvas.yview_moveto(0)\\n # count the loop\\n self.loopCounterUI.set(self.loopCounterUI.get() + 1)\\n\\n # Run the test cases\\n self.runThis()\\n\\n # Below are just to reset the UI\\n if not self.stopLoop:\\n print(\\\"loop not stopped so proceed\\\")\\n # let user know script is stopping\\n x = Label(\\n self.testFrame, text=f'End of Loop',\\n background=self.bgChooser(),\\n foreground=\\\"#630984\\\",\\n font=self.boldFont)\\n x.pack(fill=X)\\n # flag gor BG and labels\\n self.bgCounter += 1\\n self.LabelLists.append(x)\\n # allow window to catch up\\n self.tkRoot.update()\\n self.update_scrollbar()\\n else:\\n print(\\\"loop has been stopped so not gonna print End of Loop\\\")\\n\\n # pause before restarting loop\\n self.loopCount.set(self.loopCount.get()-1)\\n time.sleep(1)\\n\\n # disable stop button\\n self.btnStop.config(state=\\\"disabled\\\")\\n # re-enable button after loop is done\\n self.btnStart.config(state=\\\"normal\\\")\\n self.txtLoop.config(state=\\\"normal\\\", textvariable=self.loopCount)\\n self.labelLoop.config(text=\\\"Enter Loop Count: \\\")\\n # self.testCanvas.yview_moveto(0)\\n # Let user know the script is done\\n if not self.stopLoop:\\n # loop did not stopped\\n x = Label(\\n self.testFrame, text=f'Test is done!',\\n background=self.bgChooser(),\\n foreground=\\\"#057224\\\",\\n font=self.boldFont)\\n x.pack(fill=X)\\n self.bgCounter += 1\\n else:\\n x = Label(\\n self.testFrame, text=f'Test stopped!',\\n background=self.bgChooser(),\\n foreground=\\\"#057224\\\",\\n font=self.boldFont)\\n x.pack(fill=X)\\n self.bgCounter += 1\\n self.btnStart.config(state=\\\"normal\\\")\\n self.txtLoop.config(state=\\\"normal\\\", textvariable=self.loopCount)\\n self.labelLoop.config(text=\\\"Enter Loop count: \\\")\\n self.loopCount.set(50000)\\n self.LabelLists.append(x)\\n # allow window to catch up\\n self.tkRoot.update()\\n self.update_scrollbar()\\n thread = threading.Thread(target=repeatIt)\\n thread.start()\",\n \"def gif_fps(self, gif_fps):\\n if gif_fps is not None and gif_fps > 30:\\n raise ValueError(\\\"Invalid value for `gif_fps`, must be a value less than or equal to `30`\\\")\\n\\n self._gif_fps = gif_fps\",\n \"def loop( self ):\\n import gtk\\n while self.count >= 1:\\n log.debug( 'GTK loop restarting' )\\n while gtk.events_pending():\\n gtk.main_iteration()\\n log.debug( 'GTK loop exiting' )\\n try:\\n del self.t_loop\\n except AttributeError, err:\\n pass\",\n \"def write_gifs(self, clip, gifs_dir, **kwargs):\\n for start, end, _, _ in self:\\n name = \\\"%s/%08d_%08d.gif\\\" % (gifs_dir, 100 * start, 100 * end)\\n clip.subclip(start, end).write_gif(name, **kwargs)\",\n \"async def loop(self, ctx: commands.Context) -> Optional[bool]:\\n\\n self.queue[ctx.guild.id].loop = (\\n Loops.LOOP if self.queue[ctx.guild.id].loop != Loops.LOOP else Loops.NO_LOOP\\n )\\n return self.queue[ctx.guild.id].loop == Loops.LOOP\",\n \"async def _loop(self, ctx: commands.Context):\\n\\n if not ctx.voice_state.is_playing:\\n raise commands.CommandError('Nothing being played at the moment.')\\n\\n # Inverse boolean value to loop and unloop.\\n ctx.voice_state.loop = not ctx.voice_state.loop\\n await ctx.message.add_reaction('✅')\",\n \"async def _loop(self, ctx: commands.Context):\\n\\n if not ctx.voice_state.is_playing:\\n return await ctx.send('Nothing being played at the moment.')\\n\\n # Inverse boolean value to loop and unloop.\\n ctx.voice_state.loop = not ctx.voice_state.loop\\n await ctx.message.add_reaction('✅')\",\n \"async def _loop(self, ctx: commands.Context):\\n\\n if not ctx.voice_state.is_playing:\\n return await ctx.send('Nothing being played at the moment.')\\n\\n # Inverse boolean value to loop and unloop.\\n ctx.voice_state.loop = not ctx.voice_state.loop\\n await ctx.message.add_reaction('✅')\",\n \"async def gif(self, ctx: discord.ext.commands.Context, *args):\\n print(\\\"-------------------------\\\")\\n message_channel: discord.abc.Messageable = ctx.message.channel\\n currentgifkey = self.botVariables.get_gif_key()\\n print(\\\"GifRequest:Arguments:\\\" + str(len(args)))\\n tag = \\\"\\\"\\n if len(args) == 0: # request a random gif\\n print(\\\"Gif Request with No arguments\\\")\\n url = \\\"http://api.giphy.com/v1/gifs/random?api_key=\\\" + currentgifkey\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as resp:\\n r = await resp.json()\\n if 'data' in r:\\n await message_channel.send(r['data']['url'])\\n elif 'message' in r:\\n await message_channel.send(\\\"An error occurred:\\\" + r['message'])\\n else: # request a gif with tags\\n for x in range(0, len(args)):\\n tag = tag + args[x]\\n if x != (len(args) - 1):\\n tag += \\\" \\\"\\n tag = urllib.parse.quote(tag)\\n url = \\\"http://api.giphy.com/v1/gifs/random?api_key=\\\" + currentgifkey + \\\"&tag=\\\" + tag\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as resp:\\n r = await resp.json()\\n print(\\\"GifRequest:Gif Found\\\")\\n if (len(r['data'])) == 0:\\n await message_channel.send(\\\"No GIF found with those tags :frowning: \\\")\\n else:\\n if 'data' in r:\\n await message_channel.send(r['data']['url'])\\n elif 'message' in r:\\n await message_channel.send(\\\"An error occurred:\\\" + r['message'])\\n print(\\\"-------------------------\\\")\",\n \"def change_loop_to(self, loop_name: Optional[Text]) -> None:\\n if loop_name is not None:\\n self.active_loop = {\\n LOOP_NAME: loop_name,\\n LOOP_INTERRUPTED: False,\\n LOOP_REJECTED: False,\\n TRIGGER_MESSAGE: self.get_latest_message().parse_data,\\n }\\n else:\\n self.active_loop = {}\",\n \"def loop_run(self, loops):\\n self.loop_seek(self.num_loops + loops)\",\n \"def loop(self):\\n pass\",\n \"def gif(filename, array, fps=10, scale=1.0):\\n # ensure that the file has the .gif extension\\n filename = filename + '.gif'\\n\\n # copy into the color dimension if the images are black and white\\n if array.ndim == 3:\\n array = array[..., np.newaxis] * np.ones(3)\\n\\n # make the moviepy clip\\n clip = ImageSequenceClip(list(array), fps=fps).resize(scale)\\n clip.write_gif(filename, fps=fps)\\n return True\",\n \"def compose_in_gif(images, output_file, delay):\\n images[0].save(\\n output_file, \\n format='GIF', append_images=images[1:], \\n save_all=True, duration=delay, loop=0,\\n )\",\n \"def get_loop(self) -> bool:\\n return self._select_interface(self._rc_get_loop, self._http_get_loop)\",\n \"def create_gifs(folder, time_per_image=0.1):\\n # Retrieve images paths\\n images_dict = defaultdict(list)\\n folders_sorting_key = lambda s: int(s.split(\\\"_\\\")[-1])\\n obs_folders = [f for f in os.listdir(folder) if f.split(\\\"_\\\")[0] == \\\"observations\\\"]\\n obs_folders = sorted(obs_folders, key=folders_sorting_key)\\n for obs_folder in obs_folders:\\n for f in os.listdir(os.path.join(folder, obs_folder)):\\n image_name = \\\"_\\\".join(f.split(\\\"_\\\")[:-1])\\n images_dict[image_name].append(os.path.join(folder, obs_folder, f))\\n # Create gifs\\n for name in images_dict:\\n target = os.path.join(folder, name + \\\".gif\\\")\\n LungsLoader._create_gif(images_dict[name], target, time_per_image)\",\n \"def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\\n\\n self._gif_fps = None\\n self._color_depth = None\\n self._gif_loop = None\\n self._height = None\\n self._start = None\\n self._duration = None\\n self._suffix = None\\n self._overlay = None\\n self._overlay_alignment = None\\n self._overlay_scale = None\\n self._label = None\\n self.discriminator = None\\n\\n if gif_fps is not None:\\n self.gif_fps = gif_fps\\n if color_depth is not None:\\n self.color_depth = color_depth\\n if gif_loop is not None:\\n self.gif_loop = gif_loop\\n self.height = height\\n self.start = start\\n if duration is not None:\\n self.duration = duration\\n if suffix is not None:\\n self.suffix = suffix\\n if overlay is not None:\\n self.overlay = overlay\\n if overlay_alignment is not None:\\n self.overlay_alignment = overlay_alignment\\n if overlay_scale is not None:\\n self.overlay_scale = overlay_scale\\n if label is not None:\\n self.label = label\",\n \"def animate(directory,gifname,n_t,step=2,duration=0.2):\\n\\t# create list of filenames\\n\\tfnames = dir_fname(directory,\\\"*\\\")\\n\\t# create list of plots\\n\\timages=[] \\n\\tfor k in range(0,n_t):\\n\\t\\tk = k*step\\n\\t\\tprint('Mounting Im '+ str(k))\\n\\t\\tFIG_NAME=fnames[k]\\n\\t\\timages.append(imageio.imread(FIG_NAME)) # read\\n\\t# Now we can assemble the video\\n\\timageio.mimsave(gifname, images,duration=duration) # create gif\\n\\tprint('Animation'+gifname+'Ready')\\n\\treturn True\",\n \"def loop(self):\\n raise NotImplementedError()\",\n \"def _change_loop_to(self, loop_name: Optional[Text]) -> None:\\n if loop_name is not None:\\n self.active_loop = {\\n LOOP_NAME: loop_name,\\n LOOP_INTERRUPTED: False,\\n LOOP_REJECTED: False,\\n TRIGGER_MESSAGE: self.get_latest_message().parse_data,\\n }\\n else:\\n self.active_loop = {}\",\n \"def while_loop(self):\\n if self._loop is None:\\n self._loop = self._while_loop()\\n return self._loop\\n return self._loop\",\n \"def gif(self, num_games, slow_mult=2, delete_pics=True,\\n kill_limit_per_game=1000):\\n slow_mult = int(slow_mult)\\n gif_name = \\\"gifs\\\\\\\\\\\"+self.name\\n\\n try:\\n os.remove(gif_name+'.gif')\\n except Exception:\\n pass\\n\\n kill_limit = kill_limit_per_game * num_games\\n\\n c = 0\\n e = 0\\n while c < kill_limit and e < num_games:\\n self.env.reset()\\n game_over = False\\n # get initial input\\n input_t = self.env.observe()\\n\\n plt.imshow(self.env.draw_state(),\\n interpolation='none', cmap='gray')\\n plt.savefig(\\\"gifs\\\\\\\\%d.png\\\" % c)\\n plt.close()\\n c += 1\\n while not game_over and c < kill_limit:\\n input_tm1 = input_t\\n\\n # get next action\\n q = self.model.predict(input_tm1)\\n action = np.argmax(q[0])\\n\\n # apply action, get rewards and new state\\n input_t, reward, game_over = self.env.act(action)\\n\\n plt.imshow(self.env.draw_state(),\\n interpolation='none', cmap='gray')\\n plt.savefig(\\\"gifs\\\\\\\\%d.png\\\" % c)\\n plt.close()\\n c += 1\\n\\n e += 1\\n\\n # Making a temporary gif and slowing it down seems to be the only way I\\n # can make a slower gif. For some reason the command works in cmd but\\n # not here so i guess I am stuck with fast gifs.\\n \\\"\\\"\\\"\\n call1 = ['ffmpeg', '-i', '%d.png', gif_name+'_temp.gif']\\n subprocess.call(call1)\\n call2 = ['ffmpeg', '-i', gif_name+'_temp.gif', '-filter:v',\\n '\\\"setpts={}.0*PTS\\\"'.format(slow_mult), gif_name+'.gif']\\n subprocess.call(call2, shell=True)\\n # ffmpeg -i catch_small_model.gif -filter:v \\\"setpts=3.0*PTS\\\" catch_small_model_slow.gif\\n print(call2)\\n try:\\n os.remove(gif_name+'_temp.gif')\\n except Exception as e:\\n print(e)\\n \\\"\\\"\\\"\\n subprocess.call(['ffmpeg', '-i', 'gifs\\\\\\\\%d.png', gif_name+'.gif'])\\n\\n if delete_pics:\\n for i in range(c):\\n try:\\n os.remove(\\\"gifs\\\\\\\\%d.png\\\" % i)\\n except Exception as e:\\n print(e)\",\n \"def toggle_loop(self):\\n if not self.can_alter_line():\\n return\\n if self.loop:\\n self.loop = None\\n else:\\n self.caller.location.ndb.event_line_loop = True\\n self.msg(\\\"Line looping set to: %s\\\" % str(bool(self.loop)))\",\n \"async def async_set_repeat(self, repeat):\\n if not self._slave_mode:\\n self._repeat = repeat\\n if repeat == REPEAT_MODE_OFF:\\n mode = '0'\\n elif repeat == REPEAT_MODE_ALL:\\n mode = '2' if self._shuffle else '3'\\n elif repeat == REPEAT_MODE_ONE:\\n mode = '1'\\n value = await self.async_call_linkplay_httpapi(\\\"setPlayerCmd:loopmode:{0}\\\".format(mode), None)\\n if value != \\\"OK\\\":\\n _LOGGER.warning(\\\"Failed to change repeat mode. Device: %s, Got response: %s\\\", self.entity_id, value)\\n else:\\n await self._master.async_set_repeat(repeat)\",\n \"def _set_loop(tik_instance, num_core, max_core, total_dim):\\n core_loop = tik_instance.Scalar(\\\"uint64\\\")\\n\\n with tik_instance.if_scope(num_core < total_dim % AICORE_NUM):\\n core_loop.set_as(_ceil_div(total_dim, max_core))\\n with tik_instance.else_scope():\\n core_loop.set_as(total_dim // max_core)\\n\\n return core_loop\",\n \"def _set_loops(loop_data):\\n # Initiate a loop column with 1 for each loop tag\\n loop_data[u'loop'] = 0\\n loop_data.ix[loop_data.text.str.contains(u'loop_'),u'loop'] = 1\\n\\n # Ensure the index is linear, but set it up so the original\\n # index can be replaced\\n old_columns = loop_data.columns\\n loop_data = loop_data.reset_index(drop=False)\\n index_column = list(set(loop_data.columns) - set(old_columns))\\n \\n # Get the difference between index positions of the loop tags\\n loop_index = loop_data.ix[loop_data.loop==1].index\\n loop_diff = loop_index[1:] - loop_index[:-1]\\n\\n # For nested loops, the difference \\n depth = 0\\n for idx,diff in zip(loop_index[:-1],loop_diff):\\n if diff <= 2:\\n depth += 1\\n loop_data.ix[idx,u'loop'] += depth\\n else:\\n depth = 0\\n \\n \\n # Reset the index\\n loop_data.set_index(index_column, drop=True)\\n if u'index' in loop_data.columns:\\n loop_data = loop_data.drop([u'index'], axis = 1)\\n \\n return loop_data\",\n \"def generate_gif(directory: (\\\"Folder name\\\", \\\"positional\\\"),\\n image_format: ('Image format', 'positional') = '.png',\\n print_file_names=False):\\n import imageio\\n from glob import glob\\n from natsort import natsorted\\n\\n images = []\\n # Create a list of file names in the specified directory\\n filenames = glob(directory + '/*' + image_format)\\n\\n filenames = natsorted(filenames, key=lambda y: y.lower())\\n # Sort the list 'filenames' using the traditional method.\\n # Traditional method -\\n # isolate the entire first number in the string, then sort by that number\\n # If this step is not included,\\n # files will be sorted like so: 0, 100, 110, 200, 3, 420, etc...\\n\\n if print_file_names: # For troubleshooting\\n for i in filenames:\\n print(i)\\n\\n for filename in filenames:\\n images.append(imageio.imread(filename))\\n # Append each file to the list that will become the gif\\n\\n imageio.mimsave(directory + '.gif', images)\\n # Save the gif as the name of the directory\\n # that the images were generated from\\n return\",\n \"def gif_generation(orig_label_path, bound_data_path):\\n for sample in os.listdir(bound_data_path):\\n if not sample.startswith('.') and osp.isdir(osp.join(bound_data_path, sample)):\\n sample_path = osp.join(bound_data_path, sample)\\n for artery in os.listdir(sample_path):\\n orig_label_pick_path = osp.join(orig_label_path, sample, artery, 'data.pkl')\\n bound_pick_path = osp.join(bound_data_path, sample, artery, 'data.pkl')\\n\\n # function to save result of each artery into gif\\n save_gif_artery(orig_label_pick_path, bound_pick_path)\",\n \"def GAME_LOOP():\\n pass\",\n \"def startColorLoop():\\n b.set_group(1, 'on', True)\\n b.set_group(1, 'bri', 254)\\n b.set_group(1, 'hue', 255)\\n b.set_group(1, 'sat', 255)\\n b.set_group(1, 'effect', 'colorloop')\",\n \"def loop():\\n global loop_idx\\n sys.stdout.write('loop index %d/%d\\\\r\\\\n' % (loop_idx, _LOOPS))\\n time.sleep(0.5)\\n loop_idx += 1\\n return loop_idx > _LOOPS\",\n \"def start_loop(self, loop):\\n asyncio.set_event_loop(loop)\\n loop.run_forever()\",\n \"def game_loop(self):\\n self.interface.game_loop(self)\",\n \"def create_gif(base_folder):\\n img_list = []\\n search_path = glob.glob(os.path.join(base_folder, '*.png'))\\n search_path.sort()\\n for f in search_path:\\n im = Image.open(f)\\n img_list.append(im)\\n save_file = os.path.join(base_folder, 'animated_gif.gif')\\n img_list[0].save(save_file,\\n save_all=True, append_images=img_list[1:], optimize=False, duration=180, loop=0)\",\n \"def loop(self):\\r\\n while self.__running:\\r\\n self.__check_events()\\r\\n self.__render()\\r\\n self.__reset_variables()\",\n \"def saveGIFBatch(directory, path, name=''):\\n # for each frame in batch\\n images = []\\n for filename in directory:\\n print(filename)\\n images.append(imageio.imread(filename))\\n\\n name_gif = path + '/' + name + '.gif'\\n imageio.mimsave(name_gif, images)\",\n \"def write_loop_text(self):\\n\\t\\tself.write_components['loop'] = \\\"\\\"\\\"loop( ({sets})$({cond}), {loop})\\n\\t\\t\\\"\\\"\\\".format( sets = ', '.join(self.shock_gm.database[self.loop_name].names),\\n\\t\\t\\t\\t\\tcond = self.shock_gm.database.get(self.loop_name).to_str,\\n\\t\\t\\t\\t\\tloop = self.loop_text)\\n\\t\\treturn self.write_components['loop']\",\n \"def loop_type(graph = None):\\n\\tbreakpoints = 0\\n\\tfor edge in nx.generate_edgelist(graph):\\n\\t\\tif ('breakpoint' in edge):\\n\\t\\t\\tbreakpoints += 1\\n\\n\\tif breakpoints == 1:\\n\\t\\tif is_loop(graph = graph):\\n\\t\\t\\treturn 'hairpinloop'\\n\\t\\telse:\\n\\t\\t\\treturn 'dangling_end'\\n\\n\\tif is_loop(graph = graph):\\n\\t\\tif breakpoints == 2:\\n\\t\\t\\treturn multiloop_type(graph = graph)\\n\\t\\telif breakpoints == 3:\\n\\t\\t\\treturn 'multiloop3'\\n\\t\\telif breakpoints == 4:\\n\\t\\t\\treturn 'multiloop4'\\n\\t\\telif breakpoints == 5:\\n\\t\\t\\treturn 'multiloop5'\\n\\treturn 'NA'\",\n \"def convert_gif(path: str,\\n gif_name: str = 'gif_name.gif',\\n frame_limit: int = 100):\\n video_path = glob(path + \\\"/*.mp4\\\")[-1]\\n vidcap = cv2.VideoCapture(video_path)\\n success, frame = vidcap.read()\\n count = 0\\n\\n # extracting and saving video frames.\\n while success:\\n cv2.imwrite(f\\\"{path}/frame{count}.png\\\", frame) \\n success, frame = vidcap.read()\\n count += 1\\n if count > frame_limit:\\n break\\n print(\\\"total frames:\\\", count)\\n\\n # generate animated GIF.\\n img, *imgs = [Image.open(f) for f in sorted(glob(path+\\\"/*.png\\\"))]\\n img.save(fp=f\\\"{path}/{gif_name}\\\", format='GIF', append_images=imgs,\\n save_all=True, duration=200, loop=0)\\n \\n # remove frames\\n [os.remove(os.path.join(path, f)) for f in glob(path+\\\"/*.png\\\")]\",\n \"def MULTIPLAYER_LOOP():\\n pass\",\n \"def iteration(self, iteration):\\n self._iteration = iteration\",\n \"def iteration(self, iteration):\\n self._iteration = iteration\",\n \"def iteration(self, iteration):\\n self._iteration = iteration\",\n \"def loop_stop(self):\\n self._loop_state = LState.Stopping\\n self.log_debug(\\\"Stopping loop\\\")\",\n \"async def queueloop(self, ctx: commands.Context) -> Optional[bool]:\\n\\n queue = self.queue[ctx.guild.id]\\n\\n queue.loop = (\\n Loops.QUEUE_LOOP\\n if self.queue[ctx.guild.id].loop != Loops.QUEUE_LOOP\\n else Loops.NO_LOOP\\n )\\n\\n if queue.loop == Loops.QUEUE_LOOP:\\n queue.queue_loop_start = queue.pos\\n\\n return queue.loop == Loops.QUEUE_LOOP\",\n \"def loop_run(self):\\n super(HasLoops, self).loop_run()\\n for loop in getattr(self, \\\"_loops\\\", []):\\n loop.loop_remove_from_parent = weak_method(self.remove_loop)\\n loop.loop_run()\",\n \"def make_gif(image_list, gif_name):\\n if not gif_name.endswith(\\\".gif\\\"):\\n gif_name += \\\".gif\\\"\\n imageio.mimsave(gif_name, [imageio.imread(x) for x in image_list])\",\n \"def create_gif():\\n anim_file = 'sample/training.gif'\\n\\n with imageio.get_writer(anim_file, mode='I') as writer:\\n filenames = glob.glob('sample/*.jpg')\\n filenames = sorted(filenames, key=lambda filename: int(filename[11:-4]))\\n for filename in filenames:\\n image = imageio.imread(filename)\\n writer.append_data(image)\\n image = imageio.imread(filename)\\n writer.append_data(image)\",\n \"def loop(self):\\r\\n\\r\\n self._next_state = self._current_state\",\n \"def loop(self,timeout=1):\\n self.stream.loop(timeout)\",\n \"def _run(self):\\n while(self._loop):\\n pass\",\n \"def save_gif(frames):\\n print(\\\"Saving gif images!\\\")\\n for i in range(len(frames)):\\n im_out_path = \\\"gif/gif_emilie_will_\\\" + str(i) + \\\".png\\\"\\n plt.imsave(im_out_path, frames[i])\",\n \"def graphics_loop(self, font):\\n self.screen.blit(self.background, (0, 0))\\n if not self.scroll:\\n self.all_sprites.draw(self.screen)\\n else:\\n self.draw_onscreen()\\n #display which step we're on\\n if pygame.font:\\n text = font.render(str(self.stepid), 1, (255, 255, 255))\\n textpos = text.get_rect(centerx = int(\\n (self.screen.get_width() * 0.5)))\\n self.screen.blit(text, textpos)\\n pygame.display.flip()\\n #cap at x fps\\n self.clock.tick(self.max_fps)\",\n \"def setIdle(self, flag):\\n if( flag ) :\\n if( self.idleWork == -1) :\\n self.idleWork = gobject.idle_add( self.idle_callback )\\n else :\\n if( self.idleWork != -1) :\\n gobject.source_remove( self.idleWork )\\n self.idleWork = -1\",\n \"def send_GIF():\\n try:\\n gif_icon = driver.find_element_by_xpath('//*[@data-tip=\\\"GIF\\\"]')\\n gif_icon.click()\\n wait(wait_time=10)\\n gifs = driver.find_elements_by_class_name('giphy-gif')\\n src = gifs[0].get_attribute('src')\\n gif_ID = src[src.index('media/') + len('media/'):]\\n gif_ID = gif_ID[:gif_ID.index('/')]\\n gifs[0].click()\\n wait()\\n except Exception as e:\\n return \\\"Error: \\\" + str(e)\\n if verify_GIF_sent(gif_ID):\\n return \\\"Success\\\"\\n else:\\n return \\\"Error: GIF wasn't sent\\\"\",\n \"def on_update(self, delta_time):\\n self.time += 1\\n if self.time <= 900:\\n self.gif.update_animation()\",\n \"def __nii4dtoGif(self, inputfile, tgGif, gifSpeed=30):\\n gifId = self.__idGenerator()\\n \\n # Number of volumes in the 4D image\\n vSize = mriutil.getNbDirectionsFromDWI(inputfile)\\n vols = [gifId + '{0:04}'.format(i) for i in range(vSize)]\\n \\n # Spliting 4D image\\n cmd = 'fslsplit ' + inputfile + ' ' + gifId + ' -t'\\n self.launchCommand(cmd)\\n \\n # Extracting pngs from all volumes\\n for vol in vols:\\n self.__slicer(vol, None, vol + '.png')\\n \\n # Creating .gif\\n cmd = 'convert '\\n for vol in vols:\\n cmd += '-delay ' + str(gifSpeed) + ' ' + vol + '.png '\\n cmd += tgGif\\n self.launchCommand(cmd)\\n \\n # Cleaning temp files\\n cmd = 'rm ' + gifId + '*'\\n self.launchCommand(cmd)\",\n \"def postprocess(self, loop):\\n return loop\",\n \"def play_next_animation(self):\\n if self.animation_idx < len(self.animation_list)-1:\\n self.__next()\\n elif self.should_loop:\\n self.__loop()\\n else:\\n self.stop()\",\n \"def infinite_loop():\\n return True\",\n \"def loop(self):\\n self.screen.fill((0, 0, 0))\\n self.clock.tick(FU_FRAME_RATE)\\n self.level.update_loop(self.screen, self.clock)\\n self.handle_events()\",\n \"def set_tif(self, interface):\\n if not ((1 << interface) & self.supported_tifs()):\\n raise errors.JLinkException('Unsupported target interface: %s' % interface)\\n\\n # The return code here is actually *NOT* the previous set interface, it\\n # is ``0`` on success, otherwise ``1``.\\n res = self._dll.JLINKARM_TIF_Select(interface)\\n if res != 0:\\n return False\\n\\n self._tif = interface\\n return True\",\n \"def start(self):\\n if self.__started:\\n return\\n\\n self.__started = True\\n GLib.timeout_add(GtkMainLoop.DEADLINE_GLIB, self.__ioloop_run)\\n self.__gi_loop.run()\",\n \"def stopGTK( ):\\n if LOOP_TRACKER:\\n LOOP_TRACKER.decrement()\",\n \"def put_drawing_gif_async(self, request):\\n HttpRequest = request.to_http_info(self.api_client.configuration)\\n return self.__make_request_async(HttpRequest, 'PUT', 'file')\",\n \"def __init__(self, loop=None):\\n object.__setattr__(self, '_loop', loop or get_event_loop())\",\n \"def make_gif(im_dir, out_file, pattern='*.png', fps=10):\\n im_files = glob.glob(os.path.join(im_dir, pattern))\\n if len(im_files) == 0:\\n raise ValueError(f'No images found in {im_dir}!')\\n \\n writer = imageio.get_writer(out_file, mode='I', fps=fps)\\n for im_file in im_files:\\n im = imageio.imread(im_file)\\n writer.append_data(im)\\n writer.close()\",\n \"def bottle_song_while(num):\\n pass\",\n \"def setOverlayRepeat(self, value):\\n self.PDFreactorConfiguration.in1[\\\"overlayRepeat\\\"] = value\",\n \"def setFlag(self):\\n if self.inPlay and not self.shown:\\n self.flag = not(self.flag)\\n image_index = 11 if self.flag else 10\\n self.configure(image = Tile.images[image_index])\\n return 1 if self.flag else -1\\n return 0\",\n \"def start_frame(self):\\n\\n # Check whether we're supposed to make a frame on this iteration:\\n if self.frame_count % self.stride != 0:\\n return\\n\\n # Check whether we're already making a frame. \\n if self.in_scope:\\n print(\\\"The Gif object for {} has encountered 'start_frame' twice\\\\\\n without an intervening 'end_frame'\\\".format(self.filename))\\n raise SyntaxError\\n\\n # Construct a new figure\\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\\n self.current_frame = fig\\n\\n # Set the \\\"in_scope\\\" member True\\n self.in_scope = True\\n\\n return self.current_frame\",\n \"def display_frames_as_gif(frames, video_name):\\n Writer = animation.writers['ffmpeg']\\n writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)\\n #plt.figure(figsize=(frames[0].shape[1] / 72.0, frames[0].shape[0] / 72.0), dpi = 72)\\n patch = plt.imshow(frames[0])\\n plt.axis('off')\\n\\n def animate(i):\\n patch.set_data(frames[i])\\n\\n anim = animation.FuncAnimation(plt.gcf(), animate, frames = len(frames), interval=50)\\n# display(display_animation(anim, default_mode='loop'))\\n anim.save(result_floder + '/' + video_name, writer=writer)\",\n \"def loop_forever(self):\\n self.running = True\\n while self.running:\\n time.sleep(0.1)\",\n \"def writeGif(filename, images, duration=0.1, loops=0, dither=1):\\n \\n if PIL is None:\\n raise RuntimeError(\\\"Need PIL to write animated gif files.\\\")\\n \\n AD = Image.ADAPTIVE\\n images2 = []\\n \\n # convert to PIL\\n for im in images:\\n \\n if isinstance(im,Image.Image):\\n images2.append( im.convert('P', palette=AD, dither=dither) )\\n \\n elif np and isinstance(im, np.ndarray):\\n if im.dtype == np.uint8:\\n pass\\n elif im.dtype in [np.float32, np.float64]:\\n im = (im*255).astype(np.uint8)\\n else:\\n im = im.astype(np.uint8)\\n # convert\\n if len(im.shape)==3 and im.shape[2]==3:\\n im = Image.fromarray(im,'RGB').convert('P', palette=AD, dither=dither)\\n elif len(im.shape)==2:\\n im = Image.fromarray(im,'L').convert('P', palette=AD, dither=dither)\\n else:\\n raise ValueError(\\\"Array has invalid shape to be an image.\\\")\\n images2.append(im)\\n \\n else:\\n raise ValueError(\\\"Unknown image type.\\\")\\n \\n # check duration\\n if hasattr(duration, '__len__'):\\n if len(duration) == len(images2):\\n durations = [d for d in duration]\\n else:\\n raise ValueError(\\\"len(duration) doesn't match amount of images.\\\")\\n else:\\n durations = [duration for im in images2]\\n \\n \\n # open file\\n fp = open(filename, 'wb')\\n \\n # write\\n try:\\n n = _writeGifToFile(fp, images2, durations, loops)\\n print n, 'frames written'\\n finally:\\n fp.close()\",\n \"def main_loop(infr, max_loops=None, use_refresh=True):\\n raise RuntimeError()\\n infr.start_id_review(max_loops=max_loops, use_refresh=use_refresh)\\n # To automatically run through the loop just exhaust the generator\\n try:\\n result = next(infr._gen)\\n except StopIteration:\\n pass\\n assert result is None, 'need user interaction. cannot auto loop'\\n infr._gen = None\",\n \"def stop_updating_loop(self) -> None:\\n if self.updating_loop is not None:\\n self.updating_loop.cancel()\",\n \"def end_frame(self, **kwargs):\\n \\n # Check whether we're supposed to make a frame on this iteration:\\n if self.frame_count % self.stride != 0:\\n self.frame_count += 1\\n return\\n\\n # Check whether we're still making another frame\\n if not self.in_scope: \\n print(\\\"The Gif object for {} has encountered 'end_frame' twice\\\\\\n without an intervening 'start_frame'\\\".format(self.filename))\\n raise SyntaxError\\n\\n # Save the frame to the temporary directory\\n count_width = str(int(math.log10(self.max_frames) + 1))\\n label = \\\"{:0>\\\"+count_width+\\\"d}\\\"\\n label = label.format(self.frame_count)\\n file_path = \\\"{}_{}{}\\\".format(self.tmp_prefix, label, self.tmp_suffix)\\n self.current_frame.savefig(file_path,**kwargs)\\n\\n # Close the figure\\n plt.close(self.current_frame)\\n \\n # Update some relevant attributes\\n self.current_frame = None\\n self.in_scope = False\\n self.frame_count += 1\\n\\n return\",\n \"def setSeqElementLooping(self,SequenceIndex=1,Repeat=1,InfiniteLoop=0):#TODO implement stringonly\\n\\n if (InfiniteLoop==1):\\n self.sendMessage(\\\"SEQuence:ELEMent\\\"+str(SequenceIndex)+\\\":LOOP:INFinite 1\\\")\\n else:\\n self.sendMessage(\\\"SEQuence:ELEMent\\\"+str(SequenceIndex)+\\\":LOOP:INFinite 0\\\")\\n self.sendMessage(\\\"SEQuence:ELEMent\\\"+str(SequenceIndex)+\\\":LOOP:COUNt \\\"+str(Repeat))\",\n \"def changeGun(self):\\n self.currentGun += 1\\n self.currentGun %= len(Laser.imgs)\\n self.agent.actionCompleted()\",\n \"def AnimFromPng(name, gif=True, fps=15):\\n if(gif):\\n imgconvert = \\\"convert \\\" + \\\"-delay \\\" + str(int(1000/fps))\\n imgconvert += \\\" -dispose None \\\" + name + \\\"*.png -loop 0 \\\" + name + \\\".gif\\\"\\n system(imgconvert)\\n print imgconvert\\n else:\\n aviconvert = \\\"ffmpeg -i \\\" + name + \\\"%03d.png -b:v 2048k -r \\\" + str(fps) + \\\" \\\" + name + \\\".avi\\\"\\n system(aviconvert)\\n print aviconvert\",\n \"async def gif(self, ctx, *keywords):\\n if keywords:\\n keywords = \\\"+\\\".join(keywords)\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='sigh.. **`{}help gif`**'.format(self.config['prefix']),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\\n return\\n await self.bot.send_typing(ctx.message.channel)\\n url = (\\\"http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}\\\"\\n \\\"\\\".format(self.config['giphy-api-key'], keywords))\\n\\n async with aiohttp.ClientSession() as session:\\n async with session.get(url) as response:\\n source = await response.json(encoding='utf8')\\n\\n source = json.dumps(source)\\n result = json.loads(str(source))\\n\\n if response.status == 200:\\n if result[\\\"data\\\"]:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format(''),\\n colour=0xf20006)\\n embed.set_image(url=result[\\\"data\\\"][\\\"image_original_url\\\"])\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['succes'])\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format('No results found.'),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['warning'])\\n else:\\n embed = discord.Embed(title='{}:'.format(ctx.message.author.name),\\n description='{}'.format('Error contacting the API'),\\n colour=0xf20006)\\n last_message = await self.bot.say(embed=embed)\\n await self.bot.add_reaction(last_message, self.emojiUnicode['error'])\",\n \"def make_GIF(image_path: Union[Path, str]) -> None:\\n import imageio\\n from pygifsicle import optimize\\n\\n if isinstance(image_path, str):\\n image_path = Path(image_path)\\n\\n image_dir = image_path.parent\\n image_file = image_path.stem\\n gif_path = image_dir / f\\\"{image_file}.gif\\\"\\n gif_path = Path(\\\"./xxxx.gif\\\")\\n with imageio.get_writer(gif_path, mode='I') as writer:\\n img_files = sorted((img_file for img_file in image_dir.glob('*.png')))\\n for img_file in img_files:\\n writer.append_data(imageio.imread(img_file))\\n print(f\\\"{len(img_files)} images loaded from {image_path}\\\")\\n try:\\n optimize(gif_path)\\n except Exception:\\n print(\\\"gifsicle not installed\\\")\",\n \"def multiloop_type(graph = None):\\n\\tg = graph.copy()\\n\\tbreakpoint_nodes = []\\n\\tfor edge in g.edges(data=True):\\n\\t\\tid1 ,id2 , data = edge\\n\\t\\tif g.edge[id1][id2]['label']== '$':\\n\\t\\t\\tif not id1 in breakpoint_nodes:\\n\\t\\t\\t\\tbreakpoint_nodes.append(id1)\\n\\t\\t\\tif not id2 in breakpoint_nodes:\\n\\t\\t\\t\\tbreakpoint_nodes.append(id2)\\n\\tfor node in breakpoint_nodes:\\n\\t\\tg.remove_node(node)\\n\\tif nx.number_connected_components(g) ==1:\\n\\t\\treturn 'bulge'\\n\\telse:\\n\\t\\treturn 'internal_loop'\",\n \"def loop_forever(self):\\n while self.running:\\n time.sleep(0.01)\",\n \"def loop(self):\\n while True:\\n delay_until_next = self.tick()\\n if not delay_until_next:\\n break\\n self._sleep(delay_until_next)\",\n \"def _handle_loop(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7291405","0.6020012","0.59639007","0.57001525","0.54498154","0.54039925","0.53877467","0.532594","0.5293056","0.523517","0.52066076","0.51812136","0.51310414","0.50876","0.50081354","0.49736694","0.49516755","0.4897915","0.48965508","0.4870012","0.4854705","0.4854705","0.484016","0.4829987","0.48171955","0.48003206","0.47825247","0.47789437","0.4769995","0.47696215","0.4740212","0.47394398","0.4734552","0.47305796","0.4714947","0.47121447","0.46971384","0.4676157","0.4668222","0.4647526","0.46277484","0.46176574","0.46173254","0.46088082","0.4602249","0.46001926","0.45997635","0.45520714","0.45498702","0.45465493","0.45403394","0.45057493","0.45023775","0.4496259","0.4494296","0.4494296","0.4494296","0.44866174","0.44720155","0.44718167","0.4455042","0.4453537","0.4446156","0.44459704","0.44264835","0.4423793","0.4423109","0.44230255","0.44153565","0.44119376","0.44099382","0.44077274","0.44016206","0.43970206","0.43716595","0.4364881","0.4363436","0.4362883","0.43625274","0.43562067","0.4351952","0.43340448","0.43283972","0.43204707","0.42941517","0.42940268","0.42914367","0.4291319","0.42836547","0.42745623","0.42724255","0.42579076","0.42559043","0.42523634","0.4250965","0.42470962","0.4238287","0.42363316","0.42289045","0.42233196"],"string":"[\n \"0.7291405\",\n \"0.6020012\",\n \"0.59639007\",\n \"0.57001525\",\n \"0.54498154\",\n \"0.54039925\",\n \"0.53877467\",\n \"0.532594\",\n \"0.5293056\",\n \"0.523517\",\n \"0.52066076\",\n \"0.51812136\",\n \"0.51310414\",\n \"0.50876\",\n \"0.50081354\",\n \"0.49736694\",\n \"0.49516755\",\n \"0.4897915\",\n \"0.48965508\",\n \"0.4870012\",\n \"0.4854705\",\n \"0.4854705\",\n \"0.484016\",\n \"0.4829987\",\n \"0.48171955\",\n \"0.48003206\",\n \"0.47825247\",\n \"0.47789437\",\n \"0.4769995\",\n \"0.47696215\",\n \"0.4740212\",\n \"0.47394398\",\n \"0.4734552\",\n \"0.47305796\",\n \"0.4714947\",\n \"0.47121447\",\n \"0.46971384\",\n \"0.4676157\",\n \"0.4668222\",\n \"0.4647526\",\n \"0.46277484\",\n \"0.46176574\",\n \"0.46173254\",\n \"0.46088082\",\n \"0.4602249\",\n \"0.46001926\",\n \"0.45997635\",\n \"0.45520714\",\n \"0.45498702\",\n \"0.45465493\",\n \"0.45403394\",\n \"0.45057493\",\n \"0.45023775\",\n \"0.4496259\",\n \"0.4494296\",\n \"0.4494296\",\n \"0.4494296\",\n \"0.44866174\",\n \"0.44720155\",\n \"0.44718167\",\n \"0.4455042\",\n \"0.4453537\",\n \"0.4446156\",\n \"0.44459704\",\n \"0.44264835\",\n \"0.4423793\",\n \"0.4423109\",\n \"0.44230255\",\n \"0.44153565\",\n \"0.44119376\",\n \"0.44099382\",\n \"0.44077274\",\n \"0.44016206\",\n \"0.43970206\",\n \"0.43716595\",\n \"0.4364881\",\n \"0.4363436\",\n \"0.4362883\",\n \"0.43625274\",\n \"0.43562067\",\n \"0.4351952\",\n \"0.43340448\",\n \"0.43283972\",\n \"0.43204707\",\n \"0.42941517\",\n \"0.42940268\",\n \"0.42914367\",\n \"0.4291319\",\n \"0.42836547\",\n \"0.42745623\",\n \"0.42724255\",\n \"0.42579076\",\n \"0.42559043\",\n \"0.42523634\",\n \"0.4250965\",\n \"0.42470962\",\n \"0.4238287\",\n \"0.42363316\",\n \"0.42289045\",\n \"0.42233196\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81786376"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76576,"cells":{"query":{"kind":"string","value":"Gets the height of this GIFOutput. Height of the media to be rendered, in pixels. Should be the height of your scenes unless a smaller resolution is needed. Resolution higher than the scene resolution reduces quality. The width is automatically calculated to keep the aspect ratio."},"document":{"kind":"string","value":"def height(self):\n return self._height"},"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_height(self) -> int:\n return self.rsimulator.get_frame_height()","def get_height(self):\n if self.height:\n return self.height\n \n if not self._oembed:\n return ''\n \n return self._oembed.get('height', None)","def height(self):\n return self.config.get('resolution', {}).get('y',1080) #720","def get_height(self) -> int:\n return int(self._surface.get_height())","def get_height(self):\n return max(map(TextImage.get_height, self.frames))","def getHeight(self):\n return frameHeight","def getHeight(self):\n return self._image.height()","def height(self):\n return _libsbml.Dimensions_height(self)","def getHeight(self):\n return _libsbml.Dimensions_getHeight(self)","def get_frame_height(self) -> int:\n return self.__sim.frame_size()[1]","def filmHeight(self):\r\n cls = mxs.classof(self._nativePointer)\r\n height = None\r\n if cls == mxs.VRayPhysicalCamera:\r\n\r\n # TODO: Why is that wrapped in a try except?\r\n try:\r\n height = self._nativePointer.film_height\r\n except AttributeError:\r\n pass\r\n\r\n elif cls == mxs.Physical:\r\n height = self._nativePointer.film_height_mm\r\n\r\n if not height:\r\n # If we failed to get a width from a camera, return the scene aperture setting.\r\n height = self.filmWidth() * (mxs.renderPixelAspect / mxs.getRendImageAspect())\r\n\r\n return height","def video_height(self):\n return self._el._parent.execute_script(\"return arguments[0].videoHeight\", self._el)","def video_height(self):\n return self._el._parent.execute_script(\"return arguments[0].videoHeight\", self._el)","def height(self):\n return (self.scene.shape[1] - self.size) // self.size + 1","def height(self):\n return self.client.call('GET', self.name + 'height')","def height(self) -> int:\n return self._image_data.height","def getHeight(self):\n return self.height","def getHeight(self):\n return self.height","def get_dimension_height(self):\n pass","def getHeight(self):\n return self._height","def height(self):\n _, ymin, _, ymax = self.viewport\n return self.parent.window_size[1] * (ymax - ymin)","def getHeight(self):\n return _tkCall(self.image.height)","def height(self) -> int:\r\n return self.rect_uv.h","def getHeight(self):\r\n height = 1\r\n if self.orientation == \"v\":\r\n height = self.size\r\n return height","def height(self) -> int:\n if self.props.max_height:\n max_height = UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)\n return min(self.isize[1].to_pixels(self.parent.height), max_height)\n else:\n return self.isize[1].to_pixels(self.parent.height)","def frameHeight(self):\n return self._frame_height","def height(self):\n return(self.SCREEN_H)","def video_playback_height(self):\n # type: () -> int\n return self._video_playback_height","def get_height(self):\n return self._height","def get_height(self):\n return self._height","def get_height(self):\n return self._height","def get_height(self):\n return self._height","def get_height(self):\n return self.__height","def frame_height(self) -> int:\n pass","def get_height(self):\r\n return self._height","def get_height(self):\r\n return self._height","def get_height(self):\r\n return self._height","def height (self):\n return self._h","def get_height():\n return resize.transforms[1].size","def getPlayerHeight(self):\n \n context = aq_inner(self.context)\n \n if context.getAudiomode():\n return 24\n else:\n return context.getHeight() + 24","def height(self):\n # type: () -> float\n return self._height","def height(self) :\n return self.m_height","def video_window_height(self):\n # type: () -> int\n return self._video_window_height","def height(self) -> int:\n return self._height","def height(self) -> int:\n return self._height","def get_height(self):\n height = np.size(self.img, 1)\n return height","def height(self):\n return len(self._pixels)","def GetHeight(self):\r\n\r\n return self._height","def height(self) -> int:\n return self.__height","def mjpegStreamHeight(self) -> int:\n\t\tif 'mjpegStreamHeight' in self._raw_result['data']:\n\t\t\treturn self._raw_result['data']['mjpegStreamHeight']\n\t\treturn 480","def height(self):\n\n return self.__height","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"height\")","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__height","def height(self):\n return self.__size[1]","def GetHeight(*args, **kwargs):\n return _gdi_.Bitmap_GetHeight(*args, **kwargs)","def height(self) -> int:\n\t\treturn self._raw_result['data']['height']","def height(self):\n self._updateExtents()\n return self._mHeight","def height(self):\r\n return self._height","def height(self):\n return self[\"height\"]","def height(self):\n return self[\"height\"]","def output_height(self):\n\t\treturn self.output_shape_param('H')","def max_height(self) -> int:\n return UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)","def getSize(self):\n return GDimension(frameWidth, frameHeight)","def height(self) -> int:\n return self._obj[self.y_dim].size","def get_height(self):\n\t\treturn len(self._background[0]) if self.get_width() > 0 and self._background[0] else 0","def getHeight(self):\n return _libsbml.BoundingBox_getHeight(self)"],"string":"[\n \"def get_height(self) -> int:\\n return self.rsimulator.get_frame_height()\",\n \"def get_height(self):\\n if self.height:\\n return self.height\\n \\n if not self._oembed:\\n return ''\\n \\n return self._oembed.get('height', None)\",\n \"def height(self):\\n return self.config.get('resolution', {}).get('y',1080) #720\",\n \"def get_height(self) -> int:\\n return int(self._surface.get_height())\",\n \"def get_height(self):\\n return max(map(TextImage.get_height, self.frames))\",\n \"def getHeight(self):\\n return frameHeight\",\n \"def getHeight(self):\\n return self._image.height()\",\n \"def height(self):\\n return _libsbml.Dimensions_height(self)\",\n \"def getHeight(self):\\n return _libsbml.Dimensions_getHeight(self)\",\n \"def get_frame_height(self) -> int:\\n return self.__sim.frame_size()[1]\",\n \"def filmHeight(self):\\r\\n cls = mxs.classof(self._nativePointer)\\r\\n height = None\\r\\n if cls == mxs.VRayPhysicalCamera:\\r\\n\\r\\n # TODO: Why is that wrapped in a try except?\\r\\n try:\\r\\n height = self._nativePointer.film_height\\r\\n except AttributeError:\\r\\n pass\\r\\n\\r\\n elif cls == mxs.Physical:\\r\\n height = self._nativePointer.film_height_mm\\r\\n\\r\\n if not height:\\r\\n # If we failed to get a width from a camera, return the scene aperture setting.\\r\\n height = self.filmWidth() * (mxs.renderPixelAspect / mxs.getRendImageAspect())\\r\\n\\r\\n return height\",\n \"def video_height(self):\\n return self._el._parent.execute_script(\\\"return arguments[0].videoHeight\\\", self._el)\",\n \"def video_height(self):\\n return self._el._parent.execute_script(\\\"return arguments[0].videoHeight\\\", self._el)\",\n \"def height(self):\\n return (self.scene.shape[1] - self.size) // self.size + 1\",\n \"def height(self):\\n return self.client.call('GET', self.name + 'height')\",\n \"def height(self) -> int:\\n return self._image_data.height\",\n \"def getHeight(self):\\n return self.height\",\n \"def getHeight(self):\\n return self.height\",\n \"def get_dimension_height(self):\\n pass\",\n \"def getHeight(self):\\n return self._height\",\n \"def height(self):\\n _, ymin, _, ymax = self.viewport\\n return self.parent.window_size[1] * (ymax - ymin)\",\n \"def getHeight(self):\\n return _tkCall(self.image.height)\",\n \"def height(self) -> int:\\r\\n return self.rect_uv.h\",\n \"def getHeight(self):\\r\\n height = 1\\r\\n if self.orientation == \\\"v\\\":\\r\\n height = self.size\\r\\n return height\",\n \"def height(self) -> int:\\n if self.props.max_height:\\n max_height = UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)\\n return min(self.isize[1].to_pixels(self.parent.height), max_height)\\n else:\\n return self.isize[1].to_pixels(self.parent.height)\",\n \"def frameHeight(self):\\n return self._frame_height\",\n \"def height(self):\\n return(self.SCREEN_H)\",\n \"def video_playback_height(self):\\n # type: () -> int\\n return self._video_playback_height\",\n \"def get_height(self):\\n return self._height\",\n \"def get_height(self):\\n return self._height\",\n \"def get_height(self):\\n return self._height\",\n \"def get_height(self):\\n return self._height\",\n \"def get_height(self):\\n return self.__height\",\n \"def frame_height(self) -> int:\\n pass\",\n \"def get_height(self):\\r\\n return self._height\",\n \"def get_height(self):\\r\\n return self._height\",\n \"def get_height(self):\\r\\n return self._height\",\n \"def height (self):\\n return self._h\",\n \"def get_height():\\n return resize.transforms[1].size\",\n \"def getPlayerHeight(self):\\n \\n context = aq_inner(self.context)\\n \\n if context.getAudiomode():\\n return 24\\n else:\\n return context.getHeight() + 24\",\n \"def height(self):\\n # type: () -> float\\n return self._height\",\n \"def height(self) :\\n return self.m_height\",\n \"def video_window_height(self):\\n # type: () -> int\\n return self._video_window_height\",\n \"def height(self) -> int:\\n return self._height\",\n \"def height(self) -> int:\\n return self._height\",\n \"def get_height(self):\\n height = np.size(self.img, 1)\\n return height\",\n \"def height(self):\\n return len(self._pixels)\",\n \"def GetHeight(self):\\r\\n\\r\\n return self._height\",\n \"def height(self) -> int:\\n return self.__height\",\n \"def mjpegStreamHeight(self) -> int:\\n\\t\\tif 'mjpegStreamHeight' in self._raw_result['data']:\\n\\t\\t\\treturn self._raw_result['data']['mjpegStreamHeight']\\n\\t\\treturn 480\",\n \"def height(self):\\n\\n return self.__height\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"height\\\")\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__height\",\n \"def height(self):\\n return self.__size[1]\",\n \"def GetHeight(*args, **kwargs):\\n return _gdi_.Bitmap_GetHeight(*args, **kwargs)\",\n \"def height(self) -> int:\\n\\t\\treturn self._raw_result['data']['height']\",\n \"def height(self):\\n self._updateExtents()\\n return self._mHeight\",\n \"def height(self):\\r\\n return self._height\",\n \"def height(self):\\n return self[\\\"height\\\"]\",\n \"def height(self):\\n return self[\\\"height\\\"]\",\n \"def output_height(self):\\n\\t\\treturn self.output_shape_param('H')\",\n \"def max_height(self) -> int:\\n return UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)\",\n \"def getSize(self):\\n return GDimension(frameWidth, frameHeight)\",\n \"def height(self) -> int:\\n return self._obj[self.y_dim].size\",\n \"def get_height(self):\\n\\t\\treturn len(self._background[0]) if self.get_width() > 0 and self._background[0] else 0\",\n \"def getHeight(self):\\n return _libsbml.BoundingBox_getHeight(self)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7565148","0.73991317","0.7380456","0.736369","0.7310083","0.7279103","0.72679317","0.7228617","0.72236824","0.71272886","0.71267223","0.70312136","0.70312136","0.7028361","0.70189685","0.7004611","0.6970833","0.6970833","0.6967758","0.69549733","0.69441545","0.69263077","0.6921985","0.69039434","0.6879385","0.6878052","0.68480736","0.6831451","0.68090755","0.68090755","0.68090755","0.68090755","0.67968076","0.6779972","0.67551744","0.67551744","0.67551744","0.6753935","0.6732554","0.67251325","0.67206603","0.6716744","0.6713735","0.6680195","0.6680195","0.66689396","0.666043","0.663549","0.6631886","0.6610395","0.66089606","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.6605861","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.66023445","0.6596183","0.6592824","0.6592107","0.6582033","0.6581063","0.6557905","0.6557905","0.65510803","0.6536314","0.6533755","0.6440437","0.6427854","0.6423643"],"string":"[\n \"0.7565148\",\n \"0.73991317\",\n \"0.7380456\",\n \"0.736369\",\n \"0.7310083\",\n \"0.7279103\",\n \"0.72679317\",\n \"0.7228617\",\n \"0.72236824\",\n \"0.71272886\",\n \"0.71267223\",\n \"0.70312136\",\n \"0.70312136\",\n \"0.7028361\",\n \"0.70189685\",\n \"0.7004611\",\n \"0.6970833\",\n \"0.6970833\",\n \"0.6967758\",\n \"0.69549733\",\n \"0.69441545\",\n \"0.69263077\",\n \"0.6921985\",\n \"0.69039434\",\n \"0.6879385\",\n \"0.6878052\",\n \"0.68480736\",\n \"0.6831451\",\n \"0.68090755\",\n \"0.68090755\",\n \"0.68090755\",\n \"0.68090755\",\n \"0.67968076\",\n \"0.6779972\",\n \"0.67551744\",\n \"0.67551744\",\n \"0.67551744\",\n \"0.6753935\",\n \"0.6732554\",\n \"0.67251325\",\n \"0.67206603\",\n \"0.6716744\",\n \"0.6713735\",\n \"0.6680195\",\n \"0.6680195\",\n \"0.66689396\",\n \"0.666043\",\n \"0.663549\",\n \"0.6631886\",\n \"0.6610395\",\n \"0.66089606\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.6605861\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.66023445\",\n \"0.6596183\",\n \"0.6592824\",\n \"0.6592107\",\n \"0.6582033\",\n \"0.6581063\",\n \"0.6557905\",\n \"0.6557905\",\n \"0.65510803\",\n \"0.6536314\",\n \"0.6533755\",\n \"0.6440437\",\n \"0.6427854\",\n \"0.6423643\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66156316"},"document_rank":{"kind":"string","value":"56"}}},{"rowIdx":76577,"cells":{"query":{"kind":"string","value":"Sets the height of this GIFOutput. Height of the media to be rendered, in pixels. Should be the height of your scenes unless a smaller resolution is needed. Resolution higher than the scene resolution reduces quality. The width is automatically calculated to keep the aspect ratio."},"document":{"kind":"string","value":"def height(self, height):\n if height is None:\n raise ValueError(\"Invalid value for `height`, must not be `None`\")\n\n self._height = height"},"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 setHeight(self, *args):\n return _libsbml.Dimensions_setHeight(self, *args)","def SetHeight(*args, **kwargs):\n return _gdi_.Bitmap_SetHeight(*args, **kwargs)","def set_height(height):\n resize.transforms[1].size = height","def SetHeight(self, h):\r\n\r\n self._height = h","def __set_height(self, height):\n self._height = height","def height(self):\n return self.config.get('resolution', {}).get('y',1080) #720","def setHeight(self, height):\n if not self._height:\n self._height = int(height)","def height(self, value: int):\n self._height = value","def height(self, height):\n\n self._height = height","def height(self, height):\n\n self._height = height","def height(self, height):\n\n self._height = height","def height(self, height):\n\n self._height = height","def height(self, height):\n\n self._height = height","def frame_height(self) -> int:\n pass","def set_igv_window_height(self, height=600):\n self.igv_window_height = int(height)","def get_height(self) -> int:\n return self.rsimulator.get_frame_height()","def get_height(self):\n if self.height:\n return self.height\n \n if not self._oembed:\n return ''\n \n return self._oembed.get('height', None)","def setHeight(self, *args):\n return _libsbml.BoundingBox_setHeight(self, *args)","def media_images_height_max(self, media_images_height_max):\n\n self._media_images_height_max = media_images_height_max","def set_size(self, width, height):\r\n \r\n self.image = pygame.transform.scale(self.image, (width, height))\r\n self.rect = self.image.get_rect()","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def setHeight(*args):","def height(self, value):\n self.integer_validator(\"height\", value)\n self.__height = value","def height(self, value):\n self._el._parent.execute_script(\"arguments[0].height = arguments[1]\", self._el, value)\n self.changed = True","def height(self, value):\n self._el._parent.execute_script(\"arguments[0].height = arguments[1]\", self._el, value)\n self.changed = True","def setSize(self, y, h):\n if (h <= 0.0):\n self.ovflRect.hide()\n self.canvas.setHeight(y)\n else:\n self.ovflRect.setRect(0, y, self.mainWidth, h)\n self.ovflRect.show()\n self.canvas.setHeight(y + h)","def setHeight(self, height=None):\r\n if(height):\r\n self.heightATOM3Integer.setValue(height)\r\n else:\r\n height = self.heightATOM3Integer.getValue()\r\n if(self.constCodeWidget != None):\r\n self.constCodeWidget.config(height=height)","def height(self, value):\n self.data_validator(\"height\", value)\n self.__height = value","def getHeight(self):\n return frameHeight","def setSize(self, width, height):\n frameWidth = width\n frameHeight = height\n repaint()","def height(self, value):\n self.validate_input(height=value)\n self.__height = value","def get_height(self):\n return max(map(TextImage.get_height, self.frames))","def height(self):\n return _libsbml.Dimensions_height(self)","def set_height(self, value):\n if value not in range(0, 27):\n raise SettingsError(\"Invalid height\")\n self._parser.set(\"settings\", \"height\", str(value))\n self._save()","def height(self):\n return(self.SCREEN_H)","def video_playback_height(self, video_playback_height):\n # type: (int) -> None\n\n if video_playback_height is not None:\n if not isinstance(video_playback_height, int):\n raise TypeError(\"Invalid type for `video_playback_height`, type has to be `int`\")\n\n self._video_playback_height = video_playback_height","def height(self, value):\n\n if type(value) != int:\n raise TypeError(\"height must be an integer\")\n\n if value <= 0:\n raise ValueError(\"height must be > 0\")\n\n self.__height = value","def height(self, value):\n if not isinstance(value, int):\n raise TypeError(\"height must be an integer\")\n if value <= 0:\n raise ValueError(\"height must be > 0\")\n self.__height = value","def get_height(self) -> int:\n return int(self._surface.get_height())","def setSize(self, width, height):\n dw = (width - self.width()) / 2.0\n dh = (height - self.height()) / 2.0\n rect = self.sceneRect()\n rect.adjust(-dw, -dh, dw, dh)\n self.setSceneRect(rect)","def height(self, value):\n if isinstance(value, int) is False:\n raise TypeError(\"height must be an integer\")\n if value <= 0:\n raise ValueError(\"height must be > 0\")\n self.__height = value","def getHeight(self):\n return self._image.height()","def filmHeight(self):\r\n cls = mxs.classof(self._nativePointer)\r\n height = None\r\n if cls == mxs.VRayPhysicalCamera:\r\n\r\n # TODO: Why is that wrapped in a try except?\r\n try:\r\n height = self._nativePointer.film_height\r\n except AttributeError:\r\n pass\r\n\r\n elif cls == mxs.Physical:\r\n height = self._nativePointer.film_height_mm\r\n\r\n if not height:\r\n # If we failed to get a width from a camera, return the scene aperture setting.\r\n height = self.filmWidth() * (mxs.renderPixelAspect / mxs.getRendImageAspect())\r\n\r\n return height","def video_height(self):\n return self._el._parent.execute_script(\"return arguments[0].videoHeight\", self._el)","def video_height(self):\n return self._el._parent.execute_script(\"return arguments[0].videoHeight\", self._el)","def height(self):\n return self.client.call('GET', self.name + 'height')","def height(self, height):\n if type(height) is not int:\n raise TypeError(\"height must be an integer\")\n if height <= 0:\n raise ValueError(\"height must be > 0\")\n self.__height = height","def getHeight(self):\n return _libsbml.Dimensions_getHeight(self)","def set_max_chunk_height(self, val=256):\n self._max_chunk_height = val","def get_frame_height(self) -> int:\n return self.__sim.frame_size()[1]","def height(self, number):\n self.validate_int(\"height\", number)\n if number <= 0:\n raise ValueError(\"height must be > 0\")\n self.__height = number","def height(self, height):\n if type(height) is not int:\n raise TypeError(\"height must be an integer\")\n if height is 0 or height < 0:\n raise ValueError(\"height must be > 0\")\n self.__height = height","def video_playback_height(self):\n # type: () -> int\n return self._video_playback_height","def height(self, height):\n if type(height) is not int:\n raise TypeError(\"height must be an integer\")\n elif height <= 0:\n raise ValueError(\"height must be > 0\")\n else:\n self.__height = height","def height(self) -> int:\r\n return self.rect_uv.h","def updateHeightsTexture(self, gl):\n\n if (self.heightsTexture.width() != self.logicalResources.n or \n self.heightsTexture.height() != self.logicalResources.m):\n self.heightsTexture.destroy()\n\n self.heightsTexture = self.createTexture(gl, self.logicalResources.m, self.logicalResources.n, \n format=QOpenGLTexture.RG32F, filter=QOpenGLTexture.Nearest)\n \n data = []\n for i in range(self.logicalResources.n):\n for j in range(self.logicalResources.m):\n data.extend([ self.logicalResources.landscapeHeightsMatrix[i][j] * ZScale\n , self.logicalResources.waterHeightsMatrix[i][j] * ZScale])\n data = struct.pack('{}f'.format(len(data)), *data)\n\n self.heightsTexture.setData(QOpenGLTexture.RG, QOpenGLTexture.Float32, data)","def mjpegStreamHeight(self) -> int:\n\t\tif 'mjpegStreamHeight' in self._raw_result['data']:\n\t\t\treturn self._raw_result['data']['mjpegStreamHeight']\n\t\treturn 480","def max_panel_height(self, height):\n self.command(\"maxPanelHeight %(height)s\" % locals())","def max_height(self) -> int:\n return UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)","def setGeoidHeight(self, geoidhgt):\n self._geoidhgt = geoidhgt or 0.0\n if self._xyz is not None:\n self.setXYZ(self._xyz)","def get_dimension_height(self):\n pass","def height(self, height):\n # type: (float) -> None\n\n if height is not None:\n if not isinstance(height, (float, int)):\n raise TypeError(\"Invalid type for `height`, type has to be `float`\")\n\n self._height = height","def frameHeight(self):\n return self._frame_height","def height(self):\n return (self.scene.shape[1] - self.size) // self.size + 1","def getHeight(self):\n return self.height","def getHeight(self):\n return self.height","def getHeight(self):\n return _tkCall(self.image.height)","def height(self) -> int:\n if self.props.max_height:\n max_height = UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)\n return min(self.isize[1].to_pixels(self.parent.height), max_height)\n else:\n return self.isize[1].to_pixels(self.parent.height)","def setMaxSize(self,width,height):\n assert (type(width) == int), \"width %s is not an int\" % `width`\n assert (width > 0), \"width %s is negative\" % `width`\n assert (type(height) == int), \"height %s is not an int\" % `height`\n assert (height > 0), \"height %s is negative\" % `height`\n self._frame._root.maxsize(width,height)","def height(self) -> int:\n return self._image_data.height","def video_window_height(self, video_window_height):\n # type: (int) -> None\n\n if video_window_height is not None:\n if not isinstance(video_window_height, int):\n raise TypeError(\"Invalid type for `video_window_height`, type has to be `int`\")\n\n self._video_window_height = video_window_height","def getHeight(self):\n return self._height","def set_height(self, height):\n self.validate()\n\n self.ping() # also serves as a valid ping\n farmer = self.lookup()\n farmer.height = height\n db.session.commit()\n\n return self.height","def height (self):\n return self._h","def height(self, height=None):\n\n if height is None:\n return self._height\n else:\n if not isinstance(height, int) and not isinstance(height, float):\n raise TypeError(\"height must be numeric, not '%s'\" % height)\n self._height = height","def set_barcode_height(self, val=50): # Default is 50\n if val < 1:\n val = 1\n\n self._barcode_height = val\n self.write(self.ASCII_GS, 'h', val)","def calc_size(self):\r\n self.height = HEIGHT_STATUS","def resizeGL(self, width, height):\n self._sceneviewer.setViewportSize(width, height)\n # resizeGL end","def getHeight(self):\r\n height = 1\r\n if self.orientation == \"v\":\r\n height = self.size\r\n return height","def output_height(self):\n\t\treturn self.output_shape_param('H')","def height(self) -> int:\n return self.__height","def calc_height(self):\n num_records = len(self.list_of_motif_objects)\n\n self.height = num_records * self.page_height","def height(self) -> int:\n return self._height","def height(self) -> int:\n return self._height","def height_in(self, height_in):\n\n self._height_in = height_in","def size(self, value):\n self.width = value\n self.height = value","def _height_changed(self, value):\r\n # update internal data\r\n self._height = value","def _set_size(self):\n if self.width_key is not None:\n width = config.get(self.width_key)\n height = config.get(self.height_key)\n self.window.resize(width, height)","def set_render_resolution(self, width, height, pixel_aspect=1.0):\n raise NotImplementedError(\"set_render_resolution is not implemented\")","def get_height(self):\r\n return self._height","def get_height(self):\r\n return self._height"],"string":"[\n \"def setHeight(self, *args):\\n return _libsbml.Dimensions_setHeight(self, *args)\",\n \"def SetHeight(*args, **kwargs):\\n return _gdi_.Bitmap_SetHeight(*args, **kwargs)\",\n \"def set_height(height):\\n resize.transforms[1].size = height\",\n \"def SetHeight(self, h):\\r\\n\\r\\n self._height = h\",\n \"def __set_height(self, height):\\n self._height = height\",\n \"def height(self):\\n return self.config.get('resolution', {}).get('y',1080) #720\",\n \"def setHeight(self, height):\\n if not self._height:\\n self._height = int(height)\",\n \"def height(self, value: int):\\n self._height = value\",\n \"def height(self, height):\\n\\n self._height = height\",\n \"def height(self, height):\\n\\n self._height = height\",\n \"def height(self, height):\\n\\n self._height = height\",\n \"def height(self, height):\\n\\n self._height = height\",\n \"def height(self, height):\\n\\n self._height = height\",\n \"def frame_height(self) -> int:\\n pass\",\n \"def set_igv_window_height(self, height=600):\\n self.igv_window_height = int(height)\",\n \"def get_height(self) -> int:\\n return self.rsimulator.get_frame_height()\",\n \"def get_height(self):\\n if self.height:\\n return self.height\\n \\n if not self._oembed:\\n return ''\\n \\n return self._oembed.get('height', None)\",\n \"def setHeight(self, *args):\\n return _libsbml.BoundingBox_setHeight(self, *args)\",\n \"def media_images_height_max(self, media_images_height_max):\\n\\n self._media_images_height_max = media_images_height_max\",\n \"def set_size(self, width, height):\\r\\n \\r\\n self.image = pygame.transform.scale(self.image, (width, height))\\r\\n self.rect = self.image.get_rect()\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def setHeight(*args):\",\n \"def height(self, value):\\n self.integer_validator(\\\"height\\\", value)\\n self.__height = value\",\n \"def height(self, value):\\n self._el._parent.execute_script(\\\"arguments[0].height = arguments[1]\\\", self._el, value)\\n self.changed = True\",\n \"def height(self, value):\\n self._el._parent.execute_script(\\\"arguments[0].height = arguments[1]\\\", self._el, value)\\n self.changed = True\",\n \"def setSize(self, y, h):\\n if (h <= 0.0):\\n self.ovflRect.hide()\\n self.canvas.setHeight(y)\\n else:\\n self.ovflRect.setRect(0, y, self.mainWidth, h)\\n self.ovflRect.show()\\n self.canvas.setHeight(y + h)\",\n \"def setHeight(self, height=None):\\r\\n if(height):\\r\\n self.heightATOM3Integer.setValue(height)\\r\\n else:\\r\\n height = self.heightATOM3Integer.getValue()\\r\\n if(self.constCodeWidget != None):\\r\\n self.constCodeWidget.config(height=height)\",\n \"def height(self, value):\\n self.data_validator(\\\"height\\\", value)\\n self.__height = value\",\n \"def getHeight(self):\\n return frameHeight\",\n \"def setSize(self, width, height):\\n frameWidth = width\\n frameHeight = height\\n repaint()\",\n \"def height(self, value):\\n self.validate_input(height=value)\\n self.__height = value\",\n \"def get_height(self):\\n return max(map(TextImage.get_height, self.frames))\",\n \"def height(self):\\n return _libsbml.Dimensions_height(self)\",\n \"def set_height(self, value):\\n if value not in range(0, 27):\\n raise SettingsError(\\\"Invalid height\\\")\\n self._parser.set(\\\"settings\\\", \\\"height\\\", str(value))\\n self._save()\",\n \"def height(self):\\n return(self.SCREEN_H)\",\n \"def video_playback_height(self, video_playback_height):\\n # type: (int) -> None\\n\\n if video_playback_height is not None:\\n if not isinstance(video_playback_height, int):\\n raise TypeError(\\\"Invalid type for `video_playback_height`, type has to be `int`\\\")\\n\\n self._video_playback_height = video_playback_height\",\n \"def height(self, value):\\n\\n if type(value) != int:\\n raise TypeError(\\\"height must be an integer\\\")\\n\\n if value <= 0:\\n raise ValueError(\\\"height must be > 0\\\")\\n\\n self.__height = value\",\n \"def height(self, value):\\n if not isinstance(value, int):\\n raise TypeError(\\\"height must be an integer\\\")\\n if value <= 0:\\n raise ValueError(\\\"height must be > 0\\\")\\n self.__height = value\",\n \"def get_height(self) -> int:\\n return int(self._surface.get_height())\",\n \"def setSize(self, width, height):\\n dw = (width - self.width()) / 2.0\\n dh = (height - self.height()) / 2.0\\n rect = self.sceneRect()\\n rect.adjust(-dw, -dh, dw, dh)\\n self.setSceneRect(rect)\",\n \"def height(self, value):\\n if isinstance(value, int) is False:\\n raise TypeError(\\\"height must be an integer\\\")\\n if value <= 0:\\n raise ValueError(\\\"height must be > 0\\\")\\n self.__height = value\",\n \"def getHeight(self):\\n return self._image.height()\",\n \"def filmHeight(self):\\r\\n cls = mxs.classof(self._nativePointer)\\r\\n height = None\\r\\n if cls == mxs.VRayPhysicalCamera:\\r\\n\\r\\n # TODO: Why is that wrapped in a try except?\\r\\n try:\\r\\n height = self._nativePointer.film_height\\r\\n except AttributeError:\\r\\n pass\\r\\n\\r\\n elif cls == mxs.Physical:\\r\\n height = self._nativePointer.film_height_mm\\r\\n\\r\\n if not height:\\r\\n # If we failed to get a width from a camera, return the scene aperture setting.\\r\\n height = self.filmWidth() * (mxs.renderPixelAspect / mxs.getRendImageAspect())\\r\\n\\r\\n return height\",\n \"def video_height(self):\\n return self._el._parent.execute_script(\\\"return arguments[0].videoHeight\\\", self._el)\",\n \"def video_height(self):\\n return self._el._parent.execute_script(\\\"return arguments[0].videoHeight\\\", self._el)\",\n \"def height(self):\\n return self.client.call('GET', self.name + 'height')\",\n \"def height(self, height):\\n if type(height) is not int:\\n raise TypeError(\\\"height must be an integer\\\")\\n if height <= 0:\\n raise ValueError(\\\"height must be > 0\\\")\\n self.__height = height\",\n \"def getHeight(self):\\n return _libsbml.Dimensions_getHeight(self)\",\n \"def set_max_chunk_height(self, val=256):\\n self._max_chunk_height = val\",\n \"def get_frame_height(self) -> int:\\n return self.__sim.frame_size()[1]\",\n \"def height(self, number):\\n self.validate_int(\\\"height\\\", number)\\n if number <= 0:\\n raise ValueError(\\\"height must be > 0\\\")\\n self.__height = number\",\n \"def height(self, height):\\n if type(height) is not int:\\n raise TypeError(\\\"height must be an integer\\\")\\n if height is 0 or height < 0:\\n raise ValueError(\\\"height must be > 0\\\")\\n self.__height = height\",\n \"def video_playback_height(self):\\n # type: () -> int\\n return self._video_playback_height\",\n \"def height(self, height):\\n if type(height) is not int:\\n raise TypeError(\\\"height must be an integer\\\")\\n elif height <= 0:\\n raise ValueError(\\\"height must be > 0\\\")\\n else:\\n self.__height = height\",\n \"def height(self) -> int:\\r\\n return self.rect_uv.h\",\n \"def updateHeightsTexture(self, gl):\\n\\n if (self.heightsTexture.width() != self.logicalResources.n or \\n self.heightsTexture.height() != self.logicalResources.m):\\n self.heightsTexture.destroy()\\n\\n self.heightsTexture = self.createTexture(gl, self.logicalResources.m, self.logicalResources.n, \\n format=QOpenGLTexture.RG32F, filter=QOpenGLTexture.Nearest)\\n \\n data = []\\n for i in range(self.logicalResources.n):\\n for j in range(self.logicalResources.m):\\n data.extend([ self.logicalResources.landscapeHeightsMatrix[i][j] * ZScale\\n , self.logicalResources.waterHeightsMatrix[i][j] * ZScale])\\n data = struct.pack('{}f'.format(len(data)), *data)\\n\\n self.heightsTexture.setData(QOpenGLTexture.RG, QOpenGLTexture.Float32, data)\",\n \"def mjpegStreamHeight(self) -> int:\\n\\t\\tif 'mjpegStreamHeight' in self._raw_result['data']:\\n\\t\\t\\treturn self._raw_result['data']['mjpegStreamHeight']\\n\\t\\treturn 480\",\n \"def max_panel_height(self, height):\\n self.command(\\\"maxPanelHeight %(height)s\\\" % locals())\",\n \"def max_height(self) -> int:\\n return UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)\",\n \"def setGeoidHeight(self, geoidhgt):\\n self._geoidhgt = geoidhgt or 0.0\\n if self._xyz is not None:\\n self.setXYZ(self._xyz)\",\n \"def get_dimension_height(self):\\n pass\",\n \"def height(self, height):\\n # type: (float) -> None\\n\\n if height is not None:\\n if not isinstance(height, (float, int)):\\n raise TypeError(\\\"Invalid type for `height`, type has to be `float`\\\")\\n\\n self._height = height\",\n \"def frameHeight(self):\\n return self._frame_height\",\n \"def height(self):\\n return (self.scene.shape[1] - self.size) // self.size + 1\",\n \"def getHeight(self):\\n return self.height\",\n \"def getHeight(self):\\n return self.height\",\n \"def getHeight(self):\\n return _tkCall(self.image.height)\",\n \"def height(self) -> int:\\n if self.props.max_height:\\n max_height = UIMetric.parse(self.props.max_height).to_pixels(self.parent.height)\\n return min(self.isize[1].to_pixels(self.parent.height), max_height)\\n else:\\n return self.isize[1].to_pixels(self.parent.height)\",\n \"def setMaxSize(self,width,height):\\n assert (type(width) == int), \\\"width %s is not an int\\\" % `width`\\n assert (width > 0), \\\"width %s is negative\\\" % `width`\\n assert (type(height) == int), \\\"height %s is not an int\\\" % `height`\\n assert (height > 0), \\\"height %s is negative\\\" % `height`\\n self._frame._root.maxsize(width,height)\",\n \"def height(self) -> int:\\n return self._image_data.height\",\n \"def video_window_height(self, video_window_height):\\n # type: (int) -> None\\n\\n if video_window_height is not None:\\n if not isinstance(video_window_height, int):\\n raise TypeError(\\\"Invalid type for `video_window_height`, type has to be `int`\\\")\\n\\n self._video_window_height = video_window_height\",\n \"def getHeight(self):\\n return self._height\",\n \"def set_height(self, height):\\n self.validate()\\n\\n self.ping() # also serves as a valid ping\\n farmer = self.lookup()\\n farmer.height = height\\n db.session.commit()\\n\\n return self.height\",\n \"def height (self):\\n return self._h\",\n \"def height(self, height=None):\\n\\n if height is None:\\n return self._height\\n else:\\n if not isinstance(height, int) and not isinstance(height, float):\\n raise TypeError(\\\"height must be numeric, not '%s'\\\" % height)\\n self._height = height\",\n \"def set_barcode_height(self, val=50): # Default is 50\\n if val < 1:\\n val = 1\\n\\n self._barcode_height = val\\n self.write(self.ASCII_GS, 'h', val)\",\n \"def calc_size(self):\\r\\n self.height = HEIGHT_STATUS\",\n \"def resizeGL(self, width, height):\\n self._sceneviewer.setViewportSize(width, height)\\n # resizeGL end\",\n \"def getHeight(self):\\r\\n height = 1\\r\\n if self.orientation == \\\"v\\\":\\r\\n height = self.size\\r\\n return height\",\n \"def output_height(self):\\n\\t\\treturn self.output_shape_param('H')\",\n \"def height(self) -> int:\\n return self.__height\",\n \"def calc_height(self):\\n num_records = len(self.list_of_motif_objects)\\n\\n self.height = num_records * self.page_height\",\n \"def height(self) -> int:\\n return self._height\",\n \"def height(self) -> int:\\n return self._height\",\n \"def height_in(self, height_in):\\n\\n self._height_in = height_in\",\n \"def size(self, value):\\n self.width = value\\n self.height = value\",\n \"def _height_changed(self, value):\\r\\n # update internal data\\r\\n self._height = value\",\n \"def _set_size(self):\\n if self.width_key is not None:\\n width = config.get(self.width_key)\\n height = config.get(self.height_key)\\n self.window.resize(width, height)\",\n \"def set_render_resolution(self, width, height, pixel_aspect=1.0):\\n raise NotImplementedError(\\\"set_render_resolution is not implemented\\\")\",\n \"def get_height(self):\\r\\n return self._height\",\n \"def get_height(self):\\r\\n return self._height\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6735364","0.6383196","0.63685995","0.630886","0.62710375","0.62426734","0.6142797","0.60943526","0.60887784","0.60887784","0.60887784","0.60887784","0.60887784","0.6074497","0.60136455","0.60128236","0.5981412","0.5960381","0.5942689","0.59383595","0.58984154","0.58984154","0.58984154","0.58984154","0.58984154","0.58984154","0.58984154","0.58984154","0.58984154","0.58984154","0.58984154","0.58834416","0.58578414","0.58578414","0.5841323","0.58278173","0.58216184","0.58209443","0.57499945","0.5748387","0.57469594","0.56802505","0.56779116","0.56758666","0.56429756","0.563968","0.563302","0.5625138","0.561648","0.55788356","0.5574225","0.55662274","0.5551032","0.5551032","0.555078","0.55501604","0.5541842","0.5530706","0.5529653","0.552298","0.5522736","0.55140275","0.551281","0.5507628","0.5498948","0.5486926","0.54841584","0.5482867","0.54808253","0.54780376","0.5471308","0.54697376","0.54666793","0.5457421","0.5457421","0.5456409","0.5455252","0.544639","0.54413646","0.5413589","0.54090357","0.5408415","0.5404107","0.5403328","0.5381891","0.537645","0.5372884","0.5367181","0.53617555","0.5353999","0.5347886","0.534292","0.534292","0.53342974","0.53329176","0.532755","0.53251696","0.53203034","0.5316932","0.5316932"],"string":"[\n \"0.6735364\",\n \"0.6383196\",\n \"0.63685995\",\n \"0.630886\",\n \"0.62710375\",\n \"0.62426734\",\n \"0.6142797\",\n \"0.60943526\",\n \"0.60887784\",\n \"0.60887784\",\n \"0.60887784\",\n \"0.60887784\",\n \"0.60887784\",\n \"0.6074497\",\n \"0.60136455\",\n \"0.60128236\",\n \"0.5981412\",\n \"0.5960381\",\n \"0.5942689\",\n \"0.59383595\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58984154\",\n \"0.58834416\",\n \"0.58578414\",\n \"0.58578414\",\n \"0.5841323\",\n \"0.58278173\",\n \"0.58216184\",\n \"0.58209443\",\n \"0.57499945\",\n \"0.5748387\",\n \"0.57469594\",\n \"0.56802505\",\n \"0.56779116\",\n \"0.56758666\",\n \"0.56429756\",\n \"0.563968\",\n \"0.563302\",\n \"0.5625138\",\n \"0.561648\",\n \"0.55788356\",\n \"0.5574225\",\n \"0.55662274\",\n \"0.5551032\",\n \"0.5551032\",\n \"0.555078\",\n \"0.55501604\",\n \"0.5541842\",\n \"0.5530706\",\n \"0.5529653\",\n \"0.552298\",\n \"0.5522736\",\n \"0.55140275\",\n \"0.551281\",\n \"0.5507628\",\n \"0.5498948\",\n \"0.5486926\",\n \"0.54841584\",\n \"0.5482867\",\n \"0.54808253\",\n \"0.54780376\",\n \"0.5471308\",\n \"0.54697376\",\n \"0.54666793\",\n \"0.5457421\",\n \"0.5457421\",\n \"0.5456409\",\n \"0.5455252\",\n \"0.544639\",\n \"0.54413646\",\n \"0.5413589\",\n \"0.54090357\",\n \"0.5408415\",\n \"0.5404107\",\n \"0.5403328\",\n \"0.5381891\",\n \"0.537645\",\n \"0.5372884\",\n \"0.5367181\",\n \"0.53617555\",\n \"0.5353999\",\n \"0.5347886\",\n \"0.534292\",\n \"0.534292\",\n \"0.53342974\",\n \"0.53329176\",\n \"0.532755\",\n \"0.53251696\",\n \"0.53203034\",\n \"0.5316932\",\n \"0.5316932\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5538502"},"document_rank":{"kind":"string","value":"57"}}},{"rowIdx":76578,"cells":{"query":{"kind":"string","value":"Gets the start of this GIFOutput. What second of the storyboard timeline to start the GIF."},"document":{"kind":"string","value":"def start(self):\n return self._start"},"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 getStartTime(self):\n return _osgAnimation.Animation_getStartTime(self)","def getStartTime(self):\n return _osgAnimation.Channel_getStartTime(self)","def get_start(self):\n return self._start","def getStart(self):\n return self._start","def _get_start(self):\n return self._start","def getStartTime(self):\n return _osgAnimation.Vec2LinearSampler_getStartTime(self)","def start(self) -> int:\n return self._start","def start(self) -> int:\n return self._start","def start(self):\n return self.__start_line","def start(self):\n return self.start_","def getStartTime(self):\n return _osgAnimation.Vec4LinearSampler_getStartTime(self)","def getStartTime(self):\n return _osgAnimation.MatrixLinearSampler_getStartTime(self)","def start(self):\n return self._get('start')","def GetAnimationStep(self):\r\n\r\n return self._animation_step","def getStartTime(self):\n return _osgAnimation.Vec3LinearSampler_getStartTime(self)","def start(self):\n\t\treturn self._start","def start_time(self):\n return self.__start","def start(self):\n # type: () -> datetime\n return self._start","def getStart(self) -> long:\n ...","def start(self):\n return self.__start","def start(self) -> pos.Pos:\n return self.__start","def start_time(self) -> pulumi.Output[Optional[int]]:\n return pulumi.get(self, \"start_time\")","def get_start_point(self):\n return self.first_point","def start_time(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"start_time\")","def first_loop_start(self) -> int:\n return self.__first_loop_start","def getStart(self):\n return _libsbml.LineSegment_getStart(self)","def start(self):\n return self._config.trace_start","def start(self) -> datetime:\n return self._start","def starts(self):\n return self.time_start","def StaggeredStart(self):\n\t\treturn self._get_attribute('staggeredStart')","def start_time(self) -> float:\n return self._start_time","def __get_starting_time(self):\n return self.__starting_time","def get_begin(self):\n return self.__begin","def start_frame(self):\n\n # Check whether we're supposed to make a frame on this iteration:\n if self.frame_count % self.stride != 0:\n return\n\n # Check whether we're already making a frame. \n if self.in_scope:\n print(\"The Gif object for {} has encountered 'start_frame' twice\\\n without an intervening 'end_frame'\".format(self.filename))\n raise SyntaxError\n\n # Construct a new figure\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\n self.current_frame = fig\n\n # Set the \"in_scope\" member True\n self.in_scope = True\n\n return self.current_frame","def time(self):\n return self._begin","def start_time(self):\n return self.time_parser.start_time","def time_start(self):\n return self._time_start","def get_first_step(self):\n return self.get_step_by_index(0)","def start_time(self):\n return self._start_time","def start_time(self):\n return self._start_time","def start_time(self):\n return self._start_time","def start_time(self):\n return self._start_time","def start_time(self):\n return self._start_time","def start_time(self):\n return self._start_time","def start_time(self):\n return self._start_time","def start_time(self):\n return self._start_time","def get_startline(self):\n return self.get_attribute(\"startline\")","def videotime_start(self):\n # type: () -> int\n return self._videotime_start","def start_time(self) -> str:\n return self._start_time","def start_time(self):\n return self._get(\"start_time\")","def getStartTime(self):\n return _osgAnimation.QuatSphericalLinearSampler_getStartTime(self)","def t0(self):\n return self._time_axis.start","def start(self):\n\t\tif self._start is not None:\n\t\t\traise RuntimeError('Animations can only be run once')\n\t\tself._start = 1\t\n\t\t# start time\n\t\tstartticks = self._startticks if self.startticks else _pg.time.get_ticks()\n\t\tfor anim in self.animations:\n\t\t\tanim._startticks = startticks\n\t\t\tanim.start()\n\t\t\tstartticks += anim.duration\n\t\t# get updated\n\t\t_running.append(self)\n\t\t_anim_started(self)","def start_time(self) -> float:\r\n ...","def start_ms(self) -> int:\n return self._start_ms","def start(self):\n\t\tif self._start is not None:\n\t\t\traise RuntimeError('Animations can only be run once')\n\t\tself._start = 1\t\n\t\t# start time\n\t\tif not self._startticks:\n\t\t\tself._startticks = _pg.time.get_ticks()\n\t\tfor anim in self.animations:\n\t\t\tanim._startticks = self._startticks\n\t\t\tanim.start()\n\t\t# get updated\n\t\t_running.append(self)\n\t\t_anim_started(self)","def start_time(self) -> str:\n return pulumi.get(self, \"start_time\")","def start_time(self) -> str:\n return pulumi.get(self, \"start_time\")","def start(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"start\")","def time_step(self):\n return self._time_step","def starting_position(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"starting_position\")","def getStartTime(self):\n return _osgAnimation.QuatSphericalLinearChannel_getStartTime(self)","def captureimage(self):\n if not self.total_time:\n return self.frames[-1]\n return None","def start_time(self):\n pass","def start_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"start_time\")","def start_time(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"start_time\")","def start(self):\n return self.properties.get(\"start\", DateTimeTimeZone())","def cal_start(self):\n return self.setup_start","def getTime(self):\n return _osgAnimation.Keyframe_getTime(self)","def start_time(self):\n return RPR.GetAudioAccessorStartTime(self.id)","def k (self):\n\n return self.start","def get_initial_point(self):\r\n if isinstance(self.pieces[0], LineSegment):\r\n return self.pieces[0].start","def start_loc(self) -> str:\n return self._start_loc","def start_on(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"start_on\")","def StartingFrameIndex(self):\n if self.force_auto_sync:\n self.get('StartingFrameIndex')\n return self._StartingFrameIndex","def current_time_step(self) -> ts.TimeStep:\n return self._current_time_step","def start_time(self):\n return self._meta['start_time']","def get_frame_time(self):\n return self.get_timings().frame_time","def start(self):\n if len(self._trace) == 0:\n return 0\n return self._trace.keys()[0]","def getISO8601Start(self):\n return self.iso8601start","def getStartTime(self):\n assert not self.isWaitingToStart(), \"Too early to tell: %s\" % self\n return \"%s\" % self.__rawInfo.startTime","def get_frame(self):\n return self.last_frame","def start(self):\n return self.trial.start + timedelta(seconds=self.start_checkpoint)","def tend(self):\n return self.tstart + self.duration","def started_on(self):\n return self.get_time(\"started_on\")","def start(self):\n try:\n return self.index[0]\n except:\n pass","def start(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"start\")","def start_time(self) -> Optional[str]:\n return pulumi.get(self, \"start_time\")","def step(self):\n return self._step","def step(self):\n return self._step","def step(self):\n return self._step","def step(self):\n return self._step","def startTime(self) -> float:\n try: return self.times[0]\n except IndexError: return 0.0","def isStart(self):\n return self.start","def cur_step(self):\n return self._cur_step","def get_line_start(self):\n return self._line_start"],"string":"[\n \"def getStartTime(self):\\n return _osgAnimation.Animation_getStartTime(self)\",\n \"def getStartTime(self):\\n return _osgAnimation.Channel_getStartTime(self)\",\n \"def get_start(self):\\n return self._start\",\n \"def getStart(self):\\n return self._start\",\n \"def _get_start(self):\\n return self._start\",\n \"def getStartTime(self):\\n return _osgAnimation.Vec2LinearSampler_getStartTime(self)\",\n \"def start(self) -> int:\\n return self._start\",\n \"def start(self) -> int:\\n return self._start\",\n \"def start(self):\\n return self.__start_line\",\n \"def start(self):\\n return self.start_\",\n \"def getStartTime(self):\\n return _osgAnimation.Vec4LinearSampler_getStartTime(self)\",\n \"def getStartTime(self):\\n return _osgAnimation.MatrixLinearSampler_getStartTime(self)\",\n \"def start(self):\\n return self._get('start')\",\n \"def GetAnimationStep(self):\\r\\n\\r\\n return self._animation_step\",\n \"def getStartTime(self):\\n return _osgAnimation.Vec3LinearSampler_getStartTime(self)\",\n \"def start(self):\\n\\t\\treturn self._start\",\n \"def start_time(self):\\n return self.__start\",\n \"def start(self):\\n # type: () -> datetime\\n return self._start\",\n \"def getStart(self) -> long:\\n ...\",\n \"def start(self):\\n return self.__start\",\n \"def start(self) -> pos.Pos:\\n return self.__start\",\n \"def start_time(self) -> pulumi.Output[Optional[int]]:\\n return pulumi.get(self, \\\"start_time\\\")\",\n \"def get_start_point(self):\\n return self.first_point\",\n \"def start_time(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"start_time\\\")\",\n \"def first_loop_start(self) -> int:\\n return self.__first_loop_start\",\n \"def getStart(self):\\n return _libsbml.LineSegment_getStart(self)\",\n \"def start(self):\\n return self._config.trace_start\",\n \"def start(self) -> datetime:\\n return self._start\",\n \"def starts(self):\\n return self.time_start\",\n \"def StaggeredStart(self):\\n\\t\\treturn self._get_attribute('staggeredStart')\",\n \"def start_time(self) -> float:\\n return self._start_time\",\n \"def __get_starting_time(self):\\n return self.__starting_time\",\n \"def get_begin(self):\\n return self.__begin\",\n \"def start_frame(self):\\n\\n # Check whether we're supposed to make a frame on this iteration:\\n if self.frame_count % self.stride != 0:\\n return\\n\\n # Check whether we're already making a frame. \\n if self.in_scope:\\n print(\\\"The Gif object for {} has encountered 'start_frame' twice\\\\\\n without an intervening 'end_frame'\\\".format(self.filename))\\n raise SyntaxError\\n\\n # Construct a new figure\\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\\n self.current_frame = fig\\n\\n # Set the \\\"in_scope\\\" member True\\n self.in_scope = True\\n\\n return self.current_frame\",\n \"def time(self):\\n return self._begin\",\n \"def start_time(self):\\n return self.time_parser.start_time\",\n \"def time_start(self):\\n return self._time_start\",\n \"def get_first_step(self):\\n return self.get_step_by_index(0)\",\n \"def start_time(self):\\n return self._start_time\",\n \"def start_time(self):\\n return self._start_time\",\n \"def start_time(self):\\n return self._start_time\",\n \"def start_time(self):\\n return self._start_time\",\n \"def start_time(self):\\n return self._start_time\",\n \"def start_time(self):\\n return self._start_time\",\n \"def start_time(self):\\n return self._start_time\",\n \"def start_time(self):\\n return self._start_time\",\n \"def get_startline(self):\\n return self.get_attribute(\\\"startline\\\")\",\n \"def videotime_start(self):\\n # type: () -> int\\n return self._videotime_start\",\n \"def start_time(self) -> str:\\n return self._start_time\",\n \"def start_time(self):\\n return self._get(\\\"start_time\\\")\",\n \"def getStartTime(self):\\n return _osgAnimation.QuatSphericalLinearSampler_getStartTime(self)\",\n \"def t0(self):\\n return self._time_axis.start\",\n \"def start(self):\\n\\t\\tif self._start is not None:\\n\\t\\t\\traise RuntimeError('Animations can only be run once')\\n\\t\\tself._start = 1\\t\\n\\t\\t# start time\\n\\t\\tstartticks = self._startticks if self.startticks else _pg.time.get_ticks()\\n\\t\\tfor anim in self.animations:\\n\\t\\t\\tanim._startticks = startticks\\n\\t\\t\\tanim.start()\\n\\t\\t\\tstartticks += anim.duration\\n\\t\\t# get updated\\n\\t\\t_running.append(self)\\n\\t\\t_anim_started(self)\",\n \"def start_time(self) -> float:\\r\\n ...\",\n \"def start_ms(self) -> int:\\n return self._start_ms\",\n \"def start(self):\\n\\t\\tif self._start is not None:\\n\\t\\t\\traise RuntimeError('Animations can only be run once')\\n\\t\\tself._start = 1\\t\\n\\t\\t# start time\\n\\t\\tif not self._startticks:\\n\\t\\t\\tself._startticks = _pg.time.get_ticks()\\n\\t\\tfor anim in self.animations:\\n\\t\\t\\tanim._startticks = self._startticks\\n\\t\\t\\tanim.start()\\n\\t\\t# get updated\\n\\t\\t_running.append(self)\\n\\t\\t_anim_started(self)\",\n \"def start_time(self) -> str:\\n return pulumi.get(self, \\\"start_time\\\")\",\n \"def start_time(self) -> str:\\n return pulumi.get(self, \\\"start_time\\\")\",\n \"def start(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"start\\\")\",\n \"def time_step(self):\\n return self._time_step\",\n \"def starting_position(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"starting_position\\\")\",\n \"def getStartTime(self):\\n return _osgAnimation.QuatSphericalLinearChannel_getStartTime(self)\",\n \"def captureimage(self):\\n if not self.total_time:\\n return self.frames[-1]\\n return None\",\n \"def start_time(self):\\n pass\",\n \"def start_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"start_time\\\")\",\n \"def start_time(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"start_time\\\")\",\n \"def start(self):\\n return self.properties.get(\\\"start\\\", DateTimeTimeZone())\",\n \"def cal_start(self):\\n return self.setup_start\",\n \"def getTime(self):\\n return _osgAnimation.Keyframe_getTime(self)\",\n \"def start_time(self):\\n return RPR.GetAudioAccessorStartTime(self.id)\",\n \"def k (self):\\n\\n return self.start\",\n \"def get_initial_point(self):\\r\\n if isinstance(self.pieces[0], LineSegment):\\r\\n return self.pieces[0].start\",\n \"def start_loc(self) -> str:\\n return self._start_loc\",\n \"def start_on(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"start_on\\\")\",\n \"def StartingFrameIndex(self):\\n if self.force_auto_sync:\\n self.get('StartingFrameIndex')\\n return self._StartingFrameIndex\",\n \"def current_time_step(self) -> ts.TimeStep:\\n return self._current_time_step\",\n \"def start_time(self):\\n return self._meta['start_time']\",\n \"def get_frame_time(self):\\n return self.get_timings().frame_time\",\n \"def start(self):\\n if len(self._trace) == 0:\\n return 0\\n return self._trace.keys()[0]\",\n \"def getISO8601Start(self):\\n return self.iso8601start\",\n \"def getStartTime(self):\\n assert not self.isWaitingToStart(), \\\"Too early to tell: %s\\\" % self\\n return \\\"%s\\\" % self.__rawInfo.startTime\",\n \"def get_frame(self):\\n return self.last_frame\",\n \"def start(self):\\n return self.trial.start + timedelta(seconds=self.start_checkpoint)\",\n \"def tend(self):\\n return self.tstart + self.duration\",\n \"def started_on(self):\\n return self.get_time(\\\"started_on\\\")\",\n \"def start(self):\\n try:\\n return self.index[0]\\n except:\\n pass\",\n \"def start(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"start\\\")\",\n \"def start_time(self) -> Optional[str]:\\n return pulumi.get(self, \\\"start_time\\\")\",\n \"def step(self):\\n return self._step\",\n \"def step(self):\\n return self._step\",\n \"def step(self):\\n return self._step\",\n \"def step(self):\\n return self._step\",\n \"def startTime(self) -> float:\\n try: return self.times[0]\\n except IndexError: return 0.0\",\n \"def isStart(self):\\n return self.start\",\n \"def cur_step(self):\\n return self._cur_step\",\n \"def get_line_start(self):\\n return self._line_start\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7076997","0.6851174","0.66245645","0.6571833","0.65565145","0.6531953","0.65159637","0.65159637","0.63531405","0.63480484","0.6346194","0.63422894","0.6338405","0.6206076","0.6201802","0.61647004","0.6138878","0.6114829","0.6110501","0.607757","0.606464","0.6062506","0.6049124","0.6045489","0.6043145","0.60163194","0.59829843","0.596722","0.59245324","0.5913982","0.5896134","0.5894679","0.5883988","0.58614016","0.5856016","0.5854485","0.5844795","0.5837465","0.5818316","0.5818316","0.5818316","0.5818316","0.5818316","0.5818316","0.5818316","0.5818316","0.579716","0.578047","0.57494986","0.5732151","0.5731532","0.56930685","0.56852514","0.56823486","0.56694126","0.56616855","0.5661386","0.5661386","0.5652055","0.5633894","0.5630301","0.5627069","0.5619128","0.5612208","0.5608372","0.5608372","0.5606679","0.56013924","0.55877036","0.5581932","0.5575905","0.5567561","0.55492115","0.55460936","0.5538606","0.55343205","0.5532295","0.5530507","0.5527145","0.5518256","0.55161875","0.55085915","0.55074984","0.55035454","0.5494943","0.5487626","0.5485139","0.54828024","0.54757017","0.54757017","0.54757017","0.54757017","0.5463053","0.54629076","0.54557675","0.5442418"],"string":"[\n \"0.7076997\",\n \"0.6851174\",\n \"0.66245645\",\n \"0.6571833\",\n \"0.65565145\",\n \"0.6531953\",\n \"0.65159637\",\n \"0.65159637\",\n \"0.63531405\",\n \"0.63480484\",\n \"0.6346194\",\n \"0.63422894\",\n \"0.6338405\",\n \"0.6206076\",\n \"0.6201802\",\n \"0.61647004\",\n \"0.6138878\",\n \"0.6114829\",\n \"0.6110501\",\n \"0.607757\",\n \"0.606464\",\n \"0.6062506\",\n \"0.6049124\",\n \"0.6045489\",\n \"0.6043145\",\n \"0.60163194\",\n \"0.59829843\",\n \"0.596722\",\n \"0.59245324\",\n \"0.5913982\",\n \"0.5896134\",\n \"0.5894679\",\n \"0.5883988\",\n \"0.58614016\",\n \"0.5856016\",\n \"0.5854485\",\n \"0.5844795\",\n \"0.5837465\",\n \"0.5818316\",\n \"0.5818316\",\n \"0.5818316\",\n \"0.5818316\",\n \"0.5818316\",\n \"0.5818316\",\n \"0.5818316\",\n \"0.5818316\",\n \"0.579716\",\n \"0.578047\",\n \"0.57494986\",\n \"0.5732151\",\n \"0.5731532\",\n \"0.56930685\",\n \"0.56852514\",\n \"0.56823486\",\n \"0.56694126\",\n \"0.56616855\",\n \"0.5661386\",\n \"0.5661386\",\n \"0.5652055\",\n \"0.5633894\",\n \"0.5630301\",\n \"0.5627069\",\n \"0.5619128\",\n \"0.5612208\",\n \"0.5608372\",\n \"0.5608372\",\n \"0.5606679\",\n \"0.56013924\",\n \"0.55877036\",\n \"0.5581932\",\n \"0.5575905\",\n \"0.5567561\",\n \"0.55492115\",\n \"0.55460936\",\n \"0.5538606\",\n \"0.55343205\",\n \"0.5532295\",\n \"0.5530507\",\n \"0.5527145\",\n \"0.5518256\",\n \"0.55161875\",\n \"0.55085915\",\n \"0.55074984\",\n \"0.55035454\",\n \"0.5494943\",\n \"0.5487626\",\n \"0.5485139\",\n \"0.54828024\",\n \"0.54757017\",\n \"0.54757017\",\n \"0.54757017\",\n \"0.54757017\",\n \"0.5463053\",\n \"0.54629076\",\n \"0.54557675\",\n \"0.5442418\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61608136"},"document_rank":{"kind":"string","value":"20"}}},{"rowIdx":76579,"cells":{"query":{"kind":"string","value":"Sets the start of this GIFOutput. What second of the storyboard timeline to start the GIF."},"document":{"kind":"string","value":"def start(self, start):\n if start is None:\n raise ValueError(\"Invalid value for `start`, must not be `None`\")\n\n self._start = start"},"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 start(self, start):\n\n self._start = start","def start(self, start):\n\n self._start = start","def start(self, start):\n\n self._start = start","def start(self, start):\n\n self._start = start","def start(self):\n\t\tif self._start is not None:\n\t\t\traise RuntimeError('Animations can only be run once')\n\t\tself._start = 1\t\n\t\t# start time\n\t\tif not self._startticks:\n\t\t\tself._startticks = _pg.time.get_ticks()\n\t\tfor anim in self.animations:\n\t\t\tanim._startticks = self._startticks\n\t\t\tanim.start()\n\t\t# get updated\n\t\t_running.append(self)\n\t\t_anim_started(self)","def start(self):\n\t\tif self._start is not None:\n\t\t\traise RuntimeError('Animations can only be run once')\n\t\tself._start = 1\t\n\t\t# start time\n\t\tstartticks = self._startticks if self.startticks else _pg.time.get_ticks()\n\t\tfor anim in self.animations:\n\t\t\tanim._startticks = startticks\n\t\t\tanim.start()\n\t\t\tstartticks += anim.duration\n\t\t# get updated\n\t\t_running.append(self)\n\t\t_anim_started(self)","def setStartTime(self, *args):\n return _osgAnimation.Animation_setStartTime(self, *args)","def start(self):\n\t\tif self._start is not None:\n\t\t\traise RuntimeError('Animations can only be run once')\n\t\t# initial state of all attributes\n\t\tself._start = dict()\t\n\t\tfor attr in self._end:\n\t\t\tsep = attr.split('__')\n\t\t\tsubtarget, subattr = eval('.'.join(['self.target']+sep[:-1])), sep[-1]\n\t\t\tself._start[attr] = getattr(subtarget, subattr)\n\t\t# start time\n\t\tif not self._startticks:\n\t\t\tself._startticks = _pg.time.get_ticks()\n\t\t# get updated\n\t\t_running.append(self)\n\t\t_anim_started(self)","def start(self, start: pos.Pos) -> None:\n self.__start = start","def start(self, max=None):\n self._start_time = time.time()\n self._step = 0\n self._percent = 0.0\n\n if max is not None:\n self._set_max_steps(max)\n\n self.display()","def start(self):\n self._state = 'Started'","def set_to_start(self) -> None:\n start_config = self._path_points[0]\n self._mobile.set_2d_pose(start_config[:3])\n self._path_done = False","def set_start(self, start_line):\n self.__start_line = start_line","def start(self):\n self.start_time = time.time()","def start(self):\n self.timeStart = pygame.time.get_ticks()","def setStart(self, *args):\n return _libsbml.LineSegment_setStart(self, *args)","def Start(self): # this is used to start the object\n ani = anim.FuncAnimation(self.f, self.animate, interval=1000)\n # animating object wth 1 sec gap\n self.plt_0.tight_layout()\n self.plt_0.show()\n # showing the plot","def start_time(self, start_time):\n self._start_time = start_time","def start_time(self, start_time):\n self._start_time = start_time","def start_animation(self) -> None:\n increment_values = {0: 1, self.original_height: -1}\n self.increment = increment_values.get(self.current_height, 0) # Compressed if","def set_start_position(self) -> None:\n self.cozmo.set_head_angle(degrees(0)).wait_for_completed()\n self.cozmo.set_lift_height(0.0).wait_for_completed()","def start_animation(self):\n\t\ttime.sleep(1)\n\t\tself.fishbowl.animate_balls()","def start_time(self, start_time):\n\n self._start_time = start_time","def start_time(self, start_time):\n\n self._start_time = start_time","def start_time(self, start_time):\n\n self._start_time = start_time","def start_time(self, start_time):\n\n self._start_time = start_time","def start_time(self, start_time):\n\n self._start_time = start_time","def start(self):\r\n self.start_time = time.time()","def start(self):\n if self._start_time:\n raise StartException()\n\n if self._title:\n sys.stdout.write(f'\\n{self._title}:\\n')\n\n self._start_time = datetime.datetime.utcnow()\n self._print(0, self._start_time)","def beginning_image_number(self, beginning_image_number):\n\n self._beginning_image_number = beginning_image_number","def beginning_image_number(self, beginning_image_number):\n\n self._beginning_image_number = beginning_image_number","def start_animation(self, initial_delay=True):\n if self._run_animation:\n # Animation already scheduled.\n return\n self._run_animation = True\n self._animation_task = self._scheduler.schedule(\n self._toggle_blink, delay_ms=self._update_interval_ms)","def start(self):\n self.reset()\n self.on_start()","def start_frame(self):\n\n # Check whether we're supposed to make a frame on this iteration:\n if self.frame_count % self.stride != 0:\n return\n\n # Check whether we're already making a frame. \n if self.in_scope:\n print(\"The Gif object for {} has encountered 'start_frame' twice\\\n without an intervening 'end_frame'\".format(self.filename))\n raise SyntaxError\n\n # Construct a new figure\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\n self.current_frame = fig\n\n # Set the \"in_scope\" member True\n self.in_scope = True\n\n return self.current_frame","def set_start_time():\n __start = current_time_milli()","def _set_start(self, coordinates):\n self._start = coordinates","def start_time(self, value):\n self._start_time = value","def start(self):\n super(ProgressBar, self).start()\n self.display()","def startNextAnim(self):\n self.notify.debug(\"startNextAnim self.okToStartNextAnim=%s\" % self.okToStartNextAnim)\n #import pdb; pdb.set_trace()\n self.curIval = None\n if self.okToStartNextAnim:\n self.notify.debug(\"got pass okToStartNextAnim\")\n whichAnim = self.chooseAnimToRun()\n self.notify.debug(\"whichAnim=%s\" % whichAnim)\n self.lastPlayingAnimPhase = whichAnim # merely for debugging\n self.curIval = self.createAnimSequence(whichAnim)\n self.notify.debug(\"starting curIval of length %s\" % self.curIval.getDuration())\n self.curIval.start()\n else:\n self.notify.debug(\"false self.okToStartNextAnim=%s\" %self.okToStartNextAnim)","def start(self):\n\t\tself._start = time.clock()\n\t\tif self._initial is None:\n\t\t\tself._initial = self._start\n\t\treturn self","def start(text=\"\"):\n global _current_line\n _current_line = StatusLine(text, WIDTH)","def start_timer(self):\n self.start_time = time.time()","def on_start(self):\n self.state = STARTED","def start(self):\n# if self._start_time is not None:\n self._start_time = time.perf_counter()","def start_timer(self):\n self.start_time = datetime.now()","def start_playing(self, mouse):\n self.start = True","def start(self, start):\n if start is None:\n raise ValueError(\"Invalid value for `start`, must not be `None`\") # noqa: E501\n\n self._start = start","def start_progress_bar(self):\r\n self.progress[\"value\"] = self.progress_step","def start(self) -> int:\n return self._start","def start(self) -> int:\n return self._start","def start_sim(self):\n self.anim = animation.FuncAnimation(self.fig, self.anim_func, frames = self.timesteps, interval = 1, blit=True)\n plt.show()","def go_to_start(self):\n self.go_to(0)","def start(self):\n self.timer.start(500)","def enter(self):\n\n self.im = Image.open(self.filename)\n\n self.frame = 0\n self.timedelta = TimeDelta().reset()\n\n self._load_frame(self.frame)\n self.dur = self._get_duration()\n\n self.is_playing = True","def set_start( self , name ):\n self.startState = name.upper()","def animate_starter(self, **kwargs):\n interval = 5 # this number works fine, but is rather arbirtary, presumably in milliseconds\n print(\"The timer length is \" + str(len(self.sy.short_timer)))\n print(\"Shape of coordinate_grid is \" + str(np.shape(self.sy.coordinate_grid)))\n print(\"The animator interval was \" + str(interval) + \" in unknown units\")\n # I don't currently understand why the galaxy chooses\n # to slow down mid way through.\n # Perhaps I should look at the FuncAnimation\n # dictionary and work out what has gone wrong.\n with plt.style.context((\"dark_background\")):\n ani = animation.FuncAnimation(\n self.fig,\n self.animate,\n frames=len(self.sy.short_timer),\n interval=interval,\n blit=True,\n init_func=self.ani_init,\n )\n ani.save(\n str(self.co.out)\n + \"/\"\n + str(self.name)\n + \"move_with_\"\n + str(self.move_with)\n + \".mp4\",\n writer=writer,\n )\n plt.clf() # always make sure you close the lid","def mark_start_point(self):\n\n GiraffeLayer.endpoints.set_current()\n rs.AddPoint(self.get_point_on(0.1))","def start(self):\n raise NotImplementedError(\"(%s).start\" % self)","def start(self):\n self._state = STATE_INACTIVE\n self._game = None\n self._last_key_press = False\n self._last_n_press = False\n self._last_lose_life = False\n self._mssg = (GLabel(text=START_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2, font_size=24))\n self.time = None\n self._points_mssg = None\n self._falling_points = []\n self._FP_mssg = None","def start(self):\n if self.debug:\n print(\"%s start\" % self.name)","def start(self):\n assert not self.state is CallState.finished\n\n self.state = CallState.started\n self.start_time = time()","def set_start(self, name):\n self.start_state = name.upper()","def start(self):\n self.ids.camera.opacity = 1\n self.ids.camera.play = True\n self.ids.start.text = 'Stop Camera'\n self.ids.camera.texture = self.ids.camera._camera.texture","def Play(self):\n\t\tself.present_frame = 0\n\t\t\n\t\tself.frames[self.present_frame].Draw()\n\t\t\n\t\tanimation_master.Register(self)","def start_sco(self, start_sco):\n\n self._start_sco = start_sco","def SetAnimationStep(self, step):\r\n\r\n self._animation_step = float(step)","def set_startline(self, line_no):\n self.set_attribute(\"startline\", line_no)","def startRep(self, rep):\n \n pass","def start_transition(self, next=None):\n if next is not None:\n self._playlist.set_next_preset_by_name(next)\n\n self._in_transition = True\n self._start_transition = True\n self._elapsed = 0.0\n self.transition_starting.emit()","def start(self):\n return self.__start","def start(self, duration=None):\n if duration is None:\n duration = self.duration\n\n self.set(duration)","def start(self):\n for i in xrange(self.num_pulses):\n self.fillColor = \"white\"\n for j in xrange(self.num_frames_on):\n self.draw()\n self.win.flip()\n if j == 0:\n # Only store the time of the first occuring on frame.\n self.utc_timestamps.append(datetime.strftime(datetime.utcnow(), '%Y-%m-%dT%H:%M:%S.%fZ'))\n self.fillColor = \"black\"\n for j in xrange(self.num_frames_off):\n self.draw()\n self.win.flip()","def set_start_time(self, *args, **kwargs):\n return _uhd_swig.usrp_source_set_start_time(self, *args, **kwargs)","def _start_clock(self):\n self._start = time.time()","def start(self, x, y):\n self.last_x = x\n self.last_y = y\n self.aperture_id = None","def initial_segment(self, initial_segment):\n\n self._initial_segment = initial_segment","def start(self):\n if not self._is_running:\n self._pos_thread = Timer(self.draw_intvl, self._run)\n self._pos_thread.start()\n self._is_running = True","def start(self,startState=None):\n if not startState or not (startState in [x[0] for x in self._states]):\n raise ValueError(\"Not a valid start state\")\n self.currentState = startState","def start(self,startState=None):\n if not startState or not (startState in [x[0] for x in self._states]):\n raise ValueError(\"Not a valid start state\")\n self.currentState = startState","def start(self):\n self.events[0].record()\n self.cur = 1","def start(self):\n\t\treturn self._start","def move_to_start(self):\n self.pos = (SCREEN_WIDTH / 2, SCREEN_HEIGHT - 64)","def FrameStart(builder):\n return Start(builder)","def epoch_start(self, epoch):\n self.epoch = epoch","def StartTimer(self):\n self._start_time = time.time()","def start(self):\n self.setup_initializer()\n self.setup_fader()\n self.fade_out_duration = 1.2","def start(self) -> None:\n logger.log(self.log_level, f'Start {self.name}...')\n self.started = True\n super().start()","def start(self):\n return self._start","def start(self):\n return self._start","def start(self):\n return self._start","def start(self):\n return self._start","def start(self):\n return self._start","def start(self, is_processing):\n self.is_processing = True\n LOGGER.info(\"Starting hyperlapse \\n \"\n \"time step = {0} [s] \\n\"\n \"spatial step = {1} [mm] \\n\"\n \"#pictures total = {2}\".format(self.time_step, self.spatial_step, self.nb_picture_total))\n delay = self.time_step/2.0\n for image_idx in range(self.nb_picture_total):\n if is_processing():\n LOGGER.info(\"Capturing image #{0}/{1}\".format(image_idx+1, self.nb_picture_total))\n self.curr_picture_idx = image_idx\n self.camera.snap()\n time.sleep(delay)\n self.slider.translate_forward()\n time.sleep(delay)\n else:\n LOGGER.info(\"Hyperlapse interrupted!\")\n break\n self.stop()","def set_start_time(self, *args, **kwargs):\n return _uhd_swig.usrp_source_sptr_set_start_time(self, *args, **kwargs)","def begin_auto_resting(self):\n self.state = 'autoresting'\n self.index = 1\n self.x_vel = self.y_vel = 0\n self.move_timer = self.current_time","def event11510220():\n header(11510220, 0)\n anim.force_animation(1511050, 0)","def start(self):\n return self.start_","def start(self):\n self.gripper_io.set_signal_value(\"go\", True)","def start(self):\n\n self.top.after(15, self.video_loop)","def start(self):\n self._call = LoopingCall.withCount(self._update)\n self._call.clock = reactor\n self._call.start(1.0 / self.framerate, now=False)\n self._running = True"],"string":"[\n \"def start(self, start):\\n\\n self._start = start\",\n \"def start(self, start):\\n\\n self._start = start\",\n \"def start(self, start):\\n\\n self._start = start\",\n \"def start(self, start):\\n\\n self._start = start\",\n \"def start(self):\\n\\t\\tif self._start is not None:\\n\\t\\t\\traise RuntimeError('Animations can only be run once')\\n\\t\\tself._start = 1\\t\\n\\t\\t# start time\\n\\t\\tif not self._startticks:\\n\\t\\t\\tself._startticks = _pg.time.get_ticks()\\n\\t\\tfor anim in self.animations:\\n\\t\\t\\tanim._startticks = self._startticks\\n\\t\\t\\tanim.start()\\n\\t\\t# get updated\\n\\t\\t_running.append(self)\\n\\t\\t_anim_started(self)\",\n \"def start(self):\\n\\t\\tif self._start is not None:\\n\\t\\t\\traise RuntimeError('Animations can only be run once')\\n\\t\\tself._start = 1\\t\\n\\t\\t# start time\\n\\t\\tstartticks = self._startticks if self.startticks else _pg.time.get_ticks()\\n\\t\\tfor anim in self.animations:\\n\\t\\t\\tanim._startticks = startticks\\n\\t\\t\\tanim.start()\\n\\t\\t\\tstartticks += anim.duration\\n\\t\\t# get updated\\n\\t\\t_running.append(self)\\n\\t\\t_anim_started(self)\",\n \"def setStartTime(self, *args):\\n return _osgAnimation.Animation_setStartTime(self, *args)\",\n \"def start(self):\\n\\t\\tif self._start is not None:\\n\\t\\t\\traise RuntimeError('Animations can only be run once')\\n\\t\\t# initial state of all attributes\\n\\t\\tself._start = dict()\\t\\n\\t\\tfor attr in self._end:\\n\\t\\t\\tsep = attr.split('__')\\n\\t\\t\\tsubtarget, subattr = eval('.'.join(['self.target']+sep[:-1])), sep[-1]\\n\\t\\t\\tself._start[attr] = getattr(subtarget, subattr)\\n\\t\\t# start time\\n\\t\\tif not self._startticks:\\n\\t\\t\\tself._startticks = _pg.time.get_ticks()\\n\\t\\t# get updated\\n\\t\\t_running.append(self)\\n\\t\\t_anim_started(self)\",\n \"def start(self, start: pos.Pos) -> None:\\n self.__start = start\",\n \"def start(self, max=None):\\n self._start_time = time.time()\\n self._step = 0\\n self._percent = 0.0\\n\\n if max is not None:\\n self._set_max_steps(max)\\n\\n self.display()\",\n \"def start(self):\\n self._state = 'Started'\",\n \"def set_to_start(self) -> None:\\n start_config = self._path_points[0]\\n self._mobile.set_2d_pose(start_config[:3])\\n self._path_done = False\",\n \"def set_start(self, start_line):\\n self.__start_line = start_line\",\n \"def start(self):\\n self.start_time = time.time()\",\n \"def start(self):\\n self.timeStart = pygame.time.get_ticks()\",\n \"def setStart(self, *args):\\n return _libsbml.LineSegment_setStart(self, *args)\",\n \"def Start(self): # this is used to start the object\\n ani = anim.FuncAnimation(self.f, self.animate, interval=1000)\\n # animating object wth 1 sec gap\\n self.plt_0.tight_layout()\\n self.plt_0.show()\\n # showing the plot\",\n \"def start_time(self, start_time):\\n self._start_time = start_time\",\n \"def start_time(self, start_time):\\n self._start_time = start_time\",\n \"def start_animation(self) -> None:\\n increment_values = {0: 1, self.original_height: -1}\\n self.increment = increment_values.get(self.current_height, 0) # Compressed if\",\n \"def set_start_position(self) -> None:\\n self.cozmo.set_head_angle(degrees(0)).wait_for_completed()\\n self.cozmo.set_lift_height(0.0).wait_for_completed()\",\n \"def start_animation(self):\\n\\t\\ttime.sleep(1)\\n\\t\\tself.fishbowl.animate_balls()\",\n \"def start_time(self, start_time):\\n\\n self._start_time = start_time\",\n \"def start_time(self, start_time):\\n\\n self._start_time = start_time\",\n \"def start_time(self, start_time):\\n\\n self._start_time = start_time\",\n \"def start_time(self, start_time):\\n\\n self._start_time = start_time\",\n \"def start_time(self, start_time):\\n\\n self._start_time = start_time\",\n \"def start(self):\\r\\n self.start_time = time.time()\",\n \"def start(self):\\n if self._start_time:\\n raise StartException()\\n\\n if self._title:\\n sys.stdout.write(f'\\\\n{self._title}:\\\\n')\\n\\n self._start_time = datetime.datetime.utcnow()\\n self._print(0, self._start_time)\",\n \"def beginning_image_number(self, beginning_image_number):\\n\\n self._beginning_image_number = beginning_image_number\",\n \"def beginning_image_number(self, beginning_image_number):\\n\\n self._beginning_image_number = beginning_image_number\",\n \"def start_animation(self, initial_delay=True):\\n if self._run_animation:\\n # Animation already scheduled.\\n return\\n self._run_animation = True\\n self._animation_task = self._scheduler.schedule(\\n self._toggle_blink, delay_ms=self._update_interval_ms)\",\n \"def start(self):\\n self.reset()\\n self.on_start()\",\n \"def start_frame(self):\\n\\n # Check whether we're supposed to make a frame on this iteration:\\n if self.frame_count % self.stride != 0:\\n return\\n\\n # Check whether we're already making a frame. \\n if self.in_scope:\\n print(\\\"The Gif object for {} has encountered 'start_frame' twice\\\\\\n without an intervening 'end_frame'\\\".format(self.filename))\\n raise SyntaxError\\n\\n # Construct a new figure\\n fig = plt.figure(figsize=(self.width,self.height), **(self.kwargs))\\n self.current_frame = fig\\n\\n # Set the \\\"in_scope\\\" member True\\n self.in_scope = True\\n\\n return self.current_frame\",\n \"def set_start_time():\\n __start = current_time_milli()\",\n \"def _set_start(self, coordinates):\\n self._start = coordinates\",\n \"def start_time(self, value):\\n self._start_time = value\",\n \"def start(self):\\n super(ProgressBar, self).start()\\n self.display()\",\n \"def startNextAnim(self):\\n self.notify.debug(\\\"startNextAnim self.okToStartNextAnim=%s\\\" % self.okToStartNextAnim)\\n #import pdb; pdb.set_trace()\\n self.curIval = None\\n if self.okToStartNextAnim:\\n self.notify.debug(\\\"got pass okToStartNextAnim\\\")\\n whichAnim = self.chooseAnimToRun()\\n self.notify.debug(\\\"whichAnim=%s\\\" % whichAnim)\\n self.lastPlayingAnimPhase = whichAnim # merely for debugging\\n self.curIval = self.createAnimSequence(whichAnim)\\n self.notify.debug(\\\"starting curIval of length %s\\\" % self.curIval.getDuration())\\n self.curIval.start()\\n else:\\n self.notify.debug(\\\"false self.okToStartNextAnim=%s\\\" %self.okToStartNextAnim)\",\n \"def start(self):\\n\\t\\tself._start = time.clock()\\n\\t\\tif self._initial is None:\\n\\t\\t\\tself._initial = self._start\\n\\t\\treturn self\",\n \"def start(text=\\\"\\\"):\\n global _current_line\\n _current_line = StatusLine(text, WIDTH)\",\n \"def start_timer(self):\\n self.start_time = time.time()\",\n \"def on_start(self):\\n self.state = STARTED\",\n \"def start(self):\\n# if self._start_time is not None:\\n self._start_time = time.perf_counter()\",\n \"def start_timer(self):\\n self.start_time = datetime.now()\",\n \"def start_playing(self, mouse):\\n self.start = True\",\n \"def start(self, start):\\n if start is None:\\n raise ValueError(\\\"Invalid value for `start`, must not be `None`\\\") # noqa: E501\\n\\n self._start = start\",\n \"def start_progress_bar(self):\\r\\n self.progress[\\\"value\\\"] = self.progress_step\",\n \"def start(self) -> int:\\n return self._start\",\n \"def start(self) -> int:\\n return self._start\",\n \"def start_sim(self):\\n self.anim = animation.FuncAnimation(self.fig, self.anim_func, frames = self.timesteps, interval = 1, blit=True)\\n plt.show()\",\n \"def go_to_start(self):\\n self.go_to(0)\",\n \"def start(self):\\n self.timer.start(500)\",\n \"def enter(self):\\n\\n self.im = Image.open(self.filename)\\n\\n self.frame = 0\\n self.timedelta = TimeDelta().reset()\\n\\n self._load_frame(self.frame)\\n self.dur = self._get_duration()\\n\\n self.is_playing = True\",\n \"def set_start( self , name ):\\n self.startState = name.upper()\",\n \"def animate_starter(self, **kwargs):\\n interval = 5 # this number works fine, but is rather arbirtary, presumably in milliseconds\\n print(\\\"The timer length is \\\" + str(len(self.sy.short_timer)))\\n print(\\\"Shape of coordinate_grid is \\\" + str(np.shape(self.sy.coordinate_grid)))\\n print(\\\"The animator interval was \\\" + str(interval) + \\\" in unknown units\\\")\\n # I don't currently understand why the galaxy chooses\\n # to slow down mid way through.\\n # Perhaps I should look at the FuncAnimation\\n # dictionary and work out what has gone wrong.\\n with plt.style.context((\\\"dark_background\\\")):\\n ani = animation.FuncAnimation(\\n self.fig,\\n self.animate,\\n frames=len(self.sy.short_timer),\\n interval=interval,\\n blit=True,\\n init_func=self.ani_init,\\n )\\n ani.save(\\n str(self.co.out)\\n + \\\"/\\\"\\n + str(self.name)\\n + \\\"move_with_\\\"\\n + str(self.move_with)\\n + \\\".mp4\\\",\\n writer=writer,\\n )\\n plt.clf() # always make sure you close the lid\",\n \"def mark_start_point(self):\\n\\n GiraffeLayer.endpoints.set_current()\\n rs.AddPoint(self.get_point_on(0.1))\",\n \"def start(self):\\n raise NotImplementedError(\\\"(%s).start\\\" % self)\",\n \"def start(self):\\n self._state = STATE_INACTIVE\\n self._game = None\\n self._last_key_press = False\\n self._last_n_press = False\\n self._last_lose_life = False\\n self._mssg = (GLabel(text=START_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2, font_size=24))\\n self.time = None\\n self._points_mssg = None\\n self._falling_points = []\\n self._FP_mssg = None\",\n \"def start(self):\\n if self.debug:\\n print(\\\"%s start\\\" % self.name)\",\n \"def start(self):\\n assert not self.state is CallState.finished\\n\\n self.state = CallState.started\\n self.start_time = time()\",\n \"def set_start(self, name):\\n self.start_state = name.upper()\",\n \"def start(self):\\n self.ids.camera.opacity = 1\\n self.ids.camera.play = True\\n self.ids.start.text = 'Stop Camera'\\n self.ids.camera.texture = self.ids.camera._camera.texture\",\n \"def Play(self):\\n\\t\\tself.present_frame = 0\\n\\t\\t\\n\\t\\tself.frames[self.present_frame].Draw()\\n\\t\\t\\n\\t\\tanimation_master.Register(self)\",\n \"def start_sco(self, start_sco):\\n\\n self._start_sco = start_sco\",\n \"def SetAnimationStep(self, step):\\r\\n\\r\\n self._animation_step = float(step)\",\n \"def set_startline(self, line_no):\\n self.set_attribute(\\\"startline\\\", line_no)\",\n \"def startRep(self, rep):\\n \\n pass\",\n \"def start_transition(self, next=None):\\n if next is not None:\\n self._playlist.set_next_preset_by_name(next)\\n\\n self._in_transition = True\\n self._start_transition = True\\n self._elapsed = 0.0\\n self.transition_starting.emit()\",\n \"def start(self):\\n return self.__start\",\n \"def start(self, duration=None):\\n if duration is None:\\n duration = self.duration\\n\\n self.set(duration)\",\n \"def start(self):\\n for i in xrange(self.num_pulses):\\n self.fillColor = \\\"white\\\"\\n for j in xrange(self.num_frames_on):\\n self.draw()\\n self.win.flip()\\n if j == 0:\\n # Only store the time of the first occuring on frame.\\n self.utc_timestamps.append(datetime.strftime(datetime.utcnow(), '%Y-%m-%dT%H:%M:%S.%fZ'))\\n self.fillColor = \\\"black\\\"\\n for j in xrange(self.num_frames_off):\\n self.draw()\\n self.win.flip()\",\n \"def set_start_time(self, *args, **kwargs):\\n return _uhd_swig.usrp_source_set_start_time(self, *args, **kwargs)\",\n \"def _start_clock(self):\\n self._start = time.time()\",\n \"def start(self, x, y):\\n self.last_x = x\\n self.last_y = y\\n self.aperture_id = None\",\n \"def initial_segment(self, initial_segment):\\n\\n self._initial_segment = initial_segment\",\n \"def start(self):\\n if not self._is_running:\\n self._pos_thread = Timer(self.draw_intvl, self._run)\\n self._pos_thread.start()\\n self._is_running = True\",\n \"def start(self,startState=None):\\n if not startState or not (startState in [x[0] for x in self._states]):\\n raise ValueError(\\\"Not a valid start state\\\")\\n self.currentState = startState\",\n \"def start(self,startState=None):\\n if not startState or not (startState in [x[0] for x in self._states]):\\n raise ValueError(\\\"Not a valid start state\\\")\\n self.currentState = startState\",\n \"def start(self):\\n self.events[0].record()\\n self.cur = 1\",\n \"def start(self):\\n\\t\\treturn self._start\",\n \"def move_to_start(self):\\n self.pos = (SCREEN_WIDTH / 2, SCREEN_HEIGHT - 64)\",\n \"def FrameStart(builder):\\n return Start(builder)\",\n \"def epoch_start(self, epoch):\\n self.epoch = epoch\",\n \"def StartTimer(self):\\n self._start_time = time.time()\",\n \"def start(self):\\n self.setup_initializer()\\n self.setup_fader()\\n self.fade_out_duration = 1.2\",\n \"def start(self) -> None:\\n logger.log(self.log_level, f'Start {self.name}...')\\n self.started = True\\n super().start()\",\n \"def start(self):\\n return self._start\",\n \"def start(self):\\n return self._start\",\n \"def start(self):\\n return self._start\",\n \"def start(self):\\n return self._start\",\n \"def start(self):\\n return self._start\",\n \"def start(self, is_processing):\\n self.is_processing = True\\n LOGGER.info(\\\"Starting hyperlapse \\\\n \\\"\\n \\\"time step = {0} [s] \\\\n\\\"\\n \\\"spatial step = {1} [mm] \\\\n\\\"\\n \\\"#pictures total = {2}\\\".format(self.time_step, self.spatial_step, self.nb_picture_total))\\n delay = self.time_step/2.0\\n for image_idx in range(self.nb_picture_total):\\n if is_processing():\\n LOGGER.info(\\\"Capturing image #{0}/{1}\\\".format(image_idx+1, self.nb_picture_total))\\n self.curr_picture_idx = image_idx\\n self.camera.snap()\\n time.sleep(delay)\\n self.slider.translate_forward()\\n time.sleep(delay)\\n else:\\n LOGGER.info(\\\"Hyperlapse interrupted!\\\")\\n break\\n self.stop()\",\n \"def set_start_time(self, *args, **kwargs):\\n return _uhd_swig.usrp_source_sptr_set_start_time(self, *args, **kwargs)\",\n \"def begin_auto_resting(self):\\n self.state = 'autoresting'\\n self.index = 1\\n self.x_vel = self.y_vel = 0\\n self.move_timer = self.current_time\",\n \"def event11510220():\\n header(11510220, 0)\\n anim.force_animation(1511050, 0)\",\n \"def start(self):\\n return self.start_\",\n \"def start(self):\\n self.gripper_io.set_signal_value(\\\"go\\\", True)\",\n \"def start(self):\\n\\n self.top.after(15, self.video_loop)\",\n \"def start(self):\\n self._call = LoopingCall.withCount(self._update)\\n self._call.clock = reactor\\n self._call.start(1.0 / self.framerate, now=False)\\n self._running = True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6723576","0.6723576","0.6723576","0.6723576","0.6678015","0.665719","0.6505287","0.6384998","0.6332083","0.62387615","0.62376267","0.62024736","0.6184223","0.6178705","0.60933346","0.60816824","0.60661453","0.5995193","0.5995193","0.59945655","0.5989577","0.59696126","0.5946503","0.5946503","0.5946503","0.5946503","0.5946503","0.5886499","0.5872577","0.587239","0.587239","0.58572656","0.58094174","0.58036864","0.57992804","0.5794064","0.5783285","0.57752603","0.5765411","0.57598746","0.5742217","0.57293403","0.57095474","0.568711","0.5673844","0.5665424","0.56449974","0.56442875","0.5643588","0.5643588","0.56285775","0.5616784","0.56098104","0.56038254","0.5593772","0.5584513","0.5571283","0.5561231","0.55463606","0.5542525","0.554207","0.5539585","0.55334276","0.55247104","0.552265","0.5517339","0.55171853","0.55071414","0.54963964","0.5486878","0.54788923","0.54780954","0.54675704","0.5456918","0.5456202","0.5439035","0.5434854","0.5432873","0.5432873","0.54043424","0.5394658","0.5389423","0.5382237","0.5376178","0.5375535","0.5371208","0.5370094","0.53695387","0.53695387","0.53695387","0.53695387","0.53695387","0.5360153","0.5357976","0.53521734","0.5344808","0.53388494","0.5337278","0.5330004","0.5324847"],"string":"[\n \"0.6723576\",\n \"0.6723576\",\n \"0.6723576\",\n \"0.6723576\",\n \"0.6678015\",\n \"0.665719\",\n \"0.6505287\",\n \"0.6384998\",\n \"0.6332083\",\n \"0.62387615\",\n \"0.62376267\",\n \"0.62024736\",\n \"0.6184223\",\n \"0.6178705\",\n \"0.60933346\",\n \"0.60816824\",\n \"0.60661453\",\n \"0.5995193\",\n \"0.5995193\",\n \"0.59945655\",\n \"0.5989577\",\n \"0.59696126\",\n \"0.5946503\",\n \"0.5946503\",\n \"0.5946503\",\n \"0.5946503\",\n \"0.5946503\",\n \"0.5886499\",\n \"0.5872577\",\n \"0.587239\",\n \"0.587239\",\n \"0.58572656\",\n \"0.58094174\",\n \"0.58036864\",\n \"0.57992804\",\n \"0.5794064\",\n \"0.5783285\",\n \"0.57752603\",\n \"0.5765411\",\n \"0.57598746\",\n \"0.5742217\",\n \"0.57293403\",\n \"0.57095474\",\n \"0.568711\",\n \"0.5673844\",\n \"0.5665424\",\n \"0.56449974\",\n \"0.56442875\",\n \"0.5643588\",\n \"0.5643588\",\n \"0.56285775\",\n \"0.5616784\",\n \"0.56098104\",\n \"0.56038254\",\n \"0.5593772\",\n \"0.5584513\",\n \"0.5571283\",\n \"0.5561231\",\n \"0.55463606\",\n \"0.5542525\",\n \"0.554207\",\n \"0.5539585\",\n \"0.55334276\",\n \"0.55247104\",\n \"0.552265\",\n \"0.5517339\",\n \"0.55171853\",\n \"0.55071414\",\n \"0.54963964\",\n \"0.5486878\",\n \"0.54788923\",\n \"0.54780954\",\n \"0.54675704\",\n \"0.5456918\",\n \"0.5456202\",\n \"0.5439035\",\n \"0.5434854\",\n \"0.5432873\",\n \"0.5432873\",\n \"0.54043424\",\n \"0.5394658\",\n \"0.5389423\",\n \"0.5382237\",\n \"0.5376178\",\n \"0.5375535\",\n \"0.5371208\",\n \"0.5370094\",\n \"0.53695387\",\n \"0.53695387\",\n \"0.53695387\",\n \"0.53695387\",\n \"0.53695387\",\n \"0.5360153\",\n \"0.5357976\",\n \"0.53521734\",\n \"0.5344808\",\n \"0.53388494\",\n \"0.5337278\",\n \"0.5330004\",\n \"0.5324847\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60994416"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":76580,"cells":{"query":{"kind":"string","value":"Gets the duration of this GIFOutput. Seconds for the duration of the GIF. Can't be longer than the video."},"document":{"kind":"string","value":"def duration(self):\n return self._duration"},"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 duration():\r\n elapsed_time, duration = video_time()\r\n return duration","def video_duration(self):\n # type: () -> int\n return self._video_duration","def get_duration(self):\n frame_dur = self.get_frame_duration()\n num_frames = self.get_num_frames()\n motion_dur = frame_dur * (num_frames - 1)\n return motion_dur","def _get_duration(self):\n try:\n dur = self.im.info[\"duration\"] / 1000.0\n except KeyError:\n dur = DEFAULT_DURATION / 1000.0 \n\n return dur","def get_duration(self):\n return self.duration","def get_duration(self) -> int:\n return int( (self._frame_count / self._fps) * 1000 )","def get_duration(self):\n return self._duration","def duration(self):\n # type: () -> int\n return self._duration","def get_duration(self):\n duration_ns = self.stream.InitialTimeToWaitGet()\n duration_ns += self.stream.NumberOfFramesGet() * self.stream.InterFrameGapGet()\n return datetime.timedelta(seconds=duration_ns / 1e9)","def getDuration(self):\n return _osgAnimation.Animation_getDuration(self)","def getDuration(self):\n if self.getDot():\n return self.duration*1.5\n else:\n return self.duration","def duration(self):\n self.wait()\n return self._duration","def duration(self):\n return self.sound.nframes","def duration(self):\n return self._get('duration')","def media_duration(self):\n return self._media_duration","def duration(self) -> str:\n return pulumi.get(self, \"duration\")","def media_duration(self):\n if 'duration' in self._status:\n return int(float(self._status['duration']))","def duration(self):\n return self._get(\"duration\")","def media_duration(self):\n return self._state.get(\"duration\", None)","def duration_seconds(self):\n duration = 0.0\n if self.is_video() or self.is_audio():\n if self.__dict__['duration']:\n try:\n duration = float(self.__dict__['duration'])\n except ValueError:\n raise FFProbeError('None numeric duration')\n return duration","def duration(self) -> float:\n return self._stop - self._start if self._stop is not None else None","def get_frame_duration(self):\n return self._frame_duration","def duration(self) -> float:\n return self.delta_t * len(self)","def duration(self) -> float:\n return self.delta_t * len(self)","def duration(self):\n with audioread.audio_open(self.path) as f:\n return f.duration","def duration(self):\n return float('{0:.2f}'.format(self.end_time - self.start_time))","def get_duration(self):\n\n return self.endtime - self.starttime","def duration(self) -> datetime.timedelta:\n return self._duration","def duration_in_seconds(self):\n return self.get_data(\"duration_in_seconds\")","def getDuration(self):\n return _osgAnimation.Motion_getDuration(self)","def _duration(self):\n if getattr(self, '_duration_cache', None):\n return self._duration_cache\n duration = extractMetadata(guessParser(\\\n InputIOStream(self))).get('duration')\n if not duration:\n raise Exception(u'Not an audio file')\n else:\n duration = duration.seconds\n self._duration_cache = duration\n return duration","def get_duration(self):\n seconds = self.duration.total_seconds()\n mins, secs = divmod(seconds, 60)\n return int(mins), int(secs)","def duration(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"duration\")","def duration(self):\n return self.end_time - self.start_time","def duration(self):\n self._current_duration = time.perf_counter() - self._duration_start\n return round(self._current_duration, 4)","def get_duration(self):\n raise UnsupportedOperation('Duration not implemented')","def duration(self):\n\n ended = time.time() if self.ended is None else self.ended\n return ended - self.started","def duration(self) -> float:\n return self.endTime()-self.startTime()","def duration_in_seconds(self):\n \"Should not set track length\"\n return self.duration / float(self.samplerate)","def get_duration(self):\n return float(self.time.iloc[-1] - self.time.iloc[0])","def duration(self):\r\n return self.stop - self.start","def Duration(self):\n\t\treturn self._get_attribute('duration')","def duration(self):\n return self.end - self.start","def duration(self) -> Optional[str]:\n return pulumi.get(self, \"duration\")","def duration(self) -> Optional[str]:\n return pulumi.get(self, \"duration\")","def getDurationMs(self):\n return self.durationMs","def Duration(self):\r\n\t\treturn self._get_attribute('duration')","def duration(self):\n return self.end_abs - self.start","def duration(self):\n started = self.started_at\n finished = self.finished_at\n if started and finished:\n return str(finished - started)\n else:\n return None # can't compute yet","def duration(self):\n if hasattr(self, 'completed_on') and hasattr(self, 'started_on'):\n diff = (self.completed_on - self.started_on)\n minutes, seconds = divmod(diff.seconds, 60)\n return \"{:0>2d}m {:0>2d}s\".format(minutes, seconds)\n else:\n return None","def duration(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"duration\")","def duration(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"duration\")","def duration(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"duration\")","def duration(self):\n pass","def duration(self):\n pass","def duration(self):\r\n\t\treturn (self.globEnd - self.globStart)","def getDurationNoDot(self):\n return self.duration","def media_duration(self):\n if (self._playing_localfile or self._playing_spotify or self._slave_mode or self._playing_mediabrowser or self._playing_mass) and self._state != STATE_UNAVAILABLE:\n return self._duration\n else:\n return None","def duration(self) -> int:\n return 0","def run_duration(self) -> 'outputs.DurationResponse':\n return pulumi.get(self, \"run_duration\")","def duration(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"duration\")","def getDuration(self):\n return (self._get_int('duration'), self._attributes.getDivisions())","def duration(self):\n return self._end - self._begin","def duration(self) -> float:\n return float(len(self.__samples))/float(self.__rate)","def media_duration(self):\n # The lovelace app loops media to prevent timing out, don't show that\n if self.app_id == CAST_APP_ID_HOMEASSISTANT_LOVELACE:\n return None\n media_status = self._media_status()[0]\n return media_status.duration if media_status else None","def duration(self):\n return (self.fcip_doc[\"latest_timestamp\"] - self.fcip_doc[\"packet_timestamps\"][0])","def duration(self):\n self._duration = self.lib.iperf_get_test_duration(self._test)\n return self._duration","def duration(self):\n return total_seconds(self.timestamp - self.start_timestamp)","def duration(self):\r\n return (self.end_time or time.time()) - self.start_time","def frame_duration(self):\n return self.samples_per_frame / self.input_data_sample_rate","def get_duration(self):\n try:\n if self.is_skipped:\n return \"00:00\"\n assert self.start_time\n assert self.stop_time\n if self.stop_time < self.start_time:\n return \"XX:XX\"\n return(\n f\"{str(int(self.stop_time - self.start_time) // 60).zfill(2)}:\"\n f\"{str(int(self.stop_time - self.start_time) % 60).zfill(2)}\")\n\n except Exception: # pylint: disable=broad-except\n self.__logger.error(\"Please run test before getting the duration\")\n return \"XX:XX\"","def duration(self):\n if not self.started:\n return None\n start = self.started\n end = self.completed\n if not end:\n end = datetime.utcnow()\n return end - start","def media_duration(self):\n return self._table.active_track_total_time.total_seconds()","def duration(self)->int:\n return self._lic.params['maxDurationInSeconds'].value","def duration( self ):\n return (self.start and time.process_time()-self.start) or 0","def get_duration(self):\n duration = 0\n\n for entry in self.entries:\n duration += entry.get_duration()\n return duration","def duration_in_minutes(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"duration_in_minutes\")","def media_duration(self) -> int | None:\n if self._media_playback_trackable():\n return self.coordinator.data.nowplaying[\n self.zone.SourceID\n ].CurrSong.Duration\n return None","def get_duration(self):\n return (self.stop_day - self.start_day) * (24 * 60) \\\n + (self.stop_hour - self.start_hour) * 60","def GetDuration(self):\n return _gmat_py.LocatedEvent_GetDuration(self)","def duration_in_millis(self):\n return self._duration_in_millis","def duration_in_minutes(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"duration_in_minutes\")","def duration(self):\n if(float(self.data_version) < 1.1):\n return None\n\n if self.start_datetime and self.end_datetime:\n delta = self.start_datetime - self.end_datetime\n return int(abs(delta.total_seconds() - delta.total_seconds() % 60) / 60)\n\n s = self.starttime.split('.')\n e = self.endtime.split('.')\n # yyyy mm dd hh mm ss\n start = datetime.datetime(year=int(s[0]), month=int(s[1]), day=int(s[2]),\n hour=int(s[3]), minute=int(s[4]), second=int(s[5]))\n end = datetime.datetime(year=int(e[0]), month=int(e[1]), day=int(e[2]),\n hour=int(e[3]), minute=int(e[4]), second=int(e[5]))\n\n delta = start - end\n return int(abs((delta.total_seconds() - delta.total_seconds() % 60) / 60))","def image_sequence_duration(self):\n return self._image_sequence_duration","def duration_display(self):\n return self.duration_poster or self.duration","def duration(self):\n # duration is the difference between the midpoints\n value = self.__end.get_midpoint() - self.__begin.get_midpoint()\n\n # vagueness of the duration is based on begin/end radius values\n vagueness = 0\n if self.__begin.get_radius() is not None:\n vagueness += self.__begin.get_radius()\n if self.__end.get_radius() is not None:\n vagueness += self.__end.get_radius()\n\n return sppasDuration(value, vagueness)","def elapsed_time():\r\n elapsed_time, duration = video_time()\r\n return elapsed_time","def get_duration(self):\n return self.source_df.end_timestamp.astype(\"datetime64\") - self.source_df.start_timestamp.astype(\"datetime64\")","def get_duration(self):\n if self.is_running():\n try:\n micros = self.__iface_props.Duration()\n return True,micros\n except dbus.exceptions.DBusException:\n return False,-1\n else:\n return False,-1","def media_duration(self) -> int | None:\n if self._device.movie.title_length:\n return self._device.movie.title_length\n return None","def duration(self):\n if self._exc_end and self._inc_begin:\n return self._exc_end - self._inc_begin\n return 0","def duration(self):\n duration = 0\n for wf in self._waveforms:\n duration += wf.duration\n return duration","def get_duration(self):\n i = self.icalendar_component\n return self._get_duration(i)"],"string":"[\n \"def duration():\\r\\n elapsed_time, duration = video_time()\\r\\n return duration\",\n \"def video_duration(self):\\n # type: () -> int\\n return self._video_duration\",\n \"def get_duration(self):\\n frame_dur = self.get_frame_duration()\\n num_frames = self.get_num_frames()\\n motion_dur = frame_dur * (num_frames - 1)\\n return motion_dur\",\n \"def _get_duration(self):\\n try:\\n dur = self.im.info[\\\"duration\\\"] / 1000.0\\n except KeyError:\\n dur = DEFAULT_DURATION / 1000.0 \\n\\n return dur\",\n \"def get_duration(self):\\n return self.duration\",\n \"def get_duration(self) -> int:\\n return int( (self._frame_count / self._fps) * 1000 )\",\n \"def get_duration(self):\\n return self._duration\",\n \"def duration(self):\\n # type: () -> int\\n return self._duration\",\n \"def get_duration(self):\\n duration_ns = self.stream.InitialTimeToWaitGet()\\n duration_ns += self.stream.NumberOfFramesGet() * self.stream.InterFrameGapGet()\\n return datetime.timedelta(seconds=duration_ns / 1e9)\",\n \"def getDuration(self):\\n return _osgAnimation.Animation_getDuration(self)\",\n \"def getDuration(self):\\n if self.getDot():\\n return self.duration*1.5\\n else:\\n return self.duration\",\n \"def duration(self):\\n self.wait()\\n return self._duration\",\n \"def duration(self):\\n return self.sound.nframes\",\n \"def duration(self):\\n return self._get('duration')\",\n \"def media_duration(self):\\n return self._media_duration\",\n \"def duration(self) -> str:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def media_duration(self):\\n if 'duration' in self._status:\\n return int(float(self._status['duration']))\",\n \"def duration(self):\\n return self._get(\\\"duration\\\")\",\n \"def media_duration(self):\\n return self._state.get(\\\"duration\\\", None)\",\n \"def duration_seconds(self):\\n duration = 0.0\\n if self.is_video() or self.is_audio():\\n if self.__dict__['duration']:\\n try:\\n duration = float(self.__dict__['duration'])\\n except ValueError:\\n raise FFProbeError('None numeric duration')\\n return duration\",\n \"def duration(self) -> float:\\n return self._stop - self._start if self._stop is not None else None\",\n \"def get_frame_duration(self):\\n return self._frame_duration\",\n \"def duration(self) -> float:\\n return self.delta_t * len(self)\",\n \"def duration(self) -> float:\\n return self.delta_t * len(self)\",\n \"def duration(self):\\n with audioread.audio_open(self.path) as f:\\n return f.duration\",\n \"def duration(self):\\n return float('{0:.2f}'.format(self.end_time - self.start_time))\",\n \"def get_duration(self):\\n\\n return self.endtime - self.starttime\",\n \"def duration(self) -> datetime.timedelta:\\n return self._duration\",\n \"def duration_in_seconds(self):\\n return self.get_data(\\\"duration_in_seconds\\\")\",\n \"def getDuration(self):\\n return _osgAnimation.Motion_getDuration(self)\",\n \"def _duration(self):\\n if getattr(self, '_duration_cache', None):\\n return self._duration_cache\\n duration = extractMetadata(guessParser(\\\\\\n InputIOStream(self))).get('duration')\\n if not duration:\\n raise Exception(u'Not an audio file')\\n else:\\n duration = duration.seconds\\n self._duration_cache = duration\\n return duration\",\n \"def get_duration(self):\\n seconds = self.duration.total_seconds()\\n mins, secs = divmod(seconds, 60)\\n return int(mins), int(secs)\",\n \"def duration(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self):\\n return self.end_time - self.start_time\",\n \"def duration(self):\\n self._current_duration = time.perf_counter() - self._duration_start\\n return round(self._current_duration, 4)\",\n \"def get_duration(self):\\n raise UnsupportedOperation('Duration not implemented')\",\n \"def duration(self):\\n\\n ended = time.time() if self.ended is None else self.ended\\n return ended - self.started\",\n \"def duration(self) -> float:\\n return self.endTime()-self.startTime()\",\n \"def duration_in_seconds(self):\\n \\\"Should not set track length\\\"\\n return self.duration / float(self.samplerate)\",\n \"def get_duration(self):\\n return float(self.time.iloc[-1] - self.time.iloc[0])\",\n \"def duration(self):\\r\\n return self.stop - self.start\",\n \"def Duration(self):\\n\\t\\treturn self._get_attribute('duration')\",\n \"def duration(self):\\n return self.end - self.start\",\n \"def duration(self) -> Optional[str]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> Optional[str]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def getDurationMs(self):\\n return self.durationMs\",\n \"def Duration(self):\\r\\n\\t\\treturn self._get_attribute('duration')\",\n \"def duration(self):\\n return self.end_abs - self.start\",\n \"def duration(self):\\n started = self.started_at\\n finished = self.finished_at\\n if started and finished:\\n return str(finished - started)\\n else:\\n return None # can't compute yet\",\n \"def duration(self):\\n if hasattr(self, 'completed_on') and hasattr(self, 'started_on'):\\n diff = (self.completed_on - self.started_on)\\n minutes, seconds = divmod(diff.seconds, 60)\\n return \\\"{:0>2d}m {:0>2d}s\\\".format(minutes, seconds)\\n else:\\n return None\",\n \"def duration(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self):\\n pass\",\n \"def duration(self):\\n pass\",\n \"def duration(self):\\r\\n\\t\\treturn (self.globEnd - self.globStart)\",\n \"def getDurationNoDot(self):\\n return self.duration\",\n \"def media_duration(self):\\n if (self._playing_localfile or self._playing_spotify or self._slave_mode or self._playing_mediabrowser or self._playing_mass) and self._state != STATE_UNAVAILABLE:\\n return self._duration\\n else:\\n return None\",\n \"def duration(self) -> int:\\n return 0\",\n \"def run_duration(self) -> 'outputs.DurationResponse':\\n return pulumi.get(self, \\\"run_duration\\\")\",\n \"def duration(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def getDuration(self):\\n return (self._get_int('duration'), self._attributes.getDivisions())\",\n \"def duration(self):\\n return self._end - self._begin\",\n \"def duration(self) -> float:\\n return float(len(self.__samples))/float(self.__rate)\",\n \"def media_duration(self):\\n # The lovelace app loops media to prevent timing out, don't show that\\n if self.app_id == CAST_APP_ID_HOMEASSISTANT_LOVELACE:\\n return None\\n media_status = self._media_status()[0]\\n return media_status.duration if media_status else None\",\n \"def duration(self):\\n return (self.fcip_doc[\\\"latest_timestamp\\\"] - self.fcip_doc[\\\"packet_timestamps\\\"][0])\",\n \"def duration(self):\\n self._duration = self.lib.iperf_get_test_duration(self._test)\\n return self._duration\",\n \"def duration(self):\\n return total_seconds(self.timestamp - self.start_timestamp)\",\n \"def duration(self):\\r\\n return (self.end_time or time.time()) - self.start_time\",\n \"def frame_duration(self):\\n return self.samples_per_frame / self.input_data_sample_rate\",\n \"def get_duration(self):\\n try:\\n if self.is_skipped:\\n return \\\"00:00\\\"\\n assert self.start_time\\n assert self.stop_time\\n if self.stop_time < self.start_time:\\n return \\\"XX:XX\\\"\\n return(\\n f\\\"{str(int(self.stop_time - self.start_time) // 60).zfill(2)}:\\\"\\n f\\\"{str(int(self.stop_time - self.start_time) % 60).zfill(2)}\\\")\\n\\n except Exception: # pylint: disable=broad-except\\n self.__logger.error(\\\"Please run test before getting the duration\\\")\\n return \\\"XX:XX\\\"\",\n \"def duration(self):\\n if not self.started:\\n return None\\n start = self.started\\n end = self.completed\\n if not end:\\n end = datetime.utcnow()\\n return end - start\",\n \"def media_duration(self):\\n return self._table.active_track_total_time.total_seconds()\",\n \"def duration(self)->int:\\n return self._lic.params['maxDurationInSeconds'].value\",\n \"def duration( self ):\\n return (self.start and time.process_time()-self.start) or 0\",\n \"def get_duration(self):\\n duration = 0\\n\\n for entry in self.entries:\\n duration += entry.get_duration()\\n return duration\",\n \"def duration_in_minutes(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"duration_in_minutes\\\")\",\n \"def media_duration(self) -> int | None:\\n if self._media_playback_trackable():\\n return self.coordinator.data.nowplaying[\\n self.zone.SourceID\\n ].CurrSong.Duration\\n return None\",\n \"def get_duration(self):\\n return (self.stop_day - self.start_day) * (24 * 60) \\\\\\n + (self.stop_hour - self.start_hour) * 60\",\n \"def GetDuration(self):\\n return _gmat_py.LocatedEvent_GetDuration(self)\",\n \"def duration_in_millis(self):\\n return self._duration_in_millis\",\n \"def duration_in_minutes(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"duration_in_minutes\\\")\",\n \"def duration(self):\\n if(float(self.data_version) < 1.1):\\n return None\\n\\n if self.start_datetime and self.end_datetime:\\n delta = self.start_datetime - self.end_datetime\\n return int(abs(delta.total_seconds() - delta.total_seconds() % 60) / 60)\\n\\n s = self.starttime.split('.')\\n e = self.endtime.split('.')\\n # yyyy mm dd hh mm ss\\n start = datetime.datetime(year=int(s[0]), month=int(s[1]), day=int(s[2]),\\n hour=int(s[3]), minute=int(s[4]), second=int(s[5]))\\n end = datetime.datetime(year=int(e[0]), month=int(e[1]), day=int(e[2]),\\n hour=int(e[3]), minute=int(e[4]), second=int(e[5]))\\n\\n delta = start - end\\n return int(abs((delta.total_seconds() - delta.total_seconds() % 60) / 60))\",\n \"def image_sequence_duration(self):\\n return self._image_sequence_duration\",\n \"def duration_display(self):\\n return self.duration_poster or self.duration\",\n \"def duration(self):\\n # duration is the difference between the midpoints\\n value = self.__end.get_midpoint() - self.__begin.get_midpoint()\\n\\n # vagueness of the duration is based on begin/end radius values\\n vagueness = 0\\n if self.__begin.get_radius() is not None:\\n vagueness += self.__begin.get_radius()\\n if self.__end.get_radius() is not None:\\n vagueness += self.__end.get_radius()\\n\\n return sppasDuration(value, vagueness)\",\n \"def elapsed_time():\\r\\n elapsed_time, duration = video_time()\\r\\n return elapsed_time\",\n \"def get_duration(self):\\n return self.source_df.end_timestamp.astype(\\\"datetime64\\\") - self.source_df.start_timestamp.astype(\\\"datetime64\\\")\",\n \"def get_duration(self):\\n if self.is_running():\\n try:\\n micros = self.__iface_props.Duration()\\n return True,micros\\n except dbus.exceptions.DBusException:\\n return False,-1\\n else:\\n return False,-1\",\n \"def media_duration(self) -> int | None:\\n if self._device.movie.title_length:\\n return self._device.movie.title_length\\n return None\",\n \"def duration(self):\\n if self._exc_end and self._inc_begin:\\n return self._exc_end - self._inc_begin\\n return 0\",\n \"def duration(self):\\n duration = 0\\n for wf in self._waveforms:\\n duration += wf.duration\\n return duration\",\n \"def get_duration(self):\\n i = self.icalendar_component\\n return self._get_duration(i)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7762158","0.7709614","0.75428295","0.7538186","0.74586827","0.74504477","0.74190795","0.7403893","0.7340937","0.733311","0.7328377","0.7324417","0.72875273","0.7262277","0.7247565","0.72455525","0.72377896","0.7232972","0.721482","0.7209425","0.7201544","0.7201467","0.71703887","0.71703887","0.7167505","0.7160746","0.7157478","0.7148401","0.71423304","0.7136928","0.7096531","0.7067071","0.7065035","0.7053042","0.7040564","0.7037696","0.7012766","0.7009447","0.7000346","0.6997239","0.6990378","0.69798267","0.6977538","0.69739825","0.69739825","0.69659954","0.69650567","0.6962402","0.6933498","0.6926404","0.6893814","0.6893814","0.6893814","0.688728","0.688728","0.68849087","0.687274","0.6862613","0.6851493","0.68239903","0.6818697","0.6805736","0.67834485","0.6775987","0.6768109","0.6757237","0.6743401","0.67356855","0.67341995","0.67307436","0.6717711","0.66939205","0.6682353","0.6677205","0.66580874","0.6609822","0.66062427","0.6600501","0.65919757","0.65758514","0.65634733","0.6553858","0.6551762","0.6526587","0.6518855","0.65113336","0.64786124","0.6462952","0.64561254","0.64495856","0.6447446","0.6435401","0.6430816"],"string":"[\n \"0.7762158\",\n \"0.7709614\",\n \"0.75428295\",\n \"0.7538186\",\n \"0.74586827\",\n \"0.74504477\",\n \"0.74190795\",\n \"0.7403893\",\n \"0.7340937\",\n \"0.733311\",\n \"0.7328377\",\n \"0.7324417\",\n \"0.72875273\",\n \"0.7262277\",\n \"0.7247565\",\n \"0.72455525\",\n \"0.72377896\",\n \"0.7232972\",\n \"0.721482\",\n \"0.7209425\",\n \"0.7201544\",\n \"0.7201467\",\n \"0.71703887\",\n \"0.71703887\",\n \"0.7167505\",\n \"0.7160746\",\n \"0.7157478\",\n \"0.7148401\",\n \"0.71423304\",\n \"0.7136928\",\n \"0.7096531\",\n \"0.7067071\",\n \"0.7065035\",\n \"0.7053042\",\n \"0.7040564\",\n \"0.7037696\",\n \"0.7012766\",\n \"0.7009447\",\n \"0.7000346\",\n \"0.6997239\",\n \"0.6990378\",\n \"0.69798267\",\n \"0.6977538\",\n \"0.69739825\",\n \"0.69739825\",\n \"0.69659954\",\n \"0.69650567\",\n \"0.6962402\",\n \"0.6933498\",\n \"0.6926404\",\n \"0.6893814\",\n \"0.6893814\",\n \"0.6893814\",\n \"0.688728\",\n \"0.688728\",\n \"0.68849087\",\n \"0.687274\",\n \"0.6862613\",\n \"0.6851493\",\n \"0.68239903\",\n \"0.6818697\",\n \"0.6805736\",\n \"0.67834485\",\n \"0.6775987\",\n \"0.6768109\",\n \"0.6757237\",\n \"0.6743401\",\n \"0.67356855\",\n \"0.67341995\",\n \"0.67307436\",\n \"0.6717711\",\n \"0.66939205\",\n \"0.6682353\",\n \"0.6677205\",\n \"0.66580874\",\n \"0.6609822\",\n \"0.66062427\",\n \"0.6600501\",\n \"0.65919757\",\n \"0.65758514\",\n \"0.65634733\",\n \"0.6553858\",\n \"0.6551762\",\n \"0.6526587\",\n \"0.6518855\",\n \"0.65113336\",\n \"0.64786124\",\n \"0.6462952\",\n \"0.64561254\",\n \"0.64495856\",\n \"0.6447446\",\n \"0.6435401\",\n \"0.6430816\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7359599"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":76581,"cells":{"query":{"kind":"string","value":"Sets the duration of this GIFOutput. Seconds for the duration of the GIF. Can't be longer than the video."},"document":{"kind":"string","value":"def duration(self, duration):\n\n self._duration = duration"},"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 setDuration(self, *args):\n return _osgAnimation.Animation_setDuration(self, *args)","def duration(self, duration):\n self._duration = duration","def duration(self, duration):\n self._duration = duration","async def async_set_duration(self, duration):\n self._duration = duration","def set_duration(self, duration):\n self.__test_result[Result.__DURATION] = round(duration * 1000)","def set_duration(self, duration_secs):\n raise UnsupportedOperation('Duration not implemented')","def duration_in_seconds(self, value):\n self.__duration = (value * 1000000)","def duration(self, duration):\n # type: (int) -> None\n\n if duration is not None:\n if not isinstance(duration, int):\n raise TypeError(\"Invalid type for `duration`, type has to be `int`\")\n\n self._duration = duration","def video_duration(self, video_duration):\n # type: (int) -> None\n\n if video_duration is not None:\n if not isinstance(video_duration, int):\n raise TypeError(\"Invalid type for `video_duration`, type has to be `int`\")\n\n self._video_duration = video_duration","def set_duration(self, duration, movable_attr=\"DTSTART\"):\n i = self.icalendar_component\n return self._set_duration(i, duration, movable_attr)","def setDuration(self, duration):\n if duration == None:\n return False\n dur = _float(duration)\n if dur == None:\n raise Error_Float(\"Cannot interpret duration {}\".format(duration))\n return False\n else:\n self.duration = dur\n self.durationMs = self.durationToMs(dur)\n return True","def duration(self):\n pass","def duration(self):\n pass","def video_duration(self):\n # type: () -> int\n return self._video_duration","def duration_in_seconds(self):\n \"Should not set track length\"\n return self.duration / float(self.samplerate)","def duration_display(self):\n return self.duration_poster or self.duration","def set_duration_tier(self, value):\n self._options['duration'] = bool(value)","def __init__(__self__, *,\n duration: Optional[pulumi.Input[str]] = None):\n if duration is not None:\n pulumi.set(__self__, \"duration\", duration)","def ugc_limit_duration(self, ugc_limit_duration):\n\n self._ugc_limit_duration = ugc_limit_duration","def set_pulseDuration(self, newval):\n rest_val = str(int(round(newval * 65536.0, 1)))\n return self._setAttr(\"pulseDuration\", rest_val)","def duration(self) -> Optional[str]:\n return pulumi.get(self, \"duration\")","def duration(self) -> Optional[str]:\n return pulumi.get(self, \"duration\")","def duration(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"duration\")","def duration(self) -> str:\n return pulumi.get(self, \"duration\")","def duration_bin(self, duration_bin):\n\n self._duration_bin = duration_bin","def _get_duration(self):\n try:\n dur = self.im.info[\"duration\"] / 1000.0\n except KeyError:\n dur = DEFAULT_DURATION / 1000.0 \n\n return dur","def duration(self) -> int:\n return 0","def duration(self):\n return self._duration","def duration(self):\n return self._duration","def duration(self):\n return self._duration","def duration(self):\n return self._duration","def duration(self):\n return self._duration","def duration(self):\n return self._duration","def duration(self):\n return self._duration","def duration(self):\n return self._duration","def media_duration(self):\n return self._state.get(\"duration\", None)","def duration(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"duration\")","def duration():\r\n elapsed_time, duration = video_time()\r\n return duration","def duration(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"duration\")","def duration(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"duration\")","def duration(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"duration\")","def duration(self):\n return self._get(\"duration\")","def duration(self):\n # type: () -> int\n return self._duration","def get_duration(self):\n return self.duration","def duration(self) -> datetime.timedelta:\n return self._duration","def duration_squash(self, duration_squash):\n\n self._duration_squash = duration_squash","def duration(self):\n return self._get('duration')","def __init__(self, duration):\n self._duration = validate_duration(duration, min_duration=16,\n max_duration=4194304)","def duration_seconds(self):\n duration = 0.0\n if self.is_video() or self.is_audio():\n if self.__dict__['duration']:\n try:\n duration = float(self.__dict__['duration'])\n except ValueError:\n raise FFProbeError('None numeric duration')\n return duration","def getDurationNoDot(self):\n return self.duration","def get_duration(self) -> int:\n return int( (self._frame_count / self._fps) * 1000 )","def duration(self)->int:\n return self._lic.params['maxDurationInSeconds'].value","def get_duration(self):\n raise UnsupportedOperation('Duration not implemented')","def media_duration(self):\n if 'duration' in self._status:\n return int(float(self._status['duration']))","def _duration(self):\n if getattr(self, '_duration_cache', None):\n return self._duration_cache\n duration = extractMetadata(guessParser(\\\n InputIOStream(self))).get('duration')\n if not duration:\n raise Exception(u'Not an audio file')\n else:\n duration = duration.seconds\n self._duration_cache = duration\n return duration","def getDuration(self):\n if self.getDot():\n return self.duration*1.5\n else:\n return self.duration","def getDuration(self):\n return _osgAnimation.Animation_getDuration(self)","def set_framerate(self, framerate):\n self._framerate = int(framerate)","def get_duration(self):\n return self._duration","def duration(self, duration):\n try:\n duration = Duration.to_timedelta(duration)\n except (ValueError, TypeError) as e:\n raise ValidationError(e)\n\n if duration.total_seconds() < 0:\n raise ValidationError('Duration must be positive.')\n self._set('duration', duration)","def gif_fps(self, gif_fps):\n if gif_fps is not None and gif_fps > 30:\n raise ValueError(\"Invalid value for `gif_fps`, must be a value less than or equal to `30`\")\n\n self._gif_fps = gif_fps","def start(self, duration=None):\n if duration is None:\n duration = self.duration\n\n self.set(duration)","def media_duration(self):\n return self._media_duration","def Duration(self):\r\n\t\treturn self._get_attribute('duration')","def get_duration(self):\n frame_dur = self.get_frame_duration()\n num_frames = self.get_num_frames()\n motion_dur = frame_dur * (num_frames - 1)\n return motion_dur","def set_timeout(self, seconds):\n self._timeout = seconds","def get_frame_duration(self):\n return self._frame_duration","def duration_in_millis(self, duration_in_millis):\n\n self._duration_in_millis = duration_in_millis","def Duration(self):\n\t\treturn self._get_attribute('duration')","def spike_duration(self, spike_duration):\n\n self._spike_duration = spike_duration","def duration(self):\n self.wait()\n return self._duration","def set_option_max_duration(self, integer, apikey=''):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/setOptionMaxDuration/', {'Integer': integer, 'apikey': apikey})))","def duration_in_minutes(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"duration_in_minutes\")","def test_duration_property(self):\n recording_dt = 0.1\n recording_shape = {\n 'no_timesteps': 1000,\n 'no_sweeps': 10,\n 'no_channels': 4,\n }\n expected_duration = recording_shape['no_timesteps'] * recording_dt\n test_rec = rt.Recording(\n np.zeros(\n [\n recording_shape['no_channels'],\n recording_shape['no_timesteps'],\n recording_shape['no_sweeps'],\n ]\n ),\n dt=recording_dt,\n )\n npt.assert_almost_equal(\n test_rec.duration,\n expected_duration,\n err_msg='Expected {} for `duration` property; got {} instead.'.format(\n expected_duration, test_rec.duration\n ),\n )","def run_duration(self) -> Optional[pulumi.Input['DurationArgs']]:\n return pulumi.get(self, \"run_duration\")","def track_duration(self):\n # raise NotImplementedError\n self.out_schema.append(\"run_duration\")\n self._track_duration = True\n # self.runner = GridExecutor.timer(self.runner)","def storage_duration(self, storage_duration):\n self.logger.debug(\"In 'storage_duration' setter.\")\n\n if storage_duration < 0:\n raise ValueError(\"Invalid storage_duration. Must be non-negative.\")\n\n self._storage_duration = storage_duration","def setRampDuration(self, ramp_duration):\r\n\t\tself.RampDuration = ramp_duration\r\n\t\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)","def setRampDuration(self, ramp_duration):\r\n\t\tself.RampDuration = ramp_duration\r\n\t\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)","def settimeout(self, value: int) -> None:\n ...","def end_duration_secs_or_frames(self, end_duration_secs_or_frames):\n\n self._end_duration_secs_or_frames = end_duration_secs_or_frames","def getDuration(self):\n return _osgAnimation.Motion_getDuration(self)","def duration(self) -> float:\n return self.delta_t * len(self)","def duration(self) -> float:\n return self.delta_t * len(self)","async def put_duration( # pylint: disable=inconsistent-return-statements\n self, complex_body: IO, *, content_type: str = \"application/json\", **kwargs: Any\n ) -> None:","def duration_in_seconds(self):\n return self.get_data(\"duration_in_seconds\")","def duration_in_minutes(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"duration_in_minutes\")","def timeout(self, value):\n if isinstance(value, timedelta):\n value = value.days * 3600 * 24 + value.seconds\n self._timeout = value # noqa","def run_duration(self) -> 'outputs.DurationResponse':\n return pulumi.get(self, \"run_duration\")","def duration(self):\n return self.sound.nframes","def reset_duration(self):\n self._duration_start = time.perf_counter()\n return self._duration_start","def __init__(self, duration, value):\n super().__init__(duration)\n self._value = float(value)","def duration(self):\n if hasattr(self, 'completed_on') and hasattr(self, 'started_on'):\n diff = (self.completed_on - self.started_on)\n minutes, seconds = divmod(diff.seconds, 60)\n return \"{:0>2d}m {:0>2d}s\".format(minutes, seconds)\n else:\n return None"],"string":"[\n \"def setDuration(self, *args):\\n return _osgAnimation.Animation_setDuration(self, *args)\",\n \"def duration(self, duration):\\n self._duration = duration\",\n \"def duration(self, duration):\\n self._duration = duration\",\n \"async def async_set_duration(self, duration):\\n self._duration = duration\",\n \"def set_duration(self, duration):\\n self.__test_result[Result.__DURATION] = round(duration * 1000)\",\n \"def set_duration(self, duration_secs):\\n raise UnsupportedOperation('Duration not implemented')\",\n \"def duration_in_seconds(self, value):\\n self.__duration = (value * 1000000)\",\n \"def duration(self, duration):\\n # type: (int) -> None\\n\\n if duration is not None:\\n if not isinstance(duration, int):\\n raise TypeError(\\\"Invalid type for `duration`, type has to be `int`\\\")\\n\\n self._duration = duration\",\n \"def video_duration(self, video_duration):\\n # type: (int) -> None\\n\\n if video_duration is not None:\\n if not isinstance(video_duration, int):\\n raise TypeError(\\\"Invalid type for `video_duration`, type has to be `int`\\\")\\n\\n self._video_duration = video_duration\",\n \"def set_duration(self, duration, movable_attr=\\\"DTSTART\\\"):\\n i = self.icalendar_component\\n return self._set_duration(i, duration, movable_attr)\",\n \"def setDuration(self, duration):\\n if duration == None:\\n return False\\n dur = _float(duration)\\n if dur == None:\\n raise Error_Float(\\\"Cannot interpret duration {}\\\".format(duration))\\n return False\\n else:\\n self.duration = dur\\n self.durationMs = self.durationToMs(dur)\\n return True\",\n \"def duration(self):\\n pass\",\n \"def duration(self):\\n pass\",\n \"def video_duration(self):\\n # type: () -> int\\n return self._video_duration\",\n \"def duration_in_seconds(self):\\n \\\"Should not set track length\\\"\\n return self.duration / float(self.samplerate)\",\n \"def duration_display(self):\\n return self.duration_poster or self.duration\",\n \"def set_duration_tier(self, value):\\n self._options['duration'] = bool(value)\",\n \"def __init__(__self__, *,\\n duration: Optional[pulumi.Input[str]] = None):\\n if duration is not None:\\n pulumi.set(__self__, \\\"duration\\\", duration)\",\n \"def ugc_limit_duration(self, ugc_limit_duration):\\n\\n self._ugc_limit_duration = ugc_limit_duration\",\n \"def set_pulseDuration(self, newval):\\n rest_val = str(int(round(newval * 65536.0, 1)))\\n return self._setAttr(\\\"pulseDuration\\\", rest_val)\",\n \"def duration(self) -> Optional[str]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> Optional[str]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> str:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration_bin(self, duration_bin):\\n\\n self._duration_bin = duration_bin\",\n \"def _get_duration(self):\\n try:\\n dur = self.im.info[\\\"duration\\\"] / 1000.0\\n except KeyError:\\n dur = DEFAULT_DURATION / 1000.0 \\n\\n return dur\",\n \"def duration(self) -> int:\\n return 0\",\n \"def duration(self):\\n return self._duration\",\n \"def duration(self):\\n return self._duration\",\n \"def duration(self):\\n return self._duration\",\n \"def duration(self):\\n return self._duration\",\n \"def duration(self):\\n return self._duration\",\n \"def duration(self):\\n return self._duration\",\n \"def duration(self):\\n return self._duration\",\n \"def duration(self):\\n return self._duration\",\n \"def media_duration(self):\\n return self._state.get(\\\"duration\\\", None)\",\n \"def duration(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration():\\r\\n elapsed_time, duration = video_time()\\r\\n return duration\",\n \"def duration(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"duration\\\")\",\n \"def duration(self):\\n return self._get(\\\"duration\\\")\",\n \"def duration(self):\\n # type: () -> int\\n return self._duration\",\n \"def get_duration(self):\\n return self.duration\",\n \"def duration(self) -> datetime.timedelta:\\n return self._duration\",\n \"def duration_squash(self, duration_squash):\\n\\n self._duration_squash = duration_squash\",\n \"def duration(self):\\n return self._get('duration')\",\n \"def __init__(self, duration):\\n self._duration = validate_duration(duration, min_duration=16,\\n max_duration=4194304)\",\n \"def duration_seconds(self):\\n duration = 0.0\\n if self.is_video() or self.is_audio():\\n if self.__dict__['duration']:\\n try:\\n duration = float(self.__dict__['duration'])\\n except ValueError:\\n raise FFProbeError('None numeric duration')\\n return duration\",\n \"def getDurationNoDot(self):\\n return self.duration\",\n \"def get_duration(self) -> int:\\n return int( (self._frame_count / self._fps) * 1000 )\",\n \"def duration(self)->int:\\n return self._lic.params['maxDurationInSeconds'].value\",\n \"def get_duration(self):\\n raise UnsupportedOperation('Duration not implemented')\",\n \"def media_duration(self):\\n if 'duration' in self._status:\\n return int(float(self._status['duration']))\",\n \"def _duration(self):\\n if getattr(self, '_duration_cache', None):\\n return self._duration_cache\\n duration = extractMetadata(guessParser(\\\\\\n InputIOStream(self))).get('duration')\\n if not duration:\\n raise Exception(u'Not an audio file')\\n else:\\n duration = duration.seconds\\n self._duration_cache = duration\\n return duration\",\n \"def getDuration(self):\\n if self.getDot():\\n return self.duration*1.5\\n else:\\n return self.duration\",\n \"def getDuration(self):\\n return _osgAnimation.Animation_getDuration(self)\",\n \"def set_framerate(self, framerate):\\n self._framerate = int(framerate)\",\n \"def get_duration(self):\\n return self._duration\",\n \"def duration(self, duration):\\n try:\\n duration = Duration.to_timedelta(duration)\\n except (ValueError, TypeError) as e:\\n raise ValidationError(e)\\n\\n if duration.total_seconds() < 0:\\n raise ValidationError('Duration must be positive.')\\n self._set('duration', duration)\",\n \"def gif_fps(self, gif_fps):\\n if gif_fps is not None and gif_fps > 30:\\n raise ValueError(\\\"Invalid value for `gif_fps`, must be a value less than or equal to `30`\\\")\\n\\n self._gif_fps = gif_fps\",\n \"def start(self, duration=None):\\n if duration is None:\\n duration = self.duration\\n\\n self.set(duration)\",\n \"def media_duration(self):\\n return self._media_duration\",\n \"def Duration(self):\\r\\n\\t\\treturn self._get_attribute('duration')\",\n \"def get_duration(self):\\n frame_dur = self.get_frame_duration()\\n num_frames = self.get_num_frames()\\n motion_dur = frame_dur * (num_frames - 1)\\n return motion_dur\",\n \"def set_timeout(self, seconds):\\n self._timeout = seconds\",\n \"def get_frame_duration(self):\\n return self._frame_duration\",\n \"def duration_in_millis(self, duration_in_millis):\\n\\n self._duration_in_millis = duration_in_millis\",\n \"def Duration(self):\\n\\t\\treturn self._get_attribute('duration')\",\n \"def spike_duration(self, spike_duration):\\n\\n self._spike_duration = spike_duration\",\n \"def duration(self):\\n self.wait()\\n return self._duration\",\n \"def set_option_max_duration(self, integer, apikey=''):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/setOptionMaxDuration/', {'Integer': integer, 'apikey': apikey})))\",\n \"def duration_in_minutes(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"duration_in_minutes\\\")\",\n \"def test_duration_property(self):\\n recording_dt = 0.1\\n recording_shape = {\\n 'no_timesteps': 1000,\\n 'no_sweeps': 10,\\n 'no_channels': 4,\\n }\\n expected_duration = recording_shape['no_timesteps'] * recording_dt\\n test_rec = rt.Recording(\\n np.zeros(\\n [\\n recording_shape['no_channels'],\\n recording_shape['no_timesteps'],\\n recording_shape['no_sweeps'],\\n ]\\n ),\\n dt=recording_dt,\\n )\\n npt.assert_almost_equal(\\n test_rec.duration,\\n expected_duration,\\n err_msg='Expected {} for `duration` property; got {} instead.'.format(\\n expected_duration, test_rec.duration\\n ),\\n )\",\n \"def run_duration(self) -> Optional[pulumi.Input['DurationArgs']]:\\n return pulumi.get(self, \\\"run_duration\\\")\",\n \"def track_duration(self):\\n # raise NotImplementedError\\n self.out_schema.append(\\\"run_duration\\\")\\n self._track_duration = True\\n # self.runner = GridExecutor.timer(self.runner)\",\n \"def storage_duration(self, storage_duration):\\n self.logger.debug(\\\"In 'storage_duration' setter.\\\")\\n\\n if storage_duration < 0:\\n raise ValueError(\\\"Invalid storage_duration. Must be non-negative.\\\")\\n\\n self._storage_duration = storage_duration\",\n \"def setRampDuration(self, ramp_duration):\\r\\n\\t\\tself.RampDuration = ramp_duration\\r\\n\\t\\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)\",\n \"def setRampDuration(self, ramp_duration):\\r\\n\\t\\tself.RampDuration = ramp_duration\\r\\n\\t\\tself.OutputValueIncrement = (self.MaxValue - self.MinValue)/(self.RampDuration/self.Ts)\",\n \"def settimeout(self, value: int) -> None:\\n ...\",\n \"def end_duration_secs_or_frames(self, end_duration_secs_or_frames):\\n\\n self._end_duration_secs_or_frames = end_duration_secs_or_frames\",\n \"def getDuration(self):\\n return _osgAnimation.Motion_getDuration(self)\",\n \"def duration(self) -> float:\\n return self.delta_t * len(self)\",\n \"def duration(self) -> float:\\n return self.delta_t * len(self)\",\n \"async def put_duration( # pylint: disable=inconsistent-return-statements\\n self, complex_body: IO, *, content_type: str = \\\"application/json\\\", **kwargs: Any\\n ) -> None:\",\n \"def duration_in_seconds(self):\\n return self.get_data(\\\"duration_in_seconds\\\")\",\n \"def duration_in_minutes(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"duration_in_minutes\\\")\",\n \"def timeout(self, value):\\n if isinstance(value, timedelta):\\n value = value.days * 3600 * 24 + value.seconds\\n self._timeout = value # noqa\",\n \"def run_duration(self) -> 'outputs.DurationResponse':\\n return pulumi.get(self, \\\"run_duration\\\")\",\n \"def duration(self):\\n return self.sound.nframes\",\n \"def reset_duration(self):\\n self._duration_start = time.perf_counter()\\n return self._duration_start\",\n \"def __init__(self, duration, value):\\n super().__init__(duration)\\n self._value = float(value)\",\n \"def duration(self):\\n if hasattr(self, 'completed_on') and hasattr(self, 'started_on'):\\n diff = (self.completed_on - self.started_on)\\n minutes, seconds = divmod(diff.seconds, 60)\\n return \\\"{:0>2d}m {:0>2d}s\\\".format(minutes, seconds)\\n else:\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7234786","0.72298867","0.72298867","0.7033115","0.6978191","0.6903736","0.6718069","0.6541939","0.65389705","0.64146113","0.623737","0.6063905","0.6063905","0.5945565","0.5841082","0.58208543","0.5790863","0.57763195","0.5763773","0.5758399","0.56954765","0.56954765","0.56387377","0.56308925","0.56243753","0.56121534","0.5600252","0.55763686","0.55763686","0.55763686","0.55763686","0.55763686","0.55763686","0.55763686","0.55763686","0.5539864","0.5534903","0.5531609","0.5529929","0.5529929","0.5529929","0.55210686","0.551673","0.55106264","0.5509285","0.5503128","0.5492392","0.5485764","0.5475036","0.54482347","0.54447","0.5436531","0.543056","0.5409259","0.5403597","0.54020894","0.54007155","0.53776747","0.5371624","0.5359591","0.53444666","0.5336933","0.5331458","0.5316943","0.5307024","0.5296641","0.52881837","0.5283077","0.52826315","0.5268551","0.5259764","0.5258675","0.5239121","0.522351","0.5207507","0.5206235","0.5199808","0.5198017","0.5198017","0.51826686","0.5174747","0.5169439","0.51694006","0.51694006","0.5160672","0.5148937","0.51480216","0.51461047","0.5138818","0.51324856","0.5119957","0.51192623","0.50979537"],"string":"[\n \"0.7234786\",\n \"0.72298867\",\n \"0.72298867\",\n \"0.7033115\",\n \"0.6978191\",\n \"0.6903736\",\n \"0.6718069\",\n \"0.6541939\",\n \"0.65389705\",\n \"0.64146113\",\n \"0.623737\",\n \"0.6063905\",\n \"0.6063905\",\n \"0.5945565\",\n \"0.5841082\",\n \"0.58208543\",\n \"0.5790863\",\n \"0.57763195\",\n \"0.5763773\",\n \"0.5758399\",\n \"0.56954765\",\n \"0.56954765\",\n \"0.56387377\",\n \"0.56308925\",\n \"0.56243753\",\n \"0.56121534\",\n \"0.5600252\",\n \"0.55763686\",\n \"0.55763686\",\n \"0.55763686\",\n \"0.55763686\",\n \"0.55763686\",\n \"0.55763686\",\n \"0.55763686\",\n \"0.55763686\",\n \"0.5539864\",\n \"0.5534903\",\n \"0.5531609\",\n \"0.5529929\",\n \"0.5529929\",\n \"0.5529929\",\n \"0.55210686\",\n \"0.551673\",\n \"0.55106264\",\n \"0.5509285\",\n \"0.5503128\",\n \"0.5492392\",\n \"0.5485764\",\n \"0.5475036\",\n \"0.54482347\",\n \"0.54447\",\n \"0.5436531\",\n \"0.543056\",\n \"0.5409259\",\n \"0.5403597\",\n \"0.54020894\",\n \"0.54007155\",\n \"0.53776747\",\n \"0.5371624\",\n \"0.5359591\",\n \"0.53444666\",\n \"0.5336933\",\n \"0.5331458\",\n \"0.5316943\",\n \"0.5307024\",\n \"0.5296641\",\n \"0.52881837\",\n \"0.5283077\",\n \"0.52826315\",\n \"0.5268551\",\n \"0.5259764\",\n \"0.5258675\",\n \"0.5239121\",\n \"0.522351\",\n \"0.5207507\",\n \"0.5206235\",\n \"0.5199808\",\n \"0.5198017\",\n \"0.5198017\",\n \"0.51826686\",\n \"0.5174747\",\n \"0.5169439\",\n \"0.51694006\",\n \"0.51694006\",\n \"0.5160672\",\n \"0.5148937\",\n \"0.51480216\",\n \"0.51461047\",\n \"0.5138818\",\n \"0.51324856\",\n \"0.5119957\",\n \"0.51192623\",\n \"0.50979537\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7048977"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":76582,"cells":{"query":{"kind":"string","value":"Gets the suffix of this GIFOutput. Unique ending of the file name so several outputs can be created then identified. Required if there is more then 1 video output."},"document":{"kind":"string","value":"def suffix(self):\n return self._suffix"},"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 suffix(self):\n return self[\"suffix\"]","def suffix(self):\n return self[\"suffix\"]","def file_suffix(self):\n return f'{self.image_count:05}' if self.sequential_naming else \\\n datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")","def suffix ( self ) :\n return self.__suffix","def suffix ( self ) :\n return self.__suffix","def suffix(self) -> typing.Optional[str]:\n return self._values.get('suffix')","def _suffix(self) -> str:\n return \"\"","def suffixsrc(self):\n return self[\"suffixsrc\"]","def suffixsrc(self):\n return self[\"suffixsrc\"]","def get_suffix(self):\n if self.device:\n return self.device\n else:\n return '%s%d' % (self.devletters(), self.get_index() + 1)","def get_suffix(self):\n return '%s%d' % (self.disk.devletters(), self.get_index() + 1)","def output_filename(self, prefix, suffix):\n filename = \"%s%s%s\" % (prefix, _ExecutionWrapper._file_index, suffix)\n _ExecutionWrapper._file_index += 1\n return filename","def suffix(self) -> Optional[URISuffix]:\n return self._suffix","def get_file_basename(self):\n return self._basename[:]","def getSuffixPattern(self):\n return self.getOrDefault(\"suffixPattern\")","def suffix():\r\n\r\n return _random.choice(\r\n [\r\n 'Sr.', 'Jr.', 'II', 'III', 'IV', 'V'\r\n ]\r\n )","def basename(self):\n return get_basename(self.filename)","def name_woext(self):\n return os.path.splitext(self._job)[0]","def _generate_output_name(extension):\n output_name = 'TDG_{:%Y-%m-%d_%H-%M-%S}.{}'.format(datetime.now(), extension)\n return output_name","def name(self):\n suffix = ''\n if 'suffix' in self.context['strategy'] \\\n and self.context['strategy']['suffix'] is not None \\\n and len(self.context['strategy']['suffix']) > 0:\n suffix = \"_\" + self.context['strategy']['suffix']\n\n return self.get_name(self.context, suffix)","def get_feature_suffix(feature_name: str) -> str:\n if \"_\" not in feature_name:\n return \"\"\n return feature_name.split(\"_\")[-1]","def getFileSuffix(filename):\n fileSuffix = \"\"\n\n if filename:\n name, extension = os.path.splitext(filename)\n fileSuffix = extension # .mp3\n\n if fileSuffix:\n # remove leading dot/period\n fileSuffix = fileSuffix[1:] # mp3\n\n if fileSuffix:\n # remove ending newline or space\n fileSuffix = fileSuffix.strip()\n\n if fileSuffix:\n # convert JPg to jpg\n fileSuffix = fileSuffix.lower()\n\n return fileSuffix","def basename(self) -> str:\n return self._basename","def get_basename(self):\n return self._basename","def filename(self):\n return self.config.get('filename', self.id) + f'_{self.file_suffix}'","def _get_abgp_file_basename(OPTIONS):\n if OPTIONS.target:\n try:\n num_loci = OPTIONS.selected_num_loci\n except:\n num_loci = len(OPTIONS.loci) + len(OPTIONS.dnafiles)\n return \"%s.%s%sSL.\" % (ABFGP_VERSION,OPTIONS.target,num_loci)\n else:\n return \"%s.\" % ABGP_VERSION","def outputname(self, identifier):\n return self._outprefix+str(identifier)+\".\"+self._suffix","def _metric_name(self, suffix):\r\n return '{}.{}'.format(self.METRIC_NAME, suffix)","def get_output_filename(self, gzip=False):\n if self.mode == 'light':\n suffix = '-light'\n else:\n suffix = ''\n\n destination = self.destination\n extension = 'fits'\n if gzip:\n destination += '-compressed'\n extension += '.gz'\n return os.path.join(destination,\n 'iphas-dr2-{0}{1}.{2}'.format(\n self.get_partname(),\n suffix,\n extension))","def filename(self):\n return '%s%s' % (self.identifier, self.extension)","def global_replication_group_id_suffix(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"global_replication_group_id_suffix\")","def _identifier_suffix(self):\r\n return ''","def get_suffix_ml_model():\n suffix = ''\n \n # consider if the model uses tail or not\n if gml.USE_TAIL: \n suffix += '_use_tail'\n else: \n suffix += '_no_tail'\n\n # consider the way of picking target variable for the model\n if gml.WAY_MODEL_TGT == 'absolute':\n suffix += '_absolute'\n elif gml.WAY_MODEL_TGT == 'relative':\n suffix += '_relative'\n else: \n exit('error on the function that gets suffix')\n\n return suffix","def name(self):\n #type: ()->Text\n return (\n os.path.splitext(os.path.basename(self.fileName))[0])","def getSuffix(self):\r\n return self.chrom","def basename(self):\n return os.path.basename(self.filepath)","def _suffix(self) -> str:\n return f\"!! Expected: {self._expected!r}\"","def _get_video_filename(self):\n fnd = self._get_session_dir()\n self.video_number += 1\n fn = os.path.join(fnd, 'V%4.4d.avi' % self.video_number)\n return fn","def current_filename(self):\n if self.char_limit is not None:\n return '{}/{}.{}.n{}.maf'.format(self.out_dir, self.chrom,\n self.taxon, self.file_num)\n else:\n return '{}/{}.{}.maf'.format(self.out_dir, self.chrom, self.taxon)","def name_sans_ext(self) -> str:\n return os.path.splitext(self.path)[0]","def generate_file_name(self):\n self._session_iterator = None # New file invalidate old interator\n self._img_count += 1\n self._current_file = '{0}/frame_{1}.jpg'.format(self._relative_path,self._img_count)\n return self.current_file","def get_filename(target_dir, filename_prefix):\n # this whole function is not the nicest thing, but isolating it makes\n # things clearer , a good refactoring would be to get\n # the info from the video_url or the current output, to avoid the\n # iteration from the current dir\n filenames = os.listdir(target_dir)\n subs_filename = filename_prefix\n for name in filenames: # Find the filename of the downloaded video\n if name.startswith(filename_prefix):\n (basename, ext) = os.path.splitext(name)\n return basename","def basename(self):\n return self.name.basename","def getSuffixLink(self):\n return self.suffix_link","def exe_suffix():\n if sys.platform == 'win32':\n return '.exe'\n return ''","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 name(self):\n\t\tnam = super( textureFile, self ).name\n\t\tif self.hasUdim:\n\t\t\ttry:\n\t\t\t\treturn nam[:nam.rindex( '.' )]\n\t\t\texcept:\n\t\t\t\treturn nam\n\t\treturn nam","def full_name(self):\n return \"output.%s\" % self.name","def filename(self):\n filename, ext = os.path.splitext(self.file.name)\n return filename.split('/')[-1]","def _get_suffix(bin, VoronoiSN):\n \n if VoronoiSN is not None:\n suffix = \"SN{0:03d}\".format(VoronoiSN)\n else:\n suffix = \"bin{0:02d}\".format(bin)\n\n return suffix","def getPlayerFilename(self):\n if (self.__playerName != \"???\"):\n return self.__filename\n else:\n return \"\"","def basename(self):\n return self._basename","def get_release_name(self) -> str:\n if self.season is not None and self.episode is None:\n return os.path.basename(os.path.dirname(self.file))\n return os.path.splitext(os.path.basename(self.file))[0]","def get_filename(self):\n name, ext = self.fkit.filename.rsplit('.', 1)\n if self._field.extension():\n ext = self._field.extension()\n return '.'.join((name, ext))","def determine_output_ending():\n file_found = False\n idx = 1\n while not file_found:\n if not os.path.isfile(LOG_DIR + \"/output%04d.png\" % (idx)):\n return \"%04d\" % (idx)\n idx += 1","def extension(self):\n #type: ()->Text\n return os.path.splitext(os.path.basename(self.fileName))[1]","def get_output_file_name(run_parameters, dir_name_key, prefix_string, suffix_string='', type_suffix='tsv'):\n output_file_name = os.path.join(run_parameters[dir_name_key], prefix_string + '_' +\n run_parameters['method'] + '_' + run_parameters[\"correlation_measure\"])\n\n output_file_name = kn.create_timestamped_filename(output_file_name) + '_' + suffix_string + '.' + type_suffix\n return output_file_name","def extension(self):\n return os.path.splitext(self.fname)[1]","def basename(self):\n return self._getbyspec(\"basename\")[0]","def out_extension(self) -> str:\n return self._out_extension","def output_file_name(self) -> typing.Optional[str]:\n return self._values.get(\"output_file_name\")","def output_file_name(self) -> typing.Optional[str]:\n return self._values.get(\"output_file_name\")","def output_file_name(self) -> typing.Optional[str]:\n return self._values.get(\"output_file_name\")","def output_file_name(self) -> typing.Optional[str]:\n return self._values.get(\"output_file_name\")","def filename(self, idx: int):\n\n batch_img_idx, _ = self.__get_img_augm_idx__(idx)\n return self.img_files[batch_img_idx]","def get_name(self, suffix_number: int = 0) -> str:\n if suffix_number:\n return f\"{self.name}_{suffix_number}\"\n return cast(str, self.name)","def getSuffix(self):\n stop = 0\n if type(self.stop) is SharedCounter:\n stop = self.stop.getVal()\n else:\n stop = self.stop\n return (self.start, stop)","def _file_name(self, dtype_out_time, extension='nc'):\n out_lbl = utils.io.data_out_label(self.intvl_out, dtype_out_time,\n dtype_vert=self.dtype_out_vert)\n in_lbl = utils.io.data_in_label(self.intvl_in, self.dtype_in_time,\n self.dtype_in_vert)\n ens_lbl = utils.io.ens_label(self.ens_mem)\n yr_lbl = utils.io.yr_label((self.start_date.year, self.end_date.year))\n return '.'.join(\n [self.name, out_lbl, in_lbl, self.model.name,\n self.run.name, ens_lbl, yr_lbl, extension]\n ).replace('..', '.')","def getWaveformFileName(self):\n return self.waveform_info.split(\":\")[1][:20]","def getOutputFilename(self, filename):\n return filename[:-4] + \".txt\"","def get_file_name(self):\n return self.path.name[6:]","def _gen_basename(param_dict, clargs):\n if param_dict['output_basename'] in ['', 'auto']:\n return clargs.input_fname.lower().split('.json')[0]\n\n else:\n return param_dict['output_basename']","def global_replication_group_id_suffix(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"global_replication_group_id_suffix\")","def name(self) -> str:\n if '/' in self.path.strip('/'):\n basename: str = os.path.basename(self.path)\n return basename\n return self.path","def _get_seq_filename(self):\n fnd = self._get_session_dir()\n self.seq_number += 1\n fn = os.path.join(fnd, 'S%4.4d.tif' % self.seq_number)\n return fn","def get_original_basename(self, xaf):\n tag_name = self.__get_original_basename_tag_name()\n return xaf.tags.get(tag_name, b\"unknown\").decode(\"utf8\")","def get_suffix(self,prefix):\n return random.choice(self[prefix])","def get_file_name(self):\n return self.upload.name[6:]","def get_cleaned_suffix(cleaning_protocol, sample, config):\n cleaned_suffix = QC_PROTOCOLS.get(cleaning_protocol, \"\")\n num_raw_files = len(config[\"sample_data\"][sample][\"raw\"])\n\n # special cases\n if cleaning_protocol not in JOINING_PROTOCOLS and num_raw_files == 1:\n # if cleaning one file for assembly, drop interleave\n cleaned_suffix = re.sub(r\"interleaved\", \"\", cleaned_suffix)\n if cleaning_protocol == \"None\" and num_raw_files == 2:\n # if not cleaning, but two files given, interleave them\n cleaned_suffix = \"interleaved\"\n if cleaning_protocol in JOINING_PROTOCOLS:\n # prepend trimmomatic params\n chemistry, barcodes = get_chemistry_barcodes(sample, config)\n barcodes = \".\".join(barcodes)\n cleaned_suffix = \".\".join([chemistry, barcodes]) + \".\" + cleaned_suffix\n\n # make sure it ends in a dot\n cleaned_suffix += \".\"\n\n # remove dupmlicate dots left over from above tweaks\n cleaned_suffix = re.sub(r\"\\.\\.\", \".\", cleaned_suffix)\n\n return cleaned_suffix","async def filename_generator(self):\n chars = list(string.ascii_letters+string.digits)\n name = ''\n for i in range(random.randint(9, 25)):\n name += random.choice(chars)\n\n if name not in self.player['audio_files']:\n return name\n\n return await self.filename_generator()","def file_title(self):\n basename = os.path.basename(self.__path)\n index_dot = basename.rfind(\".\")\n if index_dot == 0:\n return basename[1:]\n return basename if index_dot < 0 else basename[:index_dot]","def get_suffix(cls, raw_disable: RawDisable) -> str:\n variations = raw_disable.parent_test.variations\n\n maybe_variation_node = raw_disable.node.find(f'.//{cls.VARIATION_TAG}')\n if maybe_variation_node is None:\n return ''\n\n variation = maybe_variation_node.text\n if variation not in variations:\n raise DisableNodeProcessingException(f'could not find {variation!r} in defined variations; skipping node')\n\n idx = variations.index(variation)\n suffix = f'_{idx}'\n return suffix","def outputNamingBase(video, audio):\n outbase = os.path.join(\n outfolder,\n \"{}_{}_{}_{}_{}\".format(\n os.path.splitext(basev)[0],\n '___',\n os.path.splitext(basea)[0],\n '___',\n now,\n ))\n return outbase","def GetFilename(self, identifier):\n\n if self.mOutputPattern:\n return re.sub(\"%s\", str(identifier), self.mOutputPattern)\n else:\n return identifier","def purebasename(self):\n return self._getbyspec(\"purebasename\")[0]","def _suffix (self):\n\t\tif self.suffix:\n\t\t\treturn self.suffix\n\n\t\tconfig = { key:val for key, val in self.config.iteritems() if key not in ['workdir', 'forks', 'cache', 'retcodes', 'echo', 'runner', 'exportdir', 'exporthow', 'exportow', 'errorhow', 'errorntry'] or key.endswith ('Runner') }\n\t\tconfig['id'] = self.id\n\t\tconfig['tag'] = self.tag\n\t\t\n\t\tif config.has_key ('callback'):\n\t\t\tconfig['callback'] = utils.funcsig(config['callback'])\n\t\t# proc is not picklable\n\t\tif config.has_key('depends'):\n\t\t\tdepends = config['depends']\n\t\t\tpickable_depends = []\n\t\t\tif isinstance(depends, proc):\n\t\t\t\tdepends = [depends]\n\t\t\telif isinstance(depends, aggr):\n\t\t\t\tdepends = depends.procs\n\t\t\tfor depend in depends:\n\t\t\t\tpickable_depends.append(depend.id + '.' + depend.tag)\n\t\t\tconfig['depends'] = pickable_depends\n\t\t\n\t\t# lambda not pickable\n\t\tif config.has_key ('input') and isinstance(config['input'], dict):\n\t\t\tconfig['input'] = pycopy.copy(config['input'])\n\t\t\tfor key, val in config['input'].iteritems():\n\t\t\t\tconfig['input'][key] = utils.funcsig(val) if callable(val) else val\n\n\t\tsignature = pickle.dumps(str(config))\n\t\tself.props['suffix'] = utils.uid(signature)\n\t\treturn self.suffix","def last_video(self) -> str:\n return max(glob.glob(VIDEOS_DIR), key=os.path.getmtime)","def _get_available_wav_basename(label, basedir):\n cont = 0\n label = os.path.join(basedir, label)\n wav_name = label + \".wav\"\n if os.path.exists(wav_name):\n while True: # search an inexistent name for new gmm\n wav_name = label + \"\" + str(cont) + \".wav\"\n if not os.path.exists(wav_name):\n break\n cont = cont + 1\n else:\n open(label+\".wav\",'w').close()\n return label\n open(label+str(cont)+\".wav\",'w').close()\n return label + str(cont)\n #end _get_available_wav_basename","def ext(self):\n return os.path.splitext(self.path)[1]","def getCurrentFileName(self):\n return os.path.basename(self.filePath)","def name(self):\n return self._output_name","def get_filename(self):\n return self.get_package_name() + '-' + self.os + '-' + self.arch + GPPKG_EXTENSION","def getInputFileBasenameNoSuffix():\n\n inputFileBasename = getInputFileBasename()\n basenameRemovedSuffix = removeSuffix(inputFileBasename)\n return basenameRemovedSuffix","def filename(self):\n # TODO(aron): write tests for this\n\n return os.path.basename(self.file_on_disk.name)","def GetOutputFilename(self, directory=None):\n if self.forced_filename:\n logging.debug('Forced filename or pre-computed file name = %s', self.filename)\n return self.filename\n\n tags = dict()\n\n # Base tag\n tags['base'] = f\"{self['ARTIST']} - {self['DATE_RECORDED']} - {self['TITLE']}\"\n\n # Setup version subinfo\n tags['version'] = f\" ({self['VERSION']})\" if self[\"VERSION\"] else \"\"\n\n # Setup label / release subinfo\n channels = self.channels if self.channels != '2.0' else ''\n if self[\"ORIGINAL_MEDIUM\"] == \"CD\":\n labeltag = f\"{self['LABEL']} {self['ISSUE_DATE']} {channels}\"\n else:\n labeltag = f\"{self['LABEL']} {self['ISSUE_DATE']} {self['ORIGINAL_MEDIUM']} {channels}\"\n labeltag = labeltag.strip()\n tags['label'] = labeltag and f\" ({labeltag})\"\n\n # Setup disc tag\n if self[\"PART_NUMBER\"]:\n disctag = f\" (Disc {self['PART_NUMBER']}) {self['DISC_NAME']}\"\n else:\n disctag = f\" {self['DISC_NAME']}\"\n tags['disc'] = disctag.rstrip()\n\n # Merge into filename\n filename = f\"{tags['base']}{tags['version']}{tags['disc']}{tags['label']}{ext.WAV}\"\n # Replace invalid characters with either a dash or remove them\n filename = re.compile(\"[<>:/\\\\\\\\]\").sub(\"-\", filename)\n filename = re.compile(\"[|?*]\").sub(\"\", filename)\n # Replace invalid double quotes with valid single quotes\n filename = filename.replace('\"', \"'\")\n\n if directory:\n return os.path.join(directory, filename)\n return filename","def global_replication_group_id_suffix(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"global_replication_group_id_suffix\")","def get_filename(target_dir, filename_prefix):\n # This whole function is not the nicest thing, but isolating it makes\n # things clearer. A good refactoring would be to get the info from the\n # video_url or the current output, to avoid the iteration from the\n # current dir.\n filenames = os.listdir(target_dir)\n for name in filenames: # Find the filename of the downloaded video\n if name.startswith(filename_prefix):\n (basename, ext) = os.path.splitext(name)\n return basename\n return None","def get_dest_name ( self ):\n return self.filename"],"string":"[\n \"def suffix(self):\\n return self[\\\"suffix\\\"]\",\n \"def suffix(self):\\n return self[\\\"suffix\\\"]\",\n \"def file_suffix(self):\\n return f'{self.image_count:05}' if self.sequential_naming else \\\\\\n datetime.datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\")\",\n \"def suffix ( self ) :\\n return self.__suffix\",\n \"def suffix ( self ) :\\n return self.__suffix\",\n \"def suffix(self) -> typing.Optional[str]:\\n return self._values.get('suffix')\",\n \"def _suffix(self) -> str:\\n return \\\"\\\"\",\n \"def suffixsrc(self):\\n return self[\\\"suffixsrc\\\"]\",\n \"def suffixsrc(self):\\n return self[\\\"suffixsrc\\\"]\",\n \"def get_suffix(self):\\n if self.device:\\n return self.device\\n else:\\n return '%s%d' % (self.devletters(), self.get_index() + 1)\",\n \"def get_suffix(self):\\n return '%s%d' % (self.disk.devletters(), self.get_index() + 1)\",\n \"def output_filename(self, prefix, suffix):\\n filename = \\\"%s%s%s\\\" % (prefix, _ExecutionWrapper._file_index, suffix)\\n _ExecutionWrapper._file_index += 1\\n return filename\",\n \"def suffix(self) -> Optional[URISuffix]:\\n return self._suffix\",\n \"def get_file_basename(self):\\n return self._basename[:]\",\n \"def getSuffixPattern(self):\\n return self.getOrDefault(\\\"suffixPattern\\\")\",\n \"def suffix():\\r\\n\\r\\n return _random.choice(\\r\\n [\\r\\n 'Sr.', 'Jr.', 'II', 'III', 'IV', 'V'\\r\\n ]\\r\\n )\",\n \"def basename(self):\\n return get_basename(self.filename)\",\n \"def name_woext(self):\\n return os.path.splitext(self._job)[0]\",\n \"def _generate_output_name(extension):\\n output_name = 'TDG_{:%Y-%m-%d_%H-%M-%S}.{}'.format(datetime.now(), extension)\\n return output_name\",\n \"def name(self):\\n suffix = ''\\n if 'suffix' in self.context['strategy'] \\\\\\n and self.context['strategy']['suffix'] is not None \\\\\\n and len(self.context['strategy']['suffix']) > 0:\\n suffix = \\\"_\\\" + self.context['strategy']['suffix']\\n\\n return self.get_name(self.context, suffix)\",\n \"def get_feature_suffix(feature_name: str) -> str:\\n if \\\"_\\\" not in feature_name:\\n return \\\"\\\"\\n return feature_name.split(\\\"_\\\")[-1]\",\n \"def getFileSuffix(filename):\\n fileSuffix = \\\"\\\"\\n\\n if filename:\\n name, extension = os.path.splitext(filename)\\n fileSuffix = extension # .mp3\\n\\n if fileSuffix:\\n # remove leading dot/period\\n fileSuffix = fileSuffix[1:] # mp3\\n\\n if fileSuffix:\\n # remove ending newline or space\\n fileSuffix = fileSuffix.strip()\\n\\n if fileSuffix:\\n # convert JPg to jpg\\n fileSuffix = fileSuffix.lower()\\n\\n return fileSuffix\",\n \"def basename(self) -> str:\\n return self._basename\",\n \"def get_basename(self):\\n return self._basename\",\n \"def filename(self):\\n return self.config.get('filename', self.id) + f'_{self.file_suffix}'\",\n \"def _get_abgp_file_basename(OPTIONS):\\n if OPTIONS.target:\\n try:\\n num_loci = OPTIONS.selected_num_loci\\n except:\\n num_loci = len(OPTIONS.loci) + len(OPTIONS.dnafiles)\\n return \\\"%s.%s%sSL.\\\" % (ABFGP_VERSION,OPTIONS.target,num_loci)\\n else:\\n return \\\"%s.\\\" % ABGP_VERSION\",\n \"def outputname(self, identifier):\\n return self._outprefix+str(identifier)+\\\".\\\"+self._suffix\",\n \"def _metric_name(self, suffix):\\r\\n return '{}.{}'.format(self.METRIC_NAME, suffix)\",\n \"def get_output_filename(self, gzip=False):\\n if self.mode == 'light':\\n suffix = '-light'\\n else:\\n suffix = ''\\n\\n destination = self.destination\\n extension = 'fits'\\n if gzip:\\n destination += '-compressed'\\n extension += '.gz'\\n return os.path.join(destination,\\n 'iphas-dr2-{0}{1}.{2}'.format(\\n self.get_partname(),\\n suffix,\\n extension))\",\n \"def filename(self):\\n return '%s%s' % (self.identifier, self.extension)\",\n \"def global_replication_group_id_suffix(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"global_replication_group_id_suffix\\\")\",\n \"def _identifier_suffix(self):\\r\\n return ''\",\n \"def get_suffix_ml_model():\\n suffix = ''\\n \\n # consider if the model uses tail or not\\n if gml.USE_TAIL: \\n suffix += '_use_tail'\\n else: \\n suffix += '_no_tail'\\n\\n # consider the way of picking target variable for the model\\n if gml.WAY_MODEL_TGT == 'absolute':\\n suffix += '_absolute'\\n elif gml.WAY_MODEL_TGT == 'relative':\\n suffix += '_relative'\\n else: \\n exit('error on the function that gets suffix')\\n\\n return suffix\",\n \"def name(self):\\n #type: ()->Text\\n return (\\n os.path.splitext(os.path.basename(self.fileName))[0])\",\n \"def getSuffix(self):\\r\\n return self.chrom\",\n \"def basename(self):\\n return os.path.basename(self.filepath)\",\n \"def _suffix(self) -> str:\\n return f\\\"!! Expected: {self._expected!r}\\\"\",\n \"def _get_video_filename(self):\\n fnd = self._get_session_dir()\\n self.video_number += 1\\n fn = os.path.join(fnd, 'V%4.4d.avi' % self.video_number)\\n return fn\",\n \"def current_filename(self):\\n if self.char_limit is not None:\\n return '{}/{}.{}.n{}.maf'.format(self.out_dir, self.chrom,\\n self.taxon, self.file_num)\\n else:\\n return '{}/{}.{}.maf'.format(self.out_dir, self.chrom, self.taxon)\",\n \"def name_sans_ext(self) -> str:\\n return os.path.splitext(self.path)[0]\",\n \"def generate_file_name(self):\\n self._session_iterator = None # New file invalidate old interator\\n self._img_count += 1\\n self._current_file = '{0}/frame_{1}.jpg'.format(self._relative_path,self._img_count)\\n return self.current_file\",\n \"def get_filename(target_dir, filename_prefix):\\n # this whole function is not the nicest thing, but isolating it makes\\n # things clearer , a good refactoring would be to get\\n # the info from the video_url or the current output, to avoid the\\n # iteration from the current dir\\n filenames = os.listdir(target_dir)\\n subs_filename = filename_prefix\\n for name in filenames: # Find the filename of the downloaded video\\n if name.startswith(filename_prefix):\\n (basename, ext) = os.path.splitext(name)\\n return basename\",\n \"def basename(self):\\n return self.name.basename\",\n \"def getSuffixLink(self):\\n return self.suffix_link\",\n \"def exe_suffix():\\n if sys.platform == 'win32':\\n return '.exe'\\n return ''\",\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 name(self):\\n\\t\\tnam = super( textureFile, self ).name\\n\\t\\tif self.hasUdim:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\treturn nam[:nam.rindex( '.' )]\\n\\t\\t\\texcept:\\n\\t\\t\\t\\treturn nam\\n\\t\\treturn nam\",\n \"def full_name(self):\\n return \\\"output.%s\\\" % self.name\",\n \"def filename(self):\\n filename, ext = os.path.splitext(self.file.name)\\n return filename.split('/')[-1]\",\n \"def _get_suffix(bin, VoronoiSN):\\n \\n if VoronoiSN is not None:\\n suffix = \\\"SN{0:03d}\\\".format(VoronoiSN)\\n else:\\n suffix = \\\"bin{0:02d}\\\".format(bin)\\n\\n return suffix\",\n \"def getPlayerFilename(self):\\n if (self.__playerName != \\\"???\\\"):\\n return self.__filename\\n else:\\n return \\\"\\\"\",\n \"def basename(self):\\n return self._basename\",\n \"def get_release_name(self) -> str:\\n if self.season is not None and self.episode is None:\\n return os.path.basename(os.path.dirname(self.file))\\n return os.path.splitext(os.path.basename(self.file))[0]\",\n \"def get_filename(self):\\n name, ext = self.fkit.filename.rsplit('.', 1)\\n if self._field.extension():\\n ext = self._field.extension()\\n return '.'.join((name, ext))\",\n \"def determine_output_ending():\\n file_found = False\\n idx = 1\\n while not file_found:\\n if not os.path.isfile(LOG_DIR + \\\"/output%04d.png\\\" % (idx)):\\n return \\\"%04d\\\" % (idx)\\n idx += 1\",\n \"def extension(self):\\n #type: ()->Text\\n return os.path.splitext(os.path.basename(self.fileName))[1]\",\n \"def get_output_file_name(run_parameters, dir_name_key, prefix_string, suffix_string='', type_suffix='tsv'):\\n output_file_name = os.path.join(run_parameters[dir_name_key], prefix_string + '_' +\\n run_parameters['method'] + '_' + run_parameters[\\\"correlation_measure\\\"])\\n\\n output_file_name = kn.create_timestamped_filename(output_file_name) + '_' + suffix_string + '.' + type_suffix\\n return output_file_name\",\n \"def extension(self):\\n return os.path.splitext(self.fname)[1]\",\n \"def basename(self):\\n return self._getbyspec(\\\"basename\\\")[0]\",\n \"def out_extension(self) -> str:\\n return self._out_extension\",\n \"def output_file_name(self) -> typing.Optional[str]:\\n return self._values.get(\\\"output_file_name\\\")\",\n \"def output_file_name(self) -> typing.Optional[str]:\\n return self._values.get(\\\"output_file_name\\\")\",\n \"def output_file_name(self) -> typing.Optional[str]:\\n return self._values.get(\\\"output_file_name\\\")\",\n \"def output_file_name(self) -> typing.Optional[str]:\\n return self._values.get(\\\"output_file_name\\\")\",\n \"def filename(self, idx: int):\\n\\n batch_img_idx, _ = self.__get_img_augm_idx__(idx)\\n return self.img_files[batch_img_idx]\",\n \"def get_name(self, suffix_number: int = 0) -> str:\\n if suffix_number:\\n return f\\\"{self.name}_{suffix_number}\\\"\\n return cast(str, self.name)\",\n \"def getSuffix(self):\\n stop = 0\\n if type(self.stop) is SharedCounter:\\n stop = self.stop.getVal()\\n else:\\n stop = self.stop\\n return (self.start, stop)\",\n \"def _file_name(self, dtype_out_time, extension='nc'):\\n out_lbl = utils.io.data_out_label(self.intvl_out, dtype_out_time,\\n dtype_vert=self.dtype_out_vert)\\n in_lbl = utils.io.data_in_label(self.intvl_in, self.dtype_in_time,\\n self.dtype_in_vert)\\n ens_lbl = utils.io.ens_label(self.ens_mem)\\n yr_lbl = utils.io.yr_label((self.start_date.year, self.end_date.year))\\n return '.'.join(\\n [self.name, out_lbl, in_lbl, self.model.name,\\n self.run.name, ens_lbl, yr_lbl, extension]\\n ).replace('..', '.')\",\n \"def getWaveformFileName(self):\\n return self.waveform_info.split(\\\":\\\")[1][:20]\",\n \"def getOutputFilename(self, filename):\\n return filename[:-4] + \\\".txt\\\"\",\n \"def get_file_name(self):\\n return self.path.name[6:]\",\n \"def _gen_basename(param_dict, clargs):\\n if param_dict['output_basename'] in ['', 'auto']:\\n return clargs.input_fname.lower().split('.json')[0]\\n\\n else:\\n return param_dict['output_basename']\",\n \"def global_replication_group_id_suffix(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"global_replication_group_id_suffix\\\")\",\n \"def name(self) -> str:\\n if '/' in self.path.strip('/'):\\n basename: str = os.path.basename(self.path)\\n return basename\\n return self.path\",\n \"def _get_seq_filename(self):\\n fnd = self._get_session_dir()\\n self.seq_number += 1\\n fn = os.path.join(fnd, 'S%4.4d.tif' % self.seq_number)\\n return fn\",\n \"def get_original_basename(self, xaf):\\n tag_name = self.__get_original_basename_tag_name()\\n return xaf.tags.get(tag_name, b\\\"unknown\\\").decode(\\\"utf8\\\")\",\n \"def get_suffix(self,prefix):\\n return random.choice(self[prefix])\",\n \"def get_file_name(self):\\n return self.upload.name[6:]\",\n \"def get_cleaned_suffix(cleaning_protocol, sample, config):\\n cleaned_suffix = QC_PROTOCOLS.get(cleaning_protocol, \\\"\\\")\\n num_raw_files = len(config[\\\"sample_data\\\"][sample][\\\"raw\\\"])\\n\\n # special cases\\n if cleaning_protocol not in JOINING_PROTOCOLS and num_raw_files == 1:\\n # if cleaning one file for assembly, drop interleave\\n cleaned_suffix = re.sub(r\\\"interleaved\\\", \\\"\\\", cleaned_suffix)\\n if cleaning_protocol == \\\"None\\\" and num_raw_files == 2:\\n # if not cleaning, but two files given, interleave them\\n cleaned_suffix = \\\"interleaved\\\"\\n if cleaning_protocol in JOINING_PROTOCOLS:\\n # prepend trimmomatic params\\n chemistry, barcodes = get_chemistry_barcodes(sample, config)\\n barcodes = \\\".\\\".join(barcodes)\\n cleaned_suffix = \\\".\\\".join([chemistry, barcodes]) + \\\".\\\" + cleaned_suffix\\n\\n # make sure it ends in a dot\\n cleaned_suffix += \\\".\\\"\\n\\n # remove dupmlicate dots left over from above tweaks\\n cleaned_suffix = re.sub(r\\\"\\\\.\\\\.\\\", \\\".\\\", cleaned_suffix)\\n\\n return cleaned_suffix\",\n \"async def filename_generator(self):\\n chars = list(string.ascii_letters+string.digits)\\n name = ''\\n for i in range(random.randint(9, 25)):\\n name += random.choice(chars)\\n\\n if name not in self.player['audio_files']:\\n return name\\n\\n return await self.filename_generator()\",\n \"def file_title(self):\\n basename = os.path.basename(self.__path)\\n index_dot = basename.rfind(\\\".\\\")\\n if index_dot == 0:\\n return basename[1:]\\n return basename if index_dot < 0 else basename[:index_dot]\",\n \"def get_suffix(cls, raw_disable: RawDisable) -> str:\\n variations = raw_disable.parent_test.variations\\n\\n maybe_variation_node = raw_disable.node.find(f'.//{cls.VARIATION_TAG}')\\n if maybe_variation_node is None:\\n return ''\\n\\n variation = maybe_variation_node.text\\n if variation not in variations:\\n raise DisableNodeProcessingException(f'could not find {variation!r} in defined variations; skipping node')\\n\\n idx = variations.index(variation)\\n suffix = f'_{idx}'\\n return suffix\",\n \"def outputNamingBase(video, audio):\\n outbase = os.path.join(\\n outfolder,\\n \\\"{}_{}_{}_{}_{}\\\".format(\\n os.path.splitext(basev)[0],\\n '___',\\n os.path.splitext(basea)[0],\\n '___',\\n now,\\n ))\\n return outbase\",\n \"def GetFilename(self, identifier):\\n\\n if self.mOutputPattern:\\n return re.sub(\\\"%s\\\", str(identifier), self.mOutputPattern)\\n else:\\n return identifier\",\n \"def purebasename(self):\\n return self._getbyspec(\\\"purebasename\\\")[0]\",\n \"def _suffix (self):\\n\\t\\tif self.suffix:\\n\\t\\t\\treturn self.suffix\\n\\n\\t\\tconfig = { key:val for key, val in self.config.iteritems() if key not in ['workdir', 'forks', 'cache', 'retcodes', 'echo', 'runner', 'exportdir', 'exporthow', 'exportow', 'errorhow', 'errorntry'] or key.endswith ('Runner') }\\n\\t\\tconfig['id'] = self.id\\n\\t\\tconfig['tag'] = self.tag\\n\\t\\t\\n\\t\\tif config.has_key ('callback'):\\n\\t\\t\\tconfig['callback'] = utils.funcsig(config['callback'])\\n\\t\\t# proc is not picklable\\n\\t\\tif config.has_key('depends'):\\n\\t\\t\\tdepends = config['depends']\\n\\t\\t\\tpickable_depends = []\\n\\t\\t\\tif isinstance(depends, proc):\\n\\t\\t\\t\\tdepends = [depends]\\n\\t\\t\\telif isinstance(depends, aggr):\\n\\t\\t\\t\\tdepends = depends.procs\\n\\t\\t\\tfor depend in depends:\\n\\t\\t\\t\\tpickable_depends.append(depend.id + '.' + depend.tag)\\n\\t\\t\\tconfig['depends'] = pickable_depends\\n\\t\\t\\n\\t\\t# lambda not pickable\\n\\t\\tif config.has_key ('input') and isinstance(config['input'], dict):\\n\\t\\t\\tconfig['input'] = pycopy.copy(config['input'])\\n\\t\\t\\tfor key, val in config['input'].iteritems():\\n\\t\\t\\t\\tconfig['input'][key] = utils.funcsig(val) if callable(val) else val\\n\\n\\t\\tsignature = pickle.dumps(str(config))\\n\\t\\tself.props['suffix'] = utils.uid(signature)\\n\\t\\treturn self.suffix\",\n \"def last_video(self) -> str:\\n return max(glob.glob(VIDEOS_DIR), key=os.path.getmtime)\",\n \"def _get_available_wav_basename(label, basedir):\\n cont = 0\\n label = os.path.join(basedir, label)\\n wav_name = label + \\\".wav\\\"\\n if os.path.exists(wav_name):\\n while True: # search an inexistent name for new gmm\\n wav_name = label + \\\"\\\" + str(cont) + \\\".wav\\\"\\n if not os.path.exists(wav_name):\\n break\\n cont = cont + 1\\n else:\\n open(label+\\\".wav\\\",'w').close()\\n return label\\n open(label+str(cont)+\\\".wav\\\",'w').close()\\n return label + str(cont)\\n #end _get_available_wav_basename\",\n \"def ext(self):\\n return os.path.splitext(self.path)[1]\",\n \"def getCurrentFileName(self):\\n return os.path.basename(self.filePath)\",\n \"def name(self):\\n return self._output_name\",\n \"def get_filename(self):\\n return self.get_package_name() + '-' + self.os + '-' + self.arch + GPPKG_EXTENSION\",\n \"def getInputFileBasenameNoSuffix():\\n\\n inputFileBasename = getInputFileBasename()\\n basenameRemovedSuffix = removeSuffix(inputFileBasename)\\n return basenameRemovedSuffix\",\n \"def filename(self):\\n # TODO(aron): write tests for this\\n\\n return os.path.basename(self.file_on_disk.name)\",\n \"def GetOutputFilename(self, directory=None):\\n if self.forced_filename:\\n logging.debug('Forced filename or pre-computed file name = %s', self.filename)\\n return self.filename\\n\\n tags = dict()\\n\\n # Base tag\\n tags['base'] = f\\\"{self['ARTIST']} - {self['DATE_RECORDED']} - {self['TITLE']}\\\"\\n\\n # Setup version subinfo\\n tags['version'] = f\\\" ({self['VERSION']})\\\" if self[\\\"VERSION\\\"] else \\\"\\\"\\n\\n # Setup label / release subinfo\\n channels = self.channels if self.channels != '2.0' else ''\\n if self[\\\"ORIGINAL_MEDIUM\\\"] == \\\"CD\\\":\\n labeltag = f\\\"{self['LABEL']} {self['ISSUE_DATE']} {channels}\\\"\\n else:\\n labeltag = f\\\"{self['LABEL']} {self['ISSUE_DATE']} {self['ORIGINAL_MEDIUM']} {channels}\\\"\\n labeltag = labeltag.strip()\\n tags['label'] = labeltag and f\\\" ({labeltag})\\\"\\n\\n # Setup disc tag\\n if self[\\\"PART_NUMBER\\\"]:\\n disctag = f\\\" (Disc {self['PART_NUMBER']}) {self['DISC_NAME']}\\\"\\n else:\\n disctag = f\\\" {self['DISC_NAME']}\\\"\\n tags['disc'] = disctag.rstrip()\\n\\n # Merge into filename\\n filename = f\\\"{tags['base']}{tags['version']}{tags['disc']}{tags['label']}{ext.WAV}\\\"\\n # Replace invalid characters with either a dash or remove them\\n filename = re.compile(\\\"[<>:/\\\\\\\\\\\\\\\\]\\\").sub(\\\"-\\\", filename)\\n filename = re.compile(\\\"[|?*]\\\").sub(\\\"\\\", filename)\\n # Replace invalid double quotes with valid single quotes\\n filename = filename.replace('\\\"', \\\"'\\\")\\n\\n if directory:\\n return os.path.join(directory, filename)\\n return filename\",\n \"def global_replication_group_id_suffix(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"global_replication_group_id_suffix\\\")\",\n \"def get_filename(target_dir, filename_prefix):\\n # This whole function is not the nicest thing, but isolating it makes\\n # things clearer. A good refactoring would be to get the info from the\\n # video_url or the current output, to avoid the iteration from the\\n # current dir.\\n filenames = os.listdir(target_dir)\\n for name in filenames: # Find the filename of the downloaded video\\n if name.startswith(filename_prefix):\\n (basename, ext) = os.path.splitext(name)\\n return basename\\n return None\",\n \"def get_dest_name ( self ):\\n return self.filename\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7610536","0.7610536","0.75316405","0.7521287","0.7521287","0.7347243","0.7304037","0.70785016","0.70785016","0.70710915","0.7039384","0.69881004","0.6693291","0.6596418","0.65870094","0.651454","0.64653707","0.6425669","0.63848877","0.63419944","0.6322918","0.6322515","0.63209456","0.62993026","0.6295164","0.6284368","0.6268517","0.6260777","0.6250806","0.6248273","0.6237964","0.62098306","0.6205975","0.6202707","0.6194487","0.61729425","0.61353976","0.6116416","0.6096","0.6092614","0.6073773","0.6071069","0.6067798","0.60595644","0.6045418","0.6044378","0.60408497","0.60390747","0.6034978","0.6028224","0.60252076","0.6024062","0.6023865","0.60224724","0.6004676","0.60011345","0.5996945","0.59882325","0.5978397","0.5977195","0.5970318","0.5970318","0.5970318","0.5970318","0.59681183","0.5961984","0.59618497","0.5958936","0.595721","0.5946282","0.593943","0.5935916","0.5927329","0.5921983","0.59045595","0.58906585","0.5886978","0.5882312","0.5878371","0.5865968","0.58574706","0.58520263","0.5845778","0.584173","0.58414036","0.58397216","0.5822703","0.58188796","0.5817619","0.58168215","0.58136314","0.5813613","0.580515","0.5804634","0.5797454","0.57951874","0.57904345","0.5779044"],"string":"[\n \"0.7610536\",\n \"0.7610536\",\n \"0.75316405\",\n \"0.7521287\",\n \"0.7521287\",\n \"0.7347243\",\n \"0.7304037\",\n \"0.70785016\",\n \"0.70785016\",\n \"0.70710915\",\n \"0.7039384\",\n \"0.69881004\",\n \"0.6693291\",\n \"0.6596418\",\n \"0.65870094\",\n \"0.651454\",\n \"0.64653707\",\n \"0.6425669\",\n \"0.63848877\",\n \"0.63419944\",\n \"0.6322918\",\n \"0.6322515\",\n \"0.63209456\",\n \"0.62993026\",\n \"0.6295164\",\n \"0.6284368\",\n \"0.6268517\",\n \"0.6260777\",\n \"0.6250806\",\n \"0.6248273\",\n \"0.6237964\",\n \"0.62098306\",\n \"0.6205975\",\n \"0.6202707\",\n \"0.6194487\",\n \"0.61729425\",\n \"0.61353976\",\n \"0.6116416\",\n \"0.6096\",\n \"0.6092614\",\n \"0.6073773\",\n \"0.6071069\",\n \"0.6067798\",\n \"0.60595644\",\n \"0.6045418\",\n \"0.6044378\",\n \"0.60408497\",\n \"0.60390747\",\n \"0.6034978\",\n \"0.6028224\",\n \"0.60252076\",\n \"0.6024062\",\n \"0.6023865\",\n \"0.60224724\",\n \"0.6004676\",\n \"0.60011345\",\n \"0.5996945\",\n \"0.59882325\",\n \"0.5978397\",\n \"0.5977195\",\n \"0.5970318\",\n \"0.5970318\",\n \"0.5970318\",\n \"0.5970318\",\n \"0.59681183\",\n \"0.5961984\",\n \"0.59618497\",\n \"0.5958936\",\n \"0.595721\",\n \"0.5946282\",\n \"0.593943\",\n \"0.5935916\",\n \"0.5927329\",\n \"0.5921983\",\n \"0.59045595\",\n \"0.58906585\",\n \"0.5886978\",\n \"0.5882312\",\n \"0.5878371\",\n \"0.5865968\",\n \"0.58574706\",\n \"0.58520263\",\n \"0.5845778\",\n \"0.584173\",\n \"0.58414036\",\n \"0.58397216\",\n \"0.5822703\",\n \"0.58188796\",\n \"0.5817619\",\n \"0.58168215\",\n \"0.58136314\",\n \"0.5813613\",\n \"0.580515\",\n \"0.5804634\",\n \"0.5797454\",\n \"0.57951874\",\n \"0.57904345\",\n \"0.5779044\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7638083"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":76583,"cells":{"query":{"kind":"string","value":"Sets the suffix of this GIFOutput. Unique ending of the file name so several outputs can be created then identified. Required if there is more then 1 video output."},"document":{"kind":"string","value":"def suffix(self, suffix):\n\n self._suffix = suffix"},"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 setSuffix(self, value):\n return self._set(suffix=value)","def file_suffix(self):\n return f'{self.image_count:05}' if self.sequential_naming else \\\n datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")","def suffix(self):\n return self._suffix","def suffix(self):\n return self._suffix","def suffix(self):\n return self._suffix","def suffix(self):\n return self[\"suffix\"]","def suffix(self):\n return self[\"suffix\"]","def _suffix(self) -> str:\n return \"\"","def suffix ( self ) :\n return self.__suffix","def suffix ( self ) :\n return self.__suffix","def suffix(self) -> typing.Optional[str]:\n return self._values.get('suffix')","def output_filename(self, prefix, suffix):\n filename = \"%s%s%s\" % (prefix, _ExecutionWrapper._file_index, suffix)\n _ExecutionWrapper._file_index += 1\n return filename","def __add_filename_suffix(filename, suffix):\n return \"{}{}.pdf\".format(filename.split(\".pdf\", 1)[0], suffix)","def _metric_name(self, suffix):\r\n return '{}.{}'.format(self.METRIC_NAME, suffix)","def set_filter_suffix(self, suffix, verbose=False):\n if verbose:\n print(\"Running set_filter_suffix.\")\n for key in [\"STAR\",\"QSO\",\"GAL\"]:\n self.set_value(\"%s_LIB\"%key, \"LIB_%s_%s\"%(key,suffix))\n self.set_value(\"%s_LIB_IN\"%key, \"LIB_%s_%s\"%(key,suffix))\n self.set_value(\"%s_LIB_OUT\"%key, \"%s_%s\"%(key,suffix))\n\n self.set_value(\"FILTER_FILE\", suffix+\".filt\")\n self.set_zphotlib(verbose=verbose)","def add_suffix(name: str, suffix: str):\n return f'{name}_{suffix}'","def candidate_suffix(self, candidate_suffix):\n\n self._candidate_suffix = candidate_suffix","def suffix():\r\n\r\n return _random.choice(\r\n [\r\n 'Sr.', 'Jr.', 'II', 'III', 'IV', 'V'\r\n ]\r\n )","def suffix(self) -> Optional[URISuffix]:\n return self._suffix","def suffixsrc(self):\n return self[\"suffixsrc\"]","def suffixsrc(self):\n return self[\"suffixsrc\"]","def add_suffix_to_filename(filename, suffix):\n name, ext = os.path.splitext(filename)\n return ''.join([name, suffix, ext])","def change_to_video_name(csv_name, suffix):\n return csv_name[:-10]+\".\"+suffix","def setSuffixPattern(self, value):\n return self._set(suffixPattern=value)","def replace_suffix (name, new_suffix):\n assert isinstance(name, basestring)\n assert isinstance(new_suffix, basestring)\n split = os.path.splitext (name)\n return split [0] + new_suffix","def get_suffix(self):\n return '%s%d' % (self.disk.devletters(), self.get_index() + 1)","def replsuffix(files, suffix):\n\toutfiles = []\n\tif suffix is None: return\n\tif type(files) is type(\"\"):\n\t\tfiles = [files]\n\tfor f in files:\n\t\tfname, ext = os.path.splitext(f)\n\t\tnewfname = fname + suffix\n\t\toutfiles.append(newfname)\n\treturn outfiles","def case_suffix(self, **case_kws):\n if callable(self.output_suffix):\n return self.output_suffix(**case_kws)\n else:\n return self.output_suffix.format(**case_kws)","def _suffix(self) -> str:\n return f\"!! Expected: {self._expected!r}\"","def build_base_filename(self):\n if self.stream:\n self.stream.close()\n self.stream = None\n\n # remove old suffix\n # if self.suffix_time != \"\":\n # index = self.baseFilename.find(\".\" + self.suffix_time)\n # if index == -1:\n # index = self.baseFilename.rfind(\".\")\n # self.baseFilename = self.baseFilename[:index]\n\n # add new suffix\n current_time_tuple = time.localtime()\n self.suffix_time = time.strftime(self.suffix, current_time_tuple)\n self.baseFilename = self._get_format_filename()\n\n self.mode = 'a'\n if not self.delay:\n self.stream = self._open()","def _replace_suffix(self, word, suffix, replacement):\n assert word.endswith(suffix), \"Given word doesn't end with given suffix\"\n if suffix == \"\":\n return word + replacement\n else:\n return word[: -len(suffix)] + replacement","def addSuffixLink(self, suffix_link):\n self.suffix_link = suffix_link","def get_suffix(self):\n if self.device:\n return self.device\n else:\n return '%s%d' % (self.devletters(), self.get_index() + 1)","def add_suffix(in_image,\n suffix_str):\n bandnames = in_image.bandNames().map(lambda elem: ee.String(elem).toLowerCase().cat('_').cat(suffix_str))\n nb = bandnames.length()\n return in_image.select(ee.List.sequence(0, ee.Number(nb).subtract(1)), bandnames)","def _identifier_suffix(self):\r\n return ''","def get_name(self, suffix_number: int = 0) -> str:\n if suffix_number:\n return f\"{self.name}_{suffix_number}\"\n return cast(str, self.name)","def _suffix (self):\n\t\tif self.suffix:\n\t\t\treturn self.suffix\n\n\t\tconfig = { key:val for key, val in self.config.iteritems() if key not in ['workdir', 'forks', 'cache', 'retcodes', 'echo', 'runner', 'exportdir', 'exporthow', 'exportow', 'errorhow', 'errorntry'] or key.endswith ('Runner') }\n\t\tconfig['id'] = self.id\n\t\tconfig['tag'] = self.tag\n\t\t\n\t\tif config.has_key ('callback'):\n\t\t\tconfig['callback'] = utils.funcsig(config['callback'])\n\t\t# proc is not picklable\n\t\tif config.has_key('depends'):\n\t\t\tdepends = config['depends']\n\t\t\tpickable_depends = []\n\t\t\tif isinstance(depends, proc):\n\t\t\t\tdepends = [depends]\n\t\t\telif isinstance(depends, aggr):\n\t\t\t\tdepends = depends.procs\n\t\t\tfor depend in depends:\n\t\t\t\tpickable_depends.append(depend.id + '.' + depend.tag)\n\t\t\tconfig['depends'] = pickable_depends\n\t\t\n\t\t# lambda not pickable\n\t\tif config.has_key ('input') and isinstance(config['input'], dict):\n\t\t\tconfig['input'] = pycopy.copy(config['input'])\n\t\t\tfor key, val in config['input'].iteritems():\n\t\t\t\tconfig['input'][key] = utils.funcsig(val) if callable(val) else val\n\n\t\tsignature = pickle.dumps(str(config))\n\t\tself.props['suffix'] = utils.uid(signature)\n\t\treturn self.suffix","def getFileSuffix(filename):\n fileSuffix = \"\"\n\n if filename:\n name, extension = os.path.splitext(filename)\n fileSuffix = extension # .mp3\n\n if fileSuffix:\n # remove leading dot/period\n fileSuffix = fileSuffix[1:] # mp3\n\n if fileSuffix:\n # remove ending newline or space\n fileSuffix = fileSuffix.strip()\n\n if fileSuffix:\n # convert JPg to jpg\n fileSuffix = fileSuffix.lower()\n\n return fileSuffix","def add_suffix(self, suffix):\n # Append the suffix vowel to this WordForm.\n self.segments.append(Segment.new_segment(suffix))","def _generate_output_name(extension):\n output_name = 'TDG_{:%Y-%m-%d_%H-%M-%S}.{}'.format(datetime.now(), extension)\n return output_name","def add_filename_suffix(filepath, suffix):\r\n root, extension = splitext(basename(filepath))\r\n return root + suffix + extension","def getSuffixPattern(self):\n return self.getOrDefault(\"suffixPattern\")","def outputname(self, identifier):\n return self._outprefix+str(identifier)+\".\"+self._suffix","def setSuffixes(self, s):\n return self._set(suffixes=s)","def temp_file_name(suffix):\n return 'tmp%s%s' % (uuid.uuid4(), suffix)","def __rename_file(filename, suffix):\n filename = PDFWorkshop.__clean_filename(filename)\n return PDFWorkshop.__add_filename_suffix(filename, suffix)","def filename(self):\n return self.config.get('filename', self.id) + f'_{self.file_suffix}'","def suffix(string, suffix, sep = '_'):\n if suffix == 'production':\n suffixed = string\n else:\n suffixed = string + sep + suffix\n return suffixed","def payee_suffix(self, payee_suffix):\n\n self._payee_suffix = payee_suffix","def get_suffix_ml_model():\n suffix = ''\n \n # consider if the model uses tail or not\n if gml.USE_TAIL: \n suffix += '_use_tail'\n else: \n suffix += '_no_tail'\n\n # consider the way of picking target variable for the model\n if gml.WAY_MODEL_TGT == 'absolute':\n suffix += '_absolute'\n elif gml.WAY_MODEL_TGT == 'relative':\n suffix += '_relative'\n else: \n exit('error on the function that gets suffix')\n\n return suffix","def removesuffix(self, x) -> String:\n pass","def exe_suffix():\n if sys.platform == 'win32':\n return '.exe'\n return ''","def force_suffix(fname, suffix):\r\n head, tail = pp.split(fname)\r\n if len(tail) == 0:\r\n return head\r\n if suffix[0] == \".\":\r\n suffix = suffix[1:]\r\n fpart, fext = pp.splitext(tail)\r\n newp = pp.join(head, fpart + \".\" + suffix)\r\n return pp.normpath(newp)","def getSuffixLink(self):\n return self.suffix_link","def name(self):\n suffix = ''\n if 'suffix' in self.context['strategy'] \\\n and self.context['strategy']['suffix'] is not None \\\n and len(self.context['strategy']['suffix']) > 0:\n suffix = \"_\" + self.context['strategy']['suffix']\n\n return self.get_name(self.context, suffix)","def get_feature_suffix(feature_name: str) -> str:\n if \"_\" not in feature_name:\n return \"\"\n return feature_name.split(\"_\")[-1]","def current_filename(self):\n if self.char_limit is not None:\n return '{}/{}.{}.n{}.maf'.format(self.out_dir, self.chrom,\n self.taxon, self.file_num)\n else:\n return '{}/{}.{}.maf'.format(self.out_dir, self.chrom, self.taxon)","def __newFileName(self):\n now = datetime.now()\n dateTimeAppend = now.strftime('%y%m%d_%H%M%S')\n self.__fileName = '{}/{}_{}.wav'.format(RECORDING,\n FILE_NAME_PREFIX, \n dateTimeAppend)","def __setPlayerFilename(self):\n if self.__playerName != \"???\":\n l=self.__playerName.rsplit(\" \")\n nameWithoutSpaces=\"_\".join(l)\n self.__filename = fileLocs.playerProfiles+\"\\\\\"+nameWithoutSpaces+r\".p\"","def setExtension(self, ext):\n if ext:\n self._writer.extension = ext\n else:\n self._writer.extension = None","def SetFileName(self, filename):\n WriteImageDataToUBC.SetFileName(self, filename)","def output_filename(self, modifier):\n fs = self._filesystem\n output_filename = fs.join(self._root_output_dir, self._test_name)\n return fs.splitext(output_filename)[0] + modifier","def addSuffixes(self, alist):\n for i, (word, filename) in enumerate(alist):\n withsuffix = self._findVideoFile(filename)\n alist[i] = (word, withsuffix)\n return alist","def remove_suffix(input_string, suffix):\n if suffix and input_string.endswith(suffix):\n return input_string[:-len(suffix)]\n return input_string","def get_output_filename(self, gzip=False):\n if self.mode == 'light':\n suffix = '-light'\n else:\n suffix = ''\n\n destination = self.destination\n extension = 'fits'\n if gzip:\n destination += '-compressed'\n extension += '.gz'\n return os.path.join(destination,\n 'iphas-dr2-{0}{1}.{2}'.format(\n self.get_partname(),\n suffix,\n extension))","def get_alternative_name(self, file_root, file_ext):\n return \"%s_%s%s\" % (file_root, get_random_string(7), file_ext)","def suffix(self, e, remaining, rate):\n return f' {e + 1}/{self.max} [{remaining} remaining, {round(rate, 2)} iter/s]'","def AssignOutputFilename(self, output_file):\n if output_file is None:\n gmt = time.gmtime()\n ts = calendar.timegm(gmt)\n return f\"{self.input_file}.{ts}\"\n return output_file","def strip_optional_suffix(string, suffix):\n if string.endswith(suffix):\n string = string[:-len(suffix)]\n return string","def parse_suffix_command(self):\n evt_string = self.event['text']\n\n arg_string, suffix = evt_string[:-2], evt_string[-2:]\n\n if arg_string and (suffix in self.valid_suffixes.keys()):\n plugin = self.valid_suffixes[suffix](\n self.event,\n arg_string,\n suffix\n )\n plugin.run()","def _get_suffix(bin, VoronoiSN):\n \n if VoronoiSN is not None:\n suffix = \"SN{0:03d}\".format(VoronoiSN)\n else:\n suffix = \"bin{0:02d}\".format(bin)\n\n return suffix","def create_filename(value):\n return '%s.mp3' % slugify(value, u'_')","def storage_endpoint_suffix(self, storage_endpoint_suffix):\n\n self._storage_endpoint_suffix = storage_endpoint_suffix","def GenerateOutputFilename(extension):\n\n # used for resolv.conf\n if '.' in extension:\n filename = extension\n else:\n output_base = 'namebench_%s' % datetime.datetime.strftime(datetime.datetime.now(),\n '%Y-%m-%d %H%M')\n output_base = output_base.replace(':', '').replace(' ', '_')\n filename = '.'.join((output_base, extension))\n\n output_dir = tempfile.gettempdir()\n return os.path.join(output_dir, filename)","def test_suffix():\n transformer = hug.transform.suffix({\".js\": int, \".txt\": str})\n\n class FakeRequest(object):\n path = \"hey.js\"\n\n request = FakeRequest()\n assert transformer(\"1\", request) == 1\n\n request.path = \"hey.txt\"\n assert transformer(2, request) == \"2\"\n\n request.path = \"hey.undefined\"\n transformer({\"data\": \"value\"}, request) == {\"data\": \"value\"}","def filename(self):\n return '%s%s' % (self.identifier, self.extension)","def save(self, filename=None, show_path=False, use_ffmpeg=False, **kwds):\n if filename is None:\n suffix = '.gif'\n else:\n suffix = os.path.splitext(filename)[1]\n if len(suffix) == 0:\n suffix = '.gif'\n\n if filename is None or suffix == '.gif':\n self.gif(savefile=filename, show_path=show_path,\n use_ffmpeg=use_ffmpeg, **kwds)\n elif suffix == '.sobj':\n SageObject.save(self, filename)\n if show_path:\n print(\"Animation saved to file %s.\" % filename)\n else:\n self.ffmpeg(savefile=filename, show_path=show_path, **kwds)","def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True, ext=None):\n if not basename:\n msg = \"Unable to generate filename for command %s. \" % self.cmd\n msg += \"basename is not set!\"\n raise ValueError(msg)\n\n if cwd is None:\n cwd = os.getcwd()\n if ext is None:\n ext = Info.output_type_to_ext(self.inputs.outputtype)\n if change_ext:\n suffix = \"\".join((suffix, ext)) if suffix else ext\n\n if suffix is None:\n suffix = \"\"\n fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)\n return fname","def _set_job_name(self):\n job_path = '{}/{}'.format(self.rism3d_folder, self.job_name)\n job_name_list = glob.glob(job_path)\n if len(job_name_list) < 1:\n self._not_found_error(self.job_name)\n elif len(job_name_list) > 1:\n self._many_files_error(self.job_name)\n else:\n name = os.path.split(job_name_list[0])[1]\n self.job_name = '.'.join(name.split('.')[:-1])","def name_sans_ext(self) -> str:\n return os.path.splitext(self.path)[0]","def StripOptionalSuffix(string, suffix):\n if string.endswith(suffix):\n string = string[:-len(suffix)]\n return string","def global_replication_group_id_suffix(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"global_replication_group_id_suffix\")","def is_suffix(suffix: str, word: str):\n return word.endswith(suffix)","def name_woext(self):\n return os.path.splitext(self._job)[0]","def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\n ext='.mif'):\n\n if basename == '':\n msg = 'Unable to generate filename for command %s. ' % self.cmd\n msg += 'basename is not set!'\n raise ValueError(msg)\n if cwd is None:\n cwd = os.getcwd()\n if change_ext:\n if suffix:\n suffix = ''.join((suffix, ext))\n else:\n suffix = ext\n if suffix is None:\n suffix = ''\n fname = fname_presuffix(basename, suffix=suffix,\n use_ext=False, newpath=cwd)\n return fname","def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\n ext='.mif'):\n\n if basename == '':\n msg = 'Unable to generate filename for command %s. ' % self.cmd\n msg += 'basename is not set!'\n raise ValueError(msg)\n if cwd is None:\n cwd = os.getcwd()\n if change_ext:\n if suffix:\n suffix = ''.join((suffix, ext))\n else:\n suffix = ext\n if suffix is None:\n suffix = ''\n fname = fname_presuffix(basename, suffix=suffix,\n use_ext=False, newpath=cwd)\n return fname","def setFinalFileName(self, offset=0):\n while True:\n tempFinalFileName = input(\n offset * \" \" + \"Specify a final file name [%s]: \" % self.finalFileName) or self.finalFileName\n # Check 'tempFinalFileName' for bad formatting\n if len(re.findall(r'[^A-Za-z0-9_-]', tempFinalFileName)) == 0:\n # If no illegal characters then change finalFileName\n self.finalFileName = tempFinalFileName\n break\n else:\n print(\"Invalid file name!\")","def default_save(self,suffix=EMPTYCHAR,extra=EMPTYCHAR):\r\n\r\n pass","def _file_name(size):\n timestamp = str(int(time.time()))\n return '%s_%dx%d.%s' % (timestamp, size, size, 'jpg')","def set_file_name(self):\n name = 'LogImage'\n name_log_date = time.strftime(\"%Y%m%d\")\n self.name_log = name + name_log_date + '.log'","def add_suffix(filenames, suffix):\n\n new_filenames = set([])\n # loop over the list of files and add the suffix\n for name in filenames:\n new_filenames.add(name + \".\" + suffix)\n #print \"filenames = \"\n #print name + \".\" + suffix\n \n return new_filenames","def endswith(self, suffix):\n return self.joined().endswith(suffix)","def add_suffix(self, suffix, axis=1):\n return DataFrameDefault.register(pandas.DataFrame.add_suffix)(\n self, suffix=suffix, axis=axis\n )","def generate_file_name(self):\n self._session_iterator = None # New file invalidate old interator\n self._img_count += 1\n self._current_file = '{0}/frame_{1}.jpg'.format(self._relative_path,self._img_count)\n return self.current_file","def _file_name(self, dtype_out_time, extension='nc'):\n out_lbl = utils.io.data_out_label(self.intvl_out, dtype_out_time,\n dtype_vert=self.dtype_out_vert)\n in_lbl = utils.io.data_in_label(self.intvl_in, self.dtype_in_time,\n self.dtype_in_vert)\n ens_lbl = utils.io.ens_label(self.ens_mem)\n yr_lbl = utils.io.yr_label((self.start_date.year, self.end_date.year))\n return '.'.join(\n [self.name, out_lbl, in_lbl, self.model.name,\n self.run.name, ens_lbl, yr_lbl, extension]\n ).replace('..', '.')","def suffix(value: str, sep: str = \":\") -> str:\n return split(value, sep)[1]","def _build_tag_suffix() -> str:\n now = datetime.datetime.now(tz=datetime.timezone.utc).astimezone()\n return now.strftime(\".%Y%m%d.0\")"],"string":"[\n \"def setSuffix(self, value):\\n return self._set(suffix=value)\",\n \"def file_suffix(self):\\n return f'{self.image_count:05}' if self.sequential_naming else \\\\\\n datetime.datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\")\",\n \"def suffix(self):\\n return self._suffix\",\n \"def suffix(self):\\n return self._suffix\",\n \"def suffix(self):\\n return self._suffix\",\n \"def suffix(self):\\n return self[\\\"suffix\\\"]\",\n \"def suffix(self):\\n return self[\\\"suffix\\\"]\",\n \"def _suffix(self) -> str:\\n return \\\"\\\"\",\n \"def suffix ( self ) :\\n return self.__suffix\",\n \"def suffix ( self ) :\\n return self.__suffix\",\n \"def suffix(self) -> typing.Optional[str]:\\n return self._values.get('suffix')\",\n \"def output_filename(self, prefix, suffix):\\n filename = \\\"%s%s%s\\\" % (prefix, _ExecutionWrapper._file_index, suffix)\\n _ExecutionWrapper._file_index += 1\\n return filename\",\n \"def __add_filename_suffix(filename, suffix):\\n return \\\"{}{}.pdf\\\".format(filename.split(\\\".pdf\\\", 1)[0], suffix)\",\n \"def _metric_name(self, suffix):\\r\\n return '{}.{}'.format(self.METRIC_NAME, suffix)\",\n \"def set_filter_suffix(self, suffix, verbose=False):\\n if verbose:\\n print(\\\"Running set_filter_suffix.\\\")\\n for key in [\\\"STAR\\\",\\\"QSO\\\",\\\"GAL\\\"]:\\n self.set_value(\\\"%s_LIB\\\"%key, \\\"LIB_%s_%s\\\"%(key,suffix))\\n self.set_value(\\\"%s_LIB_IN\\\"%key, \\\"LIB_%s_%s\\\"%(key,suffix))\\n self.set_value(\\\"%s_LIB_OUT\\\"%key, \\\"%s_%s\\\"%(key,suffix))\\n\\n self.set_value(\\\"FILTER_FILE\\\", suffix+\\\".filt\\\")\\n self.set_zphotlib(verbose=verbose)\",\n \"def add_suffix(name: str, suffix: str):\\n return f'{name}_{suffix}'\",\n \"def candidate_suffix(self, candidate_suffix):\\n\\n self._candidate_suffix = candidate_suffix\",\n \"def suffix():\\r\\n\\r\\n return _random.choice(\\r\\n [\\r\\n 'Sr.', 'Jr.', 'II', 'III', 'IV', 'V'\\r\\n ]\\r\\n )\",\n \"def suffix(self) -> Optional[URISuffix]:\\n return self._suffix\",\n \"def suffixsrc(self):\\n return self[\\\"suffixsrc\\\"]\",\n \"def suffixsrc(self):\\n return self[\\\"suffixsrc\\\"]\",\n \"def add_suffix_to_filename(filename, suffix):\\n name, ext = os.path.splitext(filename)\\n return ''.join([name, suffix, ext])\",\n \"def change_to_video_name(csv_name, suffix):\\n return csv_name[:-10]+\\\".\\\"+suffix\",\n \"def setSuffixPattern(self, value):\\n return self._set(suffixPattern=value)\",\n \"def replace_suffix (name, new_suffix):\\n assert isinstance(name, basestring)\\n assert isinstance(new_suffix, basestring)\\n split = os.path.splitext (name)\\n return split [0] + new_suffix\",\n \"def get_suffix(self):\\n return '%s%d' % (self.disk.devletters(), self.get_index() + 1)\",\n \"def replsuffix(files, suffix):\\n\\toutfiles = []\\n\\tif suffix is None: return\\n\\tif type(files) is type(\\\"\\\"):\\n\\t\\tfiles = [files]\\n\\tfor f in files:\\n\\t\\tfname, ext = os.path.splitext(f)\\n\\t\\tnewfname = fname + suffix\\n\\t\\toutfiles.append(newfname)\\n\\treturn outfiles\",\n \"def case_suffix(self, **case_kws):\\n if callable(self.output_suffix):\\n return self.output_suffix(**case_kws)\\n else:\\n return self.output_suffix.format(**case_kws)\",\n \"def _suffix(self) -> str:\\n return f\\\"!! Expected: {self._expected!r}\\\"\",\n \"def build_base_filename(self):\\n if self.stream:\\n self.stream.close()\\n self.stream = None\\n\\n # remove old suffix\\n # if self.suffix_time != \\\"\\\":\\n # index = self.baseFilename.find(\\\".\\\" + self.suffix_time)\\n # if index == -1:\\n # index = self.baseFilename.rfind(\\\".\\\")\\n # self.baseFilename = self.baseFilename[:index]\\n\\n # add new suffix\\n current_time_tuple = time.localtime()\\n self.suffix_time = time.strftime(self.suffix, current_time_tuple)\\n self.baseFilename = self._get_format_filename()\\n\\n self.mode = 'a'\\n if not self.delay:\\n self.stream = self._open()\",\n \"def _replace_suffix(self, word, suffix, replacement):\\n assert word.endswith(suffix), \\\"Given word doesn't end with given suffix\\\"\\n if suffix == \\\"\\\":\\n return word + replacement\\n else:\\n return word[: -len(suffix)] + replacement\",\n \"def addSuffixLink(self, suffix_link):\\n self.suffix_link = suffix_link\",\n \"def get_suffix(self):\\n if self.device:\\n return self.device\\n else:\\n return '%s%d' % (self.devletters(), self.get_index() + 1)\",\n \"def add_suffix(in_image,\\n suffix_str):\\n bandnames = in_image.bandNames().map(lambda elem: ee.String(elem).toLowerCase().cat('_').cat(suffix_str))\\n nb = bandnames.length()\\n return in_image.select(ee.List.sequence(0, ee.Number(nb).subtract(1)), bandnames)\",\n \"def _identifier_suffix(self):\\r\\n return ''\",\n \"def get_name(self, suffix_number: int = 0) -> str:\\n if suffix_number:\\n return f\\\"{self.name}_{suffix_number}\\\"\\n return cast(str, self.name)\",\n \"def _suffix (self):\\n\\t\\tif self.suffix:\\n\\t\\t\\treturn self.suffix\\n\\n\\t\\tconfig = { key:val for key, val in self.config.iteritems() if key not in ['workdir', 'forks', 'cache', 'retcodes', 'echo', 'runner', 'exportdir', 'exporthow', 'exportow', 'errorhow', 'errorntry'] or key.endswith ('Runner') }\\n\\t\\tconfig['id'] = self.id\\n\\t\\tconfig['tag'] = self.tag\\n\\t\\t\\n\\t\\tif config.has_key ('callback'):\\n\\t\\t\\tconfig['callback'] = utils.funcsig(config['callback'])\\n\\t\\t# proc is not picklable\\n\\t\\tif config.has_key('depends'):\\n\\t\\t\\tdepends = config['depends']\\n\\t\\t\\tpickable_depends = []\\n\\t\\t\\tif isinstance(depends, proc):\\n\\t\\t\\t\\tdepends = [depends]\\n\\t\\t\\telif isinstance(depends, aggr):\\n\\t\\t\\t\\tdepends = depends.procs\\n\\t\\t\\tfor depend in depends:\\n\\t\\t\\t\\tpickable_depends.append(depend.id + '.' + depend.tag)\\n\\t\\t\\tconfig['depends'] = pickable_depends\\n\\t\\t\\n\\t\\t# lambda not pickable\\n\\t\\tif config.has_key ('input') and isinstance(config['input'], dict):\\n\\t\\t\\tconfig['input'] = pycopy.copy(config['input'])\\n\\t\\t\\tfor key, val in config['input'].iteritems():\\n\\t\\t\\t\\tconfig['input'][key] = utils.funcsig(val) if callable(val) else val\\n\\n\\t\\tsignature = pickle.dumps(str(config))\\n\\t\\tself.props['suffix'] = utils.uid(signature)\\n\\t\\treturn self.suffix\",\n \"def getFileSuffix(filename):\\n fileSuffix = \\\"\\\"\\n\\n if filename:\\n name, extension = os.path.splitext(filename)\\n fileSuffix = extension # .mp3\\n\\n if fileSuffix:\\n # remove leading dot/period\\n fileSuffix = fileSuffix[1:] # mp3\\n\\n if fileSuffix:\\n # remove ending newline or space\\n fileSuffix = fileSuffix.strip()\\n\\n if fileSuffix:\\n # convert JPg to jpg\\n fileSuffix = fileSuffix.lower()\\n\\n return fileSuffix\",\n \"def add_suffix(self, suffix):\\n # Append the suffix vowel to this WordForm.\\n self.segments.append(Segment.new_segment(suffix))\",\n \"def _generate_output_name(extension):\\n output_name = 'TDG_{:%Y-%m-%d_%H-%M-%S}.{}'.format(datetime.now(), extension)\\n return output_name\",\n \"def add_filename_suffix(filepath, suffix):\\r\\n root, extension = splitext(basename(filepath))\\r\\n return root + suffix + extension\",\n \"def getSuffixPattern(self):\\n return self.getOrDefault(\\\"suffixPattern\\\")\",\n \"def outputname(self, identifier):\\n return self._outprefix+str(identifier)+\\\".\\\"+self._suffix\",\n \"def setSuffixes(self, s):\\n return self._set(suffixes=s)\",\n \"def temp_file_name(suffix):\\n return 'tmp%s%s' % (uuid.uuid4(), suffix)\",\n \"def __rename_file(filename, suffix):\\n filename = PDFWorkshop.__clean_filename(filename)\\n return PDFWorkshop.__add_filename_suffix(filename, suffix)\",\n \"def filename(self):\\n return self.config.get('filename', self.id) + f'_{self.file_suffix}'\",\n \"def suffix(string, suffix, sep = '_'):\\n if suffix == 'production':\\n suffixed = string\\n else:\\n suffixed = string + sep + suffix\\n return suffixed\",\n \"def payee_suffix(self, payee_suffix):\\n\\n self._payee_suffix = payee_suffix\",\n \"def get_suffix_ml_model():\\n suffix = ''\\n \\n # consider if the model uses tail or not\\n if gml.USE_TAIL: \\n suffix += '_use_tail'\\n else: \\n suffix += '_no_tail'\\n\\n # consider the way of picking target variable for the model\\n if gml.WAY_MODEL_TGT == 'absolute':\\n suffix += '_absolute'\\n elif gml.WAY_MODEL_TGT == 'relative':\\n suffix += '_relative'\\n else: \\n exit('error on the function that gets suffix')\\n\\n return suffix\",\n \"def removesuffix(self, x) -> String:\\n pass\",\n \"def exe_suffix():\\n if sys.platform == 'win32':\\n return '.exe'\\n return ''\",\n \"def force_suffix(fname, suffix):\\r\\n head, tail = pp.split(fname)\\r\\n if len(tail) == 0:\\r\\n return head\\r\\n if suffix[0] == \\\".\\\":\\r\\n suffix = suffix[1:]\\r\\n fpart, fext = pp.splitext(tail)\\r\\n newp = pp.join(head, fpart + \\\".\\\" + suffix)\\r\\n return pp.normpath(newp)\",\n \"def getSuffixLink(self):\\n return self.suffix_link\",\n \"def name(self):\\n suffix = ''\\n if 'suffix' in self.context['strategy'] \\\\\\n and self.context['strategy']['suffix'] is not None \\\\\\n and len(self.context['strategy']['suffix']) > 0:\\n suffix = \\\"_\\\" + self.context['strategy']['suffix']\\n\\n return self.get_name(self.context, suffix)\",\n \"def get_feature_suffix(feature_name: str) -> str:\\n if \\\"_\\\" not in feature_name:\\n return \\\"\\\"\\n return feature_name.split(\\\"_\\\")[-1]\",\n \"def current_filename(self):\\n if self.char_limit is not None:\\n return '{}/{}.{}.n{}.maf'.format(self.out_dir, self.chrom,\\n self.taxon, self.file_num)\\n else:\\n return '{}/{}.{}.maf'.format(self.out_dir, self.chrom, self.taxon)\",\n \"def __newFileName(self):\\n now = datetime.now()\\n dateTimeAppend = now.strftime('%y%m%d_%H%M%S')\\n self.__fileName = '{}/{}_{}.wav'.format(RECORDING,\\n FILE_NAME_PREFIX, \\n dateTimeAppend)\",\n \"def __setPlayerFilename(self):\\n if self.__playerName != \\\"???\\\":\\n l=self.__playerName.rsplit(\\\" \\\")\\n nameWithoutSpaces=\\\"_\\\".join(l)\\n self.__filename = fileLocs.playerProfiles+\\\"\\\\\\\\\\\"+nameWithoutSpaces+r\\\".p\\\"\",\n \"def setExtension(self, ext):\\n if ext:\\n self._writer.extension = ext\\n else:\\n self._writer.extension = None\",\n \"def SetFileName(self, filename):\\n WriteImageDataToUBC.SetFileName(self, filename)\",\n \"def output_filename(self, modifier):\\n fs = self._filesystem\\n output_filename = fs.join(self._root_output_dir, self._test_name)\\n return fs.splitext(output_filename)[0] + modifier\",\n \"def addSuffixes(self, alist):\\n for i, (word, filename) in enumerate(alist):\\n withsuffix = self._findVideoFile(filename)\\n alist[i] = (word, withsuffix)\\n return alist\",\n \"def remove_suffix(input_string, suffix):\\n if suffix and input_string.endswith(suffix):\\n return input_string[:-len(suffix)]\\n return input_string\",\n \"def get_output_filename(self, gzip=False):\\n if self.mode == 'light':\\n suffix = '-light'\\n else:\\n suffix = ''\\n\\n destination = self.destination\\n extension = 'fits'\\n if gzip:\\n destination += '-compressed'\\n extension += '.gz'\\n return os.path.join(destination,\\n 'iphas-dr2-{0}{1}.{2}'.format(\\n self.get_partname(),\\n suffix,\\n extension))\",\n \"def get_alternative_name(self, file_root, file_ext):\\n return \\\"%s_%s%s\\\" % (file_root, get_random_string(7), file_ext)\",\n \"def suffix(self, e, remaining, rate):\\n return f' {e + 1}/{self.max} [{remaining} remaining, {round(rate, 2)} iter/s]'\",\n \"def AssignOutputFilename(self, output_file):\\n if output_file is None:\\n gmt = time.gmtime()\\n ts = calendar.timegm(gmt)\\n return f\\\"{self.input_file}.{ts}\\\"\\n return output_file\",\n \"def strip_optional_suffix(string, suffix):\\n if string.endswith(suffix):\\n string = string[:-len(suffix)]\\n return string\",\n \"def parse_suffix_command(self):\\n evt_string = self.event['text']\\n\\n arg_string, suffix = evt_string[:-2], evt_string[-2:]\\n\\n if arg_string and (suffix in self.valid_suffixes.keys()):\\n plugin = self.valid_suffixes[suffix](\\n self.event,\\n arg_string,\\n suffix\\n )\\n plugin.run()\",\n \"def _get_suffix(bin, VoronoiSN):\\n \\n if VoronoiSN is not None:\\n suffix = \\\"SN{0:03d}\\\".format(VoronoiSN)\\n else:\\n suffix = \\\"bin{0:02d}\\\".format(bin)\\n\\n return suffix\",\n \"def create_filename(value):\\n return '%s.mp3' % slugify(value, u'_')\",\n \"def storage_endpoint_suffix(self, storage_endpoint_suffix):\\n\\n self._storage_endpoint_suffix = storage_endpoint_suffix\",\n \"def GenerateOutputFilename(extension):\\n\\n # used for resolv.conf\\n if '.' in extension:\\n filename = extension\\n else:\\n output_base = 'namebench_%s' % datetime.datetime.strftime(datetime.datetime.now(),\\n '%Y-%m-%d %H%M')\\n output_base = output_base.replace(':', '').replace(' ', '_')\\n filename = '.'.join((output_base, extension))\\n\\n output_dir = tempfile.gettempdir()\\n return os.path.join(output_dir, filename)\",\n \"def test_suffix():\\n transformer = hug.transform.suffix({\\\".js\\\": int, \\\".txt\\\": str})\\n\\n class FakeRequest(object):\\n path = \\\"hey.js\\\"\\n\\n request = FakeRequest()\\n assert transformer(\\\"1\\\", request) == 1\\n\\n request.path = \\\"hey.txt\\\"\\n assert transformer(2, request) == \\\"2\\\"\\n\\n request.path = \\\"hey.undefined\\\"\\n transformer({\\\"data\\\": \\\"value\\\"}, request) == {\\\"data\\\": \\\"value\\\"}\",\n \"def filename(self):\\n return '%s%s' % (self.identifier, self.extension)\",\n \"def save(self, filename=None, show_path=False, use_ffmpeg=False, **kwds):\\n if filename is None:\\n suffix = '.gif'\\n else:\\n suffix = os.path.splitext(filename)[1]\\n if len(suffix) == 0:\\n suffix = '.gif'\\n\\n if filename is None or suffix == '.gif':\\n self.gif(savefile=filename, show_path=show_path,\\n use_ffmpeg=use_ffmpeg, **kwds)\\n elif suffix == '.sobj':\\n SageObject.save(self, filename)\\n if show_path:\\n print(\\\"Animation saved to file %s.\\\" % filename)\\n else:\\n self.ffmpeg(savefile=filename, show_path=show_path, **kwds)\",\n \"def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True, ext=None):\\n if not basename:\\n msg = \\\"Unable to generate filename for command %s. \\\" % self.cmd\\n msg += \\\"basename is not set!\\\"\\n raise ValueError(msg)\\n\\n if cwd is None:\\n cwd = os.getcwd()\\n if ext is None:\\n ext = Info.output_type_to_ext(self.inputs.outputtype)\\n if change_ext:\\n suffix = \\\"\\\".join((suffix, ext)) if suffix else ext\\n\\n if suffix is None:\\n suffix = \\\"\\\"\\n fname = fname_presuffix(basename, suffix=suffix, use_ext=False, newpath=cwd)\\n return fname\",\n \"def _set_job_name(self):\\n job_path = '{}/{}'.format(self.rism3d_folder, self.job_name)\\n job_name_list = glob.glob(job_path)\\n if len(job_name_list) < 1:\\n self._not_found_error(self.job_name)\\n elif len(job_name_list) > 1:\\n self._many_files_error(self.job_name)\\n else:\\n name = os.path.split(job_name_list[0])[1]\\n self.job_name = '.'.join(name.split('.')[:-1])\",\n \"def name_sans_ext(self) -> str:\\n return os.path.splitext(self.path)[0]\",\n \"def StripOptionalSuffix(string, suffix):\\n if string.endswith(suffix):\\n string = string[:-len(suffix)]\\n return string\",\n \"def global_replication_group_id_suffix(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"global_replication_group_id_suffix\\\")\",\n \"def is_suffix(suffix: str, word: str):\\n return word.endswith(suffix)\",\n \"def name_woext(self):\\n return os.path.splitext(self._job)[0]\",\n \"def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\\n ext='.mif'):\\n\\n if basename == '':\\n msg = 'Unable to generate filename for command %s. ' % self.cmd\\n msg += 'basename is not set!'\\n raise ValueError(msg)\\n if cwd is None:\\n cwd = os.getcwd()\\n if change_ext:\\n if suffix:\\n suffix = ''.join((suffix, ext))\\n else:\\n suffix = ext\\n if suffix is None:\\n suffix = ''\\n fname = fname_presuffix(basename, suffix=suffix,\\n use_ext=False, newpath=cwd)\\n return fname\",\n \"def _gen_fname(self, basename, cwd=None, suffix=None, change_ext=True,\\n ext='.mif'):\\n\\n if basename == '':\\n msg = 'Unable to generate filename for command %s. ' % self.cmd\\n msg += 'basename is not set!'\\n raise ValueError(msg)\\n if cwd is None:\\n cwd = os.getcwd()\\n if change_ext:\\n if suffix:\\n suffix = ''.join((suffix, ext))\\n else:\\n suffix = ext\\n if suffix is None:\\n suffix = ''\\n fname = fname_presuffix(basename, suffix=suffix,\\n use_ext=False, newpath=cwd)\\n return fname\",\n \"def setFinalFileName(self, offset=0):\\n while True:\\n tempFinalFileName = input(\\n offset * \\\" \\\" + \\\"Specify a final file name [%s]: \\\" % self.finalFileName) or self.finalFileName\\n # Check 'tempFinalFileName' for bad formatting\\n if len(re.findall(r'[^A-Za-z0-9_-]', tempFinalFileName)) == 0:\\n # If no illegal characters then change finalFileName\\n self.finalFileName = tempFinalFileName\\n break\\n else:\\n print(\\\"Invalid file name!\\\")\",\n \"def default_save(self,suffix=EMPTYCHAR,extra=EMPTYCHAR):\\r\\n\\r\\n pass\",\n \"def _file_name(size):\\n timestamp = str(int(time.time()))\\n return '%s_%dx%d.%s' % (timestamp, size, size, 'jpg')\",\n \"def set_file_name(self):\\n name = 'LogImage'\\n name_log_date = time.strftime(\\\"%Y%m%d\\\")\\n self.name_log = name + name_log_date + '.log'\",\n \"def add_suffix(filenames, suffix):\\n\\n new_filenames = set([])\\n # loop over the list of files and add the suffix\\n for name in filenames:\\n new_filenames.add(name + \\\".\\\" + suffix)\\n #print \\\"filenames = \\\"\\n #print name + \\\".\\\" + suffix\\n \\n return new_filenames\",\n \"def endswith(self, suffix):\\n return self.joined().endswith(suffix)\",\n \"def add_suffix(self, suffix, axis=1):\\n return DataFrameDefault.register(pandas.DataFrame.add_suffix)(\\n self, suffix=suffix, axis=axis\\n )\",\n \"def generate_file_name(self):\\n self._session_iterator = None # New file invalidate old interator\\n self._img_count += 1\\n self._current_file = '{0}/frame_{1}.jpg'.format(self._relative_path,self._img_count)\\n return self.current_file\",\n \"def _file_name(self, dtype_out_time, extension='nc'):\\n out_lbl = utils.io.data_out_label(self.intvl_out, dtype_out_time,\\n dtype_vert=self.dtype_out_vert)\\n in_lbl = utils.io.data_in_label(self.intvl_in, self.dtype_in_time,\\n self.dtype_in_vert)\\n ens_lbl = utils.io.ens_label(self.ens_mem)\\n yr_lbl = utils.io.yr_label((self.start_date.year, self.end_date.year))\\n return '.'.join(\\n [self.name, out_lbl, in_lbl, self.model.name,\\n self.run.name, ens_lbl, yr_lbl, extension]\\n ).replace('..', '.')\",\n \"def suffix(value: str, sep: str = \\\":\\\") -> str:\\n return split(value, sep)[1]\",\n \"def _build_tag_suffix() -> str:\\n now = datetime.datetime.now(tz=datetime.timezone.utc).astimezone()\\n return now.strftime(\\\".%Y%m%d.0\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7028223","0.69330084","0.67990613","0.67990613","0.67990613","0.67454875","0.67454875","0.67304456","0.66012996","0.66012996","0.6601247","0.6541266","0.63328516","0.6209011","0.6205128","0.61271995","0.6105634","0.6063221","0.60500926","0.60498923","0.60498923","0.6013021","0.59852254","0.5943317","0.5870958","0.5842545","0.58025116","0.57294536","0.5710795","0.57083446","0.5683194","0.567363","0.5668969","0.566674","0.5664774","0.56579536","0.5628604","0.5625474","0.562206","0.55760133","0.5574013","0.55693674","0.55350727","0.54945606","0.5463127","0.5452224","0.5422723","0.54193485","0.54181284","0.53994477","0.53956795","0.53816247","0.5357516","0.53474385","0.53356075","0.5332867","0.5324249","0.53192323","0.53057855","0.52925146","0.52740836","0.5258617","0.5257571","0.5256469","0.5253523","0.5238397","0.5234511","0.522869","0.5202897","0.5199205","0.5196434","0.51825106","0.51560616","0.5153984","0.5145662","0.51427466","0.51414716","0.51392454","0.5127294","0.51253617","0.51203465","0.5119969","0.5110097","0.5107864","0.509983","0.509983","0.50899667","0.5077237","0.5075319","0.5072676","0.5066025","0.5065751","0.50650114","0.5063983","0.50610113","0.50548947","0.50515693"],"string":"[\n \"0.7028223\",\n \"0.69330084\",\n \"0.67990613\",\n \"0.67990613\",\n \"0.67990613\",\n \"0.67454875\",\n \"0.67454875\",\n \"0.67304456\",\n \"0.66012996\",\n \"0.66012996\",\n \"0.6601247\",\n \"0.6541266\",\n \"0.63328516\",\n \"0.6209011\",\n \"0.6205128\",\n \"0.61271995\",\n \"0.6105634\",\n \"0.6063221\",\n \"0.60500926\",\n \"0.60498923\",\n \"0.60498923\",\n \"0.6013021\",\n \"0.59852254\",\n \"0.5943317\",\n \"0.5870958\",\n \"0.5842545\",\n \"0.58025116\",\n \"0.57294536\",\n \"0.5710795\",\n \"0.57083446\",\n \"0.5683194\",\n \"0.567363\",\n \"0.5668969\",\n \"0.566674\",\n \"0.5664774\",\n \"0.56579536\",\n \"0.5628604\",\n \"0.5625474\",\n \"0.562206\",\n \"0.55760133\",\n \"0.5574013\",\n \"0.55693674\",\n \"0.55350727\",\n \"0.54945606\",\n \"0.5463127\",\n \"0.5452224\",\n \"0.5422723\",\n \"0.54193485\",\n \"0.54181284\",\n \"0.53994477\",\n \"0.53956795\",\n \"0.53816247\",\n \"0.5357516\",\n \"0.53474385\",\n \"0.53356075\",\n \"0.5332867\",\n \"0.5324249\",\n \"0.53192323\",\n \"0.53057855\",\n \"0.52925146\",\n \"0.52740836\",\n \"0.5258617\",\n \"0.5257571\",\n \"0.5256469\",\n \"0.5253523\",\n \"0.5238397\",\n \"0.5234511\",\n \"0.522869\",\n \"0.5202897\",\n \"0.5199205\",\n \"0.5196434\",\n \"0.51825106\",\n \"0.51560616\",\n \"0.5153984\",\n \"0.5145662\",\n \"0.51427466\",\n \"0.51414716\",\n \"0.51392454\",\n \"0.5127294\",\n \"0.51253617\",\n \"0.51203465\",\n \"0.5119969\",\n \"0.5110097\",\n \"0.5107864\",\n \"0.509983\",\n \"0.509983\",\n \"0.50899667\",\n \"0.5077237\",\n \"0.5075319\",\n \"0.5072676\",\n \"0.5066025\",\n \"0.5065751\",\n \"0.50650114\",\n \"0.5063983\",\n \"0.50610113\",\n \"0.50548947\",\n \"0.50515693\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73530364"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":76584,"cells":{"query":{"kind":"string","value":"Gets the overlay of this GIFOutput."},"document":{"kind":"string","value":"def overlay(self):\n return self._overlay"},"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 gif_loop(self):\n return self._gif_loop","def layer(self):\n return self.GetLayer()","def draw_overlay(self):\n pass","def gif(self):\n\n if self._gif is None:\n\n url = self.url.replace('f=fits', 'f=gif')\n\n try:\n url_data = urllib.request.urlopen(url)\n except urllib.request.URLError as ee:\n raise ValueError(f'cannot open URL for these parameters: {ee}')\n\n data = url_data.read()\n\n image = PIL.Image.open(io.BytesIO(data))\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\n\n self._gif = image\n\n return self._gif","def layer(self):\n return self._layer","def get_mask(self):\n\t\treturn pygame.mask.from_surface(self.img)","def layer( self ):\n return self._layer","def opacity(self):\n return self._rgba[3]","def bg_frame(self):\n\n return self._bg_frame","def get_layer(self):\n return self._border","def get_image(self):\n self.drawer.flush()\n return self.img","def get_current_image(self):\n raise NotImplementedError","def get_background(self):\n\n log(\"Getting background for {} at {}\".format(self._location, self._t0))\n suffix = 'products/radar_transparencies/IDR{}.background.png'\n url = self.get_url(suffix.format(self._radar_id))\n background = self.get_image(url)\n if background is None:\n return None\n for layer in ('topography', 'locations', 'range'):\n log(\"Getting {} for {} at {}\".format(layer, self._location, self._t0))\n suffix = 'products/radar_transparencies/IDR{}.{}.png'.format(\n self._radar_id,\n layer\n )\n url = self.get_url(suffix)\n image = self.get_image(url)\n if image is not None:\n background = self._pilimg.alpha_composite(background, image)\n return background","def bg(self):\n return self._bg","def get_last_sprite(self) -> pygame.Surface:\n return self.__animation_dict[self.__animation_key][-1]","def getImage( self ):\n return self.__image;","def get_image(self, frame):\n rect = pygame.Rect(0, 0, self.width, self.height)\n msec = frame * config.MS_PER_FRAME\n frame = msec // 100\n rect.y = self.height - (frame % self.height)\n return self.double.subsurface(rect)","def get_image(self):\n return self.image","def get_image(self):\n return self.image","def get_image(self):\n return self.image","def fig(self):\n return self._fig","def get_loop(self):\n\n log(\"Getting loop for {} at {}\".format(self._location, self._t0))\n loop = io.BytesIO()\n try:\n frames = self.get_frames()\n if frames is None:\n raise\n log(\"Got {} frames for {} at {}\".format(\n len(frames),\n self._location,\n self._t0\n ))\n frames[0].save(\n loop,\n append_images=frames[1:],\n duration=500,\n format='GIF',\n loop=0,\n save_all=True,\n )\n except:\n log(\"Got NO frames for {} at {}\".format(self._location, self._t0))\n self._pilimg.new('RGB', (340, 370)).save(loop, format='GIF')\n if self._outfn:\n outdir = os.path.dirname(self._outfn)\n if not os.path.isdir(outdir):\n try:\n os.makedirs(outdir)\n except:\n log_error(\"Could not create directory {}\".format(outdir))\n try:\n with open(self._outfn, 'wb') as f:\n f.write(loop.getvalue())\n except:\n log_error(\"Could not write image to {}\".format(self._outfn))\n return loop.getvalue()","def get_icon(self) -> Dict[str, Any]:\n player = self._last_sessionplayer\n assert player is not None\n return player.get_icon()","def get_image(self):\n return self.camera.getImage()","def surface(self):\n return self._surface","def overlay_alignment(self):\n return self._overlay_alignment","def get_animated(self):\n return self.animated","def GetImage(self):\r\n\r\n return self._image","def background(self):\n return self.background","def getImage(self):\n\n\t\t\t_frame = str(self._frame)\n\t\t\tself._counter += 1\n\t\t\tif self._counter >= 10/ANIMATION_SPEED:\n\t\t\t\tself._frame += 1\n\t\t\t\tself._counter = 0\n\n\t\t\tif self.images[self.getState()][self.getDirection()][str(self._frame)] == {}:\n\t\t\t\tself._frame = 0\n\n\t\t\treturn self.images[self.getState()][self.getDirection()][_frame]","def update(self) -> pygame.Surface:\n return self.surface","def transparent(self) -> str:\n return pulumi.get(self, \"transparent\")","def get_rect(self):\n return self.pic.get_rect().move(self.pos)","def img(self):\n return Image(self.driver.get_screenshot_as_png())","def get_current_pic(self):\n # Change the picture\n if clock() > self.next_frame:\n if self.exploding:\n if self.frame_num < self.num_of_explosion_frames:\n self.frame_num += 1\n else:\n self.away = True\n else:\n # Chose animation direction by the asteroid's horizontal direction\n self.frame_num += int(copysign(1, self.speed[0]+self.acceleration[0]))\n if self.frame_num >= self.num_of_images:\n self.frame_num = 0\n elif self.frame_num < 0:\n self.frame_num = self.num_of_images - 1\n self.next_frame = clock() + self.frame_time\n return self.current_image_set[self.frame_num]","def get_cover_photo(self):\r\n return self.__cover_photo","def get_cover_photo(self):\r\n return self.__cover_photo","def asset(self):\n\t\treturn self._asset","def image(self):\n return self._image","def current(self) -> Union['_Imagine', None]:\n return self.top[-1] if self.top else None","def image(self):\n return self._img","def get_widget(self):\n return self.imgwin","def GetAlpha(self):\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetAlpha(self)","def image(self):\n return self._image","def image(self):\n return self._image","def image(self):\n return self._image","def image(self):\n return self._image","def image(self):\n return self._image","def image(self):\n return self._image","def gpix(self):\n return self._gpix","def opacity(self):\n # type: () -> float\n return self._opacity","def image(self) -> object:\n return self._image","def get_play_area(self):\n return self.play_area","def _get_gif_original_url(gif_dict):\n return gif_dict[\"images\"][\"original\"][\"url\"]","def _repr_png_(self):\n try:\n return self.mol._repr_png_()\n except AttributeError:\n return None","def getPic(self):\n if self.sync==False:\n self._drawOnCanvas()\n return self.canvas","def get_mask(self) -> pygame.mask.Mask:\n return pygame.mask.from_surface(self._rotate_image()[0])","def interpolation(self):\n return self._image.interpolation","def get_image(self):\n return self.process_raw_image(self.get_raw_image())","def get_tkimage(self):\n self.drawer.flush()\n return PIL.ImageTk.PhotoImage(self.img)","def GetBackgroundImage(self):\r\n\r\n return self._backgroundImage","def get_layer(self, i):\n return self.layers[i]","def grabRawFrame(self):\r\n \r\n self.surface = self.capture.get_image(self.surface)\r\n width, height = self.surface.get_size()\r\n return pygame.image.tostring(self.surface, 'RGB'), width, height, 1","def clip(self):\r\n\t\treturn self._clip","def GetBackgroundValue(self):\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUC2_GetBackgroundValue(self)","def get_frame(self):\n return self.frame","def image(self):\n return self.chunks.get('image')","def GetBitmap(self):\n return self._bitmap","def captureimage(self):\n if not self.total_time:\n return self.frames[-1]\n return None","def get_frame(self):\n return self.frames.get()","def get_frame(self):\n return self.last_frame","def _opacity(self):\n item = self.item()\n return 255 if item is None else item.getColor().alpha()","def current_layer(iface):\n return iface.layerTreeView().currentLayer()","def overlay_scale(self):\n return self._overlay_scale","def overlay(self, overlay):\n\n self._overlay = overlay","def GetMarkerAlpha(self):\n return self._attalpha[\"marker\"]","def get_icon(self):\n return self._icon","def icon(self):\n return self._var_icon","def icon(self):\n return self._var_icon","def on_draw_overlay(self):","def GetBackgroundValue(self):\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUS2_GetBackgroundValue(self)","def get_frame(self, frame: int) -> BaseImage:\n return self.sequence[frame]","def image(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"image\")","def get_icon(self):\n\n return self._icon","def GetHoverBitmap(self):\r\n \r\n return self.hover_bitmap","def get_icon(self):\r\n return get_icon(self.ICON)","def bot_image(self):\n return self.bot_image","def get_image(self):\n glReadBuffer(GL_FRONT)\n glReadPixels(0, 0, self.__width, self.__height, GL_RGBA, GL_FLOAT,\n self.__output_image)\n return self.__output_image","def GetAlpha(self):\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetAlpha(self)","def GetBackgroundValue(self):\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUL2_GetBackgroundValue(self)","def icon(self):\n return self.var_icon","def get_latest_valid_picture(self):\n return self.buffer[self.buffer_index]","def pixmap(self):\n return self._pixmap","def output_frame(self):\n if self._pipeline:\n frame = self._pipeline[-1].frame\n if not isinstance(frame, str):\n frame = frame.name\n return getattr(self, frame)\n else:\n return None","def getImage(self):\n return self.get('heightfield.image')","def back(self):\n return self._derived_properties[\"bkgd_image\"]","def get_figure(self):\n import mayavi.mlab as mlab\n if self.new_figure or self.figure_id is not None:\n self.figure = mlab.figure(self.figure_id)\n else:\n self.figure = mlab.gcf()\n\n self.figure_id = self.figure.name\n\n return self.figure","def getAssetInfo(self):\n return self._AssetInfo","def _write_overlay_info(self):\n cv2.putText(\n img=self.output,\n text=f'X: {float(self.estimated_distance[0]):6.2f} m',\n org=(25, 25),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Y: {float(self.estimated_distance[1]):6.2f} m',\n org=(25, 50),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Z: {float(self.estimated_distance[2]):6.2f} m',\n org=(25, 75),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Rotation: {float(self.estimated_rotation):6.2f} rad',\n org=(25, 100),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )","def background(self, obs_id: str, inst: str) -> str:\n return self.get_spectra(self._num_ann-1, obs_id, inst).background"],"string":"[\n \"def gif_loop(self):\\n return self._gif_loop\",\n \"def layer(self):\\n return self.GetLayer()\",\n \"def draw_overlay(self):\\n pass\",\n \"def gif(self):\\n\\n if self._gif is None:\\n\\n url = self.url.replace('f=fits', 'f=gif')\\n\\n try:\\n url_data = urllib.request.urlopen(url)\\n except urllib.request.URLError as ee:\\n raise ValueError(f'cannot open URL for these parameters: {ee}')\\n\\n data = url_data.read()\\n\\n image = PIL.Image.open(io.BytesIO(data))\\n assert isinstance(image, PIL.GifImagePlugin.GifImageFile), 'incorrect image type.'\\n\\n self._gif = image\\n\\n return self._gif\",\n \"def layer(self):\\n return self._layer\",\n \"def get_mask(self):\\n\\t\\treturn pygame.mask.from_surface(self.img)\",\n \"def layer( self ):\\n return self._layer\",\n \"def opacity(self):\\n return self._rgba[3]\",\n \"def bg_frame(self):\\n\\n return self._bg_frame\",\n \"def get_layer(self):\\n return self._border\",\n \"def get_image(self):\\n self.drawer.flush()\\n return self.img\",\n \"def get_current_image(self):\\n raise NotImplementedError\",\n \"def get_background(self):\\n\\n log(\\\"Getting background for {} at {}\\\".format(self._location, self._t0))\\n suffix = 'products/radar_transparencies/IDR{}.background.png'\\n url = self.get_url(suffix.format(self._radar_id))\\n background = self.get_image(url)\\n if background is None:\\n return None\\n for layer in ('topography', 'locations', 'range'):\\n log(\\\"Getting {} for {} at {}\\\".format(layer, self._location, self._t0))\\n suffix = 'products/radar_transparencies/IDR{}.{}.png'.format(\\n self._radar_id,\\n layer\\n )\\n url = self.get_url(suffix)\\n image = self.get_image(url)\\n if image is not None:\\n background = self._pilimg.alpha_composite(background, image)\\n return background\",\n \"def bg(self):\\n return self._bg\",\n \"def get_last_sprite(self) -> pygame.Surface:\\n return self.__animation_dict[self.__animation_key][-1]\",\n \"def getImage( self ):\\n return self.__image;\",\n \"def get_image(self, frame):\\n rect = pygame.Rect(0, 0, self.width, self.height)\\n msec = frame * config.MS_PER_FRAME\\n frame = msec // 100\\n rect.y = self.height - (frame % self.height)\\n return self.double.subsurface(rect)\",\n \"def get_image(self):\\n return self.image\",\n \"def get_image(self):\\n return self.image\",\n \"def get_image(self):\\n return self.image\",\n \"def fig(self):\\n return self._fig\",\n \"def get_loop(self):\\n\\n log(\\\"Getting loop for {} at {}\\\".format(self._location, self._t0))\\n loop = io.BytesIO()\\n try:\\n frames = self.get_frames()\\n if frames is None:\\n raise\\n log(\\\"Got {} frames for {} at {}\\\".format(\\n len(frames),\\n self._location,\\n self._t0\\n ))\\n frames[0].save(\\n loop,\\n append_images=frames[1:],\\n duration=500,\\n format='GIF',\\n loop=0,\\n save_all=True,\\n )\\n except:\\n log(\\\"Got NO frames for {} at {}\\\".format(self._location, self._t0))\\n self._pilimg.new('RGB', (340, 370)).save(loop, format='GIF')\\n if self._outfn:\\n outdir = os.path.dirname(self._outfn)\\n if not os.path.isdir(outdir):\\n try:\\n os.makedirs(outdir)\\n except:\\n log_error(\\\"Could not create directory {}\\\".format(outdir))\\n try:\\n with open(self._outfn, 'wb') as f:\\n f.write(loop.getvalue())\\n except:\\n log_error(\\\"Could not write image to {}\\\".format(self._outfn))\\n return loop.getvalue()\",\n \"def get_icon(self) -> Dict[str, Any]:\\n player = self._last_sessionplayer\\n assert player is not None\\n return player.get_icon()\",\n \"def get_image(self):\\n return self.camera.getImage()\",\n \"def surface(self):\\n return self._surface\",\n \"def overlay_alignment(self):\\n return self._overlay_alignment\",\n \"def get_animated(self):\\n return self.animated\",\n \"def GetImage(self):\\r\\n\\r\\n return self._image\",\n \"def background(self):\\n return self.background\",\n \"def getImage(self):\\n\\n\\t\\t\\t_frame = str(self._frame)\\n\\t\\t\\tself._counter += 1\\n\\t\\t\\tif self._counter >= 10/ANIMATION_SPEED:\\n\\t\\t\\t\\tself._frame += 1\\n\\t\\t\\t\\tself._counter = 0\\n\\n\\t\\t\\tif self.images[self.getState()][self.getDirection()][str(self._frame)] == {}:\\n\\t\\t\\t\\tself._frame = 0\\n\\n\\t\\t\\treturn self.images[self.getState()][self.getDirection()][_frame]\",\n \"def update(self) -> pygame.Surface:\\n return self.surface\",\n \"def transparent(self) -> str:\\n return pulumi.get(self, \\\"transparent\\\")\",\n \"def get_rect(self):\\n return self.pic.get_rect().move(self.pos)\",\n \"def img(self):\\n return Image(self.driver.get_screenshot_as_png())\",\n \"def get_current_pic(self):\\n # Change the picture\\n if clock() > self.next_frame:\\n if self.exploding:\\n if self.frame_num < self.num_of_explosion_frames:\\n self.frame_num += 1\\n else:\\n self.away = True\\n else:\\n # Chose animation direction by the asteroid's horizontal direction\\n self.frame_num += int(copysign(1, self.speed[0]+self.acceleration[0]))\\n if self.frame_num >= self.num_of_images:\\n self.frame_num = 0\\n elif self.frame_num < 0:\\n self.frame_num = self.num_of_images - 1\\n self.next_frame = clock() + self.frame_time\\n return self.current_image_set[self.frame_num]\",\n \"def get_cover_photo(self):\\r\\n return self.__cover_photo\",\n \"def get_cover_photo(self):\\r\\n return self.__cover_photo\",\n \"def asset(self):\\n\\t\\treturn self._asset\",\n \"def image(self):\\n return self._image\",\n \"def current(self) -> Union['_Imagine', None]:\\n return self.top[-1] if self.top else None\",\n \"def image(self):\\n return self._img\",\n \"def get_widget(self):\\n return self.imgwin\",\n \"def GetAlpha(self):\\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetAlpha(self)\",\n \"def image(self):\\n return self._image\",\n \"def image(self):\\n return self._image\",\n \"def image(self):\\n return self._image\",\n \"def image(self):\\n return self._image\",\n \"def image(self):\\n return self._image\",\n \"def image(self):\\n return self._image\",\n \"def gpix(self):\\n return self._gpix\",\n \"def opacity(self):\\n # type: () -> float\\n return self._opacity\",\n \"def image(self) -> object:\\n return self._image\",\n \"def get_play_area(self):\\n return self.play_area\",\n \"def _get_gif_original_url(gif_dict):\\n return gif_dict[\\\"images\\\"][\\\"original\\\"][\\\"url\\\"]\",\n \"def _repr_png_(self):\\n try:\\n return self.mol._repr_png_()\\n except AttributeError:\\n return None\",\n \"def getPic(self):\\n if self.sync==False:\\n self._drawOnCanvas()\\n return self.canvas\",\n \"def get_mask(self) -> pygame.mask.Mask:\\n return pygame.mask.from_surface(self._rotate_image()[0])\",\n \"def interpolation(self):\\n return self._image.interpolation\",\n \"def get_image(self):\\n return self.process_raw_image(self.get_raw_image())\",\n \"def get_tkimage(self):\\n self.drawer.flush()\\n return PIL.ImageTk.PhotoImage(self.img)\",\n \"def GetBackgroundImage(self):\\r\\n\\r\\n return self._backgroundImage\",\n \"def get_layer(self, i):\\n return self.layers[i]\",\n \"def grabRawFrame(self):\\r\\n \\r\\n self.surface = self.capture.get_image(self.surface)\\r\\n width, height = self.surface.get_size()\\r\\n return pygame.image.tostring(self.surface, 'RGB'), width, height, 1\",\n \"def clip(self):\\r\\n\\t\\treturn self._clip\",\n \"def GetBackgroundValue(self):\\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUC2_GetBackgroundValue(self)\",\n \"def get_frame(self):\\n return self.frame\",\n \"def image(self):\\n return self.chunks.get('image')\",\n \"def GetBitmap(self):\\n return self._bitmap\",\n \"def captureimage(self):\\n if not self.total_time:\\n return self.frames[-1]\\n return None\",\n \"def get_frame(self):\\n return self.frames.get()\",\n \"def get_frame(self):\\n return self.last_frame\",\n \"def _opacity(self):\\n item = self.item()\\n return 255 if item is None else item.getColor().alpha()\",\n \"def current_layer(iface):\\n return iface.layerTreeView().currentLayer()\",\n \"def overlay_scale(self):\\n return self._overlay_scale\",\n \"def overlay(self, overlay):\\n\\n self._overlay = overlay\",\n \"def GetMarkerAlpha(self):\\n return self._attalpha[\\\"marker\\\"]\",\n \"def get_icon(self):\\n return self._icon\",\n \"def icon(self):\\n return self._var_icon\",\n \"def icon(self):\\n return self._var_icon\",\n \"def on_draw_overlay(self):\",\n \"def GetBackgroundValue(self):\\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUS2_GetBackgroundValue(self)\",\n \"def get_frame(self, frame: int) -> BaseImage:\\n return self.sequence[frame]\",\n \"def image(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"image\\\")\",\n \"def get_icon(self):\\n\\n return self._icon\",\n \"def GetHoverBitmap(self):\\r\\n \\r\\n return self.hover_bitmap\",\n \"def get_icon(self):\\r\\n return get_icon(self.ICON)\",\n \"def bot_image(self):\\n return self.bot_image\",\n \"def get_image(self):\\n glReadBuffer(GL_FRONT)\\n glReadPixels(0, 0, self.__width, self.__height, GL_RGBA, GL_FLOAT,\\n self.__output_image)\\n return self.__output_image\",\n \"def GetAlpha(self):\\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetAlpha(self)\",\n \"def GetBackgroundValue(self):\\n return _itkLabelShapeOpeningImageFilterPython.itkLabelShapeOpeningImageFilterIUL2_GetBackgroundValue(self)\",\n \"def icon(self):\\n return self.var_icon\",\n \"def get_latest_valid_picture(self):\\n return self.buffer[self.buffer_index]\",\n \"def pixmap(self):\\n return self._pixmap\",\n \"def output_frame(self):\\n if self._pipeline:\\n frame = self._pipeline[-1].frame\\n if not isinstance(frame, str):\\n frame = frame.name\\n return getattr(self, frame)\\n else:\\n return None\",\n \"def getImage(self):\\n return self.get('heightfield.image')\",\n \"def back(self):\\n return self._derived_properties[\\\"bkgd_image\\\"]\",\n \"def get_figure(self):\\n import mayavi.mlab as mlab\\n if self.new_figure or self.figure_id is not None:\\n self.figure = mlab.figure(self.figure_id)\\n else:\\n self.figure = mlab.gcf()\\n\\n self.figure_id = self.figure.name\\n\\n return self.figure\",\n \"def getAssetInfo(self):\\n return self._AssetInfo\",\n \"def _write_overlay_info(self):\\n cv2.putText(\\n img=self.output,\\n text=f'X: {float(self.estimated_distance[0]):6.2f} m',\\n org=(25, 25),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Y: {float(self.estimated_distance[1]):6.2f} m',\\n org=(25, 50),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Z: {float(self.estimated_distance[2]):6.2f} m',\\n org=(25, 75),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Rotation: {float(self.estimated_rotation):6.2f} rad',\\n org=(25, 100),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\",\n \"def background(self, obs_id: str, inst: str) -> str:\\n return self.get_spectra(self._num_ann-1, obs_id, inst).background\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58112276","0.5789104","0.5632958","0.5590468","0.55475557","0.5475671","0.54720825","0.54714066","0.54669756","0.54507834","0.54363924","0.5428256","0.5422926","0.54158616","0.5394534","0.5377252","0.5376429","0.53099346","0.53099346","0.53099346","0.52672136","0.5229456","0.52161723","0.5214578","0.5210359","0.5200192","0.5194636","0.51729405","0.51671946","0.51502186","0.51502043","0.5128089","0.51191896","0.5113627","0.5111992","0.50994885","0.50994885","0.50960803","0.5091914","0.50889087","0.5078828","0.50660217","0.5048432","0.50450766","0.50450766","0.50450766","0.50450766","0.50450766","0.50450766","0.5039765","0.5027737","0.50220436","0.50192636","0.50177777","0.5012354","0.5006063","0.49952117","0.49932876","0.49929446","0.49745527","0.49728093","0.49707338","0.49669912","0.49654406","0.4962591","0.49530518","0.49525866","0.49507987","0.49342555","0.49272725","0.49249884","0.49202606","0.49176353","0.49104017","0.49090135","0.49080056","0.49044886","0.4899572","0.4899572","0.48975632","0.48883867","0.4885896","0.48845088","0.4877692","0.48757273","0.4870919","0.48584482","0.48582897","0.48552173","0.4852502","0.48463088","0.48463076","0.4842162","0.4836384","0.4834089","0.48322266","0.48295254","0.4823586","0.48152342","0.481313"],"string":"[\n \"0.58112276\",\n \"0.5789104\",\n \"0.5632958\",\n \"0.5590468\",\n \"0.55475557\",\n \"0.5475671\",\n \"0.54720825\",\n \"0.54714066\",\n \"0.54669756\",\n \"0.54507834\",\n \"0.54363924\",\n \"0.5428256\",\n \"0.5422926\",\n \"0.54158616\",\n \"0.5394534\",\n \"0.5377252\",\n \"0.5376429\",\n \"0.53099346\",\n \"0.53099346\",\n \"0.53099346\",\n \"0.52672136\",\n \"0.5229456\",\n \"0.52161723\",\n \"0.5214578\",\n \"0.5210359\",\n \"0.5200192\",\n \"0.5194636\",\n \"0.51729405\",\n \"0.51671946\",\n \"0.51502186\",\n \"0.51502043\",\n \"0.5128089\",\n \"0.51191896\",\n \"0.5113627\",\n \"0.5111992\",\n \"0.50994885\",\n \"0.50994885\",\n \"0.50960803\",\n \"0.5091914\",\n \"0.50889087\",\n \"0.5078828\",\n \"0.50660217\",\n \"0.5048432\",\n \"0.50450766\",\n \"0.50450766\",\n \"0.50450766\",\n \"0.50450766\",\n \"0.50450766\",\n \"0.50450766\",\n \"0.5039765\",\n \"0.5027737\",\n \"0.50220436\",\n \"0.50192636\",\n \"0.50177777\",\n \"0.5012354\",\n \"0.5006063\",\n \"0.49952117\",\n \"0.49932876\",\n \"0.49929446\",\n \"0.49745527\",\n \"0.49728093\",\n \"0.49707338\",\n \"0.49669912\",\n \"0.49654406\",\n \"0.4962591\",\n \"0.49530518\",\n \"0.49525866\",\n \"0.49507987\",\n \"0.49342555\",\n \"0.49272725\",\n \"0.49249884\",\n \"0.49202606\",\n \"0.49176353\",\n \"0.49104017\",\n \"0.49090135\",\n \"0.49080056\",\n \"0.49044886\",\n \"0.4899572\",\n \"0.4899572\",\n \"0.48975632\",\n \"0.48883867\",\n \"0.4885896\",\n \"0.48845088\",\n \"0.4877692\",\n \"0.48757273\",\n \"0.4870919\",\n \"0.48584482\",\n \"0.48582897\",\n \"0.48552173\",\n \"0.4852502\",\n \"0.48463088\",\n \"0.48463076\",\n \"0.4842162\",\n \"0.4836384\",\n \"0.4834089\",\n \"0.48322266\",\n \"0.48295254\",\n \"0.4823586\",\n \"0.48152342\",\n \"0.481313\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77030104"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76585,"cells":{"query":{"kind":"string","value":"Sets the overlay of this GIFOutput."},"document":{"kind":"string","value":"def overlay(self, overlay):\n\n self._overlay = overlay"},"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_overlay(self, image_path):\n if not osp.isfile(image_path):\n raise ValueError(\"Invalid background image '{}'\".format(image_path))\n self._overlay_image = image_path\n self._final = None # Force rebuild","def draw_overlay(self):\n pass","def set_image_overlays(self, condition):\n if not config['image_on'] or not self._target_filename:\n return\n initial_image = load_data_from_npz(self._target_filename,\n config['image_overlay_actuator'], str(condition),\n 'initial', 'image', default=None)\n target_image = load_data_from_npz(self._target_filename,\n config['image_overlay_actuator'], str(condition),\n 'target', 'image', default=None)\n self._image_visualizer.set_initial_image(initial_image,\n alpha=config['image_overlay_alpha'])\n self._image_visualizer.set_target_image(target_image,\n alpha=config['image_overlay_alpha'])","def setOpacity(self, opa):\n if self._displayPjt:\n self._displayPjt.setOpacityPalette(opa)\n if self._displayUsr:\n self._displayUsr.setOpacityPalette(opa)\n if self._displayVtk:\n self._displayVtk.setOpacityPalette(opa)","def overlay(self):\n return self._overlay","def overlay(self, img2_path=\"./hurr.png\"):\n img2 = self.imread(img2_path)\n\n self.img = self.overlay_transparent(self.img, img2, 0, 0)\n\n self.edits.append(f\"overlay:{os.path.basename(img2_path)}\")\n return self","def _draw_overlay(self, gc, view_bounds=None, mode='normal'):\n self._draw_component(gc, view_bounds, mode)\n return","def setOverlayRepeat(self, value):\n self.PDFreactorConfiguration.in1[\"overlayRepeat\"] = value","def on_draw_overlay(self):","def overlay(self, image, x, y, r=0):\n x -= (image.get_rect()[2] - self.dial.get_rect()[2])/2\n y -= (image.get_rect()[3] - self.dial.get_rect()[3])/2\n image.set_colorkey((255,255,0))\n self.dial.blit(image, (x,y))","def setPhoto(self, index):\n\n # Indicate that an image is being loaded.\n self.image_loading_busy = True\n\n image = self.frames.frames_mono(index)\n\n super(VideoFrameSelector, self).setPhoto(image,\n overlay_exclude_mark=not self.index_included[index])","def on_draw_over_backgroundimage(self):","def setTransparency(self, transparency):\n self.render_context.alpha_mode = transparency","def on_draw_over_image(self):","def set_blend_mode_over(self):\n self.image_item.setCompositionMode(QtGui.QPainter.CompositionMode_SourceOver)","def set_transparent_percent(self, percent):\n self.params['transparent_percent'] = percent","def set_output(self, iclass):\n self._custom_setter('output', iclass)\n self._custom_setter('presenting', True)","def draw_on_image(self, img):\n image = Image(img)\n\n # If the overlay has not expired, draw on the plate highlight and/or the status message\n if not self.has_expired():\n self._plate.draw_plate(image, Color.Blue())\n self._plate.draw_pins(image, self._options)","def setBlackFrame(self):\r\n frame = ImageTk.PhotoImage(Image.fromarray(np.array([[0]*self.w]*self.h)))\r\n self.player.config(image=frame)\r\n self.player.image = frame","def plot(self, A = None):\r\n if A is not None: self.A = A\r\n self.im.set_data(self.A)\r\n self.ax.draw_artist(self.im)\r\n self.fig.canvas.blit(self.ax.bbox)","def av(self, av):\n\n self._av = av","def setIcon(self, icon, alpha=False):\n try:\n pygame.display.set_icon(icon)\n except TypeError:\n icon = self.newObject(icon, alpha)\n pygame.display.set_icon(icon)","def set_sprite(self, image):\n self.current_sprite = image\n self.draw_alpha()","def blit_me(self):\n self.game_over_img.blit_me()\n self.retry_button.blit_me()","def set_alpha(self, value: Optional[int], flags: int = 0) -> 'BaseImage':\n if value is None:\n self._surface.set_alpha(None)\n return self\n assert isinstance(value, int)\n assert 0 <= value <= 255, 'alpha value must be an integer between 0 and 255'\n self._surface.set_alpha(value, flags)\n return self","def overlay(self, other_component, gc, view_bounds=None, mode=\"normal\"):\n if not self.visible:\n return\n self._compute_ticks(other_component)\n self._draw_component(gc, view_bounds, mode)\n self._cache_valid = False\n return","def put_drawing_gif(self, request):\n HttpRequest = request.to_http_info(self.api_client.configuration)\n return self.__make_request(HttpRequest, 'PUT', 'file')","def draw(self, draw_surface):\n draw_surface.blit(self.background_frame, (0, 120))","def game_over(self):\r\n win.blit(self.image_of_game_over, (250, 170))","def __set_image__(self, image:pygame.image) -> None:\n if not self.graphicsLive:\n Graphic.__init__(self, image)\n self.graphicsLive = True","def overlay_scale(self, overlay_scale):\n allowed_values = [\"fit\", \"fill\", \"none\"]\n if overlay_scale not in allowed_values:\n raise ValueError(\n \"Invalid value for `overlay_scale` ({0}), must be one of {1}\"\n .format(overlay_scale, allowed_values)\n )\n\n self._overlay_scale = overlay_scale","def set_wrapping_opacity(self, wrapping_opacity):\n self.wrapping_opacity = wrapping_opacity\n self.update_wrapping(self.all_wrappings)","def _set_transparency(self, transparency, elm):\n a = str(100 - transparency) + '196'\n \n alpha = OxmlElement('a:alpha')\n alpha.set('val', a)\n elm.srgbClr.append(alpha)","def gif_loop(self, gif_loop):\n if gif_loop is not None and gif_loop < -1:\n raise ValueError(\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\")\n\n self._gif_loop = gif_loop","def draw_on_image(self, img):\n image = Image(img)\n\n # If the overlay has not expired, draw on the plate highlight and/or the status message\n if not self.has_expired():\n image.draw_text(self._text, image.center(), self._color,\n centered=True, scale=2, thickness=3)","def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\n\n self._gif_fps = None\n self._color_depth = None\n self._gif_loop = None\n self._height = None\n self._start = None\n self._duration = None\n self._suffix = None\n self._overlay = None\n self._overlay_alignment = None\n self._overlay_scale = None\n self._label = None\n self.discriminator = None\n\n if gif_fps is not None:\n self.gif_fps = gif_fps\n if color_depth is not None:\n self.color_depth = color_depth\n if gif_loop is not None:\n self.gif_loop = gif_loop\n self.height = height\n self.start = start\n if duration is not None:\n self.duration = duration\n if suffix is not None:\n self.suffix = suffix\n if overlay is not None:\n self.overlay = overlay\n if overlay_alignment is not None:\n self.overlay_alignment = overlay_alignment\n if overlay_scale is not None:\n self.overlay_scale = overlay_scale\n if label is not None:\n self.label = label","def display_callback(self, data):\n if self.enable_overlay_publish:\n self.publish_lidar_overlay_image(data)","def update_image(self, surface):\n self.ui_widget.update_image(surface=surface)","def show(self):\r\n\r\n anim = animation.FuncAnimation(self.fig, self.animate, \r\n frames=list(self.object_stream), repeat=False,\r\n interval=self.interval, blit=self.blit)\r\n\r\n super().show()","def __opacity_slider(self, s):\n if len(self.__robots) > 0:\n self.__robots[self.__selected_robot].set_transparency(s.value)","def background(self, Background):\n SCREEN.blit(Background, (0, 0))\n #SCREEN.fill((0,0,0))","def showBlockerOverlay(self, **data):\n return self.fill_default_attributes(dict(data))","def set_cover_position(self, **kwargs):\n if ATTR_POSITION in kwargs:\n position = float(kwargs[ATTR_POSITION])\n position = min(100, max(0, position))\n self._device.level = position / 100.0","def overlay(self, overlay_w, title):\n overlay = Pane(urwid.Overlay(urwid.Filler(overlay_w),\n self._get_current_pane(),\n 'center', 60,\n 'middle', 5), title)\n self.open(overlay)","def draw(self, background):\n background.blit(self.image, (self.x_pos, self.y_pos))","def SetAlpha(self, *args):\n return _itkRGBAPixelPython.itkRGBAPixelUC_SetAlpha(self, *args)","def resizeEvent(self, event):\n event.accept()\n self.overlay.resize(event.size())\n # Move gif to the center of the widget\n self.overlay.move(self.rect().center() - self.overlay.rect().center())","def draw_alpha(self):\n if self.alpha == 255:\n self.current_sprite_alpha = self.current_sprite\n else:\n mask = pygame.Surface(self.current_sprite.get_size(), flags=pygame.SRCALPHA)\n mask.fill((255, 255, 255, self.alpha))\n self.current_sprite_alpha = self.current_sprite.copy()\n self.current_sprite_alpha.blit(mask, (0, 0), special_flags=pygame.BLEND_RGBA_MULT)","def update(self, screen, angleX, iconLayer=0):\n angleX %= 360\n angleX = 360 - angleX\n tmpImage = self.clip(self.image, 0, 0, 0, 0, 0, -35)\n tmpImage = self.rotate(tmpImage, angleX)\n self.overlay(self.frameImage, 0,0)\n if iconLayer:\n self.overlay(iconLayer[0],iconLayer[1],iconLayer[2])\n self.overlay(tmpImage, 0, 0)\n self.dial.set_colorkey((255,255,0))\n screen.blit( pygame.transform.scale(self.dial,(self.w,self.h)), self.pos )","def save_overlay(self, path):\n if self.im is None:\n raise ValueError('You didnt call the MaskOverlay, therefore there is no image in memory')\n im_masked = img_as_ubyte(self.im_masked)\n imsave(path, im_masked)","def background(self, background):\n\n self._background = background","def plot_icmaps_and_blobs(self, outfile, bg_img=None, **kwargs):\n # make sure this object has been .fit()\n self._update()\n fig = plot_overlays(\n self._icc_imgs,\n get_largest_blobs(self._icc_imgs),\n bg_img=bg_img,\n figsize=(2.5, 3),\n **kwargs\n )\n fig.savefig(outfile, facecolor=fig.get_facecolor(), edgecolor='none')","def layer_overlay(foreground, background):\n overlaid = foreground.copy()\n negative_space = np.where(foreground[:, :, 3] == 0)\n\n overlaid[negative_space] = background[negative_space]\n\n overlaid[:, :, 3] = 255\n\n return overlaid","def _update_screen(self) -> None:\n # setup the source image with an alpha channel\n alpha = 255 * np.ones_like(self.image[..., 0:1])\n image = np.concatenate([self._image, alpha], axis=-1).astype(np.uint8)\n # setup the super pixel segmentations\n super_pixels = np.zeros_like(self.image)\n super_pixels = mark_boundaries(\n super_pixels,\n self._super_pixel_segments,\n self._super_pixel_color\n )\n # concatenate the first channel of sup as the alpha channel\n super_pixels = [super_pixels, super_pixels[..., 0:1]]\n super_pixels = np.concatenate(super_pixels, axis=-1).astype(np.uint8)\n # setup the segmentation image with an alpha channel scaled by the\n # opacity parameter of the application [0, 9]\n intensity = 255 * (self._opacity / 9)\n intensity = intensity * np.ones_like(self._segmentation[..., 0:1])\n segmentation = np.concatenate([self._segmentation, intensity], axis=-1)\n segmentation = segmentation.astype(np.uint8)\n # send the images to the window\n self._view.show([image, segmentation, super_pixels])","def set_alpha(self, alpha):\n if alpha < 0 or alpha > 255:\n raise ValueError(\"alpha must be betweeen 0 and 255\")\n\n self.alpha = alpha\n self.draw_alpha()","def set_cover(self) -> None:\n self._cover = self.Dataset.get_tx(self.antecedent)\n self._is_updated = True","def SetInterpolation(self, *args, **kwargs):\n pass","def set_foreground(self):\n \n # crop, resize, color quantize\n self.crop_to_gridline()\n self.crop_title()\n self.set_size()\n self.color_quantization()\n self.display()\n img_and_pix = self.separate_colors()\n colors, images, pixels = zip(*img_and_pix)\n self.foreground = images[0]\n self.foreground = self.foreground.convert('1')","def layer(self, layer):\n self._layer = layer","def clipping(self, value):\n\n self._clipping = value\n if self.is_attached:\n self[\"clipping\"] = self._clipping","def setPen(self, *args, **kwargs):\n if kwargs == {} and (args == () or args == ('default',)):\n self.opts['pen'] = fn.mkPen(getConfigOption('foreground'))\n else:\n self.opts['pen'] = fn.mkPen(*args, **kwargs)\n\n self.picture = None\n self.update()","async def async_set_cover_position(self, **kwargs: Any) -> None:\n new_pos = kwargs[ATTR_POSITION]\n res = await self._level_cluster_handler.move_to_level_with_on_off(\n new_pos * 255 / 100, 1\n )\n\n if res[1] != Status.SUCCESS:\n raise HomeAssistantError(f\"Failed to set cover position: {res[1]}\")\n\n self._position = new_pos\n self.async_write_ha_state()","def draw(self, surface):\n surface.blit(self.image, self.rect)","def draw(self, surface):\n surface.blit(self.image, self.rect)","def draw(self, background, image_path):\n self.image = pygame.image.load(image_path).convert_alpha()\n background.blit(self.image, (self.x_pos, self.y_pos))","def overlay_up(self, idx):\n if not self.is_top_layer(idx):\n self.overlay_list[idx], self.overlay_list[idx+1] = \\\n self.overlay_list[idx+1], self.overlay_list[idx]","async def async_set_cover_position(self, **kwargs: Any) -> None:\n await self.hass.async_add_executor_job(\n self.data.set_level_percentage, 100 - kwargs[ATTR_POSITION]\n )","def draw(self, surface):\r\n surface.blit(self.image, self.rect)","def draw(self, surface):\n\n\t\tsurface.blit(self.image, self.rect.topleft)","def resetOpacity(self):\n opa = (0,)\n for i in range(1,256):\n opa += (i,)\n if self._displayPjt:\n self._displayPjt.setOpacityPalette(opa)\n if self._displayUsr:\n self._displayUsr.setOpacityPalette(opa)\n if self._displayVtk:\n self._displayVtk.setOpacityPalette(opa)","def SetBitmap(self, bmp):\r\n \r\n self.bitmap = bmp","def imshow_overlay(im, mask, alpha=0.5, color='red', **kwargs):\n mask = mask > 0\n mask = ma.masked_where(~mask, mask) \n plt.imshow(im, **kwargs)\n plt.imshow(mask, alpha=alpha, cmap=ListedColormap([color]))","def display(self, index, mask_overlay = False, save = False):\n image_data = self[index].squeeze().numpy()\n x, y = self.location_of(index)\n \n plt.figure(index)\n plt.title(f'Image {index} at ({x}, {y})')\n plt.imshow(image_data, cmap='bone')\n \n if save:\n plt.savefig(f'{index}img.png', dpi = 400)\n \n if self.masked and mask_overlay:\n mask_data = self.get_mask(index).squeeze().numpy()\n plt.imshow(mask_data, cmap='viridis', alpha=0.4)\n \n if save:\n plt.savefig(f'{index}mask.png', dpi = 400)\n \n plt.show()","def compose_in_gif(images, output_file, delay):\n images[0].save(\n output_file, \n format='GIF', append_images=images[1:], \n save_all=True, duration=delay, loop=0,\n )","def paint(self, game_screen: pygame.Surface) -> None:\r\n game_screen.blit(self._img, (self._x - self._l_w / 2, self._y - self._l_w / 2,\r\n self._l_w, self._l_w))","def set_animated(self,val):\n self.XP_Plotter.set_animated(val)\n # theoretical lines \n for line in self.lines_theory:\n line.set_animated(val)","def set_img(self, img):\n self.img = img","def plot_blank(self):\n self.figure_bmp.SetBitmap(self.controller.plot_blank())","def blit(self):\n # self.ax1.draw_artist(self.lines[:2])\n # self.ax2.draw_artist(self.lines[2:4])\n self.ax1.autoscale()\n self.ax2.autoscale()\n self.ax1.redraw_in_frame()\n self.ax2.redraw_in_frame()\n self.fig.canvas.blit(self.fig.bbox)","def on_bar(self, bar: BarData):\n self.bg.update_bar(bar)\n self.bg_large.update_bar(bar)","def blit(self):\n self.screen.blit(self.image, self.rect)","def SetHoverBitmap(self, bmp):\r\n \r\n self.hover_bitmap = bmp","def SetBackgroundValue(self, _arg: 'short const') -> \"void\":\n return _itkBinaryGrindPeakImageFilterPython.itkBinaryGrindPeakImageFilterISS2_SetBackgroundValue(self, _arg)","def set_surface(self, surface:str, image:pygame.image) -> None:\n self.surface = surface\n self.__set_image__(image)","def SetMarkerAlpha(self, alpha):\n self._attalpha[\"marker\"] = alpha\n self.SetMarkerColorAlpha(self.GetMarkerColor(), alpha)","def _update_plot(self) -> None:\n\n # Check if plotting is active\n if self._fig is None:\n return None\n LOG.debug(\"Updating plot.\")\n\n # Extract glaciated area\n hs_back = np.ma.masked_where(\n self.h <= 1,\n hillshade(\n self.ele, self.PLOT_HILLSHADE_AZIMUTH, self.PLOT_HILLSHADE_ALTITUDE\n ),\n )\n\n # Clear plot and draw axes\n self._fig.clear()\n ax = plt.subplot(121, facecolor=\"black\")\n ax.tick_params(axis=\"x\", colors=\"w\")\n ax.tick_params(axis=\"y\", colors=\"w\")\n ax.set(xlabel=\"X-coordinate [m]\", ylabel=\"Y-coordinate [m]\")\n ax.xaxis.label.set_color(\"w\")\n ax.yaxis.label.set_color(\"w\")\n title_text = f\"Year: {str(self.i)} ELA: {str(int(self.ela))} m.a.s.l.\"\n ax.set_title(title_text, color=\"white\", size=18)\n\n # Draw new image layers\n plt.imshow(self.hs, vmin=90, vmax=345, cmap=\"copper\", extent=self.extent)\n plt.imshow(255 - hs_back, vmin=1, vmax=150, cmap=\"Greys\", extent=self.extent)\n\n # Mass balance\n ax1 = plt.subplot(222, facecolor=\"black\")\n ax1.plot(self.mass_balance, color=\"w\")\n ax1.plot(self.mass_balance_trend, color=\"r\")\n ax1.set(ylabel=\"Mass balance [m]\")\n ax1.yaxis.label.set_color(\"w\")\n plt.setp(ax1.get_xticklabels(), visible=False)\n ax1.tick_params(axis=\"y\", colors=\"w\")\n ax1.set_title(f\"Gradient: {str(self.m)} m/m\", color=\"white\", size=18)\n\n # Plot mean thickness\n ax2 = plt.subplot(224, sharex=ax1, facecolor=\"black\")\n ax2.plot(self.mass, color=\"w\")\n ax2.set(xlabel=\"Year [a]\", ylabel=\"Mean thickness [m]\")\n ax2.xaxis.label.set_color(\"w\")\n ax2.yaxis.label.set_color(\"w\")\n ax2.tick_params(axis=\"x\", colors=\"w\")\n ax2.tick_params(axis=\"y\", colors=\"w\")\n\n # Draw new plot\n self._fig.canvas.draw()\n plt.pause(0.05)","def Layer(self, layer):\r\n \r\n self.dock_layer = layer\r\n return self","def __selectedOverlayChanged(self, *a):\n\n overlay = self.__displayCtx.getSelectedOverlay()\n\n # TODO Support for other overlay types\n\n self.enabled = ((overlay is not None) and\n isinstance(overlay, fslimage.Image) and\n (not overlay.saveState))\n\n for ovl in self.__overlayList:\n\n if not isinstance(ovl, fslimage.Image):\n continue\n\n ovl.deregister(self.__name, 'saveState')\n\n # Register a listener on the saved property\n # of the currently selected image, so we can\n # enable the save action when the image\n # becomes 'unsaved', and vice versa.\n if ovl is overlay:\n ovl.register(self.__name,\n self.__overlaySaveStateChanged,\n 'saveState')","def update(self):\n if self.value:\n self.image = self.rect2 \n else:\n self.image = self.rect1","def overlay(self):\n # retrieve header for photometry keywords\n # from current frame only\n hdr_str = self.run('fits header', via='get')\n\n # read it in to a fits header\n phdr = fits.Header()\n hdr = phdr.fromstring(hdr_str, sep='\\n')\n\n try:\n srcposx = hdr['SRCPOSX'] + 1\n srcposy = hdr['SRCPOSY'] + 1\n s1 = 'point({:f} {:f}) # ' \\\n 'point=x ' \\\n 'color=blue tag={{srcpos}} '\\\n 'text=SRCPOS'.format(srcposx, srcposy)\n self.run('regions', s1)\n except (KeyError, ValueError):\n pass\n try:\n stcentx = hdr['STCENTX'] + 1\n stcenty = hdr['STCENTY'] + 1\n photaper = hdr['PHOTAPER']\n photskap = [float(x) for x in hdr['PHOTSKAP'].split(',')]\n s1 = 'point({:f} {:f}) # ' \\\n 'point=x ' \\\n 'color=cyan tag={{srcpos}}'.format(stcentx, stcenty)\n self.run('regions', s1)\n s2 = 'circle({:f} {:f} {:f}) # ' \\\n 'color=cyan tag={{srcpos}}'.format(\n stcentx, stcenty, photaper)\n self.run('regions', s2)\n s3 = 'annulus({:f} {:f} {:f} {:f}) # ' \\\n 'color=cyan tag={{srcpos}} text=STCENT'.format(\n stcentx, stcenty, photskap[0], photskap[1])\n self.run('regions', s3)\n except (KeyError, ValueError):\n pass\n try:\n stcentx = hdr['STCENTX'] + 1\n stcenty = hdr['STCENTY'] + 1\n flux = hdr['STAPFLX']\n sky = hdr['STAPSKY']\n s1 = 'text({:f} {:f}) # color=cyan ' \\\n 'text=\"Flux={:.2f}, Sky={:.2f}\"'.format(\n stcentx, stcenty - 40, flux, sky)\n self.run('regions', s1)\n except (KeyError, ValueError):\n pass\n\n # try overlaying apertures as well\n try:\n self.overlay_aperture(hdr)\n except ValueError: # pragma: no cover\n # may be encountered with extensions with\n # unexpected WCSs\n pass","def draw(self):\n\n surf = self.get_oxygen_surface()\n surf.set_alpha(255)\n self.screen.blit(surf, self.pos)","def SetAlpha(self, *args):\n return _itkRGBAPixelPython.itkRGBAPixelUS_SetAlpha(self, *args)","async def async_set_cover_position(self, **kwargs: Any) -> None:\n if ATTR_POSITION in kwargs:\n position = kwargs[ATTR_POSITION]\n await self._smartbridge.set_value(self.device_id, position)","def set_force_opacity(self, force_opacity):\n self.force_opacity = force_opacity","def load_status_bar(self):\n\n self.status_bar_layer = StatusBarLayer(self.player_layer.player)\n self.add(self.status_bar_layer)","def for_tests_only():\n root = tk.Tk()\n panel = tk.Frame(root)\n panel.pack(expand=tk.YES, fill=tk.BOTH)\n lbl = ShowGif(panel)\n lbl.place(bordermode='outside', x=135, y=500)\n lbl.show('..\\\\PicUi\\\\100x100.gif')\n root.mainloop()","def apply_png_overlay(image, overlay, start_row, start_col, height=200, width=200):\n\n alpha_s = overlay[:, :, 3] / 255.0\n alpha_l = 1.0 - alpha_s\n for c in range(0, 3):\n image[start_row:start_row+height, start_col:start_col+width, c] = (\n alpha_s * overlay[:, :, c] +\n alpha_l * image[start_row:start_row+height, start_col:start_col+width, c])\n \n return image","def ChangeOpacity(self, event):\n pass","def blit_background(self):\n self.screen.fill([67, 67, 67])\n self.screen.blit(self.background, (0,0))\n pygame.draw.rect(self.screen, (0, 0, 0), self.seperate_line)","def damage_animation(self):\n if self.damaged:\n self.image = copy.copy(self.spritesheet_dict['facing left 2'])\n self.image = pg.transform.scale2x(self.image).convert_alpha()\n damage_image = copy.copy(self.image).convert_alpha()\n damage_image.fill((255, 0, 0, self.damage_alpha), special_flags=pg.BLEND_RGBA_MULT)\n self.image.blit(damage_image, (0, 0))\n if self.fade_in:\n self.damage_alpha += 25\n if self.damage_alpha >= 255:\n self.fade_in = False\n self.damage_alpha = 255\n elif not self.fade_in:\n self.damage_alpha -= 25\n if self.damage_alpha <= 0:\n self.damage_alpha = 0\n self.damaged = False\n self.fade_in = True\n self.image = self.spritesheet_dict['facing left 2']\n self.image = pg.transform.scale2x(self.image)"],"string":"[\n \"def set_overlay(self, image_path):\\n if not osp.isfile(image_path):\\n raise ValueError(\\\"Invalid background image '{}'\\\".format(image_path))\\n self._overlay_image = image_path\\n self._final = None # Force rebuild\",\n \"def draw_overlay(self):\\n pass\",\n \"def set_image_overlays(self, condition):\\n if not config['image_on'] or not self._target_filename:\\n return\\n initial_image = load_data_from_npz(self._target_filename,\\n config['image_overlay_actuator'], str(condition),\\n 'initial', 'image', default=None)\\n target_image = load_data_from_npz(self._target_filename,\\n config['image_overlay_actuator'], str(condition),\\n 'target', 'image', default=None)\\n self._image_visualizer.set_initial_image(initial_image,\\n alpha=config['image_overlay_alpha'])\\n self._image_visualizer.set_target_image(target_image,\\n alpha=config['image_overlay_alpha'])\",\n \"def setOpacity(self, opa):\\n if self._displayPjt:\\n self._displayPjt.setOpacityPalette(opa)\\n if self._displayUsr:\\n self._displayUsr.setOpacityPalette(opa)\\n if self._displayVtk:\\n self._displayVtk.setOpacityPalette(opa)\",\n \"def overlay(self):\\n return self._overlay\",\n \"def overlay(self, img2_path=\\\"./hurr.png\\\"):\\n img2 = self.imread(img2_path)\\n\\n self.img = self.overlay_transparent(self.img, img2, 0, 0)\\n\\n self.edits.append(f\\\"overlay:{os.path.basename(img2_path)}\\\")\\n return self\",\n \"def _draw_overlay(self, gc, view_bounds=None, mode='normal'):\\n self._draw_component(gc, view_bounds, mode)\\n return\",\n \"def setOverlayRepeat(self, value):\\n self.PDFreactorConfiguration.in1[\\\"overlayRepeat\\\"] = value\",\n \"def on_draw_overlay(self):\",\n \"def overlay(self, image, x, y, r=0):\\n x -= (image.get_rect()[2] - self.dial.get_rect()[2])/2\\n y -= (image.get_rect()[3] - self.dial.get_rect()[3])/2\\n image.set_colorkey((255,255,0))\\n self.dial.blit(image, (x,y))\",\n \"def setPhoto(self, index):\\n\\n # Indicate that an image is being loaded.\\n self.image_loading_busy = True\\n\\n image = self.frames.frames_mono(index)\\n\\n super(VideoFrameSelector, self).setPhoto(image,\\n overlay_exclude_mark=not self.index_included[index])\",\n \"def on_draw_over_backgroundimage(self):\",\n \"def setTransparency(self, transparency):\\n self.render_context.alpha_mode = transparency\",\n \"def on_draw_over_image(self):\",\n \"def set_blend_mode_over(self):\\n self.image_item.setCompositionMode(QtGui.QPainter.CompositionMode_SourceOver)\",\n \"def set_transparent_percent(self, percent):\\n self.params['transparent_percent'] = percent\",\n \"def set_output(self, iclass):\\n self._custom_setter('output', iclass)\\n self._custom_setter('presenting', True)\",\n \"def draw_on_image(self, img):\\n image = Image(img)\\n\\n # If the overlay has not expired, draw on the plate highlight and/or the status message\\n if not self.has_expired():\\n self._plate.draw_plate(image, Color.Blue())\\n self._plate.draw_pins(image, self._options)\",\n \"def setBlackFrame(self):\\r\\n frame = ImageTk.PhotoImage(Image.fromarray(np.array([[0]*self.w]*self.h)))\\r\\n self.player.config(image=frame)\\r\\n self.player.image = frame\",\n \"def plot(self, A = None):\\r\\n if A is not None: self.A = A\\r\\n self.im.set_data(self.A)\\r\\n self.ax.draw_artist(self.im)\\r\\n self.fig.canvas.blit(self.ax.bbox)\",\n \"def av(self, av):\\n\\n self._av = av\",\n \"def setIcon(self, icon, alpha=False):\\n try:\\n pygame.display.set_icon(icon)\\n except TypeError:\\n icon = self.newObject(icon, alpha)\\n pygame.display.set_icon(icon)\",\n \"def set_sprite(self, image):\\n self.current_sprite = image\\n self.draw_alpha()\",\n \"def blit_me(self):\\n self.game_over_img.blit_me()\\n self.retry_button.blit_me()\",\n \"def set_alpha(self, value: Optional[int], flags: int = 0) -> 'BaseImage':\\n if value is None:\\n self._surface.set_alpha(None)\\n return self\\n assert isinstance(value, int)\\n assert 0 <= value <= 255, 'alpha value must be an integer between 0 and 255'\\n self._surface.set_alpha(value, flags)\\n return self\",\n \"def overlay(self, other_component, gc, view_bounds=None, mode=\\\"normal\\\"):\\n if not self.visible:\\n return\\n self._compute_ticks(other_component)\\n self._draw_component(gc, view_bounds, mode)\\n self._cache_valid = False\\n return\",\n \"def put_drawing_gif(self, request):\\n HttpRequest = request.to_http_info(self.api_client.configuration)\\n return self.__make_request(HttpRequest, 'PUT', 'file')\",\n \"def draw(self, draw_surface):\\n draw_surface.blit(self.background_frame, (0, 120))\",\n \"def game_over(self):\\r\\n win.blit(self.image_of_game_over, (250, 170))\",\n \"def __set_image__(self, image:pygame.image) -> None:\\n if not self.graphicsLive:\\n Graphic.__init__(self, image)\\n self.graphicsLive = True\",\n \"def overlay_scale(self, overlay_scale):\\n allowed_values = [\\\"fit\\\", \\\"fill\\\", \\\"none\\\"]\\n if overlay_scale not in allowed_values:\\n raise ValueError(\\n \\\"Invalid value for `overlay_scale` ({0}), must be one of {1}\\\"\\n .format(overlay_scale, allowed_values)\\n )\\n\\n self._overlay_scale = overlay_scale\",\n \"def set_wrapping_opacity(self, wrapping_opacity):\\n self.wrapping_opacity = wrapping_opacity\\n self.update_wrapping(self.all_wrappings)\",\n \"def _set_transparency(self, transparency, elm):\\n a = str(100 - transparency) + '196'\\n \\n alpha = OxmlElement('a:alpha')\\n alpha.set('val', a)\\n elm.srgbClr.append(alpha)\",\n \"def gif_loop(self, gif_loop):\\n if gif_loop is not None and gif_loop < -1:\\n raise ValueError(\\\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\\\")\\n\\n self._gif_loop = gif_loop\",\n \"def draw_on_image(self, img):\\n image = Image(img)\\n\\n # If the overlay has not expired, draw on the plate highlight and/or the status message\\n if not self.has_expired():\\n image.draw_text(self._text, image.center(), self._color,\\n centered=True, scale=2, thickness=3)\",\n \"def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,\\n suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):\\n\\n self._gif_fps = None\\n self._color_depth = None\\n self._gif_loop = None\\n self._height = None\\n self._start = None\\n self._duration = None\\n self._suffix = None\\n self._overlay = None\\n self._overlay_alignment = None\\n self._overlay_scale = None\\n self._label = None\\n self.discriminator = None\\n\\n if gif_fps is not None:\\n self.gif_fps = gif_fps\\n if color_depth is not None:\\n self.color_depth = color_depth\\n if gif_loop is not None:\\n self.gif_loop = gif_loop\\n self.height = height\\n self.start = start\\n if duration is not None:\\n self.duration = duration\\n if suffix is not None:\\n self.suffix = suffix\\n if overlay is not None:\\n self.overlay = overlay\\n if overlay_alignment is not None:\\n self.overlay_alignment = overlay_alignment\\n if overlay_scale is not None:\\n self.overlay_scale = overlay_scale\\n if label is not None:\\n self.label = label\",\n \"def display_callback(self, data):\\n if self.enable_overlay_publish:\\n self.publish_lidar_overlay_image(data)\",\n \"def update_image(self, surface):\\n self.ui_widget.update_image(surface=surface)\",\n \"def show(self):\\r\\n\\r\\n anim = animation.FuncAnimation(self.fig, self.animate, \\r\\n frames=list(self.object_stream), repeat=False,\\r\\n interval=self.interval, blit=self.blit)\\r\\n\\r\\n super().show()\",\n \"def __opacity_slider(self, s):\\n if len(self.__robots) > 0:\\n self.__robots[self.__selected_robot].set_transparency(s.value)\",\n \"def background(self, Background):\\n SCREEN.blit(Background, (0, 0))\\n #SCREEN.fill((0,0,0))\",\n \"def showBlockerOverlay(self, **data):\\n return self.fill_default_attributes(dict(data))\",\n \"def set_cover_position(self, **kwargs):\\n if ATTR_POSITION in kwargs:\\n position = float(kwargs[ATTR_POSITION])\\n position = min(100, max(0, position))\\n self._device.level = position / 100.0\",\n \"def overlay(self, overlay_w, title):\\n overlay = Pane(urwid.Overlay(urwid.Filler(overlay_w),\\n self._get_current_pane(),\\n 'center', 60,\\n 'middle', 5), title)\\n self.open(overlay)\",\n \"def draw(self, background):\\n background.blit(self.image, (self.x_pos, self.y_pos))\",\n \"def SetAlpha(self, *args):\\n return _itkRGBAPixelPython.itkRGBAPixelUC_SetAlpha(self, *args)\",\n \"def resizeEvent(self, event):\\n event.accept()\\n self.overlay.resize(event.size())\\n # Move gif to the center of the widget\\n self.overlay.move(self.rect().center() - self.overlay.rect().center())\",\n \"def draw_alpha(self):\\n if self.alpha == 255:\\n self.current_sprite_alpha = self.current_sprite\\n else:\\n mask = pygame.Surface(self.current_sprite.get_size(), flags=pygame.SRCALPHA)\\n mask.fill((255, 255, 255, self.alpha))\\n self.current_sprite_alpha = self.current_sprite.copy()\\n self.current_sprite_alpha.blit(mask, (0, 0), special_flags=pygame.BLEND_RGBA_MULT)\",\n \"def update(self, screen, angleX, iconLayer=0):\\n angleX %= 360\\n angleX = 360 - angleX\\n tmpImage = self.clip(self.image, 0, 0, 0, 0, 0, -35)\\n tmpImage = self.rotate(tmpImage, angleX)\\n self.overlay(self.frameImage, 0,0)\\n if iconLayer:\\n self.overlay(iconLayer[0],iconLayer[1],iconLayer[2])\\n self.overlay(tmpImage, 0, 0)\\n self.dial.set_colorkey((255,255,0))\\n screen.blit( pygame.transform.scale(self.dial,(self.w,self.h)), self.pos )\",\n \"def save_overlay(self, path):\\n if self.im is None:\\n raise ValueError('You didnt call the MaskOverlay, therefore there is no image in memory')\\n im_masked = img_as_ubyte(self.im_masked)\\n imsave(path, im_masked)\",\n \"def background(self, background):\\n\\n self._background = background\",\n \"def plot_icmaps_and_blobs(self, outfile, bg_img=None, **kwargs):\\n # make sure this object has been .fit()\\n self._update()\\n fig = plot_overlays(\\n self._icc_imgs,\\n get_largest_blobs(self._icc_imgs),\\n bg_img=bg_img,\\n figsize=(2.5, 3),\\n **kwargs\\n )\\n fig.savefig(outfile, facecolor=fig.get_facecolor(), edgecolor='none')\",\n \"def layer_overlay(foreground, background):\\n overlaid = foreground.copy()\\n negative_space = np.where(foreground[:, :, 3] == 0)\\n\\n overlaid[negative_space] = background[negative_space]\\n\\n overlaid[:, :, 3] = 255\\n\\n return overlaid\",\n \"def _update_screen(self) -> None:\\n # setup the source image with an alpha channel\\n alpha = 255 * np.ones_like(self.image[..., 0:1])\\n image = np.concatenate([self._image, alpha], axis=-1).astype(np.uint8)\\n # setup the super pixel segmentations\\n super_pixels = np.zeros_like(self.image)\\n super_pixels = mark_boundaries(\\n super_pixels,\\n self._super_pixel_segments,\\n self._super_pixel_color\\n )\\n # concatenate the first channel of sup as the alpha channel\\n super_pixels = [super_pixels, super_pixels[..., 0:1]]\\n super_pixels = np.concatenate(super_pixels, axis=-1).astype(np.uint8)\\n # setup the segmentation image with an alpha channel scaled by the\\n # opacity parameter of the application [0, 9]\\n intensity = 255 * (self._opacity / 9)\\n intensity = intensity * np.ones_like(self._segmentation[..., 0:1])\\n segmentation = np.concatenate([self._segmentation, intensity], axis=-1)\\n segmentation = segmentation.astype(np.uint8)\\n # send the images to the window\\n self._view.show([image, segmentation, super_pixels])\",\n \"def set_alpha(self, alpha):\\n if alpha < 0 or alpha > 255:\\n raise ValueError(\\\"alpha must be betweeen 0 and 255\\\")\\n\\n self.alpha = alpha\\n self.draw_alpha()\",\n \"def set_cover(self) -> None:\\n self._cover = self.Dataset.get_tx(self.antecedent)\\n self._is_updated = True\",\n \"def SetInterpolation(self, *args, **kwargs):\\n pass\",\n \"def set_foreground(self):\\n \\n # crop, resize, color quantize\\n self.crop_to_gridline()\\n self.crop_title()\\n self.set_size()\\n self.color_quantization()\\n self.display()\\n img_and_pix = self.separate_colors()\\n colors, images, pixels = zip(*img_and_pix)\\n self.foreground = images[0]\\n self.foreground = self.foreground.convert('1')\",\n \"def layer(self, layer):\\n self._layer = layer\",\n \"def clipping(self, value):\\n\\n self._clipping = value\\n if self.is_attached:\\n self[\\\"clipping\\\"] = self._clipping\",\n \"def setPen(self, *args, **kwargs):\\n if kwargs == {} and (args == () or args == ('default',)):\\n self.opts['pen'] = fn.mkPen(getConfigOption('foreground'))\\n else:\\n self.opts['pen'] = fn.mkPen(*args, **kwargs)\\n\\n self.picture = None\\n self.update()\",\n \"async def async_set_cover_position(self, **kwargs: Any) -> None:\\n new_pos = kwargs[ATTR_POSITION]\\n res = await self._level_cluster_handler.move_to_level_with_on_off(\\n new_pos * 255 / 100, 1\\n )\\n\\n if res[1] != Status.SUCCESS:\\n raise HomeAssistantError(f\\\"Failed to set cover position: {res[1]}\\\")\\n\\n self._position = new_pos\\n self.async_write_ha_state()\",\n \"def draw(self, surface):\\n surface.blit(self.image, self.rect)\",\n \"def draw(self, surface):\\n surface.blit(self.image, self.rect)\",\n \"def draw(self, background, image_path):\\n self.image = pygame.image.load(image_path).convert_alpha()\\n background.blit(self.image, (self.x_pos, self.y_pos))\",\n \"def overlay_up(self, idx):\\n if not self.is_top_layer(idx):\\n self.overlay_list[idx], self.overlay_list[idx+1] = \\\\\\n self.overlay_list[idx+1], self.overlay_list[idx]\",\n \"async def async_set_cover_position(self, **kwargs: Any) -> None:\\n await self.hass.async_add_executor_job(\\n self.data.set_level_percentage, 100 - kwargs[ATTR_POSITION]\\n )\",\n \"def draw(self, surface):\\r\\n surface.blit(self.image, self.rect)\",\n \"def draw(self, surface):\\n\\n\\t\\tsurface.blit(self.image, self.rect.topleft)\",\n \"def resetOpacity(self):\\n opa = (0,)\\n for i in range(1,256):\\n opa += (i,)\\n if self._displayPjt:\\n self._displayPjt.setOpacityPalette(opa)\\n if self._displayUsr:\\n self._displayUsr.setOpacityPalette(opa)\\n if self._displayVtk:\\n self._displayVtk.setOpacityPalette(opa)\",\n \"def SetBitmap(self, bmp):\\r\\n \\r\\n self.bitmap = bmp\",\n \"def imshow_overlay(im, mask, alpha=0.5, color='red', **kwargs):\\n mask = mask > 0\\n mask = ma.masked_where(~mask, mask) \\n plt.imshow(im, **kwargs)\\n plt.imshow(mask, alpha=alpha, cmap=ListedColormap([color]))\",\n \"def display(self, index, mask_overlay = False, save = False):\\n image_data = self[index].squeeze().numpy()\\n x, y = self.location_of(index)\\n \\n plt.figure(index)\\n plt.title(f'Image {index} at ({x}, {y})')\\n plt.imshow(image_data, cmap='bone')\\n \\n if save:\\n plt.savefig(f'{index}img.png', dpi = 400)\\n \\n if self.masked and mask_overlay:\\n mask_data = self.get_mask(index).squeeze().numpy()\\n plt.imshow(mask_data, cmap='viridis', alpha=0.4)\\n \\n if save:\\n plt.savefig(f'{index}mask.png', dpi = 400)\\n \\n plt.show()\",\n \"def compose_in_gif(images, output_file, delay):\\n images[0].save(\\n output_file, \\n format='GIF', append_images=images[1:], \\n save_all=True, duration=delay, loop=0,\\n )\",\n \"def paint(self, game_screen: pygame.Surface) -> None:\\r\\n game_screen.blit(self._img, (self._x - self._l_w / 2, self._y - self._l_w / 2,\\r\\n self._l_w, self._l_w))\",\n \"def set_animated(self,val):\\n self.XP_Plotter.set_animated(val)\\n # theoretical lines \\n for line in self.lines_theory:\\n line.set_animated(val)\",\n \"def set_img(self, img):\\n self.img = img\",\n \"def plot_blank(self):\\n self.figure_bmp.SetBitmap(self.controller.plot_blank())\",\n \"def blit(self):\\n # self.ax1.draw_artist(self.lines[:2])\\n # self.ax2.draw_artist(self.lines[2:4])\\n self.ax1.autoscale()\\n self.ax2.autoscale()\\n self.ax1.redraw_in_frame()\\n self.ax2.redraw_in_frame()\\n self.fig.canvas.blit(self.fig.bbox)\",\n \"def on_bar(self, bar: BarData):\\n self.bg.update_bar(bar)\\n self.bg_large.update_bar(bar)\",\n \"def blit(self):\\n self.screen.blit(self.image, self.rect)\",\n \"def SetHoverBitmap(self, bmp):\\r\\n \\r\\n self.hover_bitmap = bmp\",\n \"def SetBackgroundValue(self, _arg: 'short const') -> \\\"void\\\":\\n return _itkBinaryGrindPeakImageFilterPython.itkBinaryGrindPeakImageFilterISS2_SetBackgroundValue(self, _arg)\",\n \"def set_surface(self, surface:str, image:pygame.image) -> None:\\n self.surface = surface\\n self.__set_image__(image)\",\n \"def SetMarkerAlpha(self, alpha):\\n self._attalpha[\\\"marker\\\"] = alpha\\n self.SetMarkerColorAlpha(self.GetMarkerColor(), alpha)\",\n \"def _update_plot(self) -> None:\\n\\n # Check if plotting is active\\n if self._fig is None:\\n return None\\n LOG.debug(\\\"Updating plot.\\\")\\n\\n # Extract glaciated area\\n hs_back = np.ma.masked_where(\\n self.h <= 1,\\n hillshade(\\n self.ele, self.PLOT_HILLSHADE_AZIMUTH, self.PLOT_HILLSHADE_ALTITUDE\\n ),\\n )\\n\\n # Clear plot and draw axes\\n self._fig.clear()\\n ax = plt.subplot(121, facecolor=\\\"black\\\")\\n ax.tick_params(axis=\\\"x\\\", colors=\\\"w\\\")\\n ax.tick_params(axis=\\\"y\\\", colors=\\\"w\\\")\\n ax.set(xlabel=\\\"X-coordinate [m]\\\", ylabel=\\\"Y-coordinate [m]\\\")\\n ax.xaxis.label.set_color(\\\"w\\\")\\n ax.yaxis.label.set_color(\\\"w\\\")\\n title_text = f\\\"Year: {str(self.i)} ELA: {str(int(self.ela))} m.a.s.l.\\\"\\n ax.set_title(title_text, color=\\\"white\\\", size=18)\\n\\n # Draw new image layers\\n plt.imshow(self.hs, vmin=90, vmax=345, cmap=\\\"copper\\\", extent=self.extent)\\n plt.imshow(255 - hs_back, vmin=1, vmax=150, cmap=\\\"Greys\\\", extent=self.extent)\\n\\n # Mass balance\\n ax1 = plt.subplot(222, facecolor=\\\"black\\\")\\n ax1.plot(self.mass_balance, color=\\\"w\\\")\\n ax1.plot(self.mass_balance_trend, color=\\\"r\\\")\\n ax1.set(ylabel=\\\"Mass balance [m]\\\")\\n ax1.yaxis.label.set_color(\\\"w\\\")\\n plt.setp(ax1.get_xticklabels(), visible=False)\\n ax1.tick_params(axis=\\\"y\\\", colors=\\\"w\\\")\\n ax1.set_title(f\\\"Gradient: {str(self.m)} m/m\\\", color=\\\"white\\\", size=18)\\n\\n # Plot mean thickness\\n ax2 = plt.subplot(224, sharex=ax1, facecolor=\\\"black\\\")\\n ax2.plot(self.mass, color=\\\"w\\\")\\n ax2.set(xlabel=\\\"Year [a]\\\", ylabel=\\\"Mean thickness [m]\\\")\\n ax2.xaxis.label.set_color(\\\"w\\\")\\n ax2.yaxis.label.set_color(\\\"w\\\")\\n ax2.tick_params(axis=\\\"x\\\", colors=\\\"w\\\")\\n ax2.tick_params(axis=\\\"y\\\", colors=\\\"w\\\")\\n\\n # Draw new plot\\n self._fig.canvas.draw()\\n plt.pause(0.05)\",\n \"def Layer(self, layer):\\r\\n \\r\\n self.dock_layer = layer\\r\\n return self\",\n \"def __selectedOverlayChanged(self, *a):\\n\\n overlay = self.__displayCtx.getSelectedOverlay()\\n\\n # TODO Support for other overlay types\\n\\n self.enabled = ((overlay is not None) and\\n isinstance(overlay, fslimage.Image) and\\n (not overlay.saveState))\\n\\n for ovl in self.__overlayList:\\n\\n if not isinstance(ovl, fslimage.Image):\\n continue\\n\\n ovl.deregister(self.__name, 'saveState')\\n\\n # Register a listener on the saved property\\n # of the currently selected image, so we can\\n # enable the save action when the image\\n # becomes 'unsaved', and vice versa.\\n if ovl is overlay:\\n ovl.register(self.__name,\\n self.__overlaySaveStateChanged,\\n 'saveState')\",\n \"def update(self):\\n if self.value:\\n self.image = self.rect2 \\n else:\\n self.image = self.rect1\",\n \"def overlay(self):\\n # retrieve header for photometry keywords\\n # from current frame only\\n hdr_str = self.run('fits header', via='get')\\n\\n # read it in to a fits header\\n phdr = fits.Header()\\n hdr = phdr.fromstring(hdr_str, sep='\\\\n')\\n\\n try:\\n srcposx = hdr['SRCPOSX'] + 1\\n srcposy = hdr['SRCPOSY'] + 1\\n s1 = 'point({:f} {:f}) # ' \\\\\\n 'point=x ' \\\\\\n 'color=blue tag={{srcpos}} '\\\\\\n 'text=SRCPOS'.format(srcposx, srcposy)\\n self.run('regions', s1)\\n except (KeyError, ValueError):\\n pass\\n try:\\n stcentx = hdr['STCENTX'] + 1\\n stcenty = hdr['STCENTY'] + 1\\n photaper = hdr['PHOTAPER']\\n photskap = [float(x) for x in hdr['PHOTSKAP'].split(',')]\\n s1 = 'point({:f} {:f}) # ' \\\\\\n 'point=x ' \\\\\\n 'color=cyan tag={{srcpos}}'.format(stcentx, stcenty)\\n self.run('regions', s1)\\n s2 = 'circle({:f} {:f} {:f}) # ' \\\\\\n 'color=cyan tag={{srcpos}}'.format(\\n stcentx, stcenty, photaper)\\n self.run('regions', s2)\\n s3 = 'annulus({:f} {:f} {:f} {:f}) # ' \\\\\\n 'color=cyan tag={{srcpos}} text=STCENT'.format(\\n stcentx, stcenty, photskap[0], photskap[1])\\n self.run('regions', s3)\\n except (KeyError, ValueError):\\n pass\\n try:\\n stcentx = hdr['STCENTX'] + 1\\n stcenty = hdr['STCENTY'] + 1\\n flux = hdr['STAPFLX']\\n sky = hdr['STAPSKY']\\n s1 = 'text({:f} {:f}) # color=cyan ' \\\\\\n 'text=\\\"Flux={:.2f}, Sky={:.2f}\\\"'.format(\\n stcentx, stcenty - 40, flux, sky)\\n self.run('regions', s1)\\n except (KeyError, ValueError):\\n pass\\n\\n # try overlaying apertures as well\\n try:\\n self.overlay_aperture(hdr)\\n except ValueError: # pragma: no cover\\n # may be encountered with extensions with\\n # unexpected WCSs\\n pass\",\n \"def draw(self):\\n\\n surf = self.get_oxygen_surface()\\n surf.set_alpha(255)\\n self.screen.blit(surf, self.pos)\",\n \"def SetAlpha(self, *args):\\n return _itkRGBAPixelPython.itkRGBAPixelUS_SetAlpha(self, *args)\",\n \"async def async_set_cover_position(self, **kwargs: Any) -> None:\\n if ATTR_POSITION in kwargs:\\n position = kwargs[ATTR_POSITION]\\n await self._smartbridge.set_value(self.device_id, position)\",\n \"def set_force_opacity(self, force_opacity):\\n self.force_opacity = force_opacity\",\n \"def load_status_bar(self):\\n\\n self.status_bar_layer = StatusBarLayer(self.player_layer.player)\\n self.add(self.status_bar_layer)\",\n \"def for_tests_only():\\n root = tk.Tk()\\n panel = tk.Frame(root)\\n panel.pack(expand=tk.YES, fill=tk.BOTH)\\n lbl = ShowGif(panel)\\n lbl.place(bordermode='outside', x=135, y=500)\\n lbl.show('..\\\\\\\\PicUi\\\\\\\\100x100.gif')\\n root.mainloop()\",\n \"def apply_png_overlay(image, overlay, start_row, start_col, height=200, width=200):\\n\\n alpha_s = overlay[:, :, 3] / 255.0\\n alpha_l = 1.0 - alpha_s\\n for c in range(0, 3):\\n image[start_row:start_row+height, start_col:start_col+width, c] = (\\n alpha_s * overlay[:, :, c] +\\n alpha_l * image[start_row:start_row+height, start_col:start_col+width, c])\\n \\n return image\",\n \"def ChangeOpacity(self, event):\\n pass\",\n \"def blit_background(self):\\n self.screen.fill([67, 67, 67])\\n self.screen.blit(self.background, (0,0))\\n pygame.draw.rect(self.screen, (0, 0, 0), self.seperate_line)\",\n \"def damage_animation(self):\\n if self.damaged:\\n self.image = copy.copy(self.spritesheet_dict['facing left 2'])\\n self.image = pg.transform.scale2x(self.image).convert_alpha()\\n damage_image = copy.copy(self.image).convert_alpha()\\n damage_image.fill((255, 0, 0, self.damage_alpha), special_flags=pg.BLEND_RGBA_MULT)\\n self.image.blit(damage_image, (0, 0))\\n if self.fade_in:\\n self.damage_alpha += 25\\n if self.damage_alpha >= 255:\\n self.fade_in = False\\n self.damage_alpha = 255\\n elif not self.fade_in:\\n self.damage_alpha -= 25\\n if self.damage_alpha <= 0:\\n self.damage_alpha = 0\\n self.damaged = False\\n self.fade_in = True\\n self.image = self.spritesheet_dict['facing left 2']\\n self.image = pg.transform.scale2x(self.image)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6185808","0.6119764","0.5662509","0.56069213","0.54998136","0.5440037","0.54383683","0.53346497","0.5262761","0.5242616","0.5206041","0.5164456","0.51297665","0.5111875","0.50731605","0.50062686","0.4991521","0.4922425","0.4873345","0.48438504","0.48411503","0.48404488","0.48397923","0.48338765","0.48237976","0.48032135","0.47944507","0.47794053","0.47723126","0.47351858","0.47168088","0.4712264","0.4711568","0.47107235","0.47083062","0.4707246","0.47011384","0.46866357","0.46860757","0.4685967","0.467427","0.46705842","0.46690056","0.46682045","0.4664777","0.46643755","0.4645242","0.46404648","0.4638646","0.4638159","0.46366993","0.4635081","0.4634129","0.46315977","0.4630432","0.46288452","0.46199936","0.46071818","0.45980614","0.4596314","0.45946628","0.4594102","0.45928577","0.45928577","0.45788902","0.4571985","0.4567523","0.45598873","0.45580435","0.45558852","0.45553085","0.45531178","0.45501456","0.45313638","0.45170552","0.451638","0.4504785","0.44967586","0.4496112","0.44911152","0.44908345","0.44864357","0.4478827","0.44768557","0.44711545","0.44701487","0.44668382","0.4466801","0.44651657","0.44609714","0.44543695","0.44526583","0.4449368","0.44491577","0.44456863","0.44435158","0.44426003","0.44400436","0.44395053","0.44316632"],"string":"[\n \"0.6185808\",\n \"0.6119764\",\n \"0.5662509\",\n \"0.56069213\",\n \"0.54998136\",\n \"0.5440037\",\n \"0.54383683\",\n \"0.53346497\",\n \"0.5262761\",\n \"0.5242616\",\n \"0.5206041\",\n \"0.5164456\",\n \"0.51297665\",\n \"0.5111875\",\n \"0.50731605\",\n \"0.50062686\",\n \"0.4991521\",\n \"0.4922425\",\n \"0.4873345\",\n \"0.48438504\",\n \"0.48411503\",\n \"0.48404488\",\n \"0.48397923\",\n \"0.48338765\",\n \"0.48237976\",\n \"0.48032135\",\n \"0.47944507\",\n \"0.47794053\",\n \"0.47723126\",\n \"0.47351858\",\n \"0.47168088\",\n \"0.4712264\",\n \"0.4711568\",\n \"0.47107235\",\n \"0.47083062\",\n \"0.4707246\",\n \"0.47011384\",\n \"0.46866357\",\n \"0.46860757\",\n \"0.4685967\",\n \"0.467427\",\n \"0.46705842\",\n \"0.46690056\",\n \"0.46682045\",\n \"0.4664777\",\n \"0.46643755\",\n \"0.4645242\",\n \"0.46404648\",\n \"0.4638646\",\n \"0.4638159\",\n \"0.46366993\",\n \"0.4635081\",\n \"0.4634129\",\n \"0.46315977\",\n \"0.4630432\",\n \"0.46288452\",\n \"0.46199936\",\n \"0.46071818\",\n \"0.45980614\",\n \"0.4596314\",\n \"0.45946628\",\n \"0.4594102\",\n \"0.45928577\",\n \"0.45928577\",\n \"0.45788902\",\n \"0.4571985\",\n \"0.4567523\",\n \"0.45598873\",\n \"0.45580435\",\n \"0.45558852\",\n \"0.45553085\",\n \"0.45531178\",\n \"0.45501456\",\n \"0.45313638\",\n \"0.45170552\",\n \"0.451638\",\n \"0.4504785\",\n \"0.44967586\",\n \"0.4496112\",\n \"0.44911152\",\n \"0.44908345\",\n \"0.44864357\",\n \"0.4478827\",\n \"0.44768557\",\n \"0.44711545\",\n \"0.44701487\",\n \"0.44668382\",\n \"0.4466801\",\n \"0.44651657\",\n \"0.44609714\",\n \"0.44543695\",\n \"0.44526583\",\n \"0.4449368\",\n \"0.44491577\",\n \"0.44456863\",\n \"0.44435158\",\n \"0.44426003\",\n \"0.44400436\",\n \"0.44395053\",\n \"0.44316632\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71629286"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76586,"cells":{"query":{"kind":"string","value":"Gets the overlay_alignment of this GIFOutput. Alignment for overlay image in case the image doesn't fit the video perfectly. The first item in the array is X. The second is Y."},"document":{"kind":"string","value":"def overlay_alignment(self):\n return self._overlay_alignment"},"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 overlay_alignment(self, overlay_alignment):\n allowed_values = [\"left\", \"center\", \"right\", \"top\", \"middle\", \"bottom\"]\n if not set(overlay_alignment).issubset(set(allowed_values)):\n raise ValueError(\n \"Invalid values for `overlay_alignment` [{0}], must be a subset of [{1}]\"\n .format(\", \".join(map(str, set(overlay_alignment) - set(allowed_values))),\n \", \".join(map(str, allowed_values)))\n )\n\n self._overlay_alignment = overlay_alignment","def get_alignment_offset(self):\n\n return 0","def GetAlignment(self):\r\n\r\n return self.alignment","def alignsrc(self):\n return self[\"alignsrc\"]","def alignsrc(self):\n return self[\"alignsrc\"]","def alignsrc(self):\n return self[\"alignsrc\"]","def vertical_alignment(self):\n self.update()\n return self._vertical_alignment","def GetAlignment(self):\r\n\r\n return self._flag","def align(self):\n return self[\"align\"]","def align(self):\n return self[\"align\"]","def align(self):\n return self[\"align\"]","def _get_image_position(self):\n tile_conf = self.get_tile_configuration()\n image_conf = tile_conf.get(\"image\", None)\n if image_conf:\n return image_conf.get(\"position\", u\"left\")","def _write_overlay_info(self):\n cv2.putText(\n img=self.output,\n text=f'X: {float(self.estimated_distance[0]):6.2f} m',\n org=(25, 25),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Y: {float(self.estimated_distance[1]):6.2f} m',\n org=(25, 50),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Z: {float(self.estimated_distance[2]):6.2f} m',\n org=(25, 75),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Rotation: {float(self.estimated_rotation):6.2f} rad',\n org=(25, 100),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )","def _get_clip_loc_in_array(self):\r\n\r\n # coordinates of upperleft and lowerright points of binding box\r\n box_ulx, box_uly, box_lrx, box_lry = self.clip_box[0][0], self.clip_box[0][1], \\\r\n self.clip_box[1][0], self.clip_box[1][1]\r\n\r\n # Get the offsets that correspond to the bounding box corner coordinates.\r\n offsets_ul = gdal.ApplyGeoTransform(self.inv_gt, box_ulx, box_uly)\r\n offsets_lr = gdal.ApplyGeoTransform(self.inv_gt, box_lrx, box_lry)\r\n\r\n # The offsets are returned as floating point, but we need integers.\r\n self.off_ulx, self.off_uly = map(int, offsets_ul)\r\n self.off_lrx, self.off_lry = map(int, offsets_lr)\r\n\r\n # Compute the numbers of rows and columns to extract, based on the offsets.\r\n self.row = self.off_lry - self.off_uly\r\n self.column = self.off_lrx - self.off_ulx","def offset(self) -> Tuple[int, int]:\n return (self.ioffset[0].to_pixels(self.parent.width),\n self.ioffset[1].to_pixels(self.parent.height))","def get_vertical_alignment ( self, object ):\n return self.vertical_alignment","def get_vertical_alignment ( self, object ):\n return self.vertical_alignment","def get_marker_absolute_pos(marker_position, clip):\n marker_x = (marker_position[\"x\"] * clip.w) - marker_image.w / 2\n marker_y = (marker_position[\"y\"] * clip.h) - marker_image.h / 2\n return marker_x, marker_y","def horizontal_alignment(self):\n self.update()\n return self._horizontal_alignment","def _get_frame_center(self, src):\n w, h = get_size(src)\n x = w / 2\n y = h / 2\n\n return x, y","def compute_positions(self):\n return (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1), \\\n (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)","def calculate_alignment(boids: List[b.Boid]) -> Tuple[float, float]:\n align_x = 0\n align_y = 0\n for boid in boids:\n align_x += boid.v * math.cos(boid.direction)\n align_y += boid.v * math.sin(boid.direction)\n return align_x / len(boids), align_y / len(boids)","def align_preprocessed(self, img):\n aligner = FaceAligner(self.args.wing_path, self.args.lm_path, self.args.img_size)\n return aligner.align(img)","def relative_position(self) -> Tuple[int, int]:\n return self.position[0] - self.region.rect.x, self.position[1] - self.region.rect.y","def relative_position(self) -> Tuple[int, int]:\n return self.position[0] - self.region.rect.x, self.position[1] - self.region.rect.y","def getVisualFieldOrigin(self):\r\n\r\n if not hasattr(self, 'finalPatchesMarked'):\r\n raise LookupError('Please mark the final patches first!!')\r\n\r\n if not hasattr(self, 'altPosMapf'):\r\n _ = self._getSignMap()\r\n\r\n try:\r\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\r\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\r\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\r\n\r\n overlap = 0 # number of overlaping pixels\r\n iterNum = 1 # number of iteration\r\n while overlap < 1:\r\n # print 'Iteration number for finding overlapping pixel:', iterNum\r\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\r\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\r\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\r\n totalField = V1 + LM + RL\r\n # plt.imshow(totalField)\r\n overlap = len(np.argwhere(totalField == 3))\r\n iterNum += 1\r\n # print 'Number of overlapping pixels:', overlap\r\n # plt.show()\r\n\r\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\r\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\r\n\r\n except KeyError:\r\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\nSetting origins to 0 ...')\r\n altPosOrigin = 0.\r\n aziPosOrigin = 0.\r\n\r\n return altPosOrigin, aziPosOrigin","def get_aligned_image(self):\n lines = self.find_lines()\n self.rotate_crop_scale(lines)\n\n return self.image","def getPixelVisualCenter(self, altMap, aziMap):\r\n\r\n altPatch = self.array * altMap\r\n meanAlt = np.mean(altPatch[altPatch != 0])\r\n aziPatch = self.array * aziMap\r\n meanAzi = np.mean(aziPatch[aziPatch != 0])\r\n\r\n return meanAlt, meanAzi","def align(self) -> np.ndarray:\n vel = self.state[:, :, Boids.Attr.VEL]\n vel_norm = np.linalg.norm(vel, axis=0)\n orientation = vel / (vel_norm + EPSILON)\n mut_influence = self._perceive(self.p_range)\n desired_orientation = np.dot(orientation, mut_influence)\n desired_orientation = np.multiply(desired_orientation, \n vel_norm + EPSILON)\n return desired_orientation - orientation","def _get_position_delta(self) -> Tuple2IntType:\n rect = self.get_rect()\n if self._drawing_position == POSITION_NORTHWEST:\n return rect.topleft\n elif self._drawing_position == POSITION_NORTH:\n return rect.midtop\n elif self._drawing_position == POSITION_NORTHEAST:\n return rect.topright\n elif self._drawing_position == POSITION_WEST:\n return rect.midleft\n elif self._drawing_position == POSITION_CENTER:\n return rect.center\n elif self._drawing_position == POSITION_EAST:\n return rect.midright\n elif self._drawing_position == POSITION_SOUTHWEST:\n return rect.bottomleft\n elif self._drawing_position == POSITION_SOUTH:\n return rect.midbottom\n elif self._drawing_position == POSITION_SOUTHEAST:\n return rect.bottomright\n else:\n raise ValueError('unknown drawing position')","def ink_offsets(self):\n if not self._rows:\n return 0, 0\n row_inked = [True in _row for _row in self._rows]\n if True not in row_inked:\n return self.width, self.height, 0, 0\n bottom = list(reversed(row_inked)).index(True)\n top = row_inked.index(True)\n col_inked = [bool(sum(_row[_i] for _row in self._rows)) for _i in range(self.width)]\n left = col_inked.index(True)\n right = list(reversed(col_inked)).index(True)\n return left, bottom, right, top","def get_horizontal_alignment ( self, object ):\n return self.horizontal_alignment","def get_horizontal_alignment ( self, object ):\n return self.horizontal_alignment","def _centered_coords(self):\n\n array = self.detection_base.height_model.array\n height, width = self.detection_base.height_model.cell_size_x * array.shape[0], \\\n self.detection_base.height_model.cell_size_y * array.shape[1]\n min_x, min_y = self.detection_base.height_model._bounding_box[0], \\\n self.detection_base.height_model._bounding_box[2]\n\n coords = self.detection_base._coords_array_single\n coords[:, 0], coords[:,1] = coords[:, 0] - (min_x + (width / 2)), coords[:,1] - (min_y + (height / 2))\n return coords","def get_pos(self) -> tuple:\n return self.rect.center","def getAlignment(self):\n # Code to complete - generated by traceback through matrix to generate aligned pairs\n \n # find the position of the max_value\n max_value = self.getMaxAlignmentScore()\n max_pos = tuple(numpy.argwhere(self.matrix == max_value)[-1])\n x_pos = max_pos[0]; y_pos = max_pos[1]\n\n # array that holds the tuples\n path = list()\n\n # now find the path to the 0\n \n while self.matrix[x_pos][y_pos] != 0:\n \n # if diagonal is a match take that as priority\n if self.string1[x_pos - 1] == self.string2[y_pos - 1]:\n path.append((x_pos - 1, y_pos - 1))\n x_pos -=1; y_pos -= 1\n continue\n\n # finds the best horizontal alignment\n bestX = 0; bestY = y_pos - 1\n for i in range(x_pos - 1):\n if self.matrix[i][y_pos - 1] >= self.matrix[bestX][bestY]:\n bestX = i\n \n # finds best vertical alignment\n bestX_vertical = x_pos - 1; bestY_vertical = 0\n for i in range(y_pos - 1):\n if self.matrix[x_pos - 1][i] >= self.matrix[bestX_vertical][bestY_vertical]:\n bestY_vertical = i\n \n # if diagonal not satisfied, see which is better\n # the horizontal of vertical alignment.\n if self.matrix[bestX][bestY] < self.matrix[bestX_vertical][bestY_vertical]:\n path.append((bestX_vertical, bestY_vertical))\n x_pos = bestX_vertical; y_pos = bestY_vertical\n else:\n path.append((bestX, bestY))\n x_pos = bestX; y_pos = bestY\n\n return path[::-1] # reversed because we want origin to highest element.","def to_alignment(self):\n alignment = dict()\n alignment[\"x\"] = self.x\n alignment[\"w\"] = self.w\n alignment[\"y\"] = self.y\n alignment[\"h\"] = self.h\n alignment[\"frame_dims\"] = self.frame_dims\n alignment[\"landmarksXY\"] = self.landmarksXY\n return alignment","def _get_image_index_position(self) :\n \n return self._image_index_position","def getAtlasPos(self):\n return self.atlasPos","def _align_frames(frame_pre, frame_now):\n height, width = frame_pre.shape\n horizontal_lines = [np.array([frame_pre[int(height * 1 / 4), :],\n frame_pre[int(height * 2 / 4), :],\n frame_pre[int(height * 3 / 4), :]]),\n\n np.array([frame_now[int(height * 1 / 4), :],\n frame_now[int(height * 2 / 4), :],\n frame_now[int(height * 3 / 4), :]])]\n\n vertical_lines = [np.array([frame_pre[:, int(width * 1 / 4)],\n frame_pre[:, int(width * 2 / 4)],\n frame_pre[:, int(width * 3 / 4)]]),\n\n np.array([frame_now[:, int(width * 1 / 4)],\n frame_now[:, int(width * 2 / 4)],\n frame_now[:, int(width * 3 / 4)]])]\n\n min_x_val = 99999\n min_y_val = 99999\n offset_x = 0\n offset_y = 0\n for offset in range(-5, 5 + 1, 1): # TODO: check this, [-7, 7]?\n a_x = horizontal_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\n b_x = horizontal_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\n val_x = np.mean(np.linalg.norm(a_x - b_x, 1, axis=1)) # norm 1\n # print('offset_x is:', offset, ' norm=', val_x)\n if val_x < min_x_val:\n min_x_val = val_x\n offset_x = offset\n\n a_y = vertical_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\n b_y = vertical_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\n val_y = np.mean(np.linalg.norm(a_y - b_y, 1, axis=1)) # norm 1\n # print('offset_y is:', offset, ' norm=', val_y)\n if val_y < min_y_val:\n min_y_val = val_y\n offset_y = offset\n\n print('The final offset_x is:', offset_x)\n print('The final offset_y is:', offset_y)\n\n # translation\n M = np.float32([[1, 0, offset_x], [0, 1, offset_y]])\n frame_now_aligned = cv2.warpAffine(frame_now.astype(np.uint8), M, (width, height)).astype(np.int32)\n\n return frame_now_aligned, offset_x, offset_y","def get_drawing_offset(self) -> Tuple2IntType:\n return self._drawing_offset","def overlay(self):\n return self._overlay","def get_image_position(\n self, iop: np.ndarray\n ) -> Tuple[float, float, float]:\n try:\n x = self.header[\"Rows\"]\n y = self.header[\"Columns\"]\n raw_ipp = self.header[\"ImagePositionPatient\"]\n pixel_spacing = self.header[\"PixelSpacing\"]\n except KeyError:\n return\n raw_shape = np.array([x, y])\n\n slice_shape = raw_shape / self.size\n translation_fix = (raw_shape - slice_shape) / 2\n Q = np.fliplr(iop) * pixel_spacing\n return raw_ipp + np.dot(Q, translation_fix[:, None]).ravel()","def _get_label_offset(dataframe, offset=0.01):\n\n x_offset = (dataframe.iloc[:, 0].max() - dataframe.iloc[:, 0].min()) * offset\n y_offset = (dataframe.iloc[:, 1].max() - dataframe.iloc[:, 1].min()) * offset\n\n return x_offset, y_offset","def calculate_y_crop_offset(self):\n\n if self.game_name:\n playing_section = PlayingArea[self.game_name]\n else:\n playing_section = 'bottom'\n\n pre_crop_height = int(round(float(IMAGE_HEIGHT) * CROPPED_SIZE / IMAGE_WIDTH))\n shrink_factor = float(CROPPED_SIZE) / IMAGE_WIDTH\n\n if playing_section == 'top':\n return 0\n elif playing_section == 'bottom':\n return pre_crop_height - CROPPED_SIZE\n elif playing_section in ['centre', 'center']:\n return (pre_crop_height - CROPPED_SIZE) // 2\n else:\n # pixel counts\n if playing_section >= 0:\n return int(round(playing_section * shrink_factor))\n else:\n return pre_crop_height + int(round(playing_section * shrink_factor)) - CROPPED_SIZE","def absolute_collide_bottomright(self):\n x,y = self.position\n rect = self.collide_rect\n return (x+rect.width/2, y)","def get_segment_alignment(*args):\n return _ida_segment.get_segment_alignment(*args)","def anchor_position(self):\n return self._anchor_x, self._anchor_y","def _get_image_physical_position(self) :\n \n return self._image_physical_position","def calculateCenter(self):\n y_avg = int(sum(self.points[:,0])/float(len(self.points)))\n x_avg = int(sum(self.points[:,1])/float(len(self.points)))\n self.center = (x_avg, y_avg)\n return(x_avg,y_avg)","def pos(self):\n return (self.raw - self.raw_zero) / self.ratio","def bounding_box(self):\n return self.ink_width, self.ink_height","def avl_angle(self):\n dif_height = (self.heights[5] - self.heights[7])\n dif_position = (self.positions[0][7] - self.positions[0][5])\n angle = atan(dif_height / dif_position) / 1.5 * 180 / pi\n return angle","def get_pix_pos(self):\r\n return vec((self.grid_pos[0]*self.app.cell_width)+TOP_BOTTOM_BUFFER//2+self.app.cell_width//2,\r\n (self.grid_pos[1]*self.app.cell_height) +\r\n TOP_BOTTOM_BUFFER//2+self.app.cell_height//2)\r\n # where Pac-Man starts relative to the board\r","def boundingBox(self):\n pmodel = (glm.vec3(1, -self.y_sign, 0)\n * self.model.pos * self.transform.scale)\n x, y, _ = self.transform.pos + pmodel\n y += -self.y_sign * self.font.table['ascent'] * self.transform.scale[1]\n return x, y, self.pixwidth(), self.pixheight()","def getStatusTextAlignment(self) -> int:\n ...","def getStatusTextAlignment(self) -> int:\n ...","def GetObstaclePos(self):\n # read all points from laser scan\n ranges = self.Lidar.ranges\n # transfer to np.array\n ranges = np.array(ranges)\n # get all the outlier points to a very large value\n ranges = np.where(ranges < self.Lidar.range_min, self.Lidar.range_max + 10, ranges)\n ranges = np.where(ranges > self.Lidar.range_max, self.Lidar.range_max + 10, ranges)\n if len(ranges) != 0:\n # get all default angles\n angles = self.Lidar.angle_max - self.Lidar.angle_increment * np.arange(len(ranges))\n else:\n # if nothing detected, set the default value to zero\n ranges = None\n angles = None\n return ranges, angles","def _get_cog_alignment(self, moving_slice_index, fixed_slice_index):\n\n if self._slices_voxel_counts[moving_slice_index] <= 0.0005 or \\\n self._slices_voxel_counts[fixed_slice_index] <= 0.0005:\n self._generate_identity_transformation(\\\n self.f['transf_center'](mIdx=moving_slice_index,\n fIdx=fixed_slice_index))\n self._logger.info(\"Blank moving slice found. f=%d,m=%d .\" % \\\n (moving_slice_index, fixed_slice_index))\n self._logger.info(\"An identity transform will be applied.\")\n return False\n\n cog_transform_getter = pos_wrappers.align_by_center_of_gravity(\n fixed_image = self.f['src_gray'](idx=fixed_slice_index),\n moving_image = self.f['src_gray'](idx=moving_slice_index),\n output_transformation = \\\n self.f['transf_center'](mIdx=moving_slice_index,\n fIdx=fixed_slice_index))\n return copy.deepcopy(cog_transform_getter)","def last_pos(self) -> tuple[int, int]:\n if not self.actions:\n return (self.start_x, self.start_y)\n else:\n box = self.get_hitbox_at(self.time_consumed)\n return box.pos_x, box.pos_y","def offset(self):\n try:\n return self._annotations[EventData.PROP_OFFSET].decode('UTF-8')\n except (KeyError, AttributeError):\n return None","def _minY(self):\n pos = GAME_HEIGHT\n for n in range(self.getLengthAlien()):\n for x in range(len(self._aliens[0])):\n if self._aliens[n][x] != None and self._aliens[n][x].y<pos:\n pos = self._aliens[n][x].y\n return pos","def get_aa_pos_on_screen(self,position,frame):\n position=position*3+float(frame)-1\n x,y=self.get_base_pos_on_screen(position)\n y=y+20.0+float(frame)*15.0\n return x,y","def get_pos(self, frame):\n frame = self.perspective_shift(frame)\n \n puck_mask = self.color_mask(frame, self.color_green, thresh=15)\n striker_mask = self.color_mask(frame, self.color_orange, thresh=25, blur=5)\n \n puck_loc, _ = self.find_centroids(puck_mask)\n striker_locs, _ = self.find_centroids(striker_mask, 2)\n \n p_pos = self.abs_to_meter(puck_loc[0])\n # cases: (pos,pos), (pos,None), (None,None)\n if striker_locs[0] is not None:\n pos_1 = self.abs_to_meter(striker_locs[0])\n pos_2 = self.abs_to_meter(striker_locs[1])\n s1_pos = pos_1 if pos_1[1]<0 else pos_2\n s2_pos = pos_2 if pos_1[1]<0 else pos_1\n else:\n s1_pos, s2_pos = None, None \n \n return [p_pos, s1_pos, s2_pos]","def fieldCenter(self):\n if self.ra0 is None:\n self.ra0 = reduce(lambda x, y: x + y, [src.pos.ra for src in self.sources]) / len(\n self.sources) if self.sources else 0\n if self.dec0 is None:\n self.dec0 = reduce(lambda x, y: x + y, [src.pos.dec for src in self.sources]) / len(\n self.sources) if self.sources else 0\n return self.ra0, self.dec0","def positionInPile(self):\n \n return self._pile.cardLabelIndex(self)","def get_position(self):\n return self._border.get_position()","def getOverlapComparisonImagesDict(self) :\n overlap_shift_comparisons = {}\n for o in self.overlaps :\n overlap_shift_comparisons[o.getShiftComparisonDetailTuple()]=o.getShiftComparisonImages()\n return overlap_shift_comparisons","def extent(self):\n left = self.transform[0]\n right = left + self.transform[1] * self.shape[1]\n top = self.transform[3]\n bottom = top + self.transform[5] * self.shape[0]\n return left, right, bottom, top","def getLPos(self):\n c = 0\n while c <= ALIENS_IN_ROW-1:\n i = 0\n for a in range(ALIEN_ROWS):\n if self._aliens[a][c] != None:\n return self._aliens[a][c].x - ALIEN_WIDTH/2\n else:\n i +=1\n if i == ALIEN_ROWS:\n c +=1","def current_probe_position(self):\n\t\t# Obtain encoder feedback and calculate probe position\n\t\tx_position = self.x_mc.current_position() / self.steps_per_cm\n\t\ty_position = self.y_mc.current_position() / self.steps_per_degree *5 #Seems that 1 encoder unit = 5 motor step unit\n\n\t\treturn x_position, y_position","def get_alignment(f_concept_var):\n for triplet, a in self.amr_obj.alignments().items():\n if f_concept_var == triplet[0] and triplet[1] == ':instance-of':\n return int(a.split('.')[1].split(',')[0])","def gonio_axis_align():\n \n # Invert camera image, so dark pin on light image becomes a peak\n cam_7.proc1.scale.put(-1)\n cam_8.proc1.scale.put(-1)\n \n # High threshold, so AD centroid doesn't interpret background\n cam_8ThresholdOld = cam_8.stats4.centroid_threshold.get()\n cam_8.stats4.centroid_threshold.put(150)\n cam_7ThresholdOld = cam_7.stats4.centroid_threshold.get()\n cam_7.stats4.centroid_threshold.put(150)\n \n # HiMag\n # Copy ROI2 geometry (HiMag Mag3) to ROI4 and use ROI4 centroid plugin\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get())\n cam_8.roi4.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get())\n cam_8.roi4.size.x.put(cam_8.roi2.size.x.get() * 0.20)\n cam_8.roi4.size.y.put(cam_8.roi2.size.y.get())\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get() + cam_8.roi2.size.x.get()/2 - cam_8.roi4.size.x.get()/2)\n \n # LoMag\n # Copy ROI2 geometry (LoMag Mag1) to ROI4 and use ROI4 centroid plugin\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get())\n cam_7.roi4.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get())\n cam_7.roi4.size.x.put(cam_7.roi2.size.x.get() * 0.05)\n cam_7.roi4.size.y.put(cam_7.roi2.size.y.get())\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get() + cam_7.roi2.size.x.get()/2 - cam_7.roi4.size.x.get()/2)\n \n centerPinYHiMag0 = centroid_avg(cam_8.stats4)[1]\n centerPinYLoMag0 = centroid_avg(cam_7.stats4)[1]\n yield from bps.mvr(gonio.o,180)\n time.sleep(2)\n centerPinYHiMag180 = centroid_avg(cam_8.stats4)[1]\n centerPinYLoMag180 = centroid_avg(cam_7.stats4)[1]\n centerPinYHiMag = (centerPinYHiMag0 + centerPinYHiMag180)/2\n centerPinYLoMag = (centerPinYLoMag0 + centerPinYLoMag180)/2\n\n centerPinOffsYHiMag = centerPinYHiMag - cam_8.roi4.size.y.get() / 2\n centerPinOffsYLoMag = centerPinYLoMag - cam_7.roi4.size.y.get() / 2\n \n # Correct Mag 3 (cam_8 ROI2)\n cam_8.roi2.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + centerPinOffsYHiMag)\n # Correct Mag 4 (cam_8 ROI1)\n cam_8.roi1.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + (cam_8.roi2.size.y.get()-cam_8.roi1.size.y.get())/2)\n \n # Correct Mag 1 (cam_7 ROI2)\n cam_7.roi2.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + centerPinOffsYLoMag)\n # Correct Mag 2 (cam_7 ROI3)\n cam_7.roi3.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + (cam_7.roi2.size.y.get()-cam_7.roi3.size.y.get())/2)\n\n # De-invert image\n cam_7.proc1.scale.put(-1)\n cam_8.proc1.scale.put(-1)\n \n # Set thresold to previous value\n cam_8.stats4.centroid_threshold.put(cam_8ThresholdOld)\n cam_7.stats4.centroid_threshold.put(cam_7ThresholdOld)\n \n return","def get_alignment(self):\n # TODO: Probably creates incorrect binaries at values very close but less than 128M due to code size.\n if 128 * 1024 * 1024 < self.get_size():\n return int(PlatformVar(\"memory_page\"))\n return 0","def _naive_layout(self) -> List[Tuple[int, int]]:\n positions = []\n width = self.parent_component.width\n height = self.parent_component.height\n padding = self.parent_component.padding\n for child in self.parent_component.children:\n cwidth, cheight = child.width, child.height\n props = child.props\n top = 0\n left = 0\n # handle horizontal and vertical alignments\n if props.h_alignment is HAlignment.LEFT:\n left = child.margin[0] + padding[0]\n elif props.h_alignment is HAlignment.CENTER:\n left = width / 2 - cwidth / 2\n elif props.h_alignment is HAlignment.RIGHT:\n left = width - (child.margin[1] + cwidth + padding[1])\n \n if props.v_alignment is VAlignment.TOP:\n top = child.margin[2] + padding[2]\n elif props.v_alignment is VAlignment.CENTER:\n top = height / 2 - cheight / 2\n elif props.v_alignment is VAlignment.BOTTOM:\n top = height - (child.margin[3] + cheight + padding[3])\n \n offset = child.offset\n positions.append((left + offset[0], top + offset[1]))\n return positions","def get_position(self):\n # The tip window must be completely outside the anchor widget;\n # otherwise when the mouse enters the tip window we get\n # a leave event and it disappears, and then we get an enter\n # event and it reappears, and so on forever :-(\n #\n # Note: This is a simplistic implementation; sub-classes will likely\n # want to override this.\n return 20, self.anchor_widget.winfo_height() + 1","def get_tileoffset(self, gid):\n return self.tileoffset_index.get(gid, (0, 0))","def calculate_graph_element_position(self, keyInfo, key, index, duration, average):\n\n # Rectangle takes (lowerleftpoint=(X, Y), width, height)\n xy = (float(key[0]), self.ax.get_ylim()[1])\n\n # If not the latest element in the key-change data\n if index < len(keyInfo) - 1:\n # Swap width and height as we are rotating 270 degrees\n height = keyInfo[index + 1][0] - keyInfo[index][0]\n else:\n height = duration - keyInfo[index][0]\n\n width = self.ax.get_ylim()[1]\n angle = 270\n\n # Plot rectangle for key changes\n try:\n fc = self.colourMap[key[1]]\n except KeyError as k:\n fc = 'grey'\n rec = mpatch.Rectangle(xy, width, height, angle=angle, alpha=0.5, fc=fc)\n\n # Calculate label positions\n rx, ry = rec.get_xy()\n lx = rx + rec.get_height() / 2.0\n ly = average\n\n return lx, ly, rec","def _get_correct_alignement(context, answer):\n gold_text = answer[\"text\"]\n start_idx = answer[\"answer_start\"]\n end_idx = start_idx + len(gold_text)\n if context[start_idx:end_idx] == gold_text:\n return start_idx, end_idx # When the gold label position is good\n elif context[start_idx - 1 : end_idx - 1] == gold_text:\n return start_idx - 1, end_idx - 1 # When the gold label is off by one character\n elif context[start_idx - 2 : end_idx - 2] == gold_text:\n return start_idx - 2, end_idx - 2 # When the gold label is off by two character\n elif context[start_idx + 1 : end_idx + 1] == gold_text:\n return start_idx + 1, end_idx + 1 # When the gold label is off by one character\n elif context[start_idx + 2 : end_idx + 2] == gold_text:\n return start_idx + 2, end_idx + 2 # When the gold label is off by two character\n else:\n raise ValueError()","def hit_area(self):\n # Use line-height (margin_height) rather than border_height\n return (self.border_box_x(), self.position_y,\n self.border_width(), self.margin_height())","def get_pixel_pos(self):\n\n c = self.get_center()\n\n return Tank.three_by_three(c[0],c[1])","def getLocation(bounding_box):\n ymin, xmin, ymax, xmax = bounding_box\n w=1280\n h=720\n left, right, top, bottom = (xmin * w, xmax * w,\n ymin * h, ymax * h)\n ###############################################\n\n top = max(0, np.floor(top + 0.5).astype('int32'))\n left = max(0, np.floor(left + 0.5).astype('int32'))\n bottom = min(h, np.floor(bottom + 0.5).astype('int32'))\n right = min(w, np.floor(right + 0.5).astype('int32'))\n # print(label, (left, top), (right, bottom))\n \n return int((left + right) / 2.0), int((top + bottom) / 2.0)\n \n # xlt, ylt, xrb, yrb = bounding_box\n # return int((xlt + xrb) / 2.0), int((ylt + yrb) / 2.0)","def getbbox(self):\r\n img_ = (self._instance > 0)\r\n rows = np.any(img_, axis=1)\r\n cols = np.any(img_, axis=0)\r\n rmin, rmax = np.argmax(rows), img_.shape[0] - 1 - np.argmax(np.flipud(rows))\r\n cmin, cmax = np.argmax(cols), img_.shape[1] - 1 - np.argmax(np.flipud(cols))\r\n return (rmin, rmax, cmin, cmax)","def get_label_position(self) -> LabelPositionStr:\n return LABEL_POSITION.inverse[self.labelPosition()]","def _CheckBoundaries(self, frameSize):\n if (frameSize[0] + self.frame_position[0] > self.display_size[0]):\n return (0, self.frame_position[1])\n elif (frameSize[1] + self.frame_position[1] > self.display_size[1]):\n return (self.frame_position[0], 0)\n else:\n return self.frame_position","def get_subtitle_offset(annotation, seen_annotations, clip):\n if not annotation[\"time\"] in seen_annotations:\n return clip.h - SUBTILE_OFFSET\n else:\n return clip.h - SUBTILE_OFFSET * (seen_annotations[annotation[\"time\"]] + 1)","def get_wcs_integer_pixel_offset(self):\n # Grab the WCS of the first image\n refWCS = self.image1.wcs\n\n # Estimate the central location for this image\n refX, refY = self.image1.shape[1]//2, self.image1.shape[0]//2\n\n # Convert pixels to sky coordinates\n refRA, refDec = refWCS.all_pix2world(refX, refY, 0, ra_dec_order=True)\n\n # Compute the pixel location of the reference RA and Dec\n dx, dy = self.image2.wcs.all_world2pix(refRA, refDec, 0)\n\n # Convert these relativeoffsets into integer values\n dx, dy = int(dx - refX), int(dy - refY)\n\n # Return the image offsets\n return (dx, dy)","def get_probe_location(self):\n\n probe_x, probe_y = self.position\n\n if self.previous_direction == (1, 0):\n probe_x += CAR_LENGTH - 1\n elif self.previous_direction == (0, 1):\n probe_y += CAR_LENGTH - 1\n\n return probe_x, probe_y","def adjust_position(self):\n\n # Adjust position for x-axis\n r = self.rect.x % 30\n if r != 0:\n if r <= 16:\n x = self.rect.x - r\n else:\n x = self.rect.x + (30 - r)\n\n else:\n x = self.rect.x\n\n # Adjust position for y-axis\n r = self.rect.y % 30\n if r != 0:\n if r <= 16:\n y = self.rect.y - r\n else:\n y = self.rect.y + (30 - r)\n else:\n y = self.rect.y\n\n return x, y","def position(self, x, y):\n if self.portrait:\n # HMSB\n index = (x + y * self.size[0]) >> 3\n offset = 7 - (x & 0x07)\n else:\n # VMSB\n index = (y >> 3) * self.size[0] + x\n offset = 7 - (y & 0x07)\n return index, offset","def calc_axes(self):\n y_axis = np.linspace(0, self.image_shape[0] - 1, self.image_shape[0])\n x_axis = np.linspace(0, self.image_shape[1] - 1, self.image_shape[1])\n if hasattr(self, 'pixelsize'):\n y_axis *= self.pixelsize[0]\n x_axis *= self.pixelsize[1]\n return x_axis, y_axis","def aligned(self):\n return self.__aligned","def get_bbox_overlap(self, that, epsilon):\n if (not isinstance(that, Annotation)):\n raise ValueError(\"Argument for intersects should be an annotation\")\n\n # find the width and height of the overlapping rectangle\n width = min(self.bbox.xmax, that.bbox.xmax) - \\\n max(self.bbox.xmin, that.bbox.xmin)\n height = min(self.bbox.ymax, that.bbox.ymax) - \\\n max(self.bbox.ymin, that.bbox.ymin)\n\n height = abs(that.bbox.ymax - self.bbox.ymin) + epsilon\n\n return (width, height)","def aligned_landmarks(self):\n landmarks = AlignerExtract().transform_points(self.landmarksXY,\n self.aligned[\"matrix\"],\n self.aligned[\"size\"],\n self.aligned[\"padding\"])\n return landmarks","def get_bubbles_rect(self):\n rect = self.bubble_imgs[len(self.bubbles)-1].get_rect()\n return rect.move(self.pad, self.height-rect.height-self.pad)","def create_pos_overlap_metric(anchor_boxes):\n y, x, h, w = np.transpose(anchor_boxes)\n y0 = y - h // 2\n x0 = x - w // 2\n y1 = y + h // 2\n x1 = x + w // 2\n\n def pos_overlap(gt_boxes):\n pos_overlaps = []\n for gt_box in gt_boxes:\n gt_y0, gt_x0, gt_y1, gt_x1 = gt_box\n gt_area = (gt_x1 - gt_x0) * (gt_y1 - gt_y0)\n int_y0 = np.maximum(gt_y0, y0)\n int_x0 = np.maximum(gt_x0, x0)\n int_y1 = np.minimum(gt_y1, y1)\n int_x1 = np.minimum(gt_x1, x1)\n int_area = np.maximum(0, int_x1 - int_x0) * np.maximum(0, int_y1 - int_y0)\n pos_overlaps.append(int_area / gt_area)\n # Group by anchor boxes\n pos_overlaps = np.transpose(pos_overlaps)\n # Get max metric index\n gt_indices = np.argmax(pos_overlaps, axis=1)\n # Choose max metric\n pos_overlaps = np.squeeze(np.take_along_axis(pos_overlaps, gt_indices[:, np.newaxis], axis=1))\n # Take respective ground-truth boxes. No reason to return indices, at least in RPN\n gt_boxes = np.take(gt_boxes, gt_indices, axis=0)\n return pos_overlaps, gt_boxes\n return pos_overlap","def fl_get_align_xy(align, xpos, ypos, width, height, xsize, ysize, \\\n xmargin, ymargin):\n _fl_get_align_xy = library.cfuncproto(\n library.load_so_libforms(), \"fl_get_align_xy\",\\\n None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int,\\\n cty.c_int, cty.c_int, cty.c_int, cty.c_int,\n cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\\\n \"\"\"void fl_get_align_xy(int align, int x, int y, int w, int h,\n int xsize, int ysize, int xoff, int yoff, int * xx, int * yy)\"\"\")\n library.check_if_flinitialized()\n library.checkfatal_allowed_value_in_list(align, xfdata.ALIGN_list)\n i_align = library.convert_to_intc(align)\n i_xpos = library.convert_to_intc(xpos)\n i_ypos = library.convert_to_intc(ypos)\n i_width = library.convert_to_intc(width)\n i_height = library.convert_to_intc(height)\n i_xsize = library.convert_to_intc(xsize)\n i_ysize = library.convert_to_intc(ysize)\n i_xmargin = library.convert_to_intc(xmargin)\n i_ymargin = library.convert_to_intc(ymargin)\n i_xx, ptr_xx = library.make_intc_and_pointer()\n i_yy, ptr_yy = library.make_intc_and_pointer()\n library.keep_elem_refs(align, i_align, xpos, i_xpos, ypos, i_ypos, \\\n width, i_width, height, i_height, xsize, i_xsize, ysize, \\\n i_ysize, xmargin, i_xmargin, ymargin, i_ymargin, i_xx, i_yy, \\\n ptr_xx, ptr_yy)\n _fl_get_align_xy(i_align, i_xpos, i_ypos, i_width, i_height, i_xsize, \\\n i_ysize, i_xmargin, i_ymargin, ptr_xx, ptr_yy)\n return i_xx.value, i_yy.value","def most_recent_damaged_pos(self):\n\n idx = len(self.oxygen_profile) - self.count - 1\n if idx < 0:\n idx = 0\n return (self.oxygen_cards[idx].render_pos[0] + self.pos[0],\n self.oxygen_cards[idx].render_pos[1] + self.pos[1])","def bounding_box(self):\n if self._owcs.pixel_bounds is None:\n if self._owcs.pixel_shape is not None:\n nx, ny = self._owcs.pixel_shape\n elif self._owcs.array_shape is not None:\n ny, nx = self._owcs.array_shape\n else:\n return None\n\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\n\n else:\n return self._owcs.pixel_bounds","def bounding_box(self):\n if self._owcs.pixel_bounds is None:\n if self._owcs.pixel_shape is not None:\n nx, ny = self._owcs.pixel_shape\n elif self._owcs.array_shape is not None:\n ny, nx = self._owcs.array_shape\n else:\n return None\n\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\n\n else:\n return self._owcs.pixel_bounds"],"string":"[\n \"def overlay_alignment(self, overlay_alignment):\\n allowed_values = [\\\"left\\\", \\\"center\\\", \\\"right\\\", \\\"top\\\", \\\"middle\\\", \\\"bottom\\\"]\\n if not set(overlay_alignment).issubset(set(allowed_values)):\\n raise ValueError(\\n \\\"Invalid values for `overlay_alignment` [{0}], must be a subset of [{1}]\\\"\\n .format(\\\", \\\".join(map(str, set(overlay_alignment) - set(allowed_values))),\\n \\\", \\\".join(map(str, allowed_values)))\\n )\\n\\n self._overlay_alignment = overlay_alignment\",\n \"def get_alignment_offset(self):\\n\\n return 0\",\n \"def GetAlignment(self):\\r\\n\\r\\n return self.alignment\",\n \"def alignsrc(self):\\n return self[\\\"alignsrc\\\"]\",\n \"def alignsrc(self):\\n return self[\\\"alignsrc\\\"]\",\n \"def alignsrc(self):\\n return self[\\\"alignsrc\\\"]\",\n \"def vertical_alignment(self):\\n self.update()\\n return self._vertical_alignment\",\n \"def GetAlignment(self):\\r\\n\\r\\n return self._flag\",\n \"def align(self):\\n return self[\\\"align\\\"]\",\n \"def align(self):\\n return self[\\\"align\\\"]\",\n \"def align(self):\\n return self[\\\"align\\\"]\",\n \"def _get_image_position(self):\\n tile_conf = self.get_tile_configuration()\\n image_conf = tile_conf.get(\\\"image\\\", None)\\n if image_conf:\\n return image_conf.get(\\\"position\\\", u\\\"left\\\")\",\n \"def _write_overlay_info(self):\\n cv2.putText(\\n img=self.output,\\n text=f'X: {float(self.estimated_distance[0]):6.2f} m',\\n org=(25, 25),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Y: {float(self.estimated_distance[1]):6.2f} m',\\n org=(25, 50),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Z: {float(self.estimated_distance[2]):6.2f} m',\\n org=(25, 75),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Rotation: {float(self.estimated_rotation):6.2f} rad',\\n org=(25, 100),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\",\n \"def _get_clip_loc_in_array(self):\\r\\n\\r\\n # coordinates of upperleft and lowerright points of binding box\\r\\n box_ulx, box_uly, box_lrx, box_lry = self.clip_box[0][0], self.clip_box[0][1], \\\\\\r\\n self.clip_box[1][0], self.clip_box[1][1]\\r\\n\\r\\n # Get the offsets that correspond to the bounding box corner coordinates.\\r\\n offsets_ul = gdal.ApplyGeoTransform(self.inv_gt, box_ulx, box_uly)\\r\\n offsets_lr = gdal.ApplyGeoTransform(self.inv_gt, box_lrx, box_lry)\\r\\n\\r\\n # The offsets are returned as floating point, but we need integers.\\r\\n self.off_ulx, self.off_uly = map(int, offsets_ul)\\r\\n self.off_lrx, self.off_lry = map(int, offsets_lr)\\r\\n\\r\\n # Compute the numbers of rows and columns to extract, based on the offsets.\\r\\n self.row = self.off_lry - self.off_uly\\r\\n self.column = self.off_lrx - self.off_ulx\",\n \"def offset(self) -> Tuple[int, int]:\\n return (self.ioffset[0].to_pixels(self.parent.width),\\n self.ioffset[1].to_pixels(self.parent.height))\",\n \"def get_vertical_alignment ( self, object ):\\n return self.vertical_alignment\",\n \"def get_vertical_alignment ( self, object ):\\n return self.vertical_alignment\",\n \"def get_marker_absolute_pos(marker_position, clip):\\n marker_x = (marker_position[\\\"x\\\"] * clip.w) - marker_image.w / 2\\n marker_y = (marker_position[\\\"y\\\"] * clip.h) - marker_image.h / 2\\n return marker_x, marker_y\",\n \"def horizontal_alignment(self):\\n self.update()\\n return self._horizontal_alignment\",\n \"def _get_frame_center(self, src):\\n w, h = get_size(src)\\n x = w / 2\\n y = h / 2\\n\\n return x, y\",\n \"def compute_positions(self):\\n return (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1), \\\\\\n (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)\",\n \"def calculate_alignment(boids: List[b.Boid]) -> Tuple[float, float]:\\n align_x = 0\\n align_y = 0\\n for boid in boids:\\n align_x += boid.v * math.cos(boid.direction)\\n align_y += boid.v * math.sin(boid.direction)\\n return align_x / len(boids), align_y / len(boids)\",\n \"def align_preprocessed(self, img):\\n aligner = FaceAligner(self.args.wing_path, self.args.lm_path, self.args.img_size)\\n return aligner.align(img)\",\n \"def relative_position(self) -> Tuple[int, int]:\\n return self.position[0] - self.region.rect.x, self.position[1] - self.region.rect.y\",\n \"def relative_position(self) -> Tuple[int, int]:\\n return self.position[0] - self.region.rect.x, self.position[1] - self.region.rect.y\",\n \"def getVisualFieldOrigin(self):\\r\\n\\r\\n if not hasattr(self, 'finalPatchesMarked'):\\r\\n raise LookupError('Please mark the final patches first!!')\\r\\n\\r\\n if not hasattr(self, 'altPosMapf'):\\r\\n _ = self._getSignMap()\\r\\n\\r\\n try:\\r\\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\\r\\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\\r\\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\\r\\n\\r\\n overlap = 0 # number of overlaping pixels\\r\\n iterNum = 1 # number of iteration\\r\\n while overlap < 1:\\r\\n # print 'Iteration number for finding overlapping pixel:', iterNum\\r\\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\\r\\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\\r\\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\\r\\n totalField = V1 + LM + RL\\r\\n # plt.imshow(totalField)\\r\\n overlap = len(np.argwhere(totalField == 3))\\r\\n iterNum += 1\\r\\n # print 'Number of overlapping pixels:', overlap\\r\\n # plt.show()\\r\\n\\r\\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\\r\\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\\r\\n\\r\\n except KeyError:\\r\\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\\\nSetting origins to 0 ...')\\r\\n altPosOrigin = 0.\\r\\n aziPosOrigin = 0.\\r\\n\\r\\n return altPosOrigin, aziPosOrigin\",\n \"def get_aligned_image(self):\\n lines = self.find_lines()\\n self.rotate_crop_scale(lines)\\n\\n return self.image\",\n \"def getPixelVisualCenter(self, altMap, aziMap):\\r\\n\\r\\n altPatch = self.array * altMap\\r\\n meanAlt = np.mean(altPatch[altPatch != 0])\\r\\n aziPatch = self.array * aziMap\\r\\n meanAzi = np.mean(aziPatch[aziPatch != 0])\\r\\n\\r\\n return meanAlt, meanAzi\",\n \"def align(self) -> np.ndarray:\\n vel = self.state[:, :, Boids.Attr.VEL]\\n vel_norm = np.linalg.norm(vel, axis=0)\\n orientation = vel / (vel_norm + EPSILON)\\n mut_influence = self._perceive(self.p_range)\\n desired_orientation = np.dot(orientation, mut_influence)\\n desired_orientation = np.multiply(desired_orientation, \\n vel_norm + EPSILON)\\n return desired_orientation - orientation\",\n \"def _get_position_delta(self) -> Tuple2IntType:\\n rect = self.get_rect()\\n if self._drawing_position == POSITION_NORTHWEST:\\n return rect.topleft\\n elif self._drawing_position == POSITION_NORTH:\\n return rect.midtop\\n elif self._drawing_position == POSITION_NORTHEAST:\\n return rect.topright\\n elif self._drawing_position == POSITION_WEST:\\n return rect.midleft\\n elif self._drawing_position == POSITION_CENTER:\\n return rect.center\\n elif self._drawing_position == POSITION_EAST:\\n return rect.midright\\n elif self._drawing_position == POSITION_SOUTHWEST:\\n return rect.bottomleft\\n elif self._drawing_position == POSITION_SOUTH:\\n return rect.midbottom\\n elif self._drawing_position == POSITION_SOUTHEAST:\\n return rect.bottomright\\n else:\\n raise ValueError('unknown drawing position')\",\n \"def ink_offsets(self):\\n if not self._rows:\\n return 0, 0\\n row_inked = [True in _row for _row in self._rows]\\n if True not in row_inked:\\n return self.width, self.height, 0, 0\\n bottom = list(reversed(row_inked)).index(True)\\n top = row_inked.index(True)\\n col_inked = [bool(sum(_row[_i] for _row in self._rows)) for _i in range(self.width)]\\n left = col_inked.index(True)\\n right = list(reversed(col_inked)).index(True)\\n return left, bottom, right, top\",\n \"def get_horizontal_alignment ( self, object ):\\n return self.horizontal_alignment\",\n \"def get_horizontal_alignment ( self, object ):\\n return self.horizontal_alignment\",\n \"def _centered_coords(self):\\n\\n array = self.detection_base.height_model.array\\n height, width = self.detection_base.height_model.cell_size_x * array.shape[0], \\\\\\n self.detection_base.height_model.cell_size_y * array.shape[1]\\n min_x, min_y = self.detection_base.height_model._bounding_box[0], \\\\\\n self.detection_base.height_model._bounding_box[2]\\n\\n coords = self.detection_base._coords_array_single\\n coords[:, 0], coords[:,1] = coords[:, 0] - (min_x + (width / 2)), coords[:,1] - (min_y + (height / 2))\\n return coords\",\n \"def get_pos(self) -> tuple:\\n return self.rect.center\",\n \"def getAlignment(self):\\n # Code to complete - generated by traceback through matrix to generate aligned pairs\\n \\n # find the position of the max_value\\n max_value = self.getMaxAlignmentScore()\\n max_pos = tuple(numpy.argwhere(self.matrix == max_value)[-1])\\n x_pos = max_pos[0]; y_pos = max_pos[1]\\n\\n # array that holds the tuples\\n path = list()\\n\\n # now find the path to the 0\\n \\n while self.matrix[x_pos][y_pos] != 0:\\n \\n # if diagonal is a match take that as priority\\n if self.string1[x_pos - 1] == self.string2[y_pos - 1]:\\n path.append((x_pos - 1, y_pos - 1))\\n x_pos -=1; y_pos -= 1\\n continue\\n\\n # finds the best horizontal alignment\\n bestX = 0; bestY = y_pos - 1\\n for i in range(x_pos - 1):\\n if self.matrix[i][y_pos - 1] >= self.matrix[bestX][bestY]:\\n bestX = i\\n \\n # finds best vertical alignment\\n bestX_vertical = x_pos - 1; bestY_vertical = 0\\n for i in range(y_pos - 1):\\n if self.matrix[x_pos - 1][i] >= self.matrix[bestX_vertical][bestY_vertical]:\\n bestY_vertical = i\\n \\n # if diagonal not satisfied, see which is better\\n # the horizontal of vertical alignment.\\n if self.matrix[bestX][bestY] < self.matrix[bestX_vertical][bestY_vertical]:\\n path.append((bestX_vertical, bestY_vertical))\\n x_pos = bestX_vertical; y_pos = bestY_vertical\\n else:\\n path.append((bestX, bestY))\\n x_pos = bestX; y_pos = bestY\\n\\n return path[::-1] # reversed because we want origin to highest element.\",\n \"def to_alignment(self):\\n alignment = dict()\\n alignment[\\\"x\\\"] = self.x\\n alignment[\\\"w\\\"] = self.w\\n alignment[\\\"y\\\"] = self.y\\n alignment[\\\"h\\\"] = self.h\\n alignment[\\\"frame_dims\\\"] = self.frame_dims\\n alignment[\\\"landmarksXY\\\"] = self.landmarksXY\\n return alignment\",\n \"def _get_image_index_position(self) :\\n \\n return self._image_index_position\",\n \"def getAtlasPos(self):\\n return self.atlasPos\",\n \"def _align_frames(frame_pre, frame_now):\\n height, width = frame_pre.shape\\n horizontal_lines = [np.array([frame_pre[int(height * 1 / 4), :],\\n frame_pre[int(height * 2 / 4), :],\\n frame_pre[int(height * 3 / 4), :]]),\\n\\n np.array([frame_now[int(height * 1 / 4), :],\\n frame_now[int(height * 2 / 4), :],\\n frame_now[int(height * 3 / 4), :]])]\\n\\n vertical_lines = [np.array([frame_pre[:, int(width * 1 / 4)],\\n frame_pre[:, int(width * 2 / 4)],\\n frame_pre[:, int(width * 3 / 4)]]),\\n\\n np.array([frame_now[:, int(width * 1 / 4)],\\n frame_now[:, int(width * 2 / 4)],\\n frame_now[:, int(width * 3 / 4)]])]\\n\\n min_x_val = 99999\\n min_y_val = 99999\\n offset_x = 0\\n offset_y = 0\\n for offset in range(-5, 5 + 1, 1): # TODO: check this, [-7, 7]?\\n a_x = horizontal_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\\n b_x = horizontal_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\\n val_x = np.mean(np.linalg.norm(a_x - b_x, 1, axis=1)) # norm 1\\n # print('offset_x is:', offset, ' norm=', val_x)\\n if val_x < min_x_val:\\n min_x_val = val_x\\n offset_x = offset\\n\\n a_y = vertical_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\\n b_y = vertical_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\\n val_y = np.mean(np.linalg.norm(a_y - b_y, 1, axis=1)) # norm 1\\n # print('offset_y is:', offset, ' norm=', val_y)\\n if val_y < min_y_val:\\n min_y_val = val_y\\n offset_y = offset\\n\\n print('The final offset_x is:', offset_x)\\n print('The final offset_y is:', offset_y)\\n\\n # translation\\n M = np.float32([[1, 0, offset_x], [0, 1, offset_y]])\\n frame_now_aligned = cv2.warpAffine(frame_now.astype(np.uint8), M, (width, height)).astype(np.int32)\\n\\n return frame_now_aligned, offset_x, offset_y\",\n \"def get_drawing_offset(self) -> Tuple2IntType:\\n return self._drawing_offset\",\n \"def overlay(self):\\n return self._overlay\",\n \"def get_image_position(\\n self, iop: np.ndarray\\n ) -> Tuple[float, float, float]:\\n try:\\n x = self.header[\\\"Rows\\\"]\\n y = self.header[\\\"Columns\\\"]\\n raw_ipp = self.header[\\\"ImagePositionPatient\\\"]\\n pixel_spacing = self.header[\\\"PixelSpacing\\\"]\\n except KeyError:\\n return\\n raw_shape = np.array([x, y])\\n\\n slice_shape = raw_shape / self.size\\n translation_fix = (raw_shape - slice_shape) / 2\\n Q = np.fliplr(iop) * pixel_spacing\\n return raw_ipp + np.dot(Q, translation_fix[:, None]).ravel()\",\n \"def _get_label_offset(dataframe, offset=0.01):\\n\\n x_offset = (dataframe.iloc[:, 0].max() - dataframe.iloc[:, 0].min()) * offset\\n y_offset = (dataframe.iloc[:, 1].max() - dataframe.iloc[:, 1].min()) * offset\\n\\n return x_offset, y_offset\",\n \"def calculate_y_crop_offset(self):\\n\\n if self.game_name:\\n playing_section = PlayingArea[self.game_name]\\n else:\\n playing_section = 'bottom'\\n\\n pre_crop_height = int(round(float(IMAGE_HEIGHT) * CROPPED_SIZE / IMAGE_WIDTH))\\n shrink_factor = float(CROPPED_SIZE) / IMAGE_WIDTH\\n\\n if playing_section == 'top':\\n return 0\\n elif playing_section == 'bottom':\\n return pre_crop_height - CROPPED_SIZE\\n elif playing_section in ['centre', 'center']:\\n return (pre_crop_height - CROPPED_SIZE) // 2\\n else:\\n # pixel counts\\n if playing_section >= 0:\\n return int(round(playing_section * shrink_factor))\\n else:\\n return pre_crop_height + int(round(playing_section * shrink_factor)) - CROPPED_SIZE\",\n \"def absolute_collide_bottomright(self):\\n x,y = self.position\\n rect = self.collide_rect\\n return (x+rect.width/2, y)\",\n \"def get_segment_alignment(*args):\\n return _ida_segment.get_segment_alignment(*args)\",\n \"def anchor_position(self):\\n return self._anchor_x, self._anchor_y\",\n \"def _get_image_physical_position(self) :\\n \\n return self._image_physical_position\",\n \"def calculateCenter(self):\\n y_avg = int(sum(self.points[:,0])/float(len(self.points)))\\n x_avg = int(sum(self.points[:,1])/float(len(self.points)))\\n self.center = (x_avg, y_avg)\\n return(x_avg,y_avg)\",\n \"def pos(self):\\n return (self.raw - self.raw_zero) / self.ratio\",\n \"def bounding_box(self):\\n return self.ink_width, self.ink_height\",\n \"def avl_angle(self):\\n dif_height = (self.heights[5] - self.heights[7])\\n dif_position = (self.positions[0][7] - self.positions[0][5])\\n angle = atan(dif_height / dif_position) / 1.5 * 180 / pi\\n return angle\",\n \"def get_pix_pos(self):\\r\\n return vec((self.grid_pos[0]*self.app.cell_width)+TOP_BOTTOM_BUFFER//2+self.app.cell_width//2,\\r\\n (self.grid_pos[1]*self.app.cell_height) +\\r\\n TOP_BOTTOM_BUFFER//2+self.app.cell_height//2)\\r\\n # where Pac-Man starts relative to the board\\r\",\n \"def boundingBox(self):\\n pmodel = (glm.vec3(1, -self.y_sign, 0)\\n * self.model.pos * self.transform.scale)\\n x, y, _ = self.transform.pos + pmodel\\n y += -self.y_sign * self.font.table['ascent'] * self.transform.scale[1]\\n return x, y, self.pixwidth(), self.pixheight()\",\n \"def getStatusTextAlignment(self) -> int:\\n ...\",\n \"def getStatusTextAlignment(self) -> int:\\n ...\",\n \"def GetObstaclePos(self):\\n # read all points from laser scan\\n ranges = self.Lidar.ranges\\n # transfer to np.array\\n ranges = np.array(ranges)\\n # get all the outlier points to a very large value\\n ranges = np.where(ranges < self.Lidar.range_min, self.Lidar.range_max + 10, ranges)\\n ranges = np.where(ranges > self.Lidar.range_max, self.Lidar.range_max + 10, ranges)\\n if len(ranges) != 0:\\n # get all default angles\\n angles = self.Lidar.angle_max - self.Lidar.angle_increment * np.arange(len(ranges))\\n else:\\n # if nothing detected, set the default value to zero\\n ranges = None\\n angles = None\\n return ranges, angles\",\n \"def _get_cog_alignment(self, moving_slice_index, fixed_slice_index):\\n\\n if self._slices_voxel_counts[moving_slice_index] <= 0.0005 or \\\\\\n self._slices_voxel_counts[fixed_slice_index] <= 0.0005:\\n self._generate_identity_transformation(\\\\\\n self.f['transf_center'](mIdx=moving_slice_index,\\n fIdx=fixed_slice_index))\\n self._logger.info(\\\"Blank moving slice found. f=%d,m=%d .\\\" % \\\\\\n (moving_slice_index, fixed_slice_index))\\n self._logger.info(\\\"An identity transform will be applied.\\\")\\n return False\\n\\n cog_transform_getter = pos_wrappers.align_by_center_of_gravity(\\n fixed_image = self.f['src_gray'](idx=fixed_slice_index),\\n moving_image = self.f['src_gray'](idx=moving_slice_index),\\n output_transformation = \\\\\\n self.f['transf_center'](mIdx=moving_slice_index,\\n fIdx=fixed_slice_index))\\n return copy.deepcopy(cog_transform_getter)\",\n \"def last_pos(self) -> tuple[int, int]:\\n if not self.actions:\\n return (self.start_x, self.start_y)\\n else:\\n box = self.get_hitbox_at(self.time_consumed)\\n return box.pos_x, box.pos_y\",\n \"def offset(self):\\n try:\\n return self._annotations[EventData.PROP_OFFSET].decode('UTF-8')\\n except (KeyError, AttributeError):\\n return None\",\n \"def _minY(self):\\n pos = GAME_HEIGHT\\n for n in range(self.getLengthAlien()):\\n for x in range(len(self._aliens[0])):\\n if self._aliens[n][x] != None and self._aliens[n][x].y<pos:\\n pos = self._aliens[n][x].y\\n return pos\",\n \"def get_aa_pos_on_screen(self,position,frame):\\n position=position*3+float(frame)-1\\n x,y=self.get_base_pos_on_screen(position)\\n y=y+20.0+float(frame)*15.0\\n return x,y\",\n \"def get_pos(self, frame):\\n frame = self.perspective_shift(frame)\\n \\n puck_mask = self.color_mask(frame, self.color_green, thresh=15)\\n striker_mask = self.color_mask(frame, self.color_orange, thresh=25, blur=5)\\n \\n puck_loc, _ = self.find_centroids(puck_mask)\\n striker_locs, _ = self.find_centroids(striker_mask, 2)\\n \\n p_pos = self.abs_to_meter(puck_loc[0])\\n # cases: (pos,pos), (pos,None), (None,None)\\n if striker_locs[0] is not None:\\n pos_1 = self.abs_to_meter(striker_locs[0])\\n pos_2 = self.abs_to_meter(striker_locs[1])\\n s1_pos = pos_1 if pos_1[1]<0 else pos_2\\n s2_pos = pos_2 if pos_1[1]<0 else pos_1\\n else:\\n s1_pos, s2_pos = None, None \\n \\n return [p_pos, s1_pos, s2_pos]\",\n \"def fieldCenter(self):\\n if self.ra0 is None:\\n self.ra0 = reduce(lambda x, y: x + y, [src.pos.ra for src in self.sources]) / len(\\n self.sources) if self.sources else 0\\n if self.dec0 is None:\\n self.dec0 = reduce(lambda x, y: x + y, [src.pos.dec for src in self.sources]) / len(\\n self.sources) if self.sources else 0\\n return self.ra0, self.dec0\",\n \"def positionInPile(self):\\n \\n return self._pile.cardLabelIndex(self)\",\n \"def get_position(self):\\n return self._border.get_position()\",\n \"def getOverlapComparisonImagesDict(self) :\\n overlap_shift_comparisons = {}\\n for o in self.overlaps :\\n overlap_shift_comparisons[o.getShiftComparisonDetailTuple()]=o.getShiftComparisonImages()\\n return overlap_shift_comparisons\",\n \"def extent(self):\\n left = self.transform[0]\\n right = left + self.transform[1] * self.shape[1]\\n top = self.transform[3]\\n bottom = top + self.transform[5] * self.shape[0]\\n return left, right, bottom, top\",\n \"def getLPos(self):\\n c = 0\\n while c <= ALIENS_IN_ROW-1:\\n i = 0\\n for a in range(ALIEN_ROWS):\\n if self._aliens[a][c] != None:\\n return self._aliens[a][c].x - ALIEN_WIDTH/2\\n else:\\n i +=1\\n if i == ALIEN_ROWS:\\n c +=1\",\n \"def current_probe_position(self):\\n\\t\\t# Obtain encoder feedback and calculate probe position\\n\\t\\tx_position = self.x_mc.current_position() / self.steps_per_cm\\n\\t\\ty_position = self.y_mc.current_position() / self.steps_per_degree *5 #Seems that 1 encoder unit = 5 motor step unit\\n\\n\\t\\treturn x_position, y_position\",\n \"def get_alignment(f_concept_var):\\n for triplet, a in self.amr_obj.alignments().items():\\n if f_concept_var == triplet[0] and triplet[1] == ':instance-of':\\n return int(a.split('.')[1].split(',')[0])\",\n \"def gonio_axis_align():\\n \\n # Invert camera image, so dark pin on light image becomes a peak\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # High threshold, so AD centroid doesn't interpret background\\n cam_8ThresholdOld = cam_8.stats4.centroid_threshold.get()\\n cam_8.stats4.centroid_threshold.put(150)\\n cam_7ThresholdOld = cam_7.stats4.centroid_threshold.get()\\n cam_7.stats4.centroid_threshold.put(150)\\n \\n # HiMag\\n # Copy ROI2 geometry (HiMag Mag3) to ROI4 and use ROI4 centroid plugin\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get())\\n cam_8.roi4.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get())\\n cam_8.roi4.size.x.put(cam_8.roi2.size.x.get() * 0.20)\\n cam_8.roi4.size.y.put(cam_8.roi2.size.y.get())\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get() + cam_8.roi2.size.x.get()/2 - cam_8.roi4.size.x.get()/2)\\n \\n # LoMag\\n # Copy ROI2 geometry (LoMag Mag1) to ROI4 and use ROI4 centroid plugin\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get())\\n cam_7.roi4.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get())\\n cam_7.roi4.size.x.put(cam_7.roi2.size.x.get() * 0.05)\\n cam_7.roi4.size.y.put(cam_7.roi2.size.y.get())\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get() + cam_7.roi2.size.x.get()/2 - cam_7.roi4.size.x.get()/2)\\n \\n centerPinYHiMag0 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag0 = centroid_avg(cam_7.stats4)[1]\\n yield from bps.mvr(gonio.o,180)\\n time.sleep(2)\\n centerPinYHiMag180 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag180 = centroid_avg(cam_7.stats4)[1]\\n centerPinYHiMag = (centerPinYHiMag0 + centerPinYHiMag180)/2\\n centerPinYLoMag = (centerPinYLoMag0 + centerPinYLoMag180)/2\\n\\n centerPinOffsYHiMag = centerPinYHiMag - cam_8.roi4.size.y.get() / 2\\n centerPinOffsYLoMag = centerPinYLoMag - cam_7.roi4.size.y.get() / 2\\n \\n # Correct Mag 3 (cam_8 ROI2)\\n cam_8.roi2.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + centerPinOffsYHiMag)\\n # Correct Mag 4 (cam_8 ROI1)\\n cam_8.roi1.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + (cam_8.roi2.size.y.get()-cam_8.roi1.size.y.get())/2)\\n \\n # Correct Mag 1 (cam_7 ROI2)\\n cam_7.roi2.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + centerPinOffsYLoMag)\\n # Correct Mag 2 (cam_7 ROI3)\\n cam_7.roi3.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + (cam_7.roi2.size.y.get()-cam_7.roi3.size.y.get())/2)\\n\\n # De-invert image\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # Set thresold to previous value\\n cam_8.stats4.centroid_threshold.put(cam_8ThresholdOld)\\n cam_7.stats4.centroid_threshold.put(cam_7ThresholdOld)\\n \\n return\",\n \"def get_alignment(self):\\n # TODO: Probably creates incorrect binaries at values very close but less than 128M due to code size.\\n if 128 * 1024 * 1024 < self.get_size():\\n return int(PlatformVar(\\\"memory_page\\\"))\\n return 0\",\n \"def _naive_layout(self) -> List[Tuple[int, int]]:\\n positions = []\\n width = self.parent_component.width\\n height = self.parent_component.height\\n padding = self.parent_component.padding\\n for child in self.parent_component.children:\\n cwidth, cheight = child.width, child.height\\n props = child.props\\n top = 0\\n left = 0\\n # handle horizontal and vertical alignments\\n if props.h_alignment is HAlignment.LEFT:\\n left = child.margin[0] + padding[0]\\n elif props.h_alignment is HAlignment.CENTER:\\n left = width / 2 - cwidth / 2\\n elif props.h_alignment is HAlignment.RIGHT:\\n left = width - (child.margin[1] + cwidth + padding[1])\\n \\n if props.v_alignment is VAlignment.TOP:\\n top = child.margin[2] + padding[2]\\n elif props.v_alignment is VAlignment.CENTER:\\n top = height / 2 - cheight / 2\\n elif props.v_alignment is VAlignment.BOTTOM:\\n top = height - (child.margin[3] + cheight + padding[3])\\n \\n offset = child.offset\\n positions.append((left + offset[0], top + offset[1]))\\n return positions\",\n \"def get_position(self):\\n # The tip window must be completely outside the anchor widget;\\n # otherwise when the mouse enters the tip window we get\\n # a leave event and it disappears, and then we get an enter\\n # event and it reappears, and so on forever :-(\\n #\\n # Note: This is a simplistic implementation; sub-classes will likely\\n # want to override this.\\n return 20, self.anchor_widget.winfo_height() + 1\",\n \"def get_tileoffset(self, gid):\\n return self.tileoffset_index.get(gid, (0, 0))\",\n \"def calculate_graph_element_position(self, keyInfo, key, index, duration, average):\\n\\n # Rectangle takes (lowerleftpoint=(X, Y), width, height)\\n xy = (float(key[0]), self.ax.get_ylim()[1])\\n\\n # If not the latest element in the key-change data\\n if index < len(keyInfo) - 1:\\n # Swap width and height as we are rotating 270 degrees\\n height = keyInfo[index + 1][0] - keyInfo[index][0]\\n else:\\n height = duration - keyInfo[index][0]\\n\\n width = self.ax.get_ylim()[1]\\n angle = 270\\n\\n # Plot rectangle for key changes\\n try:\\n fc = self.colourMap[key[1]]\\n except KeyError as k:\\n fc = 'grey'\\n rec = mpatch.Rectangle(xy, width, height, angle=angle, alpha=0.5, fc=fc)\\n\\n # Calculate label positions\\n rx, ry = rec.get_xy()\\n lx = rx + rec.get_height() / 2.0\\n ly = average\\n\\n return lx, ly, rec\",\n \"def _get_correct_alignement(context, answer):\\n gold_text = answer[\\\"text\\\"]\\n start_idx = answer[\\\"answer_start\\\"]\\n end_idx = start_idx + len(gold_text)\\n if context[start_idx:end_idx] == gold_text:\\n return start_idx, end_idx # When the gold label position is good\\n elif context[start_idx - 1 : end_idx - 1] == gold_text:\\n return start_idx - 1, end_idx - 1 # When the gold label is off by one character\\n elif context[start_idx - 2 : end_idx - 2] == gold_text:\\n return start_idx - 2, end_idx - 2 # When the gold label is off by two character\\n elif context[start_idx + 1 : end_idx + 1] == gold_text:\\n return start_idx + 1, end_idx + 1 # When the gold label is off by one character\\n elif context[start_idx + 2 : end_idx + 2] == gold_text:\\n return start_idx + 2, end_idx + 2 # When the gold label is off by two character\\n else:\\n raise ValueError()\",\n \"def hit_area(self):\\n # Use line-height (margin_height) rather than border_height\\n return (self.border_box_x(), self.position_y,\\n self.border_width(), self.margin_height())\",\n \"def get_pixel_pos(self):\\n\\n c = self.get_center()\\n\\n return Tank.three_by_three(c[0],c[1])\",\n \"def getLocation(bounding_box):\\n ymin, xmin, ymax, xmax = bounding_box\\n w=1280\\n h=720\\n left, right, top, bottom = (xmin * w, xmax * w,\\n ymin * h, ymax * h)\\n ###############################################\\n\\n top = max(0, np.floor(top + 0.5).astype('int32'))\\n left = max(0, np.floor(left + 0.5).astype('int32'))\\n bottom = min(h, np.floor(bottom + 0.5).astype('int32'))\\n right = min(w, np.floor(right + 0.5).astype('int32'))\\n # print(label, (left, top), (right, bottom))\\n \\n return int((left + right) / 2.0), int((top + bottom) / 2.0)\\n \\n # xlt, ylt, xrb, yrb = bounding_box\\n # return int((xlt + xrb) / 2.0), int((ylt + yrb) / 2.0)\",\n \"def getbbox(self):\\r\\n img_ = (self._instance > 0)\\r\\n rows = np.any(img_, axis=1)\\r\\n cols = np.any(img_, axis=0)\\r\\n rmin, rmax = np.argmax(rows), img_.shape[0] - 1 - np.argmax(np.flipud(rows))\\r\\n cmin, cmax = np.argmax(cols), img_.shape[1] - 1 - np.argmax(np.flipud(cols))\\r\\n return (rmin, rmax, cmin, cmax)\",\n \"def get_label_position(self) -> LabelPositionStr:\\n return LABEL_POSITION.inverse[self.labelPosition()]\",\n \"def _CheckBoundaries(self, frameSize):\\n if (frameSize[0] + self.frame_position[0] > self.display_size[0]):\\n return (0, self.frame_position[1])\\n elif (frameSize[1] + self.frame_position[1] > self.display_size[1]):\\n return (self.frame_position[0], 0)\\n else:\\n return self.frame_position\",\n \"def get_subtitle_offset(annotation, seen_annotations, clip):\\n if not annotation[\\\"time\\\"] in seen_annotations:\\n return clip.h - SUBTILE_OFFSET\\n else:\\n return clip.h - SUBTILE_OFFSET * (seen_annotations[annotation[\\\"time\\\"]] + 1)\",\n \"def get_wcs_integer_pixel_offset(self):\\n # Grab the WCS of the first image\\n refWCS = self.image1.wcs\\n\\n # Estimate the central location for this image\\n refX, refY = self.image1.shape[1]//2, self.image1.shape[0]//2\\n\\n # Convert pixels to sky coordinates\\n refRA, refDec = refWCS.all_pix2world(refX, refY, 0, ra_dec_order=True)\\n\\n # Compute the pixel location of the reference RA and Dec\\n dx, dy = self.image2.wcs.all_world2pix(refRA, refDec, 0)\\n\\n # Convert these relativeoffsets into integer values\\n dx, dy = int(dx - refX), int(dy - refY)\\n\\n # Return the image offsets\\n return (dx, dy)\",\n \"def get_probe_location(self):\\n\\n probe_x, probe_y = self.position\\n\\n if self.previous_direction == (1, 0):\\n probe_x += CAR_LENGTH - 1\\n elif self.previous_direction == (0, 1):\\n probe_y += CAR_LENGTH - 1\\n\\n return probe_x, probe_y\",\n \"def adjust_position(self):\\n\\n # Adjust position for x-axis\\n r = self.rect.x % 30\\n if r != 0:\\n if r <= 16:\\n x = self.rect.x - r\\n else:\\n x = self.rect.x + (30 - r)\\n\\n else:\\n x = self.rect.x\\n\\n # Adjust position for y-axis\\n r = self.rect.y % 30\\n if r != 0:\\n if r <= 16:\\n y = self.rect.y - r\\n else:\\n y = self.rect.y + (30 - r)\\n else:\\n y = self.rect.y\\n\\n return x, y\",\n \"def position(self, x, y):\\n if self.portrait:\\n # HMSB\\n index = (x + y * self.size[0]) >> 3\\n offset = 7 - (x & 0x07)\\n else:\\n # VMSB\\n index = (y >> 3) * self.size[0] + x\\n offset = 7 - (y & 0x07)\\n return index, offset\",\n \"def calc_axes(self):\\n y_axis = np.linspace(0, self.image_shape[0] - 1, self.image_shape[0])\\n x_axis = np.linspace(0, self.image_shape[1] - 1, self.image_shape[1])\\n if hasattr(self, 'pixelsize'):\\n y_axis *= self.pixelsize[0]\\n x_axis *= self.pixelsize[1]\\n return x_axis, y_axis\",\n \"def aligned(self):\\n return self.__aligned\",\n \"def get_bbox_overlap(self, that, epsilon):\\n if (not isinstance(that, Annotation)):\\n raise ValueError(\\\"Argument for intersects should be an annotation\\\")\\n\\n # find the width and height of the overlapping rectangle\\n width = min(self.bbox.xmax, that.bbox.xmax) - \\\\\\n max(self.bbox.xmin, that.bbox.xmin)\\n height = min(self.bbox.ymax, that.bbox.ymax) - \\\\\\n max(self.bbox.ymin, that.bbox.ymin)\\n\\n height = abs(that.bbox.ymax - self.bbox.ymin) + epsilon\\n\\n return (width, height)\",\n \"def aligned_landmarks(self):\\n landmarks = AlignerExtract().transform_points(self.landmarksXY,\\n self.aligned[\\\"matrix\\\"],\\n self.aligned[\\\"size\\\"],\\n self.aligned[\\\"padding\\\"])\\n return landmarks\",\n \"def get_bubbles_rect(self):\\n rect = self.bubble_imgs[len(self.bubbles)-1].get_rect()\\n return rect.move(self.pad, self.height-rect.height-self.pad)\",\n \"def create_pos_overlap_metric(anchor_boxes):\\n y, x, h, w = np.transpose(anchor_boxes)\\n y0 = y - h // 2\\n x0 = x - w // 2\\n y1 = y + h // 2\\n x1 = x + w // 2\\n\\n def pos_overlap(gt_boxes):\\n pos_overlaps = []\\n for gt_box in gt_boxes:\\n gt_y0, gt_x0, gt_y1, gt_x1 = gt_box\\n gt_area = (gt_x1 - gt_x0) * (gt_y1 - gt_y0)\\n int_y0 = np.maximum(gt_y0, y0)\\n int_x0 = np.maximum(gt_x0, x0)\\n int_y1 = np.minimum(gt_y1, y1)\\n int_x1 = np.minimum(gt_x1, x1)\\n int_area = np.maximum(0, int_x1 - int_x0) * np.maximum(0, int_y1 - int_y0)\\n pos_overlaps.append(int_area / gt_area)\\n # Group by anchor boxes\\n pos_overlaps = np.transpose(pos_overlaps)\\n # Get max metric index\\n gt_indices = np.argmax(pos_overlaps, axis=1)\\n # Choose max metric\\n pos_overlaps = np.squeeze(np.take_along_axis(pos_overlaps, gt_indices[:, np.newaxis], axis=1))\\n # Take respective ground-truth boxes. No reason to return indices, at least in RPN\\n gt_boxes = np.take(gt_boxes, gt_indices, axis=0)\\n return pos_overlaps, gt_boxes\\n return pos_overlap\",\n \"def fl_get_align_xy(align, xpos, ypos, width, height, xsize, ysize, \\\\\\n xmargin, ymargin):\\n _fl_get_align_xy = library.cfuncproto(\\n library.load_so_libforms(), \\\"fl_get_align_xy\\\",\\\\\\n None, [cty.c_int, cty.c_int, cty.c_int, cty.c_int, cty.c_int,\\\\\\n cty.c_int, cty.c_int, cty.c_int, cty.c_int,\\n cty.POINTER(cty.c_int), cty.POINTER(cty.c_int)],\\\\\\n \\\"\\\"\\\"void fl_get_align_xy(int align, int x, int y, int w, int h,\\n int xsize, int ysize, int xoff, int yoff, int * xx, int * yy)\\\"\\\"\\\")\\n library.check_if_flinitialized()\\n library.checkfatal_allowed_value_in_list(align, xfdata.ALIGN_list)\\n i_align = library.convert_to_intc(align)\\n i_xpos = library.convert_to_intc(xpos)\\n i_ypos = library.convert_to_intc(ypos)\\n i_width = library.convert_to_intc(width)\\n i_height = library.convert_to_intc(height)\\n i_xsize = library.convert_to_intc(xsize)\\n i_ysize = library.convert_to_intc(ysize)\\n i_xmargin = library.convert_to_intc(xmargin)\\n i_ymargin = library.convert_to_intc(ymargin)\\n i_xx, ptr_xx = library.make_intc_and_pointer()\\n i_yy, ptr_yy = library.make_intc_and_pointer()\\n library.keep_elem_refs(align, i_align, xpos, i_xpos, ypos, i_ypos, \\\\\\n width, i_width, height, i_height, xsize, i_xsize, ysize, \\\\\\n i_ysize, xmargin, i_xmargin, ymargin, i_ymargin, i_xx, i_yy, \\\\\\n ptr_xx, ptr_yy)\\n _fl_get_align_xy(i_align, i_xpos, i_ypos, i_width, i_height, i_xsize, \\\\\\n i_ysize, i_xmargin, i_ymargin, ptr_xx, ptr_yy)\\n return i_xx.value, i_yy.value\",\n \"def most_recent_damaged_pos(self):\\n\\n idx = len(self.oxygen_profile) - self.count - 1\\n if idx < 0:\\n idx = 0\\n return (self.oxygen_cards[idx].render_pos[0] + self.pos[0],\\n self.oxygen_cards[idx].render_pos[1] + self.pos[1])\",\n \"def bounding_box(self):\\n if self._owcs.pixel_bounds is None:\\n if self._owcs.pixel_shape is not None:\\n nx, ny = self._owcs.pixel_shape\\n elif self._owcs.array_shape is not None:\\n ny, nx = self._owcs.array_shape\\n else:\\n return None\\n\\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\\n\\n else:\\n return self._owcs.pixel_bounds\",\n \"def bounding_box(self):\\n if self._owcs.pixel_bounds is None:\\n if self._owcs.pixel_shape is not None:\\n nx, ny = self._owcs.pixel_shape\\n elif self._owcs.array_shape is not None:\\n ny, nx = self._owcs.array_shape\\n else:\\n return None\\n\\n return ((-0.5, nx - 0.5), (-0.5, ny - 0.5))\\n\\n else:\\n return self._owcs.pixel_bounds\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6082157","0.5811847","0.57966024","0.5563203","0.5563203","0.5563203","0.5542505","0.54789925","0.5473381","0.5473381","0.5473381","0.54557025","0.5414728","0.5391308","0.53716415","0.53711426","0.53711426","0.5358381","0.5308002","0.5301803","0.5293957","0.52331334","0.5207477","0.5193577","0.5193577","0.5192816","0.51900715","0.51855534","0.51822066","0.5150857","0.5149447","0.51192313","0.51192313","0.5116431","0.50986695","0.50912714","0.506672","0.5051995","0.5035586","0.5033398","0.502983","0.5011865","0.5002088","0.5000976","0.49752888","0.4963538","0.4961987","0.49409154","0.4923949","0.4916324","0.4898491","0.48976547","0.48879406","0.48861897","0.48752996","0.48675987","0.48675987","0.48554403","0.48525685","0.48524037","0.4829495","0.48277873","0.4822595","0.4822171","0.48096806","0.48059303","0.47889447","0.47870195","0.4781605","0.47752243","0.4764468","0.47633404","0.47602248","0.4759942","0.47541028","0.47469148","0.47455904","0.4745215","0.47394025","0.4737782","0.47368258","0.473299","0.4729149","0.472262","0.47194162","0.471199","0.47098434","0.47088766","0.46962515","0.46941262","0.46937034","0.46933484","0.4693321","0.46848038","0.46821192","0.46772814","0.46752736","0.46717957","0.46717465","0.46717465"],"string":"[\n \"0.6082157\",\n \"0.5811847\",\n \"0.57966024\",\n \"0.5563203\",\n \"0.5563203\",\n \"0.5563203\",\n \"0.5542505\",\n \"0.54789925\",\n \"0.5473381\",\n \"0.5473381\",\n \"0.5473381\",\n \"0.54557025\",\n \"0.5414728\",\n \"0.5391308\",\n \"0.53716415\",\n \"0.53711426\",\n \"0.53711426\",\n \"0.5358381\",\n \"0.5308002\",\n \"0.5301803\",\n \"0.5293957\",\n \"0.52331334\",\n \"0.5207477\",\n \"0.5193577\",\n \"0.5193577\",\n \"0.5192816\",\n \"0.51900715\",\n \"0.51855534\",\n \"0.51822066\",\n \"0.5150857\",\n \"0.5149447\",\n \"0.51192313\",\n \"0.51192313\",\n \"0.5116431\",\n \"0.50986695\",\n \"0.50912714\",\n \"0.506672\",\n \"0.5051995\",\n \"0.5035586\",\n \"0.5033398\",\n \"0.502983\",\n \"0.5011865\",\n \"0.5002088\",\n \"0.5000976\",\n \"0.49752888\",\n \"0.4963538\",\n \"0.4961987\",\n \"0.49409154\",\n \"0.4923949\",\n \"0.4916324\",\n \"0.4898491\",\n \"0.48976547\",\n \"0.48879406\",\n \"0.48861897\",\n \"0.48752996\",\n \"0.48675987\",\n \"0.48675987\",\n \"0.48554403\",\n \"0.48525685\",\n \"0.48524037\",\n \"0.4829495\",\n \"0.48277873\",\n \"0.4822595\",\n \"0.4822171\",\n \"0.48096806\",\n \"0.48059303\",\n \"0.47889447\",\n \"0.47870195\",\n \"0.4781605\",\n \"0.47752243\",\n \"0.4764468\",\n \"0.47633404\",\n \"0.47602248\",\n \"0.4759942\",\n \"0.47541028\",\n \"0.47469148\",\n \"0.47455904\",\n \"0.4745215\",\n \"0.47394025\",\n \"0.4737782\",\n \"0.47368258\",\n \"0.473299\",\n \"0.4729149\",\n \"0.472262\",\n \"0.47194162\",\n \"0.471199\",\n \"0.47098434\",\n \"0.47088766\",\n \"0.46962515\",\n \"0.46941262\",\n \"0.46937034\",\n \"0.46933484\",\n \"0.4693321\",\n \"0.46848038\",\n \"0.46821192\",\n \"0.46772814\",\n \"0.46752736\",\n \"0.46717957\",\n \"0.46717465\",\n \"0.46717465\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78458405"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76587,"cells":{"query":{"kind":"string","value":"Sets the overlay_alignment of this GIFOutput. Alignment for overlay image in case the image doesn't fit the video perfectly. The first item in the array is X. The second is Y."},"document":{"kind":"string","value":"def overlay_alignment(self, overlay_alignment):\n allowed_values = [\"left\", \"center\", \"right\", \"top\", \"middle\", \"bottom\"]\n if not set(overlay_alignment).issubset(set(allowed_values)):\n raise ValueError(\n \"Invalid values for `overlay_alignment` [{0}], must be a subset of [{1}]\"\n .format(\", \".join(map(str, set(overlay_alignment) - set(allowed_values))),\n \", \".join(map(str, allowed_values)))\n )\n\n self._overlay_alignment = overlay_alignment"},"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 overlay_alignment(self):\n return self._overlay_alignment","def overlay(self, overlay):\n\n self._overlay = overlay","def gonio_axis_align():\n \n # Invert camera image, so dark pin on light image becomes a peak\n cam_7.proc1.scale.put(-1)\n cam_8.proc1.scale.put(-1)\n \n # High threshold, so AD centroid doesn't interpret background\n cam_8ThresholdOld = cam_8.stats4.centroid_threshold.get()\n cam_8.stats4.centroid_threshold.put(150)\n cam_7ThresholdOld = cam_7.stats4.centroid_threshold.get()\n cam_7.stats4.centroid_threshold.put(150)\n \n # HiMag\n # Copy ROI2 geometry (HiMag Mag3) to ROI4 and use ROI4 centroid plugin\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get())\n cam_8.roi4.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get())\n cam_8.roi4.size.x.put(cam_8.roi2.size.x.get() * 0.20)\n cam_8.roi4.size.y.put(cam_8.roi2.size.y.get())\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get() + cam_8.roi2.size.x.get()/2 - cam_8.roi4.size.x.get()/2)\n \n # LoMag\n # Copy ROI2 geometry (LoMag Mag1) to ROI4 and use ROI4 centroid plugin\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get())\n cam_7.roi4.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get())\n cam_7.roi4.size.x.put(cam_7.roi2.size.x.get() * 0.05)\n cam_7.roi4.size.y.put(cam_7.roi2.size.y.get())\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get() + cam_7.roi2.size.x.get()/2 - cam_7.roi4.size.x.get()/2)\n \n centerPinYHiMag0 = centroid_avg(cam_8.stats4)[1]\n centerPinYLoMag0 = centroid_avg(cam_7.stats4)[1]\n yield from bps.mvr(gonio.o,180)\n time.sleep(2)\n centerPinYHiMag180 = centroid_avg(cam_8.stats4)[1]\n centerPinYLoMag180 = centroid_avg(cam_7.stats4)[1]\n centerPinYHiMag = (centerPinYHiMag0 + centerPinYHiMag180)/2\n centerPinYLoMag = (centerPinYLoMag0 + centerPinYLoMag180)/2\n\n centerPinOffsYHiMag = centerPinYHiMag - cam_8.roi4.size.y.get() / 2\n centerPinOffsYLoMag = centerPinYLoMag - cam_7.roi4.size.y.get() / 2\n \n # Correct Mag 3 (cam_8 ROI2)\n cam_8.roi2.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + centerPinOffsYHiMag)\n # Correct Mag 4 (cam_8 ROI1)\n cam_8.roi1.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + (cam_8.roi2.size.y.get()-cam_8.roi1.size.y.get())/2)\n \n # Correct Mag 1 (cam_7 ROI2)\n cam_7.roi2.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + centerPinOffsYLoMag)\n # Correct Mag 2 (cam_7 ROI3)\n cam_7.roi3.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + (cam_7.roi2.size.y.get()-cam_7.roi3.size.y.get())/2)\n\n # De-invert image\n cam_7.proc1.scale.put(-1)\n cam_8.proc1.scale.put(-1)\n \n # Set thresold to previous value\n cam_8.stats4.centroid_threshold.put(cam_8ThresholdOld)\n cam_7.stats4.centroid_threshold.put(cam_7ThresholdOld)\n \n return","def update_annot(self, ind, plt_ref, ref_label):\r\n\r\n # Get selected data coordinates\r\n pos = plt_ref._xy[ind[\"ind\"][0]]\r\n\r\n # Shift annotation box left or right depending on which half of the axis the pos x is located and the\r\n # direction of x increasing.\r\n if plt_ref.axes.viewLim.intervalx[0] < plt_ref.axes.viewLim.intervalx[1]:\r\n if pos[0] < (plt_ref.axes.viewLim.intervalx[0] + plt_ref.axes.viewLim.intervalx[1]) / 2:\r\n self.annot._x = -20\r\n else:\r\n self.annot._x = -80\r\n else:\r\n if pos[0] < (plt_ref.axes.viewLim.intervalx[0] + plt_ref.axes.viewLim.intervalx[1]) / 2:\r\n self.annot._x = -80\r\n else:\r\n self.annot._x = -20\r\n\r\n # Shift annotation box up or down depending on which half of the axis the pos y is located and the\r\n # direction of y increasing.\r\n if plt_ref.axes.viewLim.intervaly[0] < plt_ref.axes.viewLim.intervaly[1]:\r\n if pos[1] > (plt_ref.axes.viewLim.intervaly[0] + plt_ref.axes.viewLim.intervaly[1]) / 2:\r\n self.annot._y = -40\r\n else:\r\n self.annot._y = 20\r\n else:\r\n if pos[1] > (plt_ref.axes.viewLim.intervaly[0] + plt_ref.axes.viewLim.intervaly[1]) / 2:\r\n self.annot._y = 20\r\n else:\r\n self.annot._y = -40\r\n\r\n self.annot.xy = pos\r\n\r\n # Format and display text\r\n text = 'x: {:.2f}, {}: {:.2f}'.format(pos[0], ref_label, pos[1])\r\n self.annot.set_text(text)","def _align_frames(frame_pre, frame_now):\n height, width = frame_pre.shape\n horizontal_lines = [np.array([frame_pre[int(height * 1 / 4), :],\n frame_pre[int(height * 2 / 4), :],\n frame_pre[int(height * 3 / 4), :]]),\n\n np.array([frame_now[int(height * 1 / 4), :],\n frame_now[int(height * 2 / 4), :],\n frame_now[int(height * 3 / 4), :]])]\n\n vertical_lines = [np.array([frame_pre[:, int(width * 1 / 4)],\n frame_pre[:, int(width * 2 / 4)],\n frame_pre[:, int(width * 3 / 4)]]),\n\n np.array([frame_now[:, int(width * 1 / 4)],\n frame_now[:, int(width * 2 / 4)],\n frame_now[:, int(width * 3 / 4)]])]\n\n min_x_val = 99999\n min_y_val = 99999\n offset_x = 0\n offset_y = 0\n for offset in range(-5, 5 + 1, 1): # TODO: check this, [-7, 7]?\n a_x = horizontal_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\n b_x = horizontal_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\n val_x = np.mean(np.linalg.norm(a_x - b_x, 1, axis=1)) # norm 1\n # print('offset_x is:', offset, ' norm=', val_x)\n if val_x < min_x_val:\n min_x_val = val_x\n offset_x = offset\n\n a_y = vertical_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\n b_y = vertical_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\n val_y = np.mean(np.linalg.norm(a_y - b_y, 1, axis=1)) # norm 1\n # print('offset_y is:', offset, ' norm=', val_y)\n if val_y < min_y_val:\n min_y_val = val_y\n offset_y = offset\n\n print('The final offset_x is:', offset_x)\n print('The final offset_y is:', offset_y)\n\n # translation\n M = np.float32([[1, 0, offset_x], [0, 1, offset_y]])\n frame_now_aligned = cv2.warpAffine(frame_now.astype(np.uint8), M, (width, height)).astype(np.int32)\n\n return frame_now_aligned, offset_x, offset_y","def SetAlignment(self, l):\r\n\r\n self.alignment = l","def resetAlignmentCenter(self):\n cent = self.TiltSeries_._TiltAlignmentParas.cent\n imdimX = self.TiltSeries_._imdimX\n imdimY = self.TiltSeries_._imdimY\n print(imdimX, imdimY)\n if cent[0] != imdimX//2+1 or cent[1] != imdimY//2+1:\n #rint \"Centers do not match: cent=\"+str(cent)+\", imdim=\"+str(imdim)\n self.TiltSeries_._TiltAlignmentParas.cent = [imdimX//2+1, imdimY//2+1]","def _write_overlay_info(self):\n cv2.putText(\n img=self.output,\n text=f'X: {float(self.estimated_distance[0]):6.2f} m',\n org=(25, 25),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Y: {float(self.estimated_distance[1]):6.2f} m',\n org=(25, 50),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Z: {float(self.estimated_distance[2]):6.2f} m',\n org=(25, 75),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )\n cv2.putText(\n img=self.output,\n text=f'Rotation: {float(self.estimated_rotation):6.2f} rad',\n org=(25, 100),\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\n color=(0, 0, 255),\n fontScale=0.5\n )","def overlay_up(self, idx):\n if not self.is_top_layer(idx):\n self.overlay_list[idx], self.overlay_list[idx+1] = \\\n self.overlay_list[idx+1], self.overlay_list[idx]","def update_annot(ind):\n # update text annotation\n pos = sc.get_offsets()[ind[\"ind\"][0]]\n annot.xy = pos\n idxlist = []\n for element in PC:\n idxlist.append(np.allclose(element, pos))\n idx = idxlist.index(True)\n annotation_string = f'{idx + 1}\\n'\n if display_parameter_values:\n for i, label in enumerate(parameterList):\n annotation_string += (f'{parameters[i, idx]: 10.2f} '\n f'+/- {errors[i, idx]:8.2f} '\n f'({label})\\n')\n annot.set_text(annotation_string[:-1])\n annot.get_bbox_patch().set_alpha(0.4)\n\n # update immage annotation\n label = mapp.listOfFiles[idx].split(os.sep)[-1].split('.')[0]\n image = get_image(mapp.pltdir, label)\n ab.xy = pos\n ab.offsetbox = OffsetImage(image)\n ax.add_artist(ab)\n if show_both_images:\n additional_image = get_image(additional_fitplot_folder, label)\n ac.xy = pos + shift_second_image\n ac.offsetbox = OffsetImage(additional_image)\n ax.add_artist(ac)","def imalign(src_file, dst_file, face_landmarks, output_size=1024, transform_size=1024, enable_padding=True, x_scale=1, y_scale=1, em_scale=0.1, alpha=False):\n lm = np.array(face_landmarks)\n lm_chin = lm[0 : 17] # left-right\n lm_eyebrow_left = lm[17 : 22] # left-right\n lm_eyebrow_right = lm[22 : 27] # left-right\n lm_nose = lm[27 : 31] # top-down\n lm_nostrils = lm[31 : 36] # top-down\n lm_eye_left = lm[36 : 42] # left-clockwise\n lm_eye_right = lm[42 : 48] # left-clockwise\n lm_mouth_outer = lm[48 : 60] # left-clockwise\n lm_mouth_inner = lm[60 : 68] # left-clockwise\n\n # Calculate auxiliary vectors.\n eye_left = np.mean(lm_eye_left, axis=0)\n eye_right = np.mean(lm_eye_right, axis=0)\n eye_avg = (eye_left + eye_right) * 0.5\n eye_to_eye = eye_right - eye_left\n mouth_left = lm_mouth_outer[0]\n mouth_right = lm_mouth_outer[6]\n mouth_avg = (mouth_left + mouth_right) * 0.5\n eye_to_mouth = mouth_avg - eye_avg\n\n # Choose oriented crop rectangle.\n x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]\n x /= np.hypot(*x)\n x *= max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)\n x *= x_scale\n y = np.flipud(x) * [-y_scale, y_scale]\n c = eye_avg + eye_to_mouth * em_scale\n quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])\n qsize = np.hypot(*x) * 2\n\n # Load in-the-wild image.\n if not os.path.isfile(src_file):\n print('\\nCannot find source image. Please run \"--wilds\" before \"--align\".')\n return\n img = Image.open(src_file)\n\n # Shrink.\n shrink = int(np.floor(qsize / output_size * 0.5))\n if shrink > 1:\n rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink)))\n img = img.resize(rsize, Image.ANTIALIAS)\n quad /= shrink\n qsize /= shrink\n\n # Crop.\n border = max(int(np.rint(qsize * 0.1)), 3)\n crop = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\n crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]), min(crop[3] + border, img.size[1]))\n if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]:\n img = img.crop(crop)\n quad -= crop[0:2]\n\n # Pad.\n pad = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\n pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0), max(pad[3] - img.size[1] + border, 0))\n if enable_padding and max(pad) > border - 4:\n pad = np.maximum(pad, int(np.rint(qsize * 0.3)))\n img = np.pad(np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect')\n h, w, _ = img.shape\n y, x, _ = np.ogrid[:h, :w, :1]\n mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w-1-x) / pad[2]), 1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h-1-y) / pad[3]))\n blur = qsize * 0.02\n img += (ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)\n img += (np.median(img, axis=(0,1)) - img) * np.clip(mask, 0.0, 1.0)\n img = np.uint8(np.clip(np.rint(img), 0, 255))\n if alpha:\n mask = 1-np.clip(3.0 * mask, 0.0, 1.0)\n mask = np.uint8(np.clip(np.rint(mask*255), 0, 255))\n img = np.concatenate((img, mask), axis=2)\n img = Image.fromarray(img, 'RGBA')\n else:\n img = Image.fromarray(img, 'RGB')\n quad += pad[:2]\n\n # Transform.\n img = img.transform((transform_size, transform_size), Image.QUAD, (quad + 0.5).flatten(), Image.BILINEAR)\n print(transform_size)\n if output_size < transform_size:\n img = img.resize((output_size, output_size), Image.ANTIALIAS)\n\n # Save aligned image.\n img.save(dst_file, 'PNG')","def _layout_as_overlay(self, size=None, force=False):\n if self.component is not None:\n self.position = self.component.position\n self.bounds = self.component.bounds\n return","def _align(elements, alignment=\"ymax\"):\n if len(elements) == 0:\n return elements\n if alignment not in ([\"x\", \"y\", \"xmin\", \"xmax\", \"ymin\", \"ymax\"]):\n raise ValueError(\n \"'alignment' argument must be one of 'x','y','xmin', 'xmax', 'ymin','ymax'\"\n )\n value = Group(elements).__getattribute__(alignment)\n for e in elements:\n e.__setattr__(alignment, value)\n return elements","def set_image_overlays(self, condition):\n if not config['image_on'] or not self._target_filename:\n return\n initial_image = load_data_from_npz(self._target_filename,\n config['image_overlay_actuator'], str(condition),\n 'initial', 'image', default=None)\n target_image = load_data_from_npz(self._target_filename,\n config['image_overlay_actuator'], str(condition),\n 'target', 'image', default=None)\n self._image_visualizer.set_initial_image(initial_image,\n alpha=config['image_overlay_alpha'])\n self._image_visualizer.set_target_image(target_image,\n alpha=config['image_overlay_alpha'])","def setup_orientation_annotation(self) :\n \n # Anatomical directions in LPS convention, numpy order\n directions_anatomical = {\n \"L\" : (0,0,+1),\n \"R\" : (0,0,-1),\n \"P\" : (0,+1,0),\n \"A\" : (0,-1,0),\n \"I\" : (-1,0,0),\n \"S\" : (+1,0,0),\n }\n \n # Index directions, numpy order\n directions_index = {\n \"+x\" : (0,0,+1),\n \"-x\" : (0,0,-1),\n \"+y\" : (0,+1,0),\n \"-y\" : (0,-1,0),\n \"+z\" : (-1,0,0),\n \"-z\" : (+1,0,0),\n }\n \n directions = (directions_anatomical \n if self.display_coordinates in [\"physical\", \"nearest_axis_aligned\"]\n else directions_index)\n \n # Window locations\n locations = {\n \"up\" : (1,0),\n \"down\" : (-1,0),\n \"left\" : (0,-1),\n \"right\" : (0,1)\n }\n \n for location, p in locations.items() :\n matrix = self._3d_world_to_slice\n direction = numpy.dot(self._3d_slice_to_world, numpy.hstack((0, p)))\n \n # Find closest in-slice direction based on dot product\n closest = None\n max_distance = -1\n for name, d in directions.items() :\n distance = numpy.dot(d, direction)\n if distance > max_distance :\n max_distance = distance\n closest = name\n \n # Set text\n index = self._orientation_annotation_index[location]\n self._orientation_annotation.SetText(index, closest)","def draw_overlay(array, color):\n over = Image.new('RGBA', WORKSIZE, (0, 0, 0, 0))\n for key in array:\n draw_rectangle(over, key, color)\n return over","def align_preprocessed(self, img):\n aligner = FaceAligner(self.args.wing_path, self.args.lm_path, self.args.img_size)\n return aligner.align(img)","def load_aligned(self, image, size=256, padding=48, align_eyes=False):\n self.aligned[\"size\"] = size\n self.aligned[\"padding\"] = padding\n self.aligned[\"align_eyes\"] = align_eyes\n self.aligned[\"matrix\"] = get_align_mat(self, size, align_eyes)\n self.aligned[\"face\"] = AlignerExtract().transform(\n image,\n self.aligned[\"matrix\"],\n size,\n padding)","def apply_png_overlay(image, overlay, start_row, start_col, height=200, width=200):\n\n alpha_s = overlay[:, :, 3] / 255.0\n alpha_l = 1.0 - alpha_s\n for c in range(0, 3):\n image[start_row:start_row+height, start_col:start_col+width, c] = (\n alpha_s * overlay[:, :, c] +\n alpha_l * image[start_row:start_row+height, start_col:start_col+width, c])\n \n return image","def test_align_without_gaps(self):\n aln = ArrayAlignment(\n {\"seq1\": \"ACGG\", \"seq2\": \"CGCA\", \"seq3\": \"CCG-\"}, moltype=\"dna\"\n )\n aln_plot = aln.dotplot(\"seq1\")\n self.assertNotEqual(aln_plot._aligned_coords, None)","def set_alignment(self, alignment: constants.AlignmentStr | constants.AlignmentFlag):\n self.setAlignment(constants.ALIGNMENTS.get_enum_value(alignment))","def overlay_image(l_img, s_img, pos, transparency, src_center=False):\n\n # Center image\n if src_center:\n pos = list(pos)\n pos[0] -= int(s_img.shape[1] * 0.5)\n pos[1] -= int(s_img.shape[0] * 0.5)\n\n # Get superior image dimensions\n s_img_height, s_img_width, s_img_channels = s_img.shape\n\n if s_img_channels == 3 and transparency != 1:\n s_img = cv2.cvtColor(s_img, cv2.COLOR_BGR2BGRA)\n s_img_channels = 4\n\n # Take 3rd channel of 'img_overlay' image to get shapes\n img_overlay = s_img[:, :, 0:4]\n\n # cords assignation to overlay image\n x, y = pos\n\n # Image ranges\n y1, y2 = max(0, y), min(l_img.shape[0], y + img_overlay.shape[0])\n x1, x2 = max(0, x), min(l_img.shape[1], x + img_overlay.shape[1])\n\n # Overlay ranges\n y1o, y2o = max(0, -y), min(img_overlay.shape[0], l_img.shape[0] - y)\n x1o, x2o = max(0, -x), min(img_overlay.shape[1], l_img.shape[1] - x)\n\n # Exit if nothing to do\n if y1 >= y2 or x1 >= x2 or y1o >= y2o or x1o >= x2o:\n return l_img\n\n if s_img_channels == 4:\n # Get alphas channel\n alpha_mask = (s_img[:, :, 3] / 255.0) * transparency\n alpha_s = alpha_mask[y1o:y2o, x1o:x2o]\n alpha_l = 1.0 - alpha_s\n\n # Do the overlay with alpha channel\n for c in range(0, l_img.shape[2]):\n l_img[y1:y2, x1:x2, c] = (\n alpha_s * img_overlay[y1o:y2o, x1o:x2o, c]\n + alpha_l * l_img[y1:y2, x1:x2, c]\n )\n\n elif s_img_channels < 4:\n # Do the overlay with no alpha channel\n if l_img.shape[2] == s_img.shape[2]:\n l_img[y1:y2, x1:x2] = s_img[y1o:y2o, x1o:x2o]\n else:\n print(\"Error: to overlay images should have the same color channels\")\n return l_img\n\n # Return results\n return l_img","def vertical_alignment(self):\n self.update()\n return self._vertical_alignment","def align_and_extract_face(self, image, landmarks, output_size=(150,150), desired_left_eye_relative_position=(0.55, 0.55)):\n\n # get the key landmark features\n lp, eye_center, facebox = landmarks['left-eye-center-pos'], landmarks['eye-center-pos'], landmarks['face-box']\n\n # calculating the center box for face box, this will also be the center for the output_box\n face_box_center = calc_box_center(facebox)\n\n # calculate the output box using the box center\n output_box = (face_box_center[0] - output_size[0] / 2, face_box_center[1] - output_size[1]/2, output_size[0], output_size[1])\n\n # left eye's absolute position relative to facebox\n current_left_eye_absolute_x_position = lp[0] - facebox[0]\n\n # desired left eye's absolute position relative to output box\n desired_left_eye_absolute_x_position = output_box[2] * desired_left_eye_relative_position[0]\n\n # scale needed would be the ratio between desired and current\n scale = desired_left_eye_absolute_x_position / current_left_eye_absolute_x_position\n\n # calculate alignment angle\n angle = self.determine_rotation_angle(landmarks)\n\n # rotation origin will be the eye_center\n rotation_origin = eye_center\n\n # calculate the rotation matrix\n rotation_matrix = self.determine_rotation_matrix(rotation_origin, angle, scale)\n\n # calculate the new bounding box needed to bound/contain the rotated image\n aligned_box = self.determine_bounding_box_of_rotated_box(calc_img_box(image), rotation_matrix)\n (aligned_x, aligned_y, aligned_w, aligned_h) = aligned_box\n # update the translation to fit the rotated image to the bounding box\n rotation_matrix[0, 2] -= aligned_x\n rotation_matrix[1, 2] -= aligned_y\n\n # perform the transformation\n warped_image = cv2.warpAffine(image, rotation_matrix, (aligned_w, aligned_h), flags=cv2.INTER_CUBIC)\n\n # calculate new box positions\n new_face_box_center = calc_rotate_point_with_rotation_matrix(face_box_center, rotation_matrix)\n new_output_box = [\n int(new_face_box_center[0] - output_size[0] / 2),\n int(new_face_box_center[1] - output_size[1]/2),\n output_size[0], output_size[1]\n ]\n\n # calculate new left eye position\n new_lp = calc_rotate_point_with_rotation_matrix(lp, rotation_matrix)\n\n # calculate how far we are from the ideal y position for the left eye\n desired_left_eye_absolute_y_position = new_output_box[1] + int(new_output_box[3] * desired_left_eye_relative_position[1])\n distance = new_lp[1] - desired_left_eye_absolute_y_position\n\n # shift the y position such that the output box is in the desired y position\n new_output_box[1] += distance\n\n # it's possible output boxes's position will extend beyond current image space, pad the current image space such that they'll be enough space for the output box\n\n # figure out the padding\n x_left_pad = abs(min(0, new_output_box[0]))\n x_right_pad = abs(min(0, warped_image.shape[1] - (new_output_box[0] + new_output_box[2])))\n y_top_pad = abs(min(0, new_output_box[1]))\n y_bottom_pad = abs(min(0, warped_image.shape[0] - (new_output_box[1] + new_output_box[3])))\n\n # some amount of padding exists, create an image with enough padding space\n if x_left_pad + x_right_pad + y_top_pad + y_bottom_pad != 0:\n # create a new image with the padded distance\n new_shape = (warped_image.shape[0] + y_top_pad + y_bottom_pad, warped_image.shape[1] + x_left_pad + x_right_pad, 3)\n padded_image = np.zeros(new_shape)\n\n # copy contents of warped image into padded image\n padded_image[y_top_pad:y_top_pad + warped_image.shape[0], x_left_pad:x_left_pad + warped_image.shape[1]] = warped_image\n\n # set the warped image to the padded image\n warped_image = padded_image\n\n # now \"tare\" the coordinates of the output box so that it fits in side the padded image\n new_output_box[0] += x_left_pad\n new_output_box[1] += y_top_pad\n\n # crop the output box out of the warped image\n cropped_image = warped_image[new_output_box[1]:new_output_box[1]+new_output_box[3], new_output_box[0]:new_output_box[0]+new_output_box[2]]\n\n # return the cropped image\n return cropped_image","def to_alignment(self):\n alignment = dict()\n alignment[\"x\"] = self.x\n alignment[\"w\"] = self.w\n alignment[\"y\"] = self.y\n alignment[\"h\"] = self.h\n alignment[\"frame_dims\"] = self.frame_dims\n alignment[\"landmarksXY\"] = self.landmarksXY\n return alignment","def align(self, image, landmark_indices, anchor_points, size=96):\n\n detected = self.detect(image)\n coords = self.find_landmarks(image, detected)\n in_points = coords[landmark_indices]\n in_points = in_points.astype('float32')\n out_points = anchor_points * size\n warp_mat = cv2.getAffineTransform(in_points, out_points)\n warp_dst = cv2.warpAffine(image, warp_mat, (size, size))\n\n return warp_dst","def __resolve_annotation_conflicts(self, annotations):\n # set the bounding box and initial positions of the annotations\n # the x-value is only corrected if it is inside the graph or too close to the graph\n left = []\n right = []\n for a in annotations:\n # first, get the bounds\n self.__set_annotation_bbox(a)\n\n # now set the intitial positions\n # we want all of the text to be on the left or right of the squares\n width = a.bbox.width\n # to preserve hint values, only set the x value if it is inside the graph\n # or if it is not at least as far as the offset\n if a.y >= 0 and a.y <= self.ymax:\n if ((a.x >= self.xmax / 2) and (a.x < self.xmax)) or (a.x >= self.xmax and a.x < self.xmax + self.settings.otherParams[\"annotation.right.offset\"]):\n a.x = self.xmax + \\\n self.settings.otherParams[\"annotation.right.offset\"]\n elif ((a.x >= 0) and (a.x < self.xmax / 2)) or (a.x <= self.xmin and a.x > self.xmin - self.settings.otherParams[\"annotation.left.offset\"]):\n a.x = self.xmin - \\\n self.settings.otherParams[\"annotation.left.offset\"] - width\n a.bbox.x0 = a.x\n a.bbox.x1 = a.x + width\n if (a.x >= self.xmax / 2):\n a.set_relpos((0, 0.5))\n right.append(a)\n if (a.x < self.xmax / 2):\n a.set_relpos((1, 0.5))\n left.append(a)\n elif a.y < 0:\n a.set_relpos((0.5, 0))\n right.append(a)\n elif a.y > self.ymax:\n a.set_relpos((0.5, 1))\n right.append(a)\n\n # for the left, we want to prioritze labels\n # with lower x values to minimize the crossover of annotation lines\n # for the right, we want to prioritize labels that are closer\n # to the right side of the graph to minimuze the crossover of annotation lines\n left.sort(key=lambda a: (a.event_point.y, a.event_point.x))\n right.sort(key=lambda a: (a.event_point.y, -a.event_point.x))\n\n final = []\n for lst in [left, right]:\n _f = []\n for unchecked in lst:\n for checked in _f:\n if unchecked.overlaps(checked):\n correction = unchecked.get_xy_correction(\n checked, self.label_space_epsilon)\n unchecked.update_Y_with_correction(correction)\n if unchecked.is_within_epsilon_of(checked, self.label_space_epsilon):\n correction = [0, self.label_space_epsilon]\n unchecked.update_Y_with_correction(correction)\n _f.append(unchecked)\n final.extend(_f)\n\n return final","def do_polar_alignment_test(self, *arg):\n if self.ready is False:\n return\n\n start_time = current_time(flatten=True)\n\n base_dir = '{}/images/drift_align/{}'.format(\n os.getenv('PANDIR'), start_time)\n plot_fn = '{}/{}_center_overlay.jpg'.format(base_dir, start_time)\n\n mount = self.pocs.observatory.mount\n\n print_info(\"Moving to home position\")\n self.pocs.say(\"Moving to home position\")\n mount.slew_to_home()\n\n # Polar Rotation\n pole_fn = polar_rotation(self.pocs, base_dir=base_dir)\n pole_fn = pole_fn.replace('.cr2', '.fits')\n\n # Mount Rotation\n rotate_fn = mount_rotation(self.pocs, base_dir=base_dir)\n rotate_fn = rotate_fn.replace('.cr2', '.fits')\n\n print_info(\"Moving back to home\")\n self.pocs.say(\"Moving back to home\")\n mount.slew_to_home()\n\n print_info(\"Solving celestial pole image\")\n self.pocs.say(\"Solving celestial pole image\")\n try:\n pole_center = polar_alignment_utils.analyze_polar_rotation(pole_fn)\n except error.SolveError:\n print_warning(\"Unable to solve pole image.\")\n print_warning(\"Will proceeed with rotation image but analysis not possible\")\n pole_center = None\n else:\n pole_center = (float(pole_center[0]), float(pole_center[1]))\n\n print_info(\"Starting analysis of rotation image\")\n self.pocs.say(\"Starting analysis of rotation image\")\n try:\n rotate_center = polar_alignment_utils.analyze_ra_rotation(rotate_fn)\n except Exception:\n print_warning(\"Unable to process rotation image\")\n rotate_center = None\n\n if pole_center is not None and rotate_center is not None:\n print_info(\"Plotting centers\")\n self.pocs.say(\"Plotting centers\")\n\n print_info(\"Pole: {} {}\".format(pole_center, pole_fn))\n self.pocs.say(\"Pole : {:0.2f} x {:0.2f}\".format(\n pole_center[0], pole_center[1]))\n\n print_info(\"Rotate: {} {}\".format(rotate_center, rotate_fn))\n self.pocs.say(\"Rotate: {:0.2f} x {:0.2f}\".format(\n rotate_center[0], rotate_center[1]))\n\n d_x = pole_center[0] - rotate_center[0]\n d_y = pole_center[1] - rotate_center[1]\n\n self.pocs.say(\"d_x: {:0.2f}\".format(d_x))\n self.pocs.say(\"d_y: {:0.2f}\".format(d_y))\n\n fig = polar_alignment_utils.plot_center(\n pole_fn, rotate_fn, pole_center, rotate_center)\n\n print_info(\"Plot image: {}\".format(plot_fn))\n fig.tight_layout()\n fig.savefig(plot_fn)\n\n try:\n os.unlink('/var/panoptes/images/latest.jpg')\n except Exception:\n pass\n try:\n os.symlink(plot_fn, '/var/panoptes/images/latest.jpg')\n except Exception:\n print_warning(\"Can't link latest image\")\n\n with open('/var/panoptes/images/drift_align/center.txt'.format(base_dir), 'a') as f:\n f.write('{}.{},{},{},{},{},{}\\n'.format(start_time, pole_center[0], pole_center[\n 1], rotate_center[0], rotate_center[1], d_x, d_y))\n\n print_info(\"Done with polar alignment test\")\n self.pocs.say(\"Done with polar alignment test\")","def from_alignment(self, alignment, image=None):\n self.x = alignment[\"x\"]\n self.w = alignment[\"w\"]\n self.y = alignment[\"y\"]\n self.h = alignment[\"h\"]\n self.frame_dims = alignment[\"frame_dims\"]\n self.landmarksXY = alignment[\"landmarksXY\"]\n if image.any():\n self.image_to_face(image)","def pos_image(image, x,y):\n image.anchor_x = x\n image.anchor_y = y","def overlayImage(self, filename):\n overlayTime = time.time()\n\n # local refs\n ren = self.ren\n renWinInteract = self.renWinInteract\n renIndex = self.parent.rendererIndex\n\n # to do this we change cam pos to far away and\n # save temp image with just text in\n\n # so move the camera far away\n camera = ren.GetActiveCamera()\n origCamPos = camera.GetPosition()\n newCamPos = [0] * 3\n newCamPos[0] = origCamPos[0] * 100000\n newCamPos[1] = origCamPos[1] * 100000\n newCamPos[2] = origCamPos[2] * 100000\n camera.SetPosition(newCamPos)\n\n # also hide axes if visible\n if self.axes.isEnabled():\n axesHidden = True\n self.toggleAxes()\n else:\n axesHidden = False\n\n try:\n # save image\n overlayFilePrefix = os.path.join(self.mainWindow.tmpDirectory, \"renderer%d_overlay\" % renIndex)\n overlayFile = self.saveImage(\"VTK\", \"jpg\", overlayFilePrefix, False)\n if not os.path.exists(overlayFile):\n print(\"WARNING: overlay file does not exist: %s\" % overlayFile)\n return\n\n try:\n # open POV-Ray image\n povim = Image.open(filename)\n modified = False\n\n # find text in top left corner\n im = Image.open(overlayFile)\n\n # start point\n xmin = ymin = 0\n xmax = int(im.size[0] * 0.5)\n ymax = int(im.size[1] * 0.8)\n\n # find extremes\n xmin, xmax, ymin, ymax = self.findOverlayExtremes(im, xmin, xmax, ymin, ymax)\n\n # crop\n region = im.crop((xmin, ymin, xmax + 2, ymax + 2))\n\n # add to povray image\n if region.size[0] != 0:\n region = region.resize((region.size[0], region.size[1]), Image.ANTIALIAS)\n povim.paste(region, (0, 0))\n modified = True\n\n # now look for anything at the bottom => scalar bar\n im = Image.open(overlayFile)\n\n # start point\n xmin = 0\n ymin = im.size[1] - 80\n xmax = im.size[0]\n ymax = im.size[1]\n\n # find extremes\n xmin, xmax, ymin, ymax = self.findOverlayExtremes(im, xmin, xmax, ymin, ymax)\n\n # crop\n region = im.crop((xmin, ymin, xmax, ymax))\n\n # add?\n if region.size[0] != 0:\n newregiondimx = int(povim.size[0] * 0.8)\n dx = (float(povim.size[0]) * 0.8 - float(region.size[0])) / float(region.size[0])\n newregiondimy = region.size[1] + int(region.size[1] * dx)\n region = region.resize((newregiondimx, newregiondimy), Image.ANTIALIAS)\n\n xpos = int((povim.size[0] - region.size[0]) / 2.0)\n povim.paste(region, (xpos, int(povim.size[1] - region.size[1])))\n\n modified = True\n\n # now look for text in top right corner\n im = Image.open(overlayFile)\n\n # start point\n xmin = int(im.size[0] * 0.5)\n ymin = 0\n xmax = im.size[0]\n ymax = int(im.size[1] * 0.6)\n\n # find extremes\n xmin, xmax, ymin, ymax = self.findOverlayExtremes(im, xmin, xmax, ymin, ymax)\n\n # crop\n region = im.crop((xmin - 2, ymin, xmax, ymax + 2))\n\n if region.size[0] != 0:\n region = region.resize((region.size[0], region.size[1]), Image.ANTIALIAS)\n xpos = povim.size[0] - 220\n povim.paste(region, (xpos, 0))\n\n modified = True\n\n # save image\n if modified:\n povim.save(filename)\n\n finally:\n os.unlink(overlayFile)\n\n finally:\n # return to original cam pos\n camera.SetPosition(origCamPos)\n renWinInteract.ReInitialize()\n\n # show axes again\n if axesHidden:\n self.toggleAxes()\n\n overlayTime = time.time() - overlayTime\n self.logger.debug(\"Overlay time: %f s\", overlayTime)","def _align(self):\n\n shape = np.shape(self.x)\n\n # Get angle of direction (cbi: center beam index)\n # NOTE: This implementation seems to be unstable, because the shot with the center beam index can be NaN\n # cbi = np.median(np.arange(len(self.x[0, :]))).astype(int)\n # vec1 = [self.x[0, cbi], self.y[0, cbi], 0.0]\n # vec2 = [self.x[-1, cbi], self.y[-1, cbi], 0.0]\n\n # Alternative implementation with mean over all entries within the line.\n # -> should be a good approximation of the line center\n # NOTE: 2019-05-30: Relaxed the criterion even further (mean of first and last 10 scan lines)\n vec1 = [np.nanmedian(self.x[0:10, :]), np.nanmedian(self.y[0:10, :]), 0.0]\n vec2 = [np.nanmedian(self.x[-11:-1, :]), np.nanmedian(self.y[-11:-1, :]), 0.0]\n angle = -1.0*np.arctan((vec2[1]-vec1[1])/(vec2[0]-vec1[0]))\n\n # validity check -> Do not rotate if angle is nan\n if np.isnan(angle):\n return\n\n # Get center point\n xc = np.nanmedian(self.x)\n yc = np.nanmedian(self.y)\n\n # Reform points\n points = [self.x.flatten()-xc, self.y.flatten()-yc]\n\n # Execute the rotation\n rot_matrix = np.array([[np.cos(angle), -np.sin(angle)],\n [np.sin(angle), np.cos(angle)]])\n points_rotated = rot_matrix.dot(points)\n self.x = np.reshape(points_rotated[0, :], shape)\n self.y = np.reshape(points_rotated[1, :], shape)\n\n # Save conversion parameters for reuse\n self._align_parameters = {'center_point': (xc, yc),\n 'angle': angle,\n 'rotation_matrix': rot_matrix}","def overlay_down(self, idx):\n if not self.is_bottom_layer(idx):\n self.overlay_list[idx], self.overlay_list[idx-1] = \\\n self.overlay_list[idx-1], self.overlay_list[idx]","def draw_overlay(self):\n pass","def set_vertical_alignment(self, value):\n if self._simplecell:\n self.fetch()\n self.vertical_alignment = value\n return self","def align(img, landmarks, d_size=(400, 400), normalized=False, show=False):\n assert len(landmarks) == 10\n assert isinstance(img, np.ndarray)\n landmarks = np.array(landmarks).reshape(5, 2)\n dw, dh = d_size\n\n keypoints = landmarks.copy().astype(np.float64)\n if normalized:\n keypoints[:, 0] *= img.shape[1]\n keypoints[:, 1] *= img.shape[0]\n\n keypoints_ref = np.zeros((5, 2), dtype=np.float64)\n keypoints_ref[:, 0] = FivePointsAligner.ref_landmarks[:, 0] * dw\n keypoints_ref[:, 1] = FivePointsAligner.ref_landmarks[:, 1] * dh\n\n transform_matrix = transformation_from_points(keypoints_ref, keypoints)\n output_im = cv.warpAffine(img, transform_matrix, d_size, flags=cv.WARP_INVERSE_MAP)\n\n if show:\n tmp_output = output_im.copy()\n for point in keypoints_ref:\n cv.circle(tmp_output, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\n for point in keypoints:\n cv.circle(img, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\n img = cv.resize(img, d_size)\n cv.imshow('source/warped', np.hstack((img, tmp_output)))\n cv.waitKey()\n\n return output_im","def bb8_transform(ex_rois, gt_bb8_coordinates, bb8_variance, granularity, im_info):\n assert ex_rois.shape[0] == gt_bb8_coordinates.shape[0], 'inconsistent rois number'\n\n ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0\n ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0\n ex_ctr_x = ex_rois[:, 0] + 0.5 * (ex_widths - 1.0)\n ex_ctr_y = ex_rois[:, 1] + 0.5 * (ex_heights - 1.0)\n\n # fine grained anchor centers\n ex_FGA_ctr_x = np.zeros(shape=(ex_rois.shape[0], 1, granularity[1]))\n ex_FGA_ctr_y = np.zeros(shape=(ex_rois.shape[0], granularity[0], 1))\n for i in range(granularity[1]):\n ex_FGA_ctr_x[:, 0, i] = ex_ctr_x + (i - int((granularity[1] - 1) / 2)) * ex_widths / granularity[1]\n ex_FGA_ctr_x = np.repeat(ex_FGA_ctr_x, repeats=granularity[0], axis=1)\n for i in range(granularity[0]):\n ex_FGA_ctr_y[:, i, 0] = ex_ctr_y + (i - int((granularity[0] - 1) / 2)) * ex_heights / granularity[0]\n ex_FGA_ctr_y = np.repeat(ex_FGA_ctr_y, repeats=granularity[1], axis=2)\n\n\n # gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0\n # gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0\n gt_bb8_coordinates = gt_bb8_coordinates.reshape((gt_bb8_coordinates.shape[0], 8, 2))\n gt_bb8_coordinates_x = gt_bb8_coordinates[:, :, 0] * im_info[1]\n gt_bb8_coordinates_y = gt_bb8_coordinates[:, :, 1] * im_info[0]\n\n distance_x = gt_bb8_coordinates_x[:, :, np.newaxis, np.newaxis] - ex_FGA_ctr_x[:, np.newaxis]\n distance_y = gt_bb8_coordinates_y[:, :, np.newaxis, np.newaxis] - ex_FGA_ctr_y[:, np.newaxis]\n distance = np.sqrt(np.square(distance_x) + np.square(distance_y))\n\n FGA_cls_targets = np.zeros_like(distance)\n FGA_cls_targets = FGA_cls_targets.reshape((FGA_cls_targets.shape[0], FGA_cls_targets.shape[1], -1))\n # min_distances = np.min(distance.reshape((distance.shape[0], distance.shape[1], -1)), axis=2)\n index = np.argmin(distance.reshape((distance.shape[0], distance.shape[1], -1)), axis=2)\n for i in range(FGA_cls_targets.shape[0]):\n for j in range(FGA_cls_targets.shape[1]):\n FGA_cls_targets[i, j, index[i, j]] = 1\n FGA_cls_targets = FGA_cls_targets.reshape(distance.shape)\n\n # shape (N, 8)\n FGA_reg_targets_dx = distance_x[FGA_cls_targets > 0].reshape((distance_x.shape[0], -1))\n FGA_reg_targets_dx = FGA_reg_targets_dx / (ex_widths[:, np.newaxis] / granularity[1] + 1e-14) / bb8_variance[0]\n FGA_reg_targets_dy = distance_y[FGA_cls_targets > 0].reshape((distance_y.shape[0], -1))\n FGA_reg_targets_dy = FGA_reg_targets_dy / (ex_heights[:, np.newaxis] / granularity[0] + 1e-14) / bb8_variance[1]\n\n # shape (N, 16) xyxy\n FGA_reg_targets = np.stack((FGA_reg_targets_dx, FGA_reg_targets_dy), axis=-1).reshape((FGA_cls_targets.shape[0], -1))\n FGA_reg_weights = np.ones_like(FGA_reg_targets)\n\n # for softmax target (N, 8)\n FGA_cls_targets = np.argmax(FGA_cls_targets.reshape(FGA_cls_targets.shape[0], FGA_cls_targets.shape[1], -1), axis=2)\n\n return FGA_cls_targets, FGA_reg_targets, FGA_reg_weights","def blend(self, alignment_offset):\n stitched_image = None\n\n return stitched_image","def _set_anchor_center(img):\n img.anchor_x = int(img.width / 2)\n img.anchor_y = int(img.height / 2)","def _annotate_images(self, frameList):\n\t\timage_array = frameList\n\t\tfor i, image in enumerate(image_array):\n\t\t\tif i in list(self.detection_frames.keys()):\n\t\t\t\tfor obj in list(self.detection_frames[i].keys()):\n\t\t\t\t\tx, y, w, h, frame, text, track_id = self.detection_index[obj]\n\t\t\t\t\tCOLOR = COLORS[text]\n\t\t\t\t\t# if the detection is human\n\t\t\t\t\tif text == 'face':\n\t\t\t\t\t\ttext = text + \" id:{}\".format(track_id)\n\t\t\t\t\t\t# predict \n\t\t\t\t\t\tgender = self.genderDetect.classify(image[y:y+h, x:x+w, :])\n\t\t\t\t\t\tgender = 'female' if gender[0] < 0.5 else 'male'\n\t\t\t\t\t\tcv2.putText(image, gender, (x + w // 2 - 10, y + h + 15),\n\t\t\t\t\t\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.6, COLOR, 2, cv2.LINE_AA)\n\n\t\t\t\t\timage_array[i] = cv2.rectangle(image_array[i], (x, y), (x + w, y + h), COLOR, 2)\n\t\t\t\t\tcv2.putText(image_array[i], text, (x, y - 5),\n\t\t\t\t\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.6, COLOR, 2, cv2.LINE_AA)\n\n\n\t\t\tcv2.imwrite(f'{SAVE_PATH}{self.clip}{i}.jpg', image_array[i])","def horizontal_alignment(self):\n self.update()\n return self._horizontal_alignment","def alignsrc(self):\n return self[\"alignsrc\"]","def alignsrc(self):\n return self[\"alignsrc\"]","def alignsrc(self):\n return self[\"alignsrc\"]","def align(self, alignment=\"ymax\") -> \"Group\":\n _align(elements=self.elements, alignment=alignment)\n return self","def align(self):\n ...","def test_align(self):\n al = align(self.amp1, self.amp2).m\n\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\n self.assertAlmostEqual(al.vert.mean(axis=0)[0], 0, delta=TestAlign.DELTA)\n self.assertAlmostEqual(al.vert.mean(axis=0)[1], 0, delta=TestAlign.DELTA)\n self.assertAlmostEqual(al.vert.mean(axis=0)[2], 0, delta=TestAlign.DELTA)","def align(self, *, skip_corners=False, return_on_invalid_result=False, warpwarnings=False, **kwargs):\n #load the images for all HPFs and keep them in memory as long as\n #the AlignSample is active\n self.getDAPI()\n self.logger.info(\"starting alignment\")\n\n weighted_sum_mse = 0.\n sum_weights = 0.\n done = set()\n\n for i, overlap in enumerate(self.overlaps, start=1):\n if skip_corners and overlap.tag in [1,3,7,9] :\n continue\n self.logger.debug(f\"aligning overlap {overlap.n} ({i}/{len(self.overlaps)})\")\n result = None\n #check if the inverse overlap has already been aligned\n #(e.g. if the current overlap is between (1, 2), check the overlap between (2, 1))\n #if so, we don't have to align again\n if self.inverseoverlapsdictkey(overlap) in done:\n inverseoverlap = self.overlapsdict[self.inverseoverlapsdictkey(overlap)]\n if hasattr(inverseoverlap, \"result\"):\n result = overlap.getinversealignment(inverseoverlap)\n #do the alignment\n if result is None:\n result = overlap.align(gputhread=self.gputhread, gpufftdict=self.gpufftdict, **kwargs)\n done.add(self.overlapsdictkey(overlap))\n\n #contribution of the mean squared difference after alignment\n #to the weighted sum\n if result is not None and result.exit == 0: \n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\n weighted_sum_mse+=w*result.mse[2]\n sum_weights+=w\n else :\n if result is None:\n reason = \"is None\"\n else:\n reason = f\"has exit status {result.exit}\"\n if return_on_invalid_result :\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: returning 1e10!!')\n return 1e10\n else :\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: adding 1e10 to sum_mse!!')\n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\n weighted_sum_mse+=w*1e10\n sum_weights+=w\n\n self.logger.info(\"finished align loop for \"+self.SlideID)\n return weighted_sum_mse/sum_weights","def extended_frame_annotation(self, original_frame):\n self.frame = self.annotated_frame(original_frame)\n text = \"\"\n if self.is_right():\n text = \"Looking right\"\n elif self.is_left():\n text = \"Looking left\"\n elif self.is_center():\n text = \"Looking center\"\n\n h_ratio = \"HR: \" + str(self.horizontal_ratio())[:4]\n v_ratio = \"VR: \" + str(self.vertical_ratio())[:4]\n\n width = int(0.9 * self.frame.shape[1])\n height = int(0.9 * self.frame.shape[0])\n\n # cv2.putText(self.frame, text, (60, 60), cv2.FONT_HERSHEY_DUPLEX, 2, (255, 0, 0), 2)\n # cv2.putText(self.frame, h_ratio, (60, height), cv2.FONT_HERSHEY_DUPLEX, 2, (255, 0, 0), 2)\n # cv2.putText(self.frame, v_ratio, (int(0.8 * width), height), cv2.FONT_HERSHEY_DUPLEX, 2, (255, 0, 0), 2)\n return self.frame","def montage_tissues_axial(overlay_csf, overlay_wm, overlay_gm, underlay, png_name):\n def determine_start_and_end(data, direction, percent):\n x, y, z = data.shape\n xx1 = 0\n xx2 = x - 1\n zz1 = 0\n zz2 = z - 1\n total_non_zero_voxels = len(np.nonzero(data.flatten())[0])\n thresh = percent * float(total_non_zero_voxels)\n start = None\n end = None\n if 'axial' in direction:\n while(zz2 > 0):\n d = len(np.nonzero(data[:, :, zz2].flatten())[0])\n if float(d) > thresh:\n break\n zz2 -= 1\n while(zz1 < zz2):\n d = len(np.nonzero(data[:, :, zz1].flatten())[0])\n if float(d) > thresh:\n break\n zz1 += 1\n start = zz1\n end = zz2\n else:\n while(xx2 > 0):\n d = len(np.nonzero(data[xx2, :, :].flatten())[0])\n if float(d) > thresh:\n break\n xx2 -= 1\n while(xx1 < xx2):\n d = len(np.nonzero(data[xx1, :, :].flatten())[0])\n if float(d) > thresh:\n break\n xx1 += 1\n start = xx1\n end = xx2\n return start, end\n def get_spacing(across, down, dimension):\n space = 10\n prod = (across*down*space)\n if prod > dimension:\n while(across*down*space) > dimension:\n space -= 1\n else:\n while(across*down*space) < dimension:\n space += 1\n return space\n\n import os\n import matplotlib\n import commands\n# matplotlib.use('Agg')\n import numpy as np\n ###\n try:\n from mpl_toolkits.axes_grid1 import ImageGrid\n except:\n from mpl_toolkits.axes_grid import ImageGrid\n import matplotlib.pyplot as plt\n import matplotlib.colors as col\n import nibabel as nb\n import matplotlib.cm as cm\n\n Y = nb.load(underlay).get_data()\n z1, z2 = determine_start_and_end(Y, 'axial', 0.0001)\n spacing = get_spacing(6, 3, z2 - z1)\n X_csf = nb.load(overlay_csf).get_data()\n X_wm = nb.load(overlay_wm).get_data()\n X_gm = nb.load(overlay_gm).get_data()\n X_csf = X_csf.astype(np.float16)\n X_wm = X_wm.astype(np.float16)\n X_gm = X_gm.astype(np.float16)\n Y = Y.astype(np.float16)\n\n max_csf = np.nanmax(np.abs(X_csf.flatten()))\n X_csf[X_csf != 0.0] = max_csf\n max_wm = np.nanmax(np.abs(X_wm.flatten()))\n X_wm[X_wm != 0.0] = max_wm\n max_gm = np.nanmax(np.abs(X_gm.flatten()))\n X_gm[X_gm != 0.0] = max_gm\n x, y, z = Y.shape\n fig = plt.figure(1)\n max_ = np.max(np.abs(Y))\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\"None\", direction=\"row\")\n\n zz = z1\n for i in range(6*3):\n\n if zz >= z2:\n break\n\n im = grid[i].imshow(np.rot90(Y[:, :, zz]), cmap=cm.Greys_r)\n zz += spacing\n\n x, y, z = X_csf.shape\n X_csf[X_csf == 0.0] = np.nan\n X_wm[X_wm == 0.0] = np.nan\n X_gm[X_gm == 0.0] = np.nan\n print '~~', max_\n\n\n zz = z1\n im = None\n for i in range(6*3):\n\n\n if zz >= z2:\n break\n\n im = grid[i].imshow(np.rot90(X_csf[:, :, zz]), cmap=cm.winter, alpha=0.7, vmin=0, vmax=max_csf) ###\n im = grid[i].imshow(np.rot90(X_wm[:, :, zz]), cmap=cm.GnBu , alpha=0.7, vmin=0, vmax=max_wm)\n im = grid[i].imshow(np.rot90(X_gm[:, :, zz]), cmap=cm.bwr, alpha=0.7, vmin=0, vmax=max_gm)\n\n grid[i].axes.get_xaxis().set_visible(False)\n grid[i].axes.get_yaxis().set_visible(False)\n zz += spacing\n\n cbar = grid.cbar_axes[0].colorbar(im)\n\n #plt.show()\n plt.axis(\"off\")\n png_name = str(os.path.join(os.getcwd(), png_name))\n plt.savefig(png_name, dpi=300, bbox_inches='tight', )\n plt.close()\n\n return png_name","def align(self):\n\n # load the alignment parameters into the align_params object\n self.align_params.load_params_from_file(self.input_file)\n\n # populate the score matrices based on the input parameters\n self.populate_score_matrices()\n\n # perform a traceback and write the output to an output file\n\n ### FILL IN ###","def make_minmax_overlay(imgpaths, do_align=False, rszFac=1.0, imgCache=None,\n queue_mygauge=None,\n bindataP=None):\n # TODO: Implement with bbs_map\n def load_image(imgpath):\n if imgCache == None:\n return misc.imread(imgpath, flatten=True)\n elif bindataP != None:\n (img, tag), isHit = imgCache.load_binarydat(imgpath, bindataP)\n return img\n else:\n (img, imgpath), isHit = imgCache.load(imgpath)\n return img\n overlayMin, overlayMax = None, None\n Iref = None\n for path in imgpaths:\n img = load_image(path)\n if do_align and Iref == None:\n Iref = img\n elif do_align:\n (H, img, err) = imagesAlign(img, Iref, fillval=0, rszFac=rszFac)\n if (overlayMin == None):\n overlayMin = img\n else:\n if overlayMin.shape != img.shape:\n h, w = overlayMin.shape\n img = resize_img_norescale(img, (w,h))\n overlayMin = np.fmin(overlayMin, img)\n if (overlayMax == None):\n overlayMax = img\n else:\n if overlayMax.shape != img.shape:\n h, w = overlayMax.shape\n img = resize_img_norescale(img, (w,h))\n overlayMax = np.fmax(overlayMax, img)\n if queue_mygauge != None:\n queue_mygauge.put(True)\n\n # HACK: To prevent auto-dynamic-rescaling bugs, where an all-white\n # image is interpreted as all-black, artificially insert a 0.0 at (0,0).\n # See: http://stefaanlippens.net/scipy_unscaledimsave\n overlayMin[0,0] = 0.0\n overlayMax[0,0] = 0.0\n\n return overlayMin, overlayMax","def setup_annotation(self):\n annotation = self.ax_fig.annotate(\n '', xy=(0, 0), ha='left',\n xytext=(-20, 20), textcoords='offset points', va='bottom',\n bbox=dict(\n boxstyle='round,pad=0.5', fc='yellow', alpha=0.2),\n arrowprops=dict(\n arrowstyle='->', connectionstyle='arc3,rad=0'))\n return annotation","def y_tick_label(self, y, size, offset=7, ax=None):\n if ax is None:\n ax = plt.gca()\n if self.final_image is not None:\n imagebox = OffsetImage(self.final_image, zoom=size)\n ab = AnnotationBbox(\n imagebox, (0, y),\n xybox=(-offset, 0),\n xycoords=('axes fraction', 'data'),\n box_alignment=(1, .5),\n boxcoords='offset points',\n bboxprops={'edgecolor': 'none', 'facecolor': 'none'},\n arrowprops={\n 'arrowstyle': '-',\n 'shrinkA': 0,\n 'shrinkB': 1\n },\n pad=0.1)\n ax.add_artist(ab)\n zorder = ab.zorder\n else:\n zorder = 0\n if self.marker:\n if self.final_image is not None:\n markersize = max(self.final_image.size)\n else:\n markersize = 50\n markersize = markersize * size\n d = DrawingArea(markersize, markersize)\n if self.marker_front:\n zorder_marker = zorder + 0.1\n else:\n zorder_marker = zorder - 0.1\n d.set_zorder(zorder_marker)\n d.set_alpha(0)\n if self.marker_front:\n d.add_artist(plt.Line2D(\n [markersize / 2], [markersize / 2],\n marker=self.marker, markeredgecolor=self.col,\n markerfacecolor=(0, 0, 0, 0), markersize=markersize,\n markeredgewidth=self.markeredgewidth,\n transform=d.get_transform(),\n zorder=zorder_marker))\n else:\n d.add_artist(plt.Line2D(\n [markersize / 2], [markersize / 2],\n marker=self.marker, markeredgecolor=self.col,\n markerfacecolor=self.col, markersize=markersize,\n markeredgewidth=self.markeredgewidth,\n transform=d.get_transform(),\n zorder=zorder_marker))\n ab_marker = AnnotationBbox(\n d, (0, y),\n xybox=(-offset, 0),\n xycoords=('axes fraction', 'data'),\n box_alignment=(1, 0.5),\n boxcoords='offset points',\n bboxprops={'edgecolor': 'none', 'facecolor': 'none'},\n arrowprops={\n 'arrowstyle': '-',\n 'shrinkA': 0,\n 'shrinkB': 1\n },\n pad=0.1)\n ab_marker.set_zorder(zorder_marker)\n ab_marker.set_alpha(0)\n ax.add_artist(ab_marker)\n if self.string is not None:\n ax.annotate(\n self.string, (0, y),\n xytext=(-offset, 0),\n xycoords=('axes fraction', 'data'),\n textcoords='offset points',\n horizontalalignment='right',\n verticalalignment='center',\n arrowprops={\n 'arrowstyle': '-',\n 'shrinkA': 0,\n 'shrinkB': 1\n },\n zorder=zorder + 1,\n fontsize=self.fontsize, fontname=self.fontname,\n color=self.fontcolor)","def concat_images(imga, imgb, xoffset=0, yoffset=0, direction='horizontal',\n ontop=True, adjust_z=False, center_offset=True):\n if direction == 'horizontal':\n max_dim = np.maximum.reduce([imga.shape, imgb.shape])\n\n center_a = np.array(np.divide(imga.shape, 2), dtype=int)\n center_b = np.array(np.divide(imgb.shape, 2), dtype=int)\n offset = (abs(yoffset), abs(xoffset))\n\n if center_offset:\n new_offset = np.subtract(center_a, np.add(center_b, offset))\n\n if (max_dim == imgb.shape).all():\n tmp = np.copy(imgb)\n imgb = np.copy(imga)\n imga = np.copy(tmp)\n ontop = toggle(ontop)\n xoffset *= -1\n yoffset *= -1\n\n # elif not (max_dim == imga.shape).all():\n # for i, m in enumerate(max_dim):\n # if m not in imga.shape:\n # new_offset[i] = center_a[i] - (center_b[i] + offset[i])\n # else:\n # new_offset[i] = center_a[i] + offset[i] - center_b[i]\n\n new_offset[new_offset > 0] = 0\n center_new = np.array(np.divide(max_dim, 2), dtype=int)\n new_img = np.full(np.add(max_dim, np.abs(new_offset)), np.nan)\n\n Sa0 = slice(int(center_new[0] - imga.shape[0]/2 + 0.5),\n int(center_new[0] + imga.shape[0]/2 + 0.5))\n Sa1 = slice(int(center_new[1] - imga.shape[1]/2 + 0.5),\n int(center_new[1] + imga.shape[1]/2 + 0.5))\n Sb0 = slice(int(center_new[0] + abs(yoffset) - imgb.shape[0]/2 + 0.5),\n int(center_new[0] + abs(yoffset) + imgb.shape[0]/2 + 0.5))\n Sb1 = slice(int(center_new[1] + abs(xoffset) - imgb.shape[1]/2 + 0.5),\n int(center_new[1] + abs(xoffset) + imgb.shape[1]/2 + 0.5))\n\n xdir = np.sign(xoffset)\n ydir = np.sign(yoffset)\n\n if ydir == 0:\n ydir = 1\n if xdir == 0:\n xdir = 1\n\n imga = imga[::ydir, ::xdir]\n imgb = imgb[::ydir, ::xdir]\n\n if adjust_z:\n top_img = 1 * new_img\n top_img[Sa0, Sa1] = imga\n top_img[Sb0, Sb1] = imgb\n low_img = 1 * new_img\n low_img[Sb0, Sb1] = imgb\n low_img[Sa0, Sa1] = imga\n\n diff = top_img - low_img\n m = np.nanmean(diff)\n s = np.nanstd(diff)\n mask = np.abs(diff) < m + s\n diff[mask] = np.nan\n add = np.nanmean(diff)\n\n print(add)\n\n imgb -= add\n\n if ontop:\n new_img[Sa0, Sa1] = imga\n new_img[Sb0, Sb1] = imgb\n else:\n new_img[Sb0, Sb1] = imgb\n new_img[Sa0, Sa1] = imga\n\n return new_img[::ydir, ::xdir]","def layer_overlay(foreground, background):\n overlaid = foreground.copy()\n negative_space = np.where(foreground[:, :, 3] == 0)\n\n overlaid[negative_space] = background[negative_space]\n\n overlaid[:, :, 3] = 255\n\n return overlaid","def convert_roi_align(g, op, block):\n\n rois = g.get_node(op.input(\"ROIs\")[0])\n spatial_scale = op.attr(\"spatial_scale\")\n if op.attr(\"aligned\"):\n offset = _expr.const(0.5, dtype=\"float32\")\n roi_offset = _op.divide(offset, _expr.const(spatial_scale, dtype=\"float32\"))\n rois = _op.subtract(rois, roi_offset)\n num_rois = infer_shape(rois)[0]\n zero_node = _expr.const(0, dtype=\"int32\")\n batch_index = _op.full(zero_node, [num_rois, 1], dtype=\"float32\")\n rois = _op.concatenate([batch_index, rois], axis=1)\n out = _op.vision.roi_align(\n g.get_node(op.input(\"X\")[0]),\n rois,\n pooled_size=[op.attr(\"pooled_height\"), op.attr(\"pooled_width\")],\n spatial_scale=spatial_scale,\n sample_ratio=op.attr(\"sampling_ratio\"),\n mode=\"avg\",\n )\n g.add_node(op.output(\"Out\")[0], out)","def align(imgDim, rgbImg,\n landmarks, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP,\n skipMulti=True):\n assert imgDim is not None\n assert rgbImg is not None\n assert landmarks is not None\n\n #if bb is None:\n # bb = self.getLargestFaceBoundingBox(rgbImg, skipMulti)\n # if bb is None:\n # return\n\n #if landmarks is None:\n # landmarks = self.findLandmarks(rgbImg, bb)\n\n npLandmarks = np.float32(landmarks)\n npLandmarkIndices = np.array(landmarkIndices)\n\n H = cv2.getAffineTransform(npLandmarks[npLandmarkIndices],\n imgDim * MINMAX_TEMPLATE[npLandmarkIndices])\n thumbnail = cv2.warpAffine(rgbImg, H, (imgDim, imgDim))\n\n return thumbnail","def get_alignment_offset(self):\n\n return 0","def plot_overlay2axes(self, axes) -> None:\n # calculate height (based on leaf analysis ratio)\n upper_point = (\n self.leaf_center_px - self.leaf_width_px / 2 * self._analysis_ratio\n )\n lower_point = (\n self.leaf_center_px + self.leaf_width_px / 2 * self._analysis_ratio\n )\n height = abs(upper_point - lower_point) * 0.8\n\n for idx, line in enumerate(self.marker_lines):\n width = abs(self.error[idx]) * self._image.dpmm\n y = line.center.y\n x = self.position[idx] - (self.error[idx] * self._image.dpmm) / 2\n\n if self._orientation == Orientation.UP_DOWN:\n r = Rectangle(width, height, center=(x, y))\n # if any of the values are over tolerance, show another larger rectangle to draw the eye\n if not self.passed[idx] or not self.passed_action[idx]:\n re = Rectangle(\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\n )\n re.plot2axes(\n axes,\n edgecolor=\"none\",\n fill=True,\n alpha=0.5,\n facecolor=self.bg_color[idx],\n )\n else:\n r = Rectangle(height, width, center=(x, y))\n if not self.passed[idx] or not self.passed_action[idx]:\n re = Rectangle(\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\n )\n re.plot2axes(\n axes,\n edgecolor=\"none\",\n fill=True,\n alpha=0.5,\n facecolor=self.bg_color[idx],\n )\n r.plot2axes(\n axes, edgecolor=\"none\", fill=True, alpha=1, facecolor=self.bg_color[idx]\n )","def get_annotation_box(self, pos, ax):\n imagebox = OffsetImage(self.icon, zoom=0.04, cmap='gray')\n imagebox.image.axes = ax\n\n if self.destination == self.location:\n xy = pos[self.location]\n\n else:\n weight = self.local_environment.graph.edges[self.location, self.destination][\"weight\"]\n if False: #weight > 1000:\n xy_from = pos[self.location]\n xy_to = pos[self.destination]\n pos_ratio = (weight - self.time_remaining_to_dest) / weight\n xy = (1 - pos_ratio) * xy_from + pos_ratio * xy_to\n else:\n xy = pos[self.location]\n\n ab = AnnotationBbox(imagebox, xy,\n xybox=(50, 50),\n xycoords='data',\n boxcoords=\"offset points\",\n pad=0,\n\n arrowprops=dict(\n arrowstyle=\"->\",\n connectionstyle=\"angle,angleA=0,angleB=90,rad=3\")\n )\n ab.set_zorder(0)\n ax.add_artist(ab)","def SetToolAlignment(self, alignment=wx.EXPAND):\r\n\r\n self._tool_alignment = alignment","def setPosition(self, rects):\n\t\tif (rects==[]):\n\t\t\tself.obscured = True\n\t\telse:\n\t\t\tself.prevPositions.append(self.position)\n\t\t\tself.position = [(rects[0],rects[1]),(rects[2],rects[3]),dt.datetime.now()]\n\t\t\tself.timeSinceDetection = 0","def overlay_boxes(self, image, predictions):\n for prediction in predictions:\n template = ''\n for idx in range(min(3, len(prediction['score']))):\n template += \"{}:{:.2f},\".format(prediction['category'][idx], prediction['score'][idx])\n color = [0, 0, 255]\n top_left, bottom_right = prediction['bbox'][:2], prediction['bbox'][2:]\n image = cv2.rectangle(\n image, tuple(top_left), tuple(bottom_right), tuple(color), 1\n )\n cv2.putText(\n image, template, (top_left[0], top_left[1]+15), cv2.FONT_HERSHEY_SIMPLEX, .6, tuple(color), 1\n )\n\n return image","def set_horizontal_alignment(self, value):\n if self._simplecell:\n self.fetch()\n self.horizontal_alignment = value\n return self","def botStack_y(self):\r\n self.y_stack=self.img.shape[1]-1\r\n \r\n self.pixmap3=self.drawPixmap(\"xz\")\r\n self.lbl3.setPixmap(self.pixmap3)\r\n self.pixmap4= self.writeEdge(\"xz\")\r\n self.lbl4.setPixmap(self.pixmap4)\r\n self.y_stack_lbl.setText(str(self.y_stack+1) + '/' + str(self.img.shape[1]))","def add_annotation_to_placement(self):\n\n config.switch_acm_ctx()\n placcement_obj = ocp.OCP(\n kind=constants.PLACEMENT_KIND,\n resource_name=self.appset_placement_name,\n namespace=\"openshift-gitops\",\n )\n placcement_obj.annotate(\n annotation=\"cluster.open-cluster-management.io/experimental-scheduling-disable='true'\"\n )","def batch_align(image_list, dest_dir=\"output\"):\n if not path.exists(dest_dir):\n mkdir(dest_dir)\n if path.isdir(dest_dir):\n print \"Aligning %d images, output in %s, this may take a while\" % (len(im_list), dest_dir)\n\n ref_img = io.imread(image_list[0])\n r = Parallel(n_jobs=4, backend=\"threading\", verbose=25)(\n delayed(find_shift)(io.imread(img), ref_img) for img in image_list[1:])\n y_shift = map(lambda x: x[0], r)\n x_shift = map(lambda x: x[1], r)\n\n print min(y_shift), max(y_shift), min(x_shift), max(x_shift)\n crop = [int(min(y_shift)) - 1, int(max(y_shift)) + 1, int(min(x_shift)) - 1, int(max(x_shift)) + 1]\n\n correct(ref_img, (0, 0), \"%s/%s\" % (dest_dir, path.basename(image_list[0])), crop)\n Parallel(n_jobs=4, backend=\"threading\", verbose=25)(\n delayed(correct)(io.imread(img), r[k], \"%s/%s\" % (dest_dir, path.basename(image_list[k])), crop)\n for k, img in enumerate(image_list[1:]))\n else:\n print \"Output dir does not exists or is not a directory : %s\" % dest_dir","def align_crop(img, landmarks, standard_landmarks, crop_size=572, face_factor=0.45, align_type='similarity', order=3,\r\n mode='edge'):\r\n interpolation = {0: cv2.INTER_NEAREST,\r\n 1: cv2.INTER_LINEAR,\r\n 2: cv2.INTER_AREA,\r\n 3: cv2.INTER_CUBIC,\r\n 4: cv2.INTER_LANCZOS4,\r\n 5: cv2.INTER_LANCZOS4}\r\n border = {'constant': cv2.BORDER_CONSTANT,\r\n 'edge': cv2.BORDER_REPLICATE,\r\n 'symmetric': cv2.BORDER_REFLECT,\r\n 'reflect': cv2.BORDER_REFLECT101,\r\n 'wrap': cv2.BORDER_WRAP}\r\n\r\n # check\r\n assert align_type in ['affine', 'similarity'], \\\r\n \" [!] Invalid 'align_type'! The {} is not included in ['affine' and 'similarity']!\".format(align_type)\r\n assert order in [0, 1, 2, 3, 4, 5], \\\r\n \" [!] Invalid 'order'! The {} is not included in [0, 1, 2, 3, 4, 5]!\".format(order)\r\n assert mode in ['constant', 'edge', 'symmetric', 'reflect', 'wrap'], \\\r\n \" [!] Invalid 'mode'! the {} is not included in ['constant', 'edge', 'symmetric', 'reflect', and 'wrap']\".format(mode)\r\n\r\n # crop size\r\n if isinstance(crop_size, (list, tuple)) and len(crop_size) == 2:\r\n crop_size_h = crop_size[0]\r\n crop_size_w = crop_size[1]\r\n elif isinstance(crop_size, int):\r\n crop_size_h = crop_size_w = crop_size\r\n else:\r\n raise Exception(\" [!] Invalid 'crop_size'! The 'crop_size' should be (1) one integer for (crop_size, crop_size) ar (2) (int, int) for (crop_size_h, crop_size_w)!\")\r\n\r\n # estimate transform matrix\r\n target_landmarks = standard_landmarks * max(crop_size_h, crop_size_w) * face_factor + np.array([crop_size_w // 2, crop_size_h // 2])\r\n if align_type == 'affine': # 6 degree of freedom\r\n transform_matrix, _ = cv2.estimateAffine2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\r\n else: # 4 degree of freedom: using the combinations of translation, rotation, and uniform scaling\r\n transform_matrix, _ = cv2.estimateAffinePartial2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\r\n\r\n # warp image by given transform\r\n img_crop = cv2.warpAffine(img, transform_matrix, dsize=(crop_size_w, crop_size_h),\r\n flags=cv2.WARP_INVERSE_MAP + interpolation[order], borderMode=border[mode])\r\n\r\n # get transformed landmarks\r\n transformed_landmarks = cv2.transform(np.expand_dims(landmarks, axis=0), m=cv2.invertAffineTransform(transform_matrix))\r\n\r\n return img_crop, transformed_landmarks","def generate_overlay_images(self, overlay_name, x, y):\n for tile in range(1, self.config.number_of_tiles + 1):\n for time in self.config.time_points:\n for depth in self.config.depth_points:\n desc = self.config.tile_description_generator(tile, time, depth)\n file_name = self._generate_overlay_file_name(self.well, overlay_name, desc)\n self._generate_overlay(file_name, overlay_name + '-' + self.well + '-' + desc, x, y)","def test_align_points(self):\n mv = [\n [0, 0, 5],\n [5, 0, 5],\n [0, 5, 5]\n ]\n sv = [\n [0, 0, 0],\n [5, 0, 0],\n [0, 5, 0]\n ]\n al = align(self.amp1, self.amp2, mv=mv, sv=sv, method='contPoints').m\n zMax = self.amp1.vert[:, 2].max() - 5\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\n self.assertAlmostEqual(al.vert[:, 2].max(), zMax, delta=TestAlign.DELTA)","def overlay(main_params, output_params, drawing_params, manual_log_path=''):\n \n global doImg, doStack, doVideo\n \n exp_path = main_params[0]\n bin_path = main_params[1]\n vect_path = main_params[2] \n dest_path = main_params[3] \n verbose = main_params[4]\n debug = main_params[5]\n invert = main_params[6]\n doImg, doStack, doVideo, compress = output_params\n \n if debug:\n verbose = True\n \n # Log path determination\n if manual_log_path:\n log_path = manual_log_path\n else: \n log_path = os.path.join(dest_path, 'log.txt')\n log_txt = ''\n \n # Creation of the dest directory if it doesn't exist\n if not os.path.exists(dest_path):\n os.mkdir(dest_path)\n \n start = time.time()\n previous_step = start\n txt = 'SUP> Loading binarized stack...'\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n # Binarized stack loading\n bin_stack = tifffile.imread(bin_path) # loading the image as a numpy array\n bin_stack = np.array(bin_stack, dtype=np.uint8) # dtype safeguard\n if invert:\n bin_stack = np.invert(bin_stack) \n if debug:\n txt = 'SUP> Binarized stack shape: {}'.format(bin_stack.shape)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n # Add third axis for single image \n if len(bin_stack.shape)==2:\n bin_stack = bin_stack[np.newaxis,:,:]\n \n slices_nb_bin = bin_stack.shape[0] \n\n # To differentiate slices with mycelium from those without\n empty = []\n thalle = np.zeros(slices_nb_bin)\n for iSli in range(slices_nb_bin):\n sli = bin_stack[iSli, :, :].astype(np.uint8)\n thalle[iSli] = np.sum(sli)\n \n if thalle[iSli] <= 0: # empty slice\n empty.append(iSli)\n del bin_stack # not used anymore, del to free memory for the experimental stack\n \n if debug:\n txt = 'SUP> Number of empty slices: {}'.format(len(empty))\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n previous_step = timer\n txt = 'SUP> Loading grayscale stack...'\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n # Experimental stack loading (grayscale) \n exp_stack = tifffile.imread(exp_path) # loading the image as a numpy array\n exp_stack = np.array(exp_stack, dtype=np.uint8) # dtype safeguard\n if debug:\n txt = 'SUP> Grayscale stack shape: {}'.format(exp_stack.shape)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n # Add third axis for single image \n if len(exp_stack.shape)==2:\n exp_stack = exp_stack[np.newaxis,:,:]\n slices_nb_exp, height, width = exp_stack.shape\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n previous_step = timer\n txt = 'SUP> Loading graphs and checking alignment...'\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n # graphs loading and sorting\n graphs = nu.preloadFiles(vect_path, ['.gpickle'], debug)\n \n # Adding elements in 'graphs' for lists alignment if not already aligned\n if slices_nb_exp != len(graphs):\n for index in empty:\n graphs.insert(index, ('empty','empty')) \n if debug:\n txt = ('SUP> Length of graph list after alignment: {}'\n .format(len(graphs)))\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n # Checking that all the lenghts are aligned \n if slices_nb_bin == slices_nb_exp and slices_nb_exp == len(graphs):\n pass # everything is aligned\n else: \n txt = ('ERROR: the number of slices in the binarized stack ({}), in '\n 'the grayscale one({}), and the number of graphs ({}) are not '\n 'equal.'.format(slices_nb_bin, slices_nb_exp, len(graphs)))\n nu.writeLogAndExit(log_path, log_txt, txt)\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n previous_step = timer\n txt = 'SUP> Preparing output...'\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n # Definition of the range of images to browse and process \n rangeN = np.array([])\n if doImg: # image creation: only one slice will be processed\n if doImg >= 0: # select an image by its index\n rangeN = np.array([doImg-1])\n else: # select an image from backward\n rangeN = np.array([doImg])\n \n if doVideo or doStack: # stack or video creation: all the slices must be processed\n rangeN = range(slices_nb_exp)\n frames = [] # list to save the frames of the stack tif\n \n if doVideo:\n # Video output creation\n fourcc = cv2.VideoWriter_fourcc(*'MJPG')\n video = cv2.VideoWriter('video.avi', fourcc, 4, (width, height))\n \n if debug:\n txt = 'SUP> rangeN: {}'.format(rangeN)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n time.sleep(1) # dirty hack to wait for the console output\n previous_step = timer\n start_process = timer\n txt = 'SUP> Processing images...'\n log_txt += txt + '\\n'\n \n # Slices processing, one by one\n desc = 'SUP> Creating overlay'\n for iSli in tqdm(rangeN, desc=desc, unit='slice', disable=not verbose):\n\n txt = ('SUP> Image {} of {}...'\n .format(_computeIndex(iSli, slices_nb_exp), slices_nb_exp))\n log_txt += txt + '\\n'\n \n image = exp_stack[iSli, :, :].astype(np.uint8) # gets the slice and converts it \n DG = nx.read_gpickle(graphs[iSli][0]) # loading the graph\n ovl = createImgOverlay(image, DG, drawing_params, thalle[iSli]) \n \n if not thalle[iSli]:\n txt = 'SUP> This slice is empty.'.format(iSli+1, iSli)\n log_txt += txt + '\\n'\n\n if doStack or doVideo:\n if doStack:\n frames.append(ovl)\n if doVideo:\n video.write(ovl)\n else:\n img_path = os.path.join(dest_path, graphs[iSli][1] + \n '_superposition.png')\n cv2.imwrite(img_path, ovl)\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\n log_txt += txt + '\\n'\n previous_step = timer\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-start_process)\n log_txt += txt + '\\n'\n previous_step = timer\n\n if doStack: \n\n txt = 'SUP> Creating tif stack...'\n log_txt += txt + '\\n'\n \n # Writing tif stack\n destination = os.path.join(dest_path, 'superpose.tif')\n with tifffile.TiffWriter(destination) as tiff:\n desc = 'SUP> Creating tif stack'\n for i, frame in enumerate(tqdm(frames, total=len(frames), desc=desc,\n unit='frame', disable=not verbose)):\n txt = ('SUP> writing frame {} of {}'\n .format(i+1, len(frames)))\n log_txt += txt + '\\n'\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # color conversion for saving without cv2 \n tiff.save(frame, compress=compress)\n frames[i] = 0 # cleaning the frame once written to free up memory\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\n log_txt += txt + '\\n'\n previous_step = timer\n \n if doVideo:\n time.sleep(1) # dirty hack to wait for the console output\n txt = 'SUP> Cleaning video output...'\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n #cv2.destroyAllWindows()\n video.release()\n source = 'video.avi'\n destination = os.path.join(dest_path, 'superpose.avi')\n os.rename(source, destination)\n \n timer = time.time()\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n previous_step = timer\n \n timer = time.time()\n end = timer-start \n time.sleep(1) # dirty hack to wait for the console output \n txt = 'SUP> DONE in {:.0f} min {:.4f} s.'.format(end // 60, end % 60)\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\n \n # Writing the log \n with open(log_path, 'a+') as log:\n log.write(log_txt)","def GetAlignment(self):\r\n\r\n return self.alignment","def _load_hover_annotation(self, index):\n # Load object bounding boxes\n \n im_id, gable_bboxes = self.parse_line(index)\n num_objs = len(gable_bboxes)\n boxes = np.array(gable_bboxes, dtype=np.float32)\n gt_classes = np.empty(num_objs, dtype=np.int32)\n gt_classes.fill(1) # all bboxes are gables currently\n overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\n overlaps[:,1] = 1.0 # all boxes are gables...\n overlaps = scipy.sparse.csr_matrix(overlaps)\n seg_areas = np.zeros((num_objs), dtype=np.float32)\n for ix, bbox in enumerate(boxes):\n print bbox\n\tx1 = bbox[0] - 1\n\ty1 = bbox[1] - 1\n\tx2 = bbox[2] - 1\n\ty2 = bbox[3] - 1\n\tseg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\n print seg_areas[ix]\n\n return {'boxes' : boxes,\n 'gt_classes': gt_classes,\n 'gt_overlaps' : overlaps,\n 'seg_areas': seg_areas,\n 'flipped' : False}","def overlay(self):\n return self._overlay","def align_images(self, translation_only=False):\n # Extract feature point locations and descriptors.\n points_and_descriptors = []\n for file in self.files:\n image = sol4_utils.read_image(file, 1)\n self.images.append(image)\n self.h, self.w = image.shape\n pyramid, _ = sol4_utils.build_gaussian_pyramid(image, 3, PYR_FLT_LEVEL)\n points_and_descriptors.append(find_features(pyramid))\n\n # Compute homographies between successive pairs of images.\n Hs = []\n for i in range(len(points_and_descriptors) - 1):\n points1, points2 = points_and_descriptors[i][0], points_and_descriptors[i + 1][0]\n desc1, desc2 = points_and_descriptors[i][1], points_and_descriptors[i + 1][1]\n\n # Find matching feature points.\n ind1, ind2 = match_features(desc1, desc2, MATCH_MIN_SCORE)\n points1, points2 = points1[ind1, :], points2[ind2, :]\n\n # Compute homography using RANSAC.\n H12, inliers = ransac_homography(points1, points2,\n RANSAC_ITER_NUM, RANAC_ERR_TOL,\n translation_only)\n\n # Uncomment for debugging: display inliers and outliers among matching points.\n # In the submitted code this function should be commented out!\n if(self.display_match):\n display_matches(self.images[i], self.images[i+1], points1 , points2, inliers)\n\n Hs.append(H12)\n\n # Compute composite homographies from the central coordinate system.\n accumulated_homographies = accumulate_homographies(Hs, (len(Hs) - 1) // 2)\n self.homographies = np.stack(accumulated_homographies)\n self.frames_for_panoramas = filter_homographies_with_translation(self.homographies, minimum_right_translation=5)\n print((self.frames_for_panoramas.shape))\n self.homographies = self.homographies[self.frames_for_panoramas]","def align(self):\n features = np.load(self.cur_dir+'/'+'spec.npy', allow_pickle=True)\n targets = np.load(self.cur_dir+'/'+'target.npy', allow_pickle=True)\n \n feat_num_frames = features.shape[0]\n targ_num_frames = targets.shape[0]\n \n if feat_num_frames != targ_num_frames:\n diff = feat_num_frames - targ_num_frames\n if diff < 0:\n targets = targets[:feat_num_frames, :]\n else:\n features = features[:targ_num_frames:, :]\n \n return features.shape, targets.shape","def getPixelVisualCenter(self, altMap, aziMap):\r\n\r\n altPatch = self.array * altMap\r\n meanAlt = np.mean(altPatch[altPatch != 0])\r\n aziPatch = self.array * aziMap\r\n meanAzi = np.mean(aziPatch[aziPatch != 0])\r\n\r\n return meanAlt, meanAzi","def aligned_landmarks(self):\n landmarks = AlignerExtract().transform_points(self.landmarksXY,\n self.aligned[\"matrix\"],\n self.aligned[\"size\"],\n self.aligned[\"padding\"])\n return landmarks","def GetAlignment(self):\r\n\r\n return self._flag","def _overlay_text(\n image_file_name, x_offset_from_left_px, y_offset_from_top_px,\n text_string, font_size, use_north_gravity):\n\n command_string = '\"{0:s}\" \"{1:s}\"'.format(CONVERT_EXE_NAME, image_file_name)\n if use_north_gravity:\n command_string += ' -gravity North'\n\n command_string += (\n ' -pointsize {0:d} -font \"{1:s}\" '\n '-fill \"rgb(0, 0, 0)\" -annotate {2:+d}{3:+d} \"{4:s}\" \"{5:s}\"'\n ).format(\n font_size, TITLE_FONT_NAME,\n x_offset_from_left_px, y_offset_from_top_px, text_string,\n image_file_name\n )\n\n exit_code = os.system(command_string)\n if exit_code == 0:\n return\n\n raise ValueError(imagemagick_utils.ERROR_STRING)","def update(self):\n rect = self.img_rect.center\n self.font_img = self.font.render(self.text, True, color1)\n self.img_rect = self.font_img.get_rect()\n # self.img_rect.center = [self.title_img.get_width() + self.font_img.get_width()//2 + padding, 5*Y//8]\n self.img_rect.center = rect","def positionZoomed(self):\n rect_size = self._image.get_rect()\n\n if rect_size.width > 720:\n self.x = (int((720 - rect_size.width ) / 2))\n\n if rect_size.height > 720:\n self.y = (int((720 - rect_size.height) / 2))","def _get_cog_alignment(self, moving_slice_index, fixed_slice_index):\n\n if self._slices_voxel_counts[moving_slice_index] <= 0.0005 or \\\n self._slices_voxel_counts[fixed_slice_index] <= 0.0005:\n self._generate_identity_transformation(\\\n self.f['transf_center'](mIdx=moving_slice_index,\n fIdx=fixed_slice_index))\n self._logger.info(\"Blank moving slice found. f=%d,m=%d .\" % \\\n (moving_slice_index, fixed_slice_index))\n self._logger.info(\"An identity transform will be applied.\")\n return False\n\n cog_transform_getter = pos_wrappers.align_by_center_of_gravity(\n fixed_image = self.f['src_gray'](idx=fixed_slice_index),\n moving_image = self.f['src_gray'](idx=moving_slice_index),\n output_transformation = \\\n self.f['transf_center'](mIdx=moving_slice_index,\n fIdx=fixed_slice_index))\n return copy.deepcopy(cog_transform_getter)","def setup_annotations(self):\n sbd_path = get_data_path('sbd')\n target_path = pjoin(self.root, 'SegmentationClass/pre_encoded')\n if not os.path.exists(target_path): os.makedirs(target_path)\n path = pjoin(sbd_path, 'dataset/train.txt')\n sbd_train_list = tuple(open(path, 'r'))\n sbd_train_list = [id_.rstrip() for id_ in sbd_train_list]\n train_aug = self.files['train'] + sbd_train_list\n\n # keep unique elements (stable)\n train_aug = [train_aug[i] for i in \\\n sorted(np.unique(train_aug, return_index=True)[1])]\n self.files['train_aug'] = train_aug\n set_diff = set(self.files['val']) - set(train_aug) # remove overlap\n self.files['train_aug_val'] = list(set_diff)\n\n pre_encoded = glob.glob(pjoin(target_path, '*.png'))\n expected = np.unique(self.files['train_aug'] + self.files['val']).size\n\n if len(pre_encoded) != expected:\n print(\"Pre-encoding segmentation masks...\")\n for ii in tqdm(sbd_train_list):\n lbl_path = pjoin(sbd_path, 'dataset/cls', ii + '.mat')\n data = io.loadmat(lbl_path)\n lbl = data['GTcls'][0]['Segmentation'][0].astype(np.int32)\n lbl = m.toimage(lbl, high=lbl.max(), low=lbl.min())\n m.imsave(pjoin(target_path, ii + '.png'), lbl)\n\n for ii in tqdm(self.files['trainval']):\n fname = ii + '.png'\n lbl_path = pjoin(self.root, 'SegmentationClass', fname)\n lbl = self.encode_segmap(m.imread(lbl_path))\n lbl = m.toimage(lbl, high=lbl.max(), low=lbl.min())\n m.imsave(pjoin(target_path, fname), lbl)\n\n assert expected == 9733, 'unexpected dataset sizes'","def overlay_time_series(movie_info, time_series_data_path, output_dir, mouse_type):\n if mouse_type is None:\n print 'Error: Must provide --mouse_type when using overlay_time_series.'\n sys.exit(1)\n\n #Place animation and overlay in two separate folders\n output_dir = '/'.join(output_dir.split('/')[:-1])\n overlay_dir = output_dir + '/Overlay/Standardized_post_SfN_aligned/'\n animation_dir = output_dir + '/Time_Series_Animation/Standardized_post_Sfn_aligned/'\n check_dir(overlay_dir)\n check_dir(animation_dir)\n\n\n #Generate animation of time series\n format = '.mp4'\n animation_filename = animation_dir + key + format\n print \"animation_filename\", animation_filename\n if not os.path.isfile(animation_filename):\n make_time_series_animation(movie_info, animation_dir, \n time_series_data_path,\n mouse_type, format)\n else:\n print \"Animation file already exists: \", key\n\n #Overlay animation in corner of behavior video\n movie_file = movie_info['movie_file']\n overlay_filename = overlay_dir + key + format\n if not os.path.isfile(overlay_filename):\n start_time = movie_info['start_time']\n\n cmd = 'ffmpeg -ss '+str(start_time)+' -i '+movie_file+' -i '+animation_filename+' -filter_complex \\\"[0:v] setpts=PTS-STARTPTS, scale=640x480 [background]; [1:v] setpts=PTS-STARTPTS, scale=100x200 [upperleft]; [background][upperleft] overlay=shortest=1\\\" -c:v libx264 -y '+overlay_filename\n args = shlex.split(cmd)\n print args\n p = subprocess.Popen(args, shell=False)\n p.wait()\n else:\n print \"Overlay file already exists: \", key\n\n\n return overlay_filename","def align(self, align='left'):\n if align not in ['left', 'center', 'right', 'full']:\n raise ValueError('align must be \\'left\\', \\'center\\', \\'right\\' or \\'full\\'')\n else:\n self._write(self.__class__.__ESC + 'a' + self.__class__.__alignMap[align])","def overlay_boxes(self, image, predictions):\n labels = predictions.get_field(\"labels\")\n boxes = predictions.bbox\n\n colors = self.compute_colors_for_labels(labels).tolist()\n\n for box, color in zip(boxes, colors):\n box = box.to(torch.int64)\n top_left, bottom_right = box[:2].tolist(), box[2:].tolist()\n image = cv2.rectangle(\n image, tuple(top_left), tuple(bottom_right), tuple(color), 1\n )\n\n return image","def overlay_boxes(self, image, predictions):\n labels = predictions.get_field(\"labels\")\n boxes = predictions.bbox\n\n colors = self.compute_colors_for_labels(labels).tolist()\n\n for box, color in zip(boxes, colors):\n box = box.to(torch.int64)\n top_left, bottom_right = box[:2].tolist(), box[2:].tolist()\n image = cv2.rectangle(\n image, tuple(top_left), tuple(bottom_right), tuple(color), 1\n )\n\n return image","def align(self):\n return self[\"align\"]","def align(self):\n return self[\"align\"]","def align(self):\n return self[\"align\"]","def minimal_align(self):\n desired = int(PlatformVar(\"align\"))\n for ii in range(len(self.__content)):\n line = self.__content[ii]\n match = re.match(r'.*\\.align\\s+(\\d+).*', line)\n if match:\n align = int(match.group(1))\n # Due to GNU AS compatibility modes, .align may mean different things.\n if osarch_is_amd64 or osarch_is_ia32():\n if desired != align:\n if is_verbose():\n print(\"Replacing %i-byte alignment with %i-byte alignment.\" % (align, desired))\n self.__content[ii] = \" .balign %i\\n\" % (desired)\n else:\n print(\"Replacing low-order bit alignment %i with %i-byte alignment.\" % (align, desired))\n self.__content[ii] = \" .balign %i\\n\" % (desired)","def set_overlay(self, image_path):\n if not osp.isfile(image_path):\n raise ValueError(\"Invalid background image '{}'\".format(image_path))\n self._overlay_image = image_path\n self._final = None # Force rebuild","def make_overlay(proba_map, max_alpha=.8):\n prob_overlay = np.ones(proba_map.shape + (4,))\n prob_overlay[..., [0, 1]] = 0\n prob_overlay[..., 3] = proba_map * max_alpha\n return prob_overlay","def adjust_position(self):\n\n # Adjust position for x-axis\n r = self.rect.x % 30\n if r != 0:\n if r <= 16:\n x = self.rect.x - r\n else:\n x = self.rect.x + (30 - r)\n\n else:\n x = self.rect.x\n\n # Adjust position for y-axis\n r = self.rect.y % 30\n if r != 0:\n if r <= 16:\n y = self.rect.y - r\n else:\n y = self.rect.y + (30 - r)\n else:\n y = self.rect.y\n\n return x, y","def setTranslationsInTiltSeries(self, TiltSeries_):\n for (kk, proj) in enumerate(TiltSeries_._ProjectionList._list):\n proj.setAlignmentTransX(self._alignmentTransX[kk])\n proj.setAlignmentTransY(self._alignmentTransY[kk])","def _rotate_img(self, results):\n angle = self.angle\n height, width = results['img_shape'][:2]\n center = ((width - 1) * 0.5, (height - 1) * 0.5)\n\n # Compute rotation matrix\n mat_rotation = cv2.getRotationMatrix2D(center, -angle, 1)\n\n # Compute height and width of new image after rotation\n cos = np.abs(mat_rotation[0, 0])\n sin = np.abs(mat_rotation[0, 1])\n width_new = height * sin + width * cos\n height_new = height * cos + width * sin\n mat_rotation[0, 2] += (width_new - width) * 0.5\n mat_rotation[1, 2] += (height_new - height) * 0.5\n width_new = int(np.round(width_new))\n height_new = int(np.round(height_new))\n \n # Rotate image\n img_rotation = cv2.warpAffine(results['img'], mat_rotation, (width_new, height_new),\n borderValue=self.borderValue)\n results['img'] = img_rotation\n results['img_shape'] = results['img'].shape\n\n # Rotate corresponding annotations: all boxes in bbox_fields\n for key in results.get('bbox_fields', []):\n gt_boxes_ret = []\n for poly in results[key]:\n rot_array = []\n poly_length = len(poly)\n\n if poly_length == 4:\n poly = [poly[0], poly[1], poly[2], poly[1], poly[2], poly[3], poly[0], poly[3]]\n\n # Convert to np.array of shape (:, 2)\n for i in range(0, len(poly), 2):\n rot_array.append(np.array([poly[i], poly[i + 1]]))\n\n # Rotate corresponding annotations\n rot_array = np.array([rot_array])\n rot_array = cv2.transform(rot_array, mat_rotation).squeeze().reshape(len(poly))\n\n if poly_length == 4:\n x_coords = rot_array[0::2]\n y_coords = rot_array[1::2]\n rot_array = np.array([\n np.min(x_coords),\n np.min(y_coords),\n np.max(x_coords),\n np.max(y_coords)\n ])\n\n gt_boxes_ret.append(rot_array)\n if len(results[key]) > 0:\n results[key] = gt_boxes_ret\n\n # Rotate gt_bboxes according to gt_poly_bboxes\n if 'gt_bboxes' in results and 'gt_poly_bboxes' in results:\n gt_bboxes = []\n gt_bboxes_ignore = []\n\n for poly in results['gt_poly_bboxes']:\n poly = np.array(poly, dtype=np.double)\n x_coords = poly[0::2]\n y_coords = poly[1::2]\n aligned_poly = [\n np.min(x_coords),\n np.min(y_coords),\n np.max(x_coords),\n np.max(y_coords)\n ]\n gt_bboxes.append(aligned_poly)\n\n for poly in results['gt_poly_bboxes_ignore']:\n poly = np.array(poly, dtype=np.double)\n x_coords = poly[0::2]\n y_coords = poly[1::2]\n aligned_poly = [\n np.min(x_coords),\n np.min(y_coords),\n np.max(x_coords),\n np.max(y_coords)\n ]\n gt_bboxes_ignore.append(aligned_poly)\n\n if len(gt_bboxes) == 0:\n gt_bboxes = np.zeros((0, 4), dtype=np.float32)\n else:\n gt_bboxes = np.array(gt_bboxes, dtype=np.float32)\n\n if len(gt_bboxes_ignore) == 0:\n gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)\n else:\n gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)\n\n results['gt_bboxes'] = gt_bboxes\n results['gt_bboxes_ignore'] = gt_bboxes_ignore\n\n # Rotate corresponding annotations: all boxes in cbbox_fields\n for key in results.get('cbbox_fields', []):\n gt_cboxes_ret = []\n for instance in results[key]:\n tmp_cboxes = []\n for poly in instance:\n rot_array = []\n # Convert to np.array of shape (:, 2)\n for i in range(0, len(poly), 2):\n rot_array.append(np.array([poly[i], poly[i + 1]]))\n rot_array = np.array([rot_array])\n # Rotate corresponding annotations\n rot_array = cv2.transform(rot_array, mat_rotation).squeeze().reshape(len(poly))\n tmp_cboxes.append(rot_array)\n gt_cboxes_ret.append(tmp_cboxes)\n results[key] = gt_cboxes_ret\n\n # Rotate corresponding annotations: all masks in mask_fields\n for key in results.get('mask_fields', []):\n mask = results[key].masks.transpose((1, 2, 0))\n if len(results[key].masks) == 0:\n results[key] = results[key].resize((height_new, width_new))\n else:\n # Rotate mask\n mask_rotation = cv2.warpAffine(mask, mat_rotation, (width_new, height_new),\n borderValue=self.borderValue)\n if mask_rotation.ndim == 2:\n # case when only one mask, (h, w)\n mask_rotation = mask_rotation[:, :, None] # (h, w, 1)\n mask_rotation = mask_rotation.transpose((2, 0, 1))\n results[key].masks = mask_rotation\n results[key].height = height_new\n results[key].width = width_new","def setPosition(self):\n self.data['pos-x'] = \"%s\" % self.x()\n self.data['pos-y'] = \"%s\" % self.y()","def get_aligned_image(self):\n lines = self.find_lines()\n self.rotate_crop_scale(lines)\n\n return self.image"],"string":"[\n \"def overlay_alignment(self):\\n return self._overlay_alignment\",\n \"def overlay(self, overlay):\\n\\n self._overlay = overlay\",\n \"def gonio_axis_align():\\n \\n # Invert camera image, so dark pin on light image becomes a peak\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # High threshold, so AD centroid doesn't interpret background\\n cam_8ThresholdOld = cam_8.stats4.centroid_threshold.get()\\n cam_8.stats4.centroid_threshold.put(150)\\n cam_7ThresholdOld = cam_7.stats4.centroid_threshold.get()\\n cam_7.stats4.centroid_threshold.put(150)\\n \\n # HiMag\\n # Copy ROI2 geometry (HiMag Mag3) to ROI4 and use ROI4 centroid plugin\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get())\\n cam_8.roi4.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get())\\n cam_8.roi4.size.x.put(cam_8.roi2.size.x.get() * 0.20)\\n cam_8.roi4.size.y.put(cam_8.roi2.size.y.get())\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get() + cam_8.roi2.size.x.get()/2 - cam_8.roi4.size.x.get()/2)\\n \\n # LoMag\\n # Copy ROI2 geometry (LoMag Mag1) to ROI4 and use ROI4 centroid plugin\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get())\\n cam_7.roi4.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get())\\n cam_7.roi4.size.x.put(cam_7.roi2.size.x.get() * 0.05)\\n cam_7.roi4.size.y.put(cam_7.roi2.size.y.get())\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get() + cam_7.roi2.size.x.get()/2 - cam_7.roi4.size.x.get()/2)\\n \\n centerPinYHiMag0 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag0 = centroid_avg(cam_7.stats4)[1]\\n yield from bps.mvr(gonio.o,180)\\n time.sleep(2)\\n centerPinYHiMag180 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag180 = centroid_avg(cam_7.stats4)[1]\\n centerPinYHiMag = (centerPinYHiMag0 + centerPinYHiMag180)/2\\n centerPinYLoMag = (centerPinYLoMag0 + centerPinYLoMag180)/2\\n\\n centerPinOffsYHiMag = centerPinYHiMag - cam_8.roi4.size.y.get() / 2\\n centerPinOffsYLoMag = centerPinYLoMag - cam_7.roi4.size.y.get() / 2\\n \\n # Correct Mag 3 (cam_8 ROI2)\\n cam_8.roi2.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + centerPinOffsYHiMag)\\n # Correct Mag 4 (cam_8 ROI1)\\n cam_8.roi1.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + (cam_8.roi2.size.y.get()-cam_8.roi1.size.y.get())/2)\\n \\n # Correct Mag 1 (cam_7 ROI2)\\n cam_7.roi2.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + centerPinOffsYLoMag)\\n # Correct Mag 2 (cam_7 ROI3)\\n cam_7.roi3.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + (cam_7.roi2.size.y.get()-cam_7.roi3.size.y.get())/2)\\n\\n # De-invert image\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # Set thresold to previous value\\n cam_8.stats4.centroid_threshold.put(cam_8ThresholdOld)\\n cam_7.stats4.centroid_threshold.put(cam_7ThresholdOld)\\n \\n return\",\n \"def update_annot(self, ind, plt_ref, ref_label):\\r\\n\\r\\n # Get selected data coordinates\\r\\n pos = plt_ref._xy[ind[\\\"ind\\\"][0]]\\r\\n\\r\\n # Shift annotation box left or right depending on which half of the axis the pos x is located and the\\r\\n # direction of x increasing.\\r\\n if plt_ref.axes.viewLim.intervalx[0] < plt_ref.axes.viewLim.intervalx[1]:\\r\\n if pos[0] < (plt_ref.axes.viewLim.intervalx[0] + plt_ref.axes.viewLim.intervalx[1]) / 2:\\r\\n self.annot._x = -20\\r\\n else:\\r\\n self.annot._x = -80\\r\\n else:\\r\\n if pos[0] < (plt_ref.axes.viewLim.intervalx[0] + plt_ref.axes.viewLim.intervalx[1]) / 2:\\r\\n self.annot._x = -80\\r\\n else:\\r\\n self.annot._x = -20\\r\\n\\r\\n # Shift annotation box up or down depending on which half of the axis the pos y is located and the\\r\\n # direction of y increasing.\\r\\n if plt_ref.axes.viewLim.intervaly[0] < plt_ref.axes.viewLim.intervaly[1]:\\r\\n if pos[1] > (plt_ref.axes.viewLim.intervaly[0] + plt_ref.axes.viewLim.intervaly[1]) / 2:\\r\\n self.annot._y = -40\\r\\n else:\\r\\n self.annot._y = 20\\r\\n else:\\r\\n if pos[1] > (plt_ref.axes.viewLim.intervaly[0] + plt_ref.axes.viewLim.intervaly[1]) / 2:\\r\\n self.annot._y = 20\\r\\n else:\\r\\n self.annot._y = -40\\r\\n\\r\\n self.annot.xy = pos\\r\\n\\r\\n # Format and display text\\r\\n text = 'x: {:.2f}, {}: {:.2f}'.format(pos[0], ref_label, pos[1])\\r\\n self.annot.set_text(text)\",\n \"def _align_frames(frame_pre, frame_now):\\n height, width = frame_pre.shape\\n horizontal_lines = [np.array([frame_pre[int(height * 1 / 4), :],\\n frame_pre[int(height * 2 / 4), :],\\n frame_pre[int(height * 3 / 4), :]]),\\n\\n np.array([frame_now[int(height * 1 / 4), :],\\n frame_now[int(height * 2 / 4), :],\\n frame_now[int(height * 3 / 4), :]])]\\n\\n vertical_lines = [np.array([frame_pre[:, int(width * 1 / 4)],\\n frame_pre[:, int(width * 2 / 4)],\\n frame_pre[:, int(width * 3 / 4)]]),\\n\\n np.array([frame_now[:, int(width * 1 / 4)],\\n frame_now[:, int(width * 2 / 4)],\\n frame_now[:, int(width * 3 / 4)]])]\\n\\n min_x_val = 99999\\n min_y_val = 99999\\n offset_x = 0\\n offset_y = 0\\n for offset in range(-5, 5 + 1, 1): # TODO: check this, [-7, 7]?\\n a_x = horizontal_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\\n b_x = horizontal_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\\n val_x = np.mean(np.linalg.norm(a_x - b_x, 1, axis=1)) # norm 1\\n # print('offset_x is:', offset, ' norm=', val_x)\\n if val_x < min_x_val:\\n min_x_val = val_x\\n offset_x = offset\\n\\n a_y = vertical_lines[0][:, max(offset, 0):-1 + min(offset, 0)]\\n b_y = vertical_lines[1][:, max(-offset, 0):-1 + min(-offset, 0)]\\n val_y = np.mean(np.linalg.norm(a_y - b_y, 1, axis=1)) # norm 1\\n # print('offset_y is:', offset, ' norm=', val_y)\\n if val_y < min_y_val:\\n min_y_val = val_y\\n offset_y = offset\\n\\n print('The final offset_x is:', offset_x)\\n print('The final offset_y is:', offset_y)\\n\\n # translation\\n M = np.float32([[1, 0, offset_x], [0, 1, offset_y]])\\n frame_now_aligned = cv2.warpAffine(frame_now.astype(np.uint8), M, (width, height)).astype(np.int32)\\n\\n return frame_now_aligned, offset_x, offset_y\",\n \"def SetAlignment(self, l):\\r\\n\\r\\n self.alignment = l\",\n \"def resetAlignmentCenter(self):\\n cent = self.TiltSeries_._TiltAlignmentParas.cent\\n imdimX = self.TiltSeries_._imdimX\\n imdimY = self.TiltSeries_._imdimY\\n print(imdimX, imdimY)\\n if cent[0] != imdimX//2+1 or cent[1] != imdimY//2+1:\\n #rint \\\"Centers do not match: cent=\\\"+str(cent)+\\\", imdim=\\\"+str(imdim)\\n self.TiltSeries_._TiltAlignmentParas.cent = [imdimX//2+1, imdimY//2+1]\",\n \"def _write_overlay_info(self):\\n cv2.putText(\\n img=self.output,\\n text=f'X: {float(self.estimated_distance[0]):6.2f} m',\\n org=(25, 25),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Y: {float(self.estimated_distance[1]):6.2f} m',\\n org=(25, 50),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Z: {float(self.estimated_distance[2]):6.2f} m',\\n org=(25, 75),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\\n cv2.putText(\\n img=self.output,\\n text=f'Rotation: {float(self.estimated_rotation):6.2f} rad',\\n org=(25, 100),\\n fontFace=cv2.FONT_HERSHEY_SIMPLEX,\\n color=(0, 0, 255),\\n fontScale=0.5\\n )\",\n \"def overlay_up(self, idx):\\n if not self.is_top_layer(idx):\\n self.overlay_list[idx], self.overlay_list[idx+1] = \\\\\\n self.overlay_list[idx+1], self.overlay_list[idx]\",\n \"def update_annot(ind):\\n # update text annotation\\n pos = sc.get_offsets()[ind[\\\"ind\\\"][0]]\\n annot.xy = pos\\n idxlist = []\\n for element in PC:\\n idxlist.append(np.allclose(element, pos))\\n idx = idxlist.index(True)\\n annotation_string = f'{idx + 1}\\\\n'\\n if display_parameter_values:\\n for i, label in enumerate(parameterList):\\n annotation_string += (f'{parameters[i, idx]: 10.2f} '\\n f'+/- {errors[i, idx]:8.2f} '\\n f'({label})\\\\n')\\n annot.set_text(annotation_string[:-1])\\n annot.get_bbox_patch().set_alpha(0.4)\\n\\n # update immage annotation\\n label = mapp.listOfFiles[idx].split(os.sep)[-1].split('.')[0]\\n image = get_image(mapp.pltdir, label)\\n ab.xy = pos\\n ab.offsetbox = OffsetImage(image)\\n ax.add_artist(ab)\\n if show_both_images:\\n additional_image = get_image(additional_fitplot_folder, label)\\n ac.xy = pos + shift_second_image\\n ac.offsetbox = OffsetImage(additional_image)\\n ax.add_artist(ac)\",\n \"def imalign(src_file, dst_file, face_landmarks, output_size=1024, transform_size=1024, enable_padding=True, x_scale=1, y_scale=1, em_scale=0.1, alpha=False):\\n lm = np.array(face_landmarks)\\n lm_chin = lm[0 : 17] # left-right\\n lm_eyebrow_left = lm[17 : 22] # left-right\\n lm_eyebrow_right = lm[22 : 27] # left-right\\n lm_nose = lm[27 : 31] # top-down\\n lm_nostrils = lm[31 : 36] # top-down\\n lm_eye_left = lm[36 : 42] # left-clockwise\\n lm_eye_right = lm[42 : 48] # left-clockwise\\n lm_mouth_outer = lm[48 : 60] # left-clockwise\\n lm_mouth_inner = lm[60 : 68] # left-clockwise\\n\\n # Calculate auxiliary vectors.\\n eye_left = np.mean(lm_eye_left, axis=0)\\n eye_right = np.mean(lm_eye_right, axis=0)\\n eye_avg = (eye_left + eye_right) * 0.5\\n eye_to_eye = eye_right - eye_left\\n mouth_left = lm_mouth_outer[0]\\n mouth_right = lm_mouth_outer[6]\\n mouth_avg = (mouth_left + mouth_right) * 0.5\\n eye_to_mouth = mouth_avg - eye_avg\\n\\n # Choose oriented crop rectangle.\\n x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]\\n x /= np.hypot(*x)\\n x *= max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)\\n x *= x_scale\\n y = np.flipud(x) * [-y_scale, y_scale]\\n c = eye_avg + eye_to_mouth * em_scale\\n quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])\\n qsize = np.hypot(*x) * 2\\n\\n # Load in-the-wild image.\\n if not os.path.isfile(src_file):\\n print('\\\\nCannot find source image. Please run \\\"--wilds\\\" before \\\"--align\\\".')\\n return\\n img = Image.open(src_file)\\n\\n # Shrink.\\n shrink = int(np.floor(qsize / output_size * 0.5))\\n if shrink > 1:\\n rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink)))\\n img = img.resize(rsize, Image.ANTIALIAS)\\n quad /= shrink\\n qsize /= shrink\\n\\n # Crop.\\n border = max(int(np.rint(qsize * 0.1)), 3)\\n crop = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\\n crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]), min(crop[3] + border, img.size[1]))\\n if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]:\\n img = img.crop(crop)\\n quad -= crop[0:2]\\n\\n # Pad.\\n pad = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))\\n pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0), max(pad[3] - img.size[1] + border, 0))\\n if enable_padding and max(pad) > border - 4:\\n pad = np.maximum(pad, int(np.rint(qsize * 0.3)))\\n img = np.pad(np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect')\\n h, w, _ = img.shape\\n y, x, _ = np.ogrid[:h, :w, :1]\\n mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w-1-x) / pad[2]), 1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h-1-y) / pad[3]))\\n blur = qsize * 0.02\\n img += (ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)\\n img += (np.median(img, axis=(0,1)) - img) * np.clip(mask, 0.0, 1.0)\\n img = np.uint8(np.clip(np.rint(img), 0, 255))\\n if alpha:\\n mask = 1-np.clip(3.0 * mask, 0.0, 1.0)\\n mask = np.uint8(np.clip(np.rint(mask*255), 0, 255))\\n img = np.concatenate((img, mask), axis=2)\\n img = Image.fromarray(img, 'RGBA')\\n else:\\n img = Image.fromarray(img, 'RGB')\\n quad += pad[:2]\\n\\n # Transform.\\n img = img.transform((transform_size, transform_size), Image.QUAD, (quad + 0.5).flatten(), Image.BILINEAR)\\n print(transform_size)\\n if output_size < transform_size:\\n img = img.resize((output_size, output_size), Image.ANTIALIAS)\\n\\n # Save aligned image.\\n img.save(dst_file, 'PNG')\",\n \"def _layout_as_overlay(self, size=None, force=False):\\n if self.component is not None:\\n self.position = self.component.position\\n self.bounds = self.component.bounds\\n return\",\n \"def _align(elements, alignment=\\\"ymax\\\"):\\n if len(elements) == 0:\\n return elements\\n if alignment not in ([\\\"x\\\", \\\"y\\\", \\\"xmin\\\", \\\"xmax\\\", \\\"ymin\\\", \\\"ymax\\\"]):\\n raise ValueError(\\n \\\"'alignment' argument must be one of 'x','y','xmin', 'xmax', 'ymin','ymax'\\\"\\n )\\n value = Group(elements).__getattribute__(alignment)\\n for e in elements:\\n e.__setattr__(alignment, value)\\n return elements\",\n \"def set_image_overlays(self, condition):\\n if not config['image_on'] or not self._target_filename:\\n return\\n initial_image = load_data_from_npz(self._target_filename,\\n config['image_overlay_actuator'], str(condition),\\n 'initial', 'image', default=None)\\n target_image = load_data_from_npz(self._target_filename,\\n config['image_overlay_actuator'], str(condition),\\n 'target', 'image', default=None)\\n self._image_visualizer.set_initial_image(initial_image,\\n alpha=config['image_overlay_alpha'])\\n self._image_visualizer.set_target_image(target_image,\\n alpha=config['image_overlay_alpha'])\",\n \"def setup_orientation_annotation(self) :\\n \\n # Anatomical directions in LPS convention, numpy order\\n directions_anatomical = {\\n \\\"L\\\" : (0,0,+1),\\n \\\"R\\\" : (0,0,-1),\\n \\\"P\\\" : (0,+1,0),\\n \\\"A\\\" : (0,-1,0),\\n \\\"I\\\" : (-1,0,0),\\n \\\"S\\\" : (+1,0,0),\\n }\\n \\n # Index directions, numpy order\\n directions_index = {\\n \\\"+x\\\" : (0,0,+1),\\n \\\"-x\\\" : (0,0,-1),\\n \\\"+y\\\" : (0,+1,0),\\n \\\"-y\\\" : (0,-1,0),\\n \\\"+z\\\" : (-1,0,0),\\n \\\"-z\\\" : (+1,0,0),\\n }\\n \\n directions = (directions_anatomical \\n if self.display_coordinates in [\\\"physical\\\", \\\"nearest_axis_aligned\\\"]\\n else directions_index)\\n \\n # Window locations\\n locations = {\\n \\\"up\\\" : (1,0),\\n \\\"down\\\" : (-1,0),\\n \\\"left\\\" : (0,-1),\\n \\\"right\\\" : (0,1)\\n }\\n \\n for location, p in locations.items() :\\n matrix = self._3d_world_to_slice\\n direction = numpy.dot(self._3d_slice_to_world, numpy.hstack((0, p)))\\n \\n # Find closest in-slice direction based on dot product\\n closest = None\\n max_distance = -1\\n for name, d in directions.items() :\\n distance = numpy.dot(d, direction)\\n if distance > max_distance :\\n max_distance = distance\\n closest = name\\n \\n # Set text\\n index = self._orientation_annotation_index[location]\\n self._orientation_annotation.SetText(index, closest)\",\n \"def draw_overlay(array, color):\\n over = Image.new('RGBA', WORKSIZE, (0, 0, 0, 0))\\n for key in array:\\n draw_rectangle(over, key, color)\\n return over\",\n \"def align_preprocessed(self, img):\\n aligner = FaceAligner(self.args.wing_path, self.args.lm_path, self.args.img_size)\\n return aligner.align(img)\",\n \"def load_aligned(self, image, size=256, padding=48, align_eyes=False):\\n self.aligned[\\\"size\\\"] = size\\n self.aligned[\\\"padding\\\"] = padding\\n self.aligned[\\\"align_eyes\\\"] = align_eyes\\n self.aligned[\\\"matrix\\\"] = get_align_mat(self, size, align_eyes)\\n self.aligned[\\\"face\\\"] = AlignerExtract().transform(\\n image,\\n self.aligned[\\\"matrix\\\"],\\n size,\\n padding)\",\n \"def apply_png_overlay(image, overlay, start_row, start_col, height=200, width=200):\\n\\n alpha_s = overlay[:, :, 3] / 255.0\\n alpha_l = 1.0 - alpha_s\\n for c in range(0, 3):\\n image[start_row:start_row+height, start_col:start_col+width, c] = (\\n alpha_s * overlay[:, :, c] +\\n alpha_l * image[start_row:start_row+height, start_col:start_col+width, c])\\n \\n return image\",\n \"def test_align_without_gaps(self):\\n aln = ArrayAlignment(\\n {\\\"seq1\\\": \\\"ACGG\\\", \\\"seq2\\\": \\\"CGCA\\\", \\\"seq3\\\": \\\"CCG-\\\"}, moltype=\\\"dna\\\"\\n )\\n aln_plot = aln.dotplot(\\\"seq1\\\")\\n self.assertNotEqual(aln_plot._aligned_coords, None)\",\n \"def set_alignment(self, alignment: constants.AlignmentStr | constants.AlignmentFlag):\\n self.setAlignment(constants.ALIGNMENTS.get_enum_value(alignment))\",\n \"def overlay_image(l_img, s_img, pos, transparency, src_center=False):\\n\\n # Center image\\n if src_center:\\n pos = list(pos)\\n pos[0] -= int(s_img.shape[1] * 0.5)\\n pos[1] -= int(s_img.shape[0] * 0.5)\\n\\n # Get superior image dimensions\\n s_img_height, s_img_width, s_img_channels = s_img.shape\\n\\n if s_img_channels == 3 and transparency != 1:\\n s_img = cv2.cvtColor(s_img, cv2.COLOR_BGR2BGRA)\\n s_img_channels = 4\\n\\n # Take 3rd channel of 'img_overlay' image to get shapes\\n img_overlay = s_img[:, :, 0:4]\\n\\n # cords assignation to overlay image\\n x, y = pos\\n\\n # Image ranges\\n y1, y2 = max(0, y), min(l_img.shape[0], y + img_overlay.shape[0])\\n x1, x2 = max(0, x), min(l_img.shape[1], x + img_overlay.shape[1])\\n\\n # Overlay ranges\\n y1o, y2o = max(0, -y), min(img_overlay.shape[0], l_img.shape[0] - y)\\n x1o, x2o = max(0, -x), min(img_overlay.shape[1], l_img.shape[1] - x)\\n\\n # Exit if nothing to do\\n if y1 >= y2 or x1 >= x2 or y1o >= y2o or x1o >= x2o:\\n return l_img\\n\\n if s_img_channels == 4:\\n # Get alphas channel\\n alpha_mask = (s_img[:, :, 3] / 255.0) * transparency\\n alpha_s = alpha_mask[y1o:y2o, x1o:x2o]\\n alpha_l = 1.0 - alpha_s\\n\\n # Do the overlay with alpha channel\\n for c in range(0, l_img.shape[2]):\\n l_img[y1:y2, x1:x2, c] = (\\n alpha_s * img_overlay[y1o:y2o, x1o:x2o, c]\\n + alpha_l * l_img[y1:y2, x1:x2, c]\\n )\\n\\n elif s_img_channels < 4:\\n # Do the overlay with no alpha channel\\n if l_img.shape[2] == s_img.shape[2]:\\n l_img[y1:y2, x1:x2] = s_img[y1o:y2o, x1o:x2o]\\n else:\\n print(\\\"Error: to overlay images should have the same color channels\\\")\\n return l_img\\n\\n # Return results\\n return l_img\",\n \"def vertical_alignment(self):\\n self.update()\\n return self._vertical_alignment\",\n \"def align_and_extract_face(self, image, landmarks, output_size=(150,150), desired_left_eye_relative_position=(0.55, 0.55)):\\n\\n # get the key landmark features\\n lp, eye_center, facebox = landmarks['left-eye-center-pos'], landmarks['eye-center-pos'], landmarks['face-box']\\n\\n # calculating the center box for face box, this will also be the center for the output_box\\n face_box_center = calc_box_center(facebox)\\n\\n # calculate the output box using the box center\\n output_box = (face_box_center[0] - output_size[0] / 2, face_box_center[1] - output_size[1]/2, output_size[0], output_size[1])\\n\\n # left eye's absolute position relative to facebox\\n current_left_eye_absolute_x_position = lp[0] - facebox[0]\\n\\n # desired left eye's absolute position relative to output box\\n desired_left_eye_absolute_x_position = output_box[2] * desired_left_eye_relative_position[0]\\n\\n # scale needed would be the ratio between desired and current\\n scale = desired_left_eye_absolute_x_position / current_left_eye_absolute_x_position\\n\\n # calculate alignment angle\\n angle = self.determine_rotation_angle(landmarks)\\n\\n # rotation origin will be the eye_center\\n rotation_origin = eye_center\\n\\n # calculate the rotation matrix\\n rotation_matrix = self.determine_rotation_matrix(rotation_origin, angle, scale)\\n\\n # calculate the new bounding box needed to bound/contain the rotated image\\n aligned_box = self.determine_bounding_box_of_rotated_box(calc_img_box(image), rotation_matrix)\\n (aligned_x, aligned_y, aligned_w, aligned_h) = aligned_box\\n # update the translation to fit the rotated image to the bounding box\\n rotation_matrix[0, 2] -= aligned_x\\n rotation_matrix[1, 2] -= aligned_y\\n\\n # perform the transformation\\n warped_image = cv2.warpAffine(image, rotation_matrix, (aligned_w, aligned_h), flags=cv2.INTER_CUBIC)\\n\\n # calculate new box positions\\n new_face_box_center = calc_rotate_point_with_rotation_matrix(face_box_center, rotation_matrix)\\n new_output_box = [\\n int(new_face_box_center[0] - output_size[0] / 2),\\n int(new_face_box_center[1] - output_size[1]/2),\\n output_size[0], output_size[1]\\n ]\\n\\n # calculate new left eye position\\n new_lp = calc_rotate_point_with_rotation_matrix(lp, rotation_matrix)\\n\\n # calculate how far we are from the ideal y position for the left eye\\n desired_left_eye_absolute_y_position = new_output_box[1] + int(new_output_box[3] * desired_left_eye_relative_position[1])\\n distance = new_lp[1] - desired_left_eye_absolute_y_position\\n\\n # shift the y position such that the output box is in the desired y position\\n new_output_box[1] += distance\\n\\n # it's possible output boxes's position will extend beyond current image space, pad the current image space such that they'll be enough space for the output box\\n\\n # figure out the padding\\n x_left_pad = abs(min(0, new_output_box[0]))\\n x_right_pad = abs(min(0, warped_image.shape[1] - (new_output_box[0] + new_output_box[2])))\\n y_top_pad = abs(min(0, new_output_box[1]))\\n y_bottom_pad = abs(min(0, warped_image.shape[0] - (new_output_box[1] + new_output_box[3])))\\n\\n # some amount of padding exists, create an image with enough padding space\\n if x_left_pad + x_right_pad + y_top_pad + y_bottom_pad != 0:\\n # create a new image with the padded distance\\n new_shape = (warped_image.shape[0] + y_top_pad + y_bottom_pad, warped_image.shape[1] + x_left_pad + x_right_pad, 3)\\n padded_image = np.zeros(new_shape)\\n\\n # copy contents of warped image into padded image\\n padded_image[y_top_pad:y_top_pad + warped_image.shape[0], x_left_pad:x_left_pad + warped_image.shape[1]] = warped_image\\n\\n # set the warped image to the padded image\\n warped_image = padded_image\\n\\n # now \\\"tare\\\" the coordinates of the output box so that it fits in side the padded image\\n new_output_box[0] += x_left_pad\\n new_output_box[1] += y_top_pad\\n\\n # crop the output box out of the warped image\\n cropped_image = warped_image[new_output_box[1]:new_output_box[1]+new_output_box[3], new_output_box[0]:new_output_box[0]+new_output_box[2]]\\n\\n # return the cropped image\\n return cropped_image\",\n \"def to_alignment(self):\\n alignment = dict()\\n alignment[\\\"x\\\"] = self.x\\n alignment[\\\"w\\\"] = self.w\\n alignment[\\\"y\\\"] = self.y\\n alignment[\\\"h\\\"] = self.h\\n alignment[\\\"frame_dims\\\"] = self.frame_dims\\n alignment[\\\"landmarksXY\\\"] = self.landmarksXY\\n return alignment\",\n \"def align(self, image, landmark_indices, anchor_points, size=96):\\n\\n detected = self.detect(image)\\n coords = self.find_landmarks(image, detected)\\n in_points = coords[landmark_indices]\\n in_points = in_points.astype('float32')\\n out_points = anchor_points * size\\n warp_mat = cv2.getAffineTransform(in_points, out_points)\\n warp_dst = cv2.warpAffine(image, warp_mat, (size, size))\\n\\n return warp_dst\",\n \"def __resolve_annotation_conflicts(self, annotations):\\n # set the bounding box and initial positions of the annotations\\n # the x-value is only corrected if it is inside the graph or too close to the graph\\n left = []\\n right = []\\n for a in annotations:\\n # first, get the bounds\\n self.__set_annotation_bbox(a)\\n\\n # now set the intitial positions\\n # we want all of the text to be on the left or right of the squares\\n width = a.bbox.width\\n # to preserve hint values, only set the x value if it is inside the graph\\n # or if it is not at least as far as the offset\\n if a.y >= 0 and a.y <= self.ymax:\\n if ((a.x >= self.xmax / 2) and (a.x < self.xmax)) or (a.x >= self.xmax and a.x < self.xmax + self.settings.otherParams[\\\"annotation.right.offset\\\"]):\\n a.x = self.xmax + \\\\\\n self.settings.otherParams[\\\"annotation.right.offset\\\"]\\n elif ((a.x >= 0) and (a.x < self.xmax / 2)) or (a.x <= self.xmin and a.x > self.xmin - self.settings.otherParams[\\\"annotation.left.offset\\\"]):\\n a.x = self.xmin - \\\\\\n self.settings.otherParams[\\\"annotation.left.offset\\\"] - width\\n a.bbox.x0 = a.x\\n a.bbox.x1 = a.x + width\\n if (a.x >= self.xmax / 2):\\n a.set_relpos((0, 0.5))\\n right.append(a)\\n if (a.x < self.xmax / 2):\\n a.set_relpos((1, 0.5))\\n left.append(a)\\n elif a.y < 0:\\n a.set_relpos((0.5, 0))\\n right.append(a)\\n elif a.y > self.ymax:\\n a.set_relpos((0.5, 1))\\n right.append(a)\\n\\n # for the left, we want to prioritze labels\\n # with lower x values to minimize the crossover of annotation lines\\n # for the right, we want to prioritize labels that are closer\\n # to the right side of the graph to minimuze the crossover of annotation lines\\n left.sort(key=lambda a: (a.event_point.y, a.event_point.x))\\n right.sort(key=lambda a: (a.event_point.y, -a.event_point.x))\\n\\n final = []\\n for lst in [left, right]:\\n _f = []\\n for unchecked in lst:\\n for checked in _f:\\n if unchecked.overlaps(checked):\\n correction = unchecked.get_xy_correction(\\n checked, self.label_space_epsilon)\\n unchecked.update_Y_with_correction(correction)\\n if unchecked.is_within_epsilon_of(checked, self.label_space_epsilon):\\n correction = [0, self.label_space_epsilon]\\n unchecked.update_Y_with_correction(correction)\\n _f.append(unchecked)\\n final.extend(_f)\\n\\n return final\",\n \"def do_polar_alignment_test(self, *arg):\\n if self.ready is False:\\n return\\n\\n start_time = current_time(flatten=True)\\n\\n base_dir = '{}/images/drift_align/{}'.format(\\n os.getenv('PANDIR'), start_time)\\n plot_fn = '{}/{}_center_overlay.jpg'.format(base_dir, start_time)\\n\\n mount = self.pocs.observatory.mount\\n\\n print_info(\\\"Moving to home position\\\")\\n self.pocs.say(\\\"Moving to home position\\\")\\n mount.slew_to_home()\\n\\n # Polar Rotation\\n pole_fn = polar_rotation(self.pocs, base_dir=base_dir)\\n pole_fn = pole_fn.replace('.cr2', '.fits')\\n\\n # Mount Rotation\\n rotate_fn = mount_rotation(self.pocs, base_dir=base_dir)\\n rotate_fn = rotate_fn.replace('.cr2', '.fits')\\n\\n print_info(\\\"Moving back to home\\\")\\n self.pocs.say(\\\"Moving back to home\\\")\\n mount.slew_to_home()\\n\\n print_info(\\\"Solving celestial pole image\\\")\\n self.pocs.say(\\\"Solving celestial pole image\\\")\\n try:\\n pole_center = polar_alignment_utils.analyze_polar_rotation(pole_fn)\\n except error.SolveError:\\n print_warning(\\\"Unable to solve pole image.\\\")\\n print_warning(\\\"Will proceeed with rotation image but analysis not possible\\\")\\n pole_center = None\\n else:\\n pole_center = (float(pole_center[0]), float(pole_center[1]))\\n\\n print_info(\\\"Starting analysis of rotation image\\\")\\n self.pocs.say(\\\"Starting analysis of rotation image\\\")\\n try:\\n rotate_center = polar_alignment_utils.analyze_ra_rotation(rotate_fn)\\n except Exception:\\n print_warning(\\\"Unable to process rotation image\\\")\\n rotate_center = None\\n\\n if pole_center is not None and rotate_center is not None:\\n print_info(\\\"Plotting centers\\\")\\n self.pocs.say(\\\"Plotting centers\\\")\\n\\n print_info(\\\"Pole: {} {}\\\".format(pole_center, pole_fn))\\n self.pocs.say(\\\"Pole : {:0.2f} x {:0.2f}\\\".format(\\n pole_center[0], pole_center[1]))\\n\\n print_info(\\\"Rotate: {} {}\\\".format(rotate_center, rotate_fn))\\n self.pocs.say(\\\"Rotate: {:0.2f} x {:0.2f}\\\".format(\\n rotate_center[0], rotate_center[1]))\\n\\n d_x = pole_center[0] - rotate_center[0]\\n d_y = pole_center[1] - rotate_center[1]\\n\\n self.pocs.say(\\\"d_x: {:0.2f}\\\".format(d_x))\\n self.pocs.say(\\\"d_y: {:0.2f}\\\".format(d_y))\\n\\n fig = polar_alignment_utils.plot_center(\\n pole_fn, rotate_fn, pole_center, rotate_center)\\n\\n print_info(\\\"Plot image: {}\\\".format(plot_fn))\\n fig.tight_layout()\\n fig.savefig(plot_fn)\\n\\n try:\\n os.unlink('/var/panoptes/images/latest.jpg')\\n except Exception:\\n pass\\n try:\\n os.symlink(plot_fn, '/var/panoptes/images/latest.jpg')\\n except Exception:\\n print_warning(\\\"Can't link latest image\\\")\\n\\n with open('/var/panoptes/images/drift_align/center.txt'.format(base_dir), 'a') as f:\\n f.write('{}.{},{},{},{},{},{}\\\\n'.format(start_time, pole_center[0], pole_center[\\n 1], rotate_center[0], rotate_center[1], d_x, d_y))\\n\\n print_info(\\\"Done with polar alignment test\\\")\\n self.pocs.say(\\\"Done with polar alignment test\\\")\",\n \"def from_alignment(self, alignment, image=None):\\n self.x = alignment[\\\"x\\\"]\\n self.w = alignment[\\\"w\\\"]\\n self.y = alignment[\\\"y\\\"]\\n self.h = alignment[\\\"h\\\"]\\n self.frame_dims = alignment[\\\"frame_dims\\\"]\\n self.landmarksXY = alignment[\\\"landmarksXY\\\"]\\n if image.any():\\n self.image_to_face(image)\",\n \"def pos_image(image, x,y):\\n image.anchor_x = x\\n image.anchor_y = y\",\n \"def overlayImage(self, filename):\\n overlayTime = time.time()\\n\\n # local refs\\n ren = self.ren\\n renWinInteract = self.renWinInteract\\n renIndex = self.parent.rendererIndex\\n\\n # to do this we change cam pos to far away and\\n # save temp image with just text in\\n\\n # so move the camera far away\\n camera = ren.GetActiveCamera()\\n origCamPos = camera.GetPosition()\\n newCamPos = [0] * 3\\n newCamPos[0] = origCamPos[0] * 100000\\n newCamPos[1] = origCamPos[1] * 100000\\n newCamPos[2] = origCamPos[2] * 100000\\n camera.SetPosition(newCamPos)\\n\\n # also hide axes if visible\\n if self.axes.isEnabled():\\n axesHidden = True\\n self.toggleAxes()\\n else:\\n axesHidden = False\\n\\n try:\\n # save image\\n overlayFilePrefix = os.path.join(self.mainWindow.tmpDirectory, \\\"renderer%d_overlay\\\" % renIndex)\\n overlayFile = self.saveImage(\\\"VTK\\\", \\\"jpg\\\", overlayFilePrefix, False)\\n if not os.path.exists(overlayFile):\\n print(\\\"WARNING: overlay file does not exist: %s\\\" % overlayFile)\\n return\\n\\n try:\\n # open POV-Ray image\\n povim = Image.open(filename)\\n modified = False\\n\\n # find text in top left corner\\n im = Image.open(overlayFile)\\n\\n # start point\\n xmin = ymin = 0\\n xmax = int(im.size[0] * 0.5)\\n ymax = int(im.size[1] * 0.8)\\n\\n # find extremes\\n xmin, xmax, ymin, ymax = self.findOverlayExtremes(im, xmin, xmax, ymin, ymax)\\n\\n # crop\\n region = im.crop((xmin, ymin, xmax + 2, ymax + 2))\\n\\n # add to povray image\\n if region.size[0] != 0:\\n region = region.resize((region.size[0], region.size[1]), Image.ANTIALIAS)\\n povim.paste(region, (0, 0))\\n modified = True\\n\\n # now look for anything at the bottom => scalar bar\\n im = Image.open(overlayFile)\\n\\n # start point\\n xmin = 0\\n ymin = im.size[1] - 80\\n xmax = im.size[0]\\n ymax = im.size[1]\\n\\n # find extremes\\n xmin, xmax, ymin, ymax = self.findOverlayExtremes(im, xmin, xmax, ymin, ymax)\\n\\n # crop\\n region = im.crop((xmin, ymin, xmax, ymax))\\n\\n # add?\\n if region.size[0] != 0:\\n newregiondimx = int(povim.size[0] * 0.8)\\n dx = (float(povim.size[0]) * 0.8 - float(region.size[0])) / float(region.size[0])\\n newregiondimy = region.size[1] + int(region.size[1] * dx)\\n region = region.resize((newregiondimx, newregiondimy), Image.ANTIALIAS)\\n\\n xpos = int((povim.size[0] - region.size[0]) / 2.0)\\n povim.paste(region, (xpos, int(povim.size[1] - region.size[1])))\\n\\n modified = True\\n\\n # now look for text in top right corner\\n im = Image.open(overlayFile)\\n\\n # start point\\n xmin = int(im.size[0] * 0.5)\\n ymin = 0\\n xmax = im.size[0]\\n ymax = int(im.size[1] * 0.6)\\n\\n # find extremes\\n xmin, xmax, ymin, ymax = self.findOverlayExtremes(im, xmin, xmax, ymin, ymax)\\n\\n # crop\\n region = im.crop((xmin - 2, ymin, xmax, ymax + 2))\\n\\n if region.size[0] != 0:\\n region = region.resize((region.size[0], region.size[1]), Image.ANTIALIAS)\\n xpos = povim.size[0] - 220\\n povim.paste(region, (xpos, 0))\\n\\n modified = True\\n\\n # save image\\n if modified:\\n povim.save(filename)\\n\\n finally:\\n os.unlink(overlayFile)\\n\\n finally:\\n # return to original cam pos\\n camera.SetPosition(origCamPos)\\n renWinInteract.ReInitialize()\\n\\n # show axes again\\n if axesHidden:\\n self.toggleAxes()\\n\\n overlayTime = time.time() - overlayTime\\n self.logger.debug(\\\"Overlay time: %f s\\\", overlayTime)\",\n \"def _align(self):\\n\\n shape = np.shape(self.x)\\n\\n # Get angle of direction (cbi: center beam index)\\n # NOTE: This implementation seems to be unstable, because the shot with the center beam index can be NaN\\n # cbi = np.median(np.arange(len(self.x[0, :]))).astype(int)\\n # vec1 = [self.x[0, cbi], self.y[0, cbi], 0.0]\\n # vec2 = [self.x[-1, cbi], self.y[-1, cbi], 0.0]\\n\\n # Alternative implementation with mean over all entries within the line.\\n # -> should be a good approximation of the line center\\n # NOTE: 2019-05-30: Relaxed the criterion even further (mean of first and last 10 scan lines)\\n vec1 = [np.nanmedian(self.x[0:10, :]), np.nanmedian(self.y[0:10, :]), 0.0]\\n vec2 = [np.nanmedian(self.x[-11:-1, :]), np.nanmedian(self.y[-11:-1, :]), 0.0]\\n angle = -1.0*np.arctan((vec2[1]-vec1[1])/(vec2[0]-vec1[0]))\\n\\n # validity check -> Do not rotate if angle is nan\\n if np.isnan(angle):\\n return\\n\\n # Get center point\\n xc = np.nanmedian(self.x)\\n yc = np.nanmedian(self.y)\\n\\n # Reform points\\n points = [self.x.flatten()-xc, self.y.flatten()-yc]\\n\\n # Execute the rotation\\n rot_matrix = np.array([[np.cos(angle), -np.sin(angle)],\\n [np.sin(angle), np.cos(angle)]])\\n points_rotated = rot_matrix.dot(points)\\n self.x = np.reshape(points_rotated[0, :], shape)\\n self.y = np.reshape(points_rotated[1, :], shape)\\n\\n # Save conversion parameters for reuse\\n self._align_parameters = {'center_point': (xc, yc),\\n 'angle': angle,\\n 'rotation_matrix': rot_matrix}\",\n \"def overlay_down(self, idx):\\n if not self.is_bottom_layer(idx):\\n self.overlay_list[idx], self.overlay_list[idx-1] = \\\\\\n self.overlay_list[idx-1], self.overlay_list[idx]\",\n \"def draw_overlay(self):\\n pass\",\n \"def set_vertical_alignment(self, value):\\n if self._simplecell:\\n self.fetch()\\n self.vertical_alignment = value\\n return self\",\n \"def align(img, landmarks, d_size=(400, 400), normalized=False, show=False):\\n assert len(landmarks) == 10\\n assert isinstance(img, np.ndarray)\\n landmarks = np.array(landmarks).reshape(5, 2)\\n dw, dh = d_size\\n\\n keypoints = landmarks.copy().astype(np.float64)\\n if normalized:\\n keypoints[:, 0] *= img.shape[1]\\n keypoints[:, 1] *= img.shape[0]\\n\\n keypoints_ref = np.zeros((5, 2), dtype=np.float64)\\n keypoints_ref[:, 0] = FivePointsAligner.ref_landmarks[:, 0] * dw\\n keypoints_ref[:, 1] = FivePointsAligner.ref_landmarks[:, 1] * dh\\n\\n transform_matrix = transformation_from_points(keypoints_ref, keypoints)\\n output_im = cv.warpAffine(img, transform_matrix, d_size, flags=cv.WARP_INVERSE_MAP)\\n\\n if show:\\n tmp_output = output_im.copy()\\n for point in keypoints_ref:\\n cv.circle(tmp_output, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\\n for point in keypoints:\\n cv.circle(img, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\\n img = cv.resize(img, d_size)\\n cv.imshow('source/warped', np.hstack((img, tmp_output)))\\n cv.waitKey()\\n\\n return output_im\",\n \"def bb8_transform(ex_rois, gt_bb8_coordinates, bb8_variance, granularity, im_info):\\n assert ex_rois.shape[0] == gt_bb8_coordinates.shape[0], 'inconsistent rois number'\\n\\n ex_widths = ex_rois[:, 2] - ex_rois[:, 0] + 1.0\\n ex_heights = ex_rois[:, 3] - ex_rois[:, 1] + 1.0\\n ex_ctr_x = ex_rois[:, 0] + 0.5 * (ex_widths - 1.0)\\n ex_ctr_y = ex_rois[:, 1] + 0.5 * (ex_heights - 1.0)\\n\\n # fine grained anchor centers\\n ex_FGA_ctr_x = np.zeros(shape=(ex_rois.shape[0], 1, granularity[1]))\\n ex_FGA_ctr_y = np.zeros(shape=(ex_rois.shape[0], granularity[0], 1))\\n for i in range(granularity[1]):\\n ex_FGA_ctr_x[:, 0, i] = ex_ctr_x + (i - int((granularity[1] - 1) / 2)) * ex_widths / granularity[1]\\n ex_FGA_ctr_x = np.repeat(ex_FGA_ctr_x, repeats=granularity[0], axis=1)\\n for i in range(granularity[0]):\\n ex_FGA_ctr_y[:, i, 0] = ex_ctr_y + (i - int((granularity[0] - 1) / 2)) * ex_heights / granularity[0]\\n ex_FGA_ctr_y = np.repeat(ex_FGA_ctr_y, repeats=granularity[1], axis=2)\\n\\n\\n # gt_widths = gt_rois[:, 2] - gt_rois[:, 0] + 1.0\\n # gt_heights = gt_rois[:, 3] - gt_rois[:, 1] + 1.0\\n gt_bb8_coordinates = gt_bb8_coordinates.reshape((gt_bb8_coordinates.shape[0], 8, 2))\\n gt_bb8_coordinates_x = gt_bb8_coordinates[:, :, 0] * im_info[1]\\n gt_bb8_coordinates_y = gt_bb8_coordinates[:, :, 1] * im_info[0]\\n\\n distance_x = gt_bb8_coordinates_x[:, :, np.newaxis, np.newaxis] - ex_FGA_ctr_x[:, np.newaxis]\\n distance_y = gt_bb8_coordinates_y[:, :, np.newaxis, np.newaxis] - ex_FGA_ctr_y[:, np.newaxis]\\n distance = np.sqrt(np.square(distance_x) + np.square(distance_y))\\n\\n FGA_cls_targets = np.zeros_like(distance)\\n FGA_cls_targets = FGA_cls_targets.reshape((FGA_cls_targets.shape[0], FGA_cls_targets.shape[1], -1))\\n # min_distances = np.min(distance.reshape((distance.shape[0], distance.shape[1], -1)), axis=2)\\n index = np.argmin(distance.reshape((distance.shape[0], distance.shape[1], -1)), axis=2)\\n for i in range(FGA_cls_targets.shape[0]):\\n for j in range(FGA_cls_targets.shape[1]):\\n FGA_cls_targets[i, j, index[i, j]] = 1\\n FGA_cls_targets = FGA_cls_targets.reshape(distance.shape)\\n\\n # shape (N, 8)\\n FGA_reg_targets_dx = distance_x[FGA_cls_targets > 0].reshape((distance_x.shape[0], -1))\\n FGA_reg_targets_dx = FGA_reg_targets_dx / (ex_widths[:, np.newaxis] / granularity[1] + 1e-14) / bb8_variance[0]\\n FGA_reg_targets_dy = distance_y[FGA_cls_targets > 0].reshape((distance_y.shape[0], -1))\\n FGA_reg_targets_dy = FGA_reg_targets_dy / (ex_heights[:, np.newaxis] / granularity[0] + 1e-14) / bb8_variance[1]\\n\\n # shape (N, 16) xyxy\\n FGA_reg_targets = np.stack((FGA_reg_targets_dx, FGA_reg_targets_dy), axis=-1).reshape((FGA_cls_targets.shape[0], -1))\\n FGA_reg_weights = np.ones_like(FGA_reg_targets)\\n\\n # for softmax target (N, 8)\\n FGA_cls_targets = np.argmax(FGA_cls_targets.reshape(FGA_cls_targets.shape[0], FGA_cls_targets.shape[1], -1), axis=2)\\n\\n return FGA_cls_targets, FGA_reg_targets, FGA_reg_weights\",\n \"def blend(self, alignment_offset):\\n stitched_image = None\\n\\n return stitched_image\",\n \"def _set_anchor_center(img):\\n img.anchor_x = int(img.width / 2)\\n img.anchor_y = int(img.height / 2)\",\n \"def _annotate_images(self, frameList):\\n\\t\\timage_array = frameList\\n\\t\\tfor i, image in enumerate(image_array):\\n\\t\\t\\tif i in list(self.detection_frames.keys()):\\n\\t\\t\\t\\tfor obj in list(self.detection_frames[i].keys()):\\n\\t\\t\\t\\t\\tx, y, w, h, frame, text, track_id = self.detection_index[obj]\\n\\t\\t\\t\\t\\tCOLOR = COLORS[text]\\n\\t\\t\\t\\t\\t# if the detection is human\\n\\t\\t\\t\\t\\tif text == 'face':\\n\\t\\t\\t\\t\\t\\ttext = text + \\\" id:{}\\\".format(track_id)\\n\\t\\t\\t\\t\\t\\t# predict \\n\\t\\t\\t\\t\\t\\tgender = self.genderDetect.classify(image[y:y+h, x:x+w, :])\\n\\t\\t\\t\\t\\t\\tgender = 'female' if gender[0] < 0.5 else 'male'\\n\\t\\t\\t\\t\\t\\tcv2.putText(image, gender, (x + w // 2 - 10, y + h + 15),\\n\\t\\t\\t\\t\\t\\t\\tcv2.FONT_HERSHEY_SIMPLEX, 0.6, COLOR, 2, cv2.LINE_AA)\\n\\n\\t\\t\\t\\t\\timage_array[i] = cv2.rectangle(image_array[i], (x, y), (x + w, y + h), COLOR, 2)\\n\\t\\t\\t\\t\\tcv2.putText(image_array[i], text, (x, y - 5),\\n\\t\\t\\t\\t\\t\\tcv2.FONT_HERSHEY_SIMPLEX, 0.6, COLOR, 2, cv2.LINE_AA)\\n\\n\\n\\t\\t\\tcv2.imwrite(f'{SAVE_PATH}{self.clip}{i}.jpg', image_array[i])\",\n \"def horizontal_alignment(self):\\n self.update()\\n return self._horizontal_alignment\",\n \"def alignsrc(self):\\n return self[\\\"alignsrc\\\"]\",\n \"def alignsrc(self):\\n return self[\\\"alignsrc\\\"]\",\n \"def alignsrc(self):\\n return self[\\\"alignsrc\\\"]\",\n \"def align(self, alignment=\\\"ymax\\\") -> \\\"Group\\\":\\n _align(elements=self.elements, alignment=alignment)\\n return self\",\n \"def align(self):\\n ...\",\n \"def test_align(self):\\n al = align(self.amp1, self.amp2).m\\n\\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\\n self.assertAlmostEqual(al.vert.mean(axis=0)[0], 0, delta=TestAlign.DELTA)\\n self.assertAlmostEqual(al.vert.mean(axis=0)[1], 0, delta=TestAlign.DELTA)\\n self.assertAlmostEqual(al.vert.mean(axis=0)[2], 0, delta=TestAlign.DELTA)\",\n \"def align(self, *, skip_corners=False, return_on_invalid_result=False, warpwarnings=False, **kwargs):\\n #load the images for all HPFs and keep them in memory as long as\\n #the AlignSample is active\\n self.getDAPI()\\n self.logger.info(\\\"starting alignment\\\")\\n\\n weighted_sum_mse = 0.\\n sum_weights = 0.\\n done = set()\\n\\n for i, overlap in enumerate(self.overlaps, start=1):\\n if skip_corners and overlap.tag in [1,3,7,9] :\\n continue\\n self.logger.debug(f\\\"aligning overlap {overlap.n} ({i}/{len(self.overlaps)})\\\")\\n result = None\\n #check if the inverse overlap has already been aligned\\n #(e.g. if the current overlap is between (1, 2), check the overlap between (2, 1))\\n #if so, we don't have to align again\\n if self.inverseoverlapsdictkey(overlap) in done:\\n inverseoverlap = self.overlapsdict[self.inverseoverlapsdictkey(overlap)]\\n if hasattr(inverseoverlap, \\\"result\\\"):\\n result = overlap.getinversealignment(inverseoverlap)\\n #do the alignment\\n if result is None:\\n result = overlap.align(gputhread=self.gputhread, gpufftdict=self.gpufftdict, **kwargs)\\n done.add(self.overlapsdictkey(overlap))\\n\\n #contribution of the mean squared difference after alignment\\n #to the weighted sum\\n if result is not None and result.exit == 0: \\n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\\n weighted_sum_mse+=w*result.mse[2]\\n sum_weights+=w\\n else :\\n if result is None:\\n reason = \\\"is None\\\"\\n else:\\n reason = f\\\"has exit status {result.exit}\\\"\\n if return_on_invalid_result :\\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: returning 1e10!!')\\n return 1e10\\n else :\\n if warpwarnings: self.logger.warningglobal(f'Overlap number {i} alignment result {reason}: adding 1e10 to sum_mse!!')\\n w = (overlap.cutimages[0].shape[0]*overlap.cutimages[0].shape[1])\\n weighted_sum_mse+=w*1e10\\n sum_weights+=w\\n\\n self.logger.info(\\\"finished align loop for \\\"+self.SlideID)\\n return weighted_sum_mse/sum_weights\",\n \"def extended_frame_annotation(self, original_frame):\\n self.frame = self.annotated_frame(original_frame)\\n text = \\\"\\\"\\n if self.is_right():\\n text = \\\"Looking right\\\"\\n elif self.is_left():\\n text = \\\"Looking left\\\"\\n elif self.is_center():\\n text = \\\"Looking center\\\"\\n\\n h_ratio = \\\"HR: \\\" + str(self.horizontal_ratio())[:4]\\n v_ratio = \\\"VR: \\\" + str(self.vertical_ratio())[:4]\\n\\n width = int(0.9 * self.frame.shape[1])\\n height = int(0.9 * self.frame.shape[0])\\n\\n # cv2.putText(self.frame, text, (60, 60), cv2.FONT_HERSHEY_DUPLEX, 2, (255, 0, 0), 2)\\n # cv2.putText(self.frame, h_ratio, (60, height), cv2.FONT_HERSHEY_DUPLEX, 2, (255, 0, 0), 2)\\n # cv2.putText(self.frame, v_ratio, (int(0.8 * width), height), cv2.FONT_HERSHEY_DUPLEX, 2, (255, 0, 0), 2)\\n return self.frame\",\n \"def montage_tissues_axial(overlay_csf, overlay_wm, overlay_gm, underlay, png_name):\\n def determine_start_and_end(data, direction, percent):\\n x, y, z = data.shape\\n xx1 = 0\\n xx2 = x - 1\\n zz1 = 0\\n zz2 = z - 1\\n total_non_zero_voxels = len(np.nonzero(data.flatten())[0])\\n thresh = percent * float(total_non_zero_voxels)\\n start = None\\n end = None\\n if 'axial' in direction:\\n while(zz2 > 0):\\n d = len(np.nonzero(data[:, :, zz2].flatten())[0])\\n if float(d) > thresh:\\n break\\n zz2 -= 1\\n while(zz1 < zz2):\\n d = len(np.nonzero(data[:, :, zz1].flatten())[0])\\n if float(d) > thresh:\\n break\\n zz1 += 1\\n start = zz1\\n end = zz2\\n else:\\n while(xx2 > 0):\\n d = len(np.nonzero(data[xx2, :, :].flatten())[0])\\n if float(d) > thresh:\\n break\\n xx2 -= 1\\n while(xx1 < xx2):\\n d = len(np.nonzero(data[xx1, :, :].flatten())[0])\\n if float(d) > thresh:\\n break\\n xx1 += 1\\n start = xx1\\n end = xx2\\n return start, end\\n def get_spacing(across, down, dimension):\\n space = 10\\n prod = (across*down*space)\\n if prod > dimension:\\n while(across*down*space) > dimension:\\n space -= 1\\n else:\\n while(across*down*space) < dimension:\\n space += 1\\n return space\\n\\n import os\\n import matplotlib\\n import commands\\n# matplotlib.use('Agg')\\n import numpy as np\\n ###\\n try:\\n from mpl_toolkits.axes_grid1 import ImageGrid\\n except:\\n from mpl_toolkits.axes_grid import ImageGrid\\n import matplotlib.pyplot as plt\\n import matplotlib.colors as col\\n import nibabel as nb\\n import matplotlib.cm as cm\\n\\n Y = nb.load(underlay).get_data()\\n z1, z2 = determine_start_and_end(Y, 'axial', 0.0001)\\n spacing = get_spacing(6, 3, z2 - z1)\\n X_csf = nb.load(overlay_csf).get_data()\\n X_wm = nb.load(overlay_wm).get_data()\\n X_gm = nb.load(overlay_gm).get_data()\\n X_csf = X_csf.astype(np.float16)\\n X_wm = X_wm.astype(np.float16)\\n X_gm = X_gm.astype(np.float16)\\n Y = Y.astype(np.float16)\\n\\n max_csf = np.nanmax(np.abs(X_csf.flatten()))\\n X_csf[X_csf != 0.0] = max_csf\\n max_wm = np.nanmax(np.abs(X_wm.flatten()))\\n X_wm[X_wm != 0.0] = max_wm\\n max_gm = np.nanmax(np.abs(X_gm.flatten()))\\n X_gm[X_gm != 0.0] = max_gm\\n x, y, z = Y.shape\\n fig = plt.figure(1)\\n max_ = np.max(np.abs(Y))\\n grid = ImageGrid(fig, 111, nrows_ncols=(3, 6), share_all=True, aspect=True, cbar_mode=\\\"None\\\", direction=\\\"row\\\")\\n\\n zz = z1\\n for i in range(6*3):\\n\\n if zz >= z2:\\n break\\n\\n im = grid[i].imshow(np.rot90(Y[:, :, zz]), cmap=cm.Greys_r)\\n zz += spacing\\n\\n x, y, z = X_csf.shape\\n X_csf[X_csf == 0.0] = np.nan\\n X_wm[X_wm == 0.0] = np.nan\\n X_gm[X_gm == 0.0] = np.nan\\n print '~~', max_\\n\\n\\n zz = z1\\n im = None\\n for i in range(6*3):\\n\\n\\n if zz >= z2:\\n break\\n\\n im = grid[i].imshow(np.rot90(X_csf[:, :, zz]), cmap=cm.winter, alpha=0.7, vmin=0, vmax=max_csf) ###\\n im = grid[i].imshow(np.rot90(X_wm[:, :, zz]), cmap=cm.GnBu , alpha=0.7, vmin=0, vmax=max_wm)\\n im = grid[i].imshow(np.rot90(X_gm[:, :, zz]), cmap=cm.bwr, alpha=0.7, vmin=0, vmax=max_gm)\\n\\n grid[i].axes.get_xaxis().set_visible(False)\\n grid[i].axes.get_yaxis().set_visible(False)\\n zz += spacing\\n\\n cbar = grid.cbar_axes[0].colorbar(im)\\n\\n #plt.show()\\n plt.axis(\\\"off\\\")\\n png_name = str(os.path.join(os.getcwd(), png_name))\\n plt.savefig(png_name, dpi=300, bbox_inches='tight', )\\n plt.close()\\n\\n return png_name\",\n \"def align(self):\\n\\n # load the alignment parameters into the align_params object\\n self.align_params.load_params_from_file(self.input_file)\\n\\n # populate the score matrices based on the input parameters\\n self.populate_score_matrices()\\n\\n # perform a traceback and write the output to an output file\\n\\n ### FILL IN ###\",\n \"def make_minmax_overlay(imgpaths, do_align=False, rszFac=1.0, imgCache=None,\\n queue_mygauge=None,\\n bindataP=None):\\n # TODO: Implement with bbs_map\\n def load_image(imgpath):\\n if imgCache == None:\\n return misc.imread(imgpath, flatten=True)\\n elif bindataP != None:\\n (img, tag), isHit = imgCache.load_binarydat(imgpath, bindataP)\\n return img\\n else:\\n (img, imgpath), isHit = imgCache.load(imgpath)\\n return img\\n overlayMin, overlayMax = None, None\\n Iref = None\\n for path in imgpaths:\\n img = load_image(path)\\n if do_align and Iref == None:\\n Iref = img\\n elif do_align:\\n (H, img, err) = imagesAlign(img, Iref, fillval=0, rszFac=rszFac)\\n if (overlayMin == None):\\n overlayMin = img\\n else:\\n if overlayMin.shape != img.shape:\\n h, w = overlayMin.shape\\n img = resize_img_norescale(img, (w,h))\\n overlayMin = np.fmin(overlayMin, img)\\n if (overlayMax == None):\\n overlayMax = img\\n else:\\n if overlayMax.shape != img.shape:\\n h, w = overlayMax.shape\\n img = resize_img_norescale(img, (w,h))\\n overlayMax = np.fmax(overlayMax, img)\\n if queue_mygauge != None:\\n queue_mygauge.put(True)\\n\\n # HACK: To prevent auto-dynamic-rescaling bugs, where an all-white\\n # image is interpreted as all-black, artificially insert a 0.0 at (0,0).\\n # See: http://stefaanlippens.net/scipy_unscaledimsave\\n overlayMin[0,0] = 0.0\\n overlayMax[0,0] = 0.0\\n\\n return overlayMin, overlayMax\",\n \"def setup_annotation(self):\\n annotation = self.ax_fig.annotate(\\n '', xy=(0, 0), ha='left',\\n xytext=(-20, 20), textcoords='offset points', va='bottom',\\n bbox=dict(\\n boxstyle='round,pad=0.5', fc='yellow', alpha=0.2),\\n arrowprops=dict(\\n arrowstyle='->', connectionstyle='arc3,rad=0'))\\n return annotation\",\n \"def y_tick_label(self, y, size, offset=7, ax=None):\\n if ax is None:\\n ax = plt.gca()\\n if self.final_image is not None:\\n imagebox = OffsetImage(self.final_image, zoom=size)\\n ab = AnnotationBbox(\\n imagebox, (0, y),\\n xybox=(-offset, 0),\\n xycoords=('axes fraction', 'data'),\\n box_alignment=(1, .5),\\n boxcoords='offset points',\\n bboxprops={'edgecolor': 'none', 'facecolor': 'none'},\\n arrowprops={\\n 'arrowstyle': '-',\\n 'shrinkA': 0,\\n 'shrinkB': 1\\n },\\n pad=0.1)\\n ax.add_artist(ab)\\n zorder = ab.zorder\\n else:\\n zorder = 0\\n if self.marker:\\n if self.final_image is not None:\\n markersize = max(self.final_image.size)\\n else:\\n markersize = 50\\n markersize = markersize * size\\n d = DrawingArea(markersize, markersize)\\n if self.marker_front:\\n zorder_marker = zorder + 0.1\\n else:\\n zorder_marker = zorder - 0.1\\n d.set_zorder(zorder_marker)\\n d.set_alpha(0)\\n if self.marker_front:\\n d.add_artist(plt.Line2D(\\n [markersize / 2], [markersize / 2],\\n marker=self.marker, markeredgecolor=self.col,\\n markerfacecolor=(0, 0, 0, 0), markersize=markersize,\\n markeredgewidth=self.markeredgewidth,\\n transform=d.get_transform(),\\n zorder=zorder_marker))\\n else:\\n d.add_artist(plt.Line2D(\\n [markersize / 2], [markersize / 2],\\n marker=self.marker, markeredgecolor=self.col,\\n markerfacecolor=self.col, markersize=markersize,\\n markeredgewidth=self.markeredgewidth,\\n transform=d.get_transform(),\\n zorder=zorder_marker))\\n ab_marker = AnnotationBbox(\\n d, (0, y),\\n xybox=(-offset, 0),\\n xycoords=('axes fraction', 'data'),\\n box_alignment=(1, 0.5),\\n boxcoords='offset points',\\n bboxprops={'edgecolor': 'none', 'facecolor': 'none'},\\n arrowprops={\\n 'arrowstyle': '-',\\n 'shrinkA': 0,\\n 'shrinkB': 1\\n },\\n pad=0.1)\\n ab_marker.set_zorder(zorder_marker)\\n ab_marker.set_alpha(0)\\n ax.add_artist(ab_marker)\\n if self.string is not None:\\n ax.annotate(\\n self.string, (0, y),\\n xytext=(-offset, 0),\\n xycoords=('axes fraction', 'data'),\\n textcoords='offset points',\\n horizontalalignment='right',\\n verticalalignment='center',\\n arrowprops={\\n 'arrowstyle': '-',\\n 'shrinkA': 0,\\n 'shrinkB': 1\\n },\\n zorder=zorder + 1,\\n fontsize=self.fontsize, fontname=self.fontname,\\n color=self.fontcolor)\",\n \"def concat_images(imga, imgb, xoffset=0, yoffset=0, direction='horizontal',\\n ontop=True, adjust_z=False, center_offset=True):\\n if direction == 'horizontal':\\n max_dim = np.maximum.reduce([imga.shape, imgb.shape])\\n\\n center_a = np.array(np.divide(imga.shape, 2), dtype=int)\\n center_b = np.array(np.divide(imgb.shape, 2), dtype=int)\\n offset = (abs(yoffset), abs(xoffset))\\n\\n if center_offset:\\n new_offset = np.subtract(center_a, np.add(center_b, offset))\\n\\n if (max_dim == imgb.shape).all():\\n tmp = np.copy(imgb)\\n imgb = np.copy(imga)\\n imga = np.copy(tmp)\\n ontop = toggle(ontop)\\n xoffset *= -1\\n yoffset *= -1\\n\\n # elif not (max_dim == imga.shape).all():\\n # for i, m in enumerate(max_dim):\\n # if m not in imga.shape:\\n # new_offset[i] = center_a[i] - (center_b[i] + offset[i])\\n # else:\\n # new_offset[i] = center_a[i] + offset[i] - center_b[i]\\n\\n new_offset[new_offset > 0] = 0\\n center_new = np.array(np.divide(max_dim, 2), dtype=int)\\n new_img = np.full(np.add(max_dim, np.abs(new_offset)), np.nan)\\n\\n Sa0 = slice(int(center_new[0] - imga.shape[0]/2 + 0.5),\\n int(center_new[0] + imga.shape[0]/2 + 0.5))\\n Sa1 = slice(int(center_new[1] - imga.shape[1]/2 + 0.5),\\n int(center_new[1] + imga.shape[1]/2 + 0.5))\\n Sb0 = slice(int(center_new[0] + abs(yoffset) - imgb.shape[0]/2 + 0.5),\\n int(center_new[0] + abs(yoffset) + imgb.shape[0]/2 + 0.5))\\n Sb1 = slice(int(center_new[1] + abs(xoffset) - imgb.shape[1]/2 + 0.5),\\n int(center_new[1] + abs(xoffset) + imgb.shape[1]/2 + 0.5))\\n\\n xdir = np.sign(xoffset)\\n ydir = np.sign(yoffset)\\n\\n if ydir == 0:\\n ydir = 1\\n if xdir == 0:\\n xdir = 1\\n\\n imga = imga[::ydir, ::xdir]\\n imgb = imgb[::ydir, ::xdir]\\n\\n if adjust_z:\\n top_img = 1 * new_img\\n top_img[Sa0, Sa1] = imga\\n top_img[Sb0, Sb1] = imgb\\n low_img = 1 * new_img\\n low_img[Sb0, Sb1] = imgb\\n low_img[Sa0, Sa1] = imga\\n\\n diff = top_img - low_img\\n m = np.nanmean(diff)\\n s = np.nanstd(diff)\\n mask = np.abs(diff) < m + s\\n diff[mask] = np.nan\\n add = np.nanmean(diff)\\n\\n print(add)\\n\\n imgb -= add\\n\\n if ontop:\\n new_img[Sa0, Sa1] = imga\\n new_img[Sb0, Sb1] = imgb\\n else:\\n new_img[Sb0, Sb1] = imgb\\n new_img[Sa0, Sa1] = imga\\n\\n return new_img[::ydir, ::xdir]\",\n \"def layer_overlay(foreground, background):\\n overlaid = foreground.copy()\\n negative_space = np.where(foreground[:, :, 3] == 0)\\n\\n overlaid[negative_space] = background[negative_space]\\n\\n overlaid[:, :, 3] = 255\\n\\n return overlaid\",\n \"def convert_roi_align(g, op, block):\\n\\n rois = g.get_node(op.input(\\\"ROIs\\\")[0])\\n spatial_scale = op.attr(\\\"spatial_scale\\\")\\n if op.attr(\\\"aligned\\\"):\\n offset = _expr.const(0.5, dtype=\\\"float32\\\")\\n roi_offset = _op.divide(offset, _expr.const(spatial_scale, dtype=\\\"float32\\\"))\\n rois = _op.subtract(rois, roi_offset)\\n num_rois = infer_shape(rois)[0]\\n zero_node = _expr.const(0, dtype=\\\"int32\\\")\\n batch_index = _op.full(zero_node, [num_rois, 1], dtype=\\\"float32\\\")\\n rois = _op.concatenate([batch_index, rois], axis=1)\\n out = _op.vision.roi_align(\\n g.get_node(op.input(\\\"X\\\")[0]),\\n rois,\\n pooled_size=[op.attr(\\\"pooled_height\\\"), op.attr(\\\"pooled_width\\\")],\\n spatial_scale=spatial_scale,\\n sample_ratio=op.attr(\\\"sampling_ratio\\\"),\\n mode=\\\"avg\\\",\\n )\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def align(imgDim, rgbImg,\\n landmarks, landmarkIndices=INNER_EYES_AND_BOTTOM_LIP,\\n skipMulti=True):\\n assert imgDim is not None\\n assert rgbImg is not None\\n assert landmarks is not None\\n\\n #if bb is None:\\n # bb = self.getLargestFaceBoundingBox(rgbImg, skipMulti)\\n # if bb is None:\\n # return\\n\\n #if landmarks is None:\\n # landmarks = self.findLandmarks(rgbImg, bb)\\n\\n npLandmarks = np.float32(landmarks)\\n npLandmarkIndices = np.array(landmarkIndices)\\n\\n H = cv2.getAffineTransform(npLandmarks[npLandmarkIndices],\\n imgDim * MINMAX_TEMPLATE[npLandmarkIndices])\\n thumbnail = cv2.warpAffine(rgbImg, H, (imgDim, imgDim))\\n\\n return thumbnail\",\n \"def get_alignment_offset(self):\\n\\n return 0\",\n \"def plot_overlay2axes(self, axes) -> None:\\n # calculate height (based on leaf analysis ratio)\\n upper_point = (\\n self.leaf_center_px - self.leaf_width_px / 2 * self._analysis_ratio\\n )\\n lower_point = (\\n self.leaf_center_px + self.leaf_width_px / 2 * self._analysis_ratio\\n )\\n height = abs(upper_point - lower_point) * 0.8\\n\\n for idx, line in enumerate(self.marker_lines):\\n width = abs(self.error[idx]) * self._image.dpmm\\n y = line.center.y\\n x = self.position[idx] - (self.error[idx] * self._image.dpmm) / 2\\n\\n if self._orientation == Orientation.UP_DOWN:\\n r = Rectangle(width, height, center=(x, y))\\n # if any of the values are over tolerance, show another larger rectangle to draw the eye\\n if not self.passed[idx] or not self.passed_action[idx]:\\n re = Rectangle(\\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\\n )\\n re.plot2axes(\\n axes,\\n edgecolor=\\\"none\\\",\\n fill=True,\\n alpha=0.5,\\n facecolor=self.bg_color[idx],\\n )\\n else:\\n r = Rectangle(height, width, center=(x, y))\\n if not self.passed[idx] or not self.passed_action[idx]:\\n re = Rectangle(\\n self._image_window.shape[1] * 0.2, height * 1.2, center=(x, y)\\n )\\n re.plot2axes(\\n axes,\\n edgecolor=\\\"none\\\",\\n fill=True,\\n alpha=0.5,\\n facecolor=self.bg_color[idx],\\n )\\n r.plot2axes(\\n axes, edgecolor=\\\"none\\\", fill=True, alpha=1, facecolor=self.bg_color[idx]\\n )\",\n \"def get_annotation_box(self, pos, ax):\\n imagebox = OffsetImage(self.icon, zoom=0.04, cmap='gray')\\n imagebox.image.axes = ax\\n\\n if self.destination == self.location:\\n xy = pos[self.location]\\n\\n else:\\n weight = self.local_environment.graph.edges[self.location, self.destination][\\\"weight\\\"]\\n if False: #weight > 1000:\\n xy_from = pos[self.location]\\n xy_to = pos[self.destination]\\n pos_ratio = (weight - self.time_remaining_to_dest) / weight\\n xy = (1 - pos_ratio) * xy_from + pos_ratio * xy_to\\n else:\\n xy = pos[self.location]\\n\\n ab = AnnotationBbox(imagebox, xy,\\n xybox=(50, 50),\\n xycoords='data',\\n boxcoords=\\\"offset points\\\",\\n pad=0,\\n\\n arrowprops=dict(\\n arrowstyle=\\\"->\\\",\\n connectionstyle=\\\"angle,angleA=0,angleB=90,rad=3\\\")\\n )\\n ab.set_zorder(0)\\n ax.add_artist(ab)\",\n \"def SetToolAlignment(self, alignment=wx.EXPAND):\\r\\n\\r\\n self._tool_alignment = alignment\",\n \"def setPosition(self, rects):\\n\\t\\tif (rects==[]):\\n\\t\\t\\tself.obscured = True\\n\\t\\telse:\\n\\t\\t\\tself.prevPositions.append(self.position)\\n\\t\\t\\tself.position = [(rects[0],rects[1]),(rects[2],rects[3]),dt.datetime.now()]\\n\\t\\t\\tself.timeSinceDetection = 0\",\n \"def overlay_boxes(self, image, predictions):\\n for prediction in predictions:\\n template = ''\\n for idx in range(min(3, len(prediction['score']))):\\n template += \\\"{}:{:.2f},\\\".format(prediction['category'][idx], prediction['score'][idx])\\n color = [0, 0, 255]\\n top_left, bottom_right = prediction['bbox'][:2], prediction['bbox'][2:]\\n image = cv2.rectangle(\\n image, tuple(top_left), tuple(bottom_right), tuple(color), 1\\n )\\n cv2.putText(\\n image, template, (top_left[0], top_left[1]+15), cv2.FONT_HERSHEY_SIMPLEX, .6, tuple(color), 1\\n )\\n\\n return image\",\n \"def set_horizontal_alignment(self, value):\\n if self._simplecell:\\n self.fetch()\\n self.horizontal_alignment = value\\n return self\",\n \"def botStack_y(self):\\r\\n self.y_stack=self.img.shape[1]-1\\r\\n \\r\\n self.pixmap3=self.drawPixmap(\\\"xz\\\")\\r\\n self.lbl3.setPixmap(self.pixmap3)\\r\\n self.pixmap4= self.writeEdge(\\\"xz\\\")\\r\\n self.lbl4.setPixmap(self.pixmap4)\\r\\n self.y_stack_lbl.setText(str(self.y_stack+1) + '/' + str(self.img.shape[1]))\",\n \"def add_annotation_to_placement(self):\\n\\n config.switch_acm_ctx()\\n placcement_obj = ocp.OCP(\\n kind=constants.PLACEMENT_KIND,\\n resource_name=self.appset_placement_name,\\n namespace=\\\"openshift-gitops\\\",\\n )\\n placcement_obj.annotate(\\n annotation=\\\"cluster.open-cluster-management.io/experimental-scheduling-disable='true'\\\"\\n )\",\n \"def batch_align(image_list, dest_dir=\\\"output\\\"):\\n if not path.exists(dest_dir):\\n mkdir(dest_dir)\\n if path.isdir(dest_dir):\\n print \\\"Aligning %d images, output in %s, this may take a while\\\" % (len(im_list), dest_dir)\\n\\n ref_img = io.imread(image_list[0])\\n r = Parallel(n_jobs=4, backend=\\\"threading\\\", verbose=25)(\\n delayed(find_shift)(io.imread(img), ref_img) for img in image_list[1:])\\n y_shift = map(lambda x: x[0], r)\\n x_shift = map(lambda x: x[1], r)\\n\\n print min(y_shift), max(y_shift), min(x_shift), max(x_shift)\\n crop = [int(min(y_shift)) - 1, int(max(y_shift)) + 1, int(min(x_shift)) - 1, int(max(x_shift)) + 1]\\n\\n correct(ref_img, (0, 0), \\\"%s/%s\\\" % (dest_dir, path.basename(image_list[0])), crop)\\n Parallel(n_jobs=4, backend=\\\"threading\\\", verbose=25)(\\n delayed(correct)(io.imread(img), r[k], \\\"%s/%s\\\" % (dest_dir, path.basename(image_list[k])), crop)\\n for k, img in enumerate(image_list[1:]))\\n else:\\n print \\\"Output dir does not exists or is not a directory : %s\\\" % dest_dir\",\n \"def align_crop(img, landmarks, standard_landmarks, crop_size=572, face_factor=0.45, align_type='similarity', order=3,\\r\\n mode='edge'):\\r\\n interpolation = {0: cv2.INTER_NEAREST,\\r\\n 1: cv2.INTER_LINEAR,\\r\\n 2: cv2.INTER_AREA,\\r\\n 3: cv2.INTER_CUBIC,\\r\\n 4: cv2.INTER_LANCZOS4,\\r\\n 5: cv2.INTER_LANCZOS4}\\r\\n border = {'constant': cv2.BORDER_CONSTANT,\\r\\n 'edge': cv2.BORDER_REPLICATE,\\r\\n 'symmetric': cv2.BORDER_REFLECT,\\r\\n 'reflect': cv2.BORDER_REFLECT101,\\r\\n 'wrap': cv2.BORDER_WRAP}\\r\\n\\r\\n # check\\r\\n assert align_type in ['affine', 'similarity'], \\\\\\r\\n \\\" [!] Invalid 'align_type'! The {} is not included in ['affine' and 'similarity']!\\\".format(align_type)\\r\\n assert order in [0, 1, 2, 3, 4, 5], \\\\\\r\\n \\\" [!] Invalid 'order'! The {} is not included in [0, 1, 2, 3, 4, 5]!\\\".format(order)\\r\\n assert mode in ['constant', 'edge', 'symmetric', 'reflect', 'wrap'], \\\\\\r\\n \\\" [!] Invalid 'mode'! the {} is not included in ['constant', 'edge', 'symmetric', 'reflect', and 'wrap']\\\".format(mode)\\r\\n\\r\\n # crop size\\r\\n if isinstance(crop_size, (list, tuple)) and len(crop_size) == 2:\\r\\n crop_size_h = crop_size[0]\\r\\n crop_size_w = crop_size[1]\\r\\n elif isinstance(crop_size, int):\\r\\n crop_size_h = crop_size_w = crop_size\\r\\n else:\\r\\n raise Exception(\\\" [!] Invalid 'crop_size'! The 'crop_size' should be (1) one integer for (crop_size, crop_size) ar (2) (int, int) for (crop_size_h, crop_size_w)!\\\")\\r\\n\\r\\n # estimate transform matrix\\r\\n target_landmarks = standard_landmarks * max(crop_size_h, crop_size_w) * face_factor + np.array([crop_size_w // 2, crop_size_h // 2])\\r\\n if align_type == 'affine': # 6 degree of freedom\\r\\n transform_matrix, _ = cv2.estimateAffine2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\\r\\n else: # 4 degree of freedom: using the combinations of translation, rotation, and uniform scaling\\r\\n transform_matrix, _ = cv2.estimateAffinePartial2D(target_landmarks, landmarks, ransacReprojThreshold=np.Inf)\\r\\n\\r\\n # warp image by given transform\\r\\n img_crop = cv2.warpAffine(img, transform_matrix, dsize=(crop_size_w, crop_size_h),\\r\\n flags=cv2.WARP_INVERSE_MAP + interpolation[order], borderMode=border[mode])\\r\\n\\r\\n # get transformed landmarks\\r\\n transformed_landmarks = cv2.transform(np.expand_dims(landmarks, axis=0), m=cv2.invertAffineTransform(transform_matrix))\\r\\n\\r\\n return img_crop, transformed_landmarks\",\n \"def generate_overlay_images(self, overlay_name, x, y):\\n for tile in range(1, self.config.number_of_tiles + 1):\\n for time in self.config.time_points:\\n for depth in self.config.depth_points:\\n desc = self.config.tile_description_generator(tile, time, depth)\\n file_name = self._generate_overlay_file_name(self.well, overlay_name, desc)\\n self._generate_overlay(file_name, overlay_name + '-' + self.well + '-' + desc, x, y)\",\n \"def test_align_points(self):\\n mv = [\\n [0, 0, 5],\\n [5, 0, 5],\\n [0, 5, 5]\\n ]\\n sv = [\\n [0, 0, 0],\\n [5, 0, 0],\\n [0, 5, 0]\\n ]\\n al = align(self.amp1, self.amp2, mv=mv, sv=sv, method='contPoints').m\\n zMax = self.amp1.vert[:, 2].max() - 5\\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\\n self.assertAlmostEqual(al.vert[:, 2].max(), zMax, delta=TestAlign.DELTA)\",\n \"def overlay(main_params, output_params, drawing_params, manual_log_path=''):\\n \\n global doImg, doStack, doVideo\\n \\n exp_path = main_params[0]\\n bin_path = main_params[1]\\n vect_path = main_params[2] \\n dest_path = main_params[3] \\n verbose = main_params[4]\\n debug = main_params[5]\\n invert = main_params[6]\\n doImg, doStack, doVideo, compress = output_params\\n \\n if debug:\\n verbose = True\\n \\n # Log path determination\\n if manual_log_path:\\n log_path = manual_log_path\\n else: \\n log_path = os.path.join(dest_path, 'log.txt')\\n log_txt = ''\\n \\n # Creation of the dest directory if it doesn't exist\\n if not os.path.exists(dest_path):\\n os.mkdir(dest_path)\\n \\n start = time.time()\\n previous_step = start\\n txt = 'SUP> Loading binarized stack...'\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n # Binarized stack loading\\n bin_stack = tifffile.imread(bin_path) # loading the image as a numpy array\\n bin_stack = np.array(bin_stack, dtype=np.uint8) # dtype safeguard\\n if invert:\\n bin_stack = np.invert(bin_stack) \\n if debug:\\n txt = 'SUP> Binarized stack shape: {}'.format(bin_stack.shape)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n # Add third axis for single image \\n if len(bin_stack.shape)==2:\\n bin_stack = bin_stack[np.newaxis,:,:]\\n \\n slices_nb_bin = bin_stack.shape[0] \\n\\n # To differentiate slices with mycelium from those without\\n empty = []\\n thalle = np.zeros(slices_nb_bin)\\n for iSli in range(slices_nb_bin):\\n sli = bin_stack[iSli, :, :].astype(np.uint8)\\n thalle[iSli] = np.sum(sli)\\n \\n if thalle[iSli] <= 0: # empty slice\\n empty.append(iSli)\\n del bin_stack # not used anymore, del to free memory for the experimental stack\\n \\n if debug:\\n txt = 'SUP> Number of empty slices: {}'.format(len(empty))\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n previous_step = timer\\n txt = 'SUP> Loading grayscale stack...'\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n # Experimental stack loading (grayscale) \\n exp_stack = tifffile.imread(exp_path) # loading the image as a numpy array\\n exp_stack = np.array(exp_stack, dtype=np.uint8) # dtype safeguard\\n if debug:\\n txt = 'SUP> Grayscale stack shape: {}'.format(exp_stack.shape)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n # Add third axis for single image \\n if len(exp_stack.shape)==2:\\n exp_stack = exp_stack[np.newaxis,:,:]\\n slices_nb_exp, height, width = exp_stack.shape\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n previous_step = timer\\n txt = 'SUP> Loading graphs and checking alignment...'\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n # graphs loading and sorting\\n graphs = nu.preloadFiles(vect_path, ['.gpickle'], debug)\\n \\n # Adding elements in 'graphs' for lists alignment if not already aligned\\n if slices_nb_exp != len(graphs):\\n for index in empty:\\n graphs.insert(index, ('empty','empty')) \\n if debug:\\n txt = ('SUP> Length of graph list after alignment: {}'\\n .format(len(graphs)))\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n # Checking that all the lenghts are aligned \\n if slices_nb_bin == slices_nb_exp and slices_nb_exp == len(graphs):\\n pass # everything is aligned\\n else: \\n txt = ('ERROR: the number of slices in the binarized stack ({}), in '\\n 'the grayscale one({}), and the number of graphs ({}) are not '\\n 'equal.'.format(slices_nb_bin, slices_nb_exp, len(graphs)))\\n nu.writeLogAndExit(log_path, log_txt, txt)\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n previous_step = timer\\n txt = 'SUP> Preparing output...'\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n # Definition of the range of images to browse and process \\n rangeN = np.array([])\\n if doImg: # image creation: only one slice will be processed\\n if doImg >= 0: # select an image by its index\\n rangeN = np.array([doImg-1])\\n else: # select an image from backward\\n rangeN = np.array([doImg])\\n \\n if doVideo or doStack: # stack or video creation: all the slices must be processed\\n rangeN = range(slices_nb_exp)\\n frames = [] # list to save the frames of the stack tif\\n \\n if doVideo:\\n # Video output creation\\n fourcc = cv2.VideoWriter_fourcc(*'MJPG')\\n video = cv2.VideoWriter('video.avi', fourcc, 4, (width, height))\\n \\n if debug:\\n txt = 'SUP> rangeN: {}'.format(rangeN)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n time.sleep(1) # dirty hack to wait for the console output\\n previous_step = timer\\n start_process = timer\\n txt = 'SUP> Processing images...'\\n log_txt += txt + '\\\\n'\\n \\n # Slices processing, one by one\\n desc = 'SUP> Creating overlay'\\n for iSli in tqdm(rangeN, desc=desc, unit='slice', disable=not verbose):\\n\\n txt = ('SUP> Image {} of {}...'\\n .format(_computeIndex(iSli, slices_nb_exp), slices_nb_exp))\\n log_txt += txt + '\\\\n'\\n \\n image = exp_stack[iSli, :, :].astype(np.uint8) # gets the slice and converts it \\n DG = nx.read_gpickle(graphs[iSli][0]) # loading the graph\\n ovl = createImgOverlay(image, DG, drawing_params, thalle[iSli]) \\n \\n if not thalle[iSli]:\\n txt = 'SUP> This slice is empty.'.format(iSli+1, iSli)\\n log_txt += txt + '\\\\n'\\n\\n if doStack or doVideo:\\n if doStack:\\n frames.append(ovl)\\n if doVideo:\\n video.write(ovl)\\n else:\\n img_path = os.path.join(dest_path, graphs[iSli][1] + \\n '_superposition.png')\\n cv2.imwrite(img_path, ovl)\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\\n log_txt += txt + '\\\\n'\\n previous_step = timer\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-start_process)\\n log_txt += txt + '\\\\n'\\n previous_step = timer\\n\\n if doStack: \\n\\n txt = 'SUP> Creating tif stack...'\\n log_txt += txt + '\\\\n'\\n \\n # Writing tif stack\\n destination = os.path.join(dest_path, 'superpose.tif')\\n with tifffile.TiffWriter(destination) as tiff:\\n desc = 'SUP> Creating tif stack'\\n for i, frame in enumerate(tqdm(frames, total=len(frames), desc=desc,\\n unit='frame', disable=not verbose)):\\n txt = ('SUP> writing frame {} of {}'\\n .format(i+1, len(frames)))\\n log_txt += txt + '\\\\n'\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # color conversion for saving without cv2 \\n tiff.save(frame, compress=compress)\\n frames[i] = 0 # cleaning the frame once written to free up memory\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\\n log_txt += txt + '\\\\n'\\n previous_step = timer\\n \\n if doVideo:\\n time.sleep(1) # dirty hack to wait for the console output\\n txt = 'SUP> Cleaning video output...'\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n #cv2.destroyAllWindows()\\n video.release()\\n source = 'video.avi'\\n destination = os.path.join(dest_path, 'superpose.avi')\\n os.rename(source, destination)\\n \\n timer = time.time()\\n txt = 'SUP> ...done in {:.4f} s.'.format(timer-previous_step)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n previous_step = timer\\n \\n timer = time.time()\\n end = timer-start \\n time.sleep(1) # dirty hack to wait for the console output \\n txt = 'SUP> DONE in {:.0f} min {:.4f} s.'.format(end // 60, end % 60)\\n log_txt = nu.printAndUpdateLog(txt, log_txt, verbose)\\n \\n # Writing the log \\n with open(log_path, 'a+') as log:\\n log.write(log_txt)\",\n \"def GetAlignment(self):\\r\\n\\r\\n return self.alignment\",\n \"def _load_hover_annotation(self, index):\\n # Load object bounding boxes\\n \\n im_id, gable_bboxes = self.parse_line(index)\\n num_objs = len(gable_bboxes)\\n boxes = np.array(gable_bboxes, dtype=np.float32)\\n gt_classes = np.empty(num_objs, dtype=np.int32)\\n gt_classes.fill(1) # all bboxes are gables currently\\n overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)\\n overlaps[:,1] = 1.0 # all boxes are gables...\\n overlaps = scipy.sparse.csr_matrix(overlaps)\\n seg_areas = np.zeros((num_objs), dtype=np.float32)\\n for ix, bbox in enumerate(boxes):\\n print bbox\\n\\tx1 = bbox[0] - 1\\n\\ty1 = bbox[1] - 1\\n\\tx2 = bbox[2] - 1\\n\\ty2 = bbox[3] - 1\\n\\tseg_areas[ix] = (x2 - x1 + 1) * (y2 - y1 + 1)\\n print seg_areas[ix]\\n\\n return {'boxes' : boxes,\\n 'gt_classes': gt_classes,\\n 'gt_overlaps' : overlaps,\\n 'seg_areas': seg_areas,\\n 'flipped' : False}\",\n \"def overlay(self):\\n return self._overlay\",\n \"def align_images(self, translation_only=False):\\n # Extract feature point locations and descriptors.\\n points_and_descriptors = []\\n for file in self.files:\\n image = sol4_utils.read_image(file, 1)\\n self.images.append(image)\\n self.h, self.w = image.shape\\n pyramid, _ = sol4_utils.build_gaussian_pyramid(image, 3, PYR_FLT_LEVEL)\\n points_and_descriptors.append(find_features(pyramid))\\n\\n # Compute homographies between successive pairs of images.\\n Hs = []\\n for i in range(len(points_and_descriptors) - 1):\\n points1, points2 = points_and_descriptors[i][0], points_and_descriptors[i + 1][0]\\n desc1, desc2 = points_and_descriptors[i][1], points_and_descriptors[i + 1][1]\\n\\n # Find matching feature points.\\n ind1, ind2 = match_features(desc1, desc2, MATCH_MIN_SCORE)\\n points1, points2 = points1[ind1, :], points2[ind2, :]\\n\\n # Compute homography using RANSAC.\\n H12, inliers = ransac_homography(points1, points2,\\n RANSAC_ITER_NUM, RANAC_ERR_TOL,\\n translation_only)\\n\\n # Uncomment for debugging: display inliers and outliers among matching points.\\n # In the submitted code this function should be commented out!\\n if(self.display_match):\\n display_matches(self.images[i], self.images[i+1], points1 , points2, inliers)\\n\\n Hs.append(H12)\\n\\n # Compute composite homographies from the central coordinate system.\\n accumulated_homographies = accumulate_homographies(Hs, (len(Hs) - 1) // 2)\\n self.homographies = np.stack(accumulated_homographies)\\n self.frames_for_panoramas = filter_homographies_with_translation(self.homographies, minimum_right_translation=5)\\n print((self.frames_for_panoramas.shape))\\n self.homographies = self.homographies[self.frames_for_panoramas]\",\n \"def align(self):\\n features = np.load(self.cur_dir+'/'+'spec.npy', allow_pickle=True)\\n targets = np.load(self.cur_dir+'/'+'target.npy', allow_pickle=True)\\n \\n feat_num_frames = features.shape[0]\\n targ_num_frames = targets.shape[0]\\n \\n if feat_num_frames != targ_num_frames:\\n diff = feat_num_frames - targ_num_frames\\n if diff < 0:\\n targets = targets[:feat_num_frames, :]\\n else:\\n features = features[:targ_num_frames:, :]\\n \\n return features.shape, targets.shape\",\n \"def getPixelVisualCenter(self, altMap, aziMap):\\r\\n\\r\\n altPatch = self.array * altMap\\r\\n meanAlt = np.mean(altPatch[altPatch != 0])\\r\\n aziPatch = self.array * aziMap\\r\\n meanAzi = np.mean(aziPatch[aziPatch != 0])\\r\\n\\r\\n return meanAlt, meanAzi\",\n \"def aligned_landmarks(self):\\n landmarks = AlignerExtract().transform_points(self.landmarksXY,\\n self.aligned[\\\"matrix\\\"],\\n self.aligned[\\\"size\\\"],\\n self.aligned[\\\"padding\\\"])\\n return landmarks\",\n \"def GetAlignment(self):\\r\\n\\r\\n return self._flag\",\n \"def _overlay_text(\\n image_file_name, x_offset_from_left_px, y_offset_from_top_px,\\n text_string, font_size, use_north_gravity):\\n\\n command_string = '\\\"{0:s}\\\" \\\"{1:s}\\\"'.format(CONVERT_EXE_NAME, image_file_name)\\n if use_north_gravity:\\n command_string += ' -gravity North'\\n\\n command_string += (\\n ' -pointsize {0:d} -font \\\"{1:s}\\\" '\\n '-fill \\\"rgb(0, 0, 0)\\\" -annotate {2:+d}{3:+d} \\\"{4:s}\\\" \\\"{5:s}\\\"'\\n ).format(\\n font_size, TITLE_FONT_NAME,\\n x_offset_from_left_px, y_offset_from_top_px, text_string,\\n image_file_name\\n )\\n\\n exit_code = os.system(command_string)\\n if exit_code == 0:\\n return\\n\\n raise ValueError(imagemagick_utils.ERROR_STRING)\",\n \"def update(self):\\n rect = self.img_rect.center\\n self.font_img = self.font.render(self.text, True, color1)\\n self.img_rect = self.font_img.get_rect()\\n # self.img_rect.center = [self.title_img.get_width() + self.font_img.get_width()//2 + padding, 5*Y//8]\\n self.img_rect.center = rect\",\n \"def positionZoomed(self):\\n rect_size = self._image.get_rect()\\n\\n if rect_size.width > 720:\\n self.x = (int((720 - rect_size.width ) / 2))\\n\\n if rect_size.height > 720:\\n self.y = (int((720 - rect_size.height) / 2))\",\n \"def _get_cog_alignment(self, moving_slice_index, fixed_slice_index):\\n\\n if self._slices_voxel_counts[moving_slice_index] <= 0.0005 or \\\\\\n self._slices_voxel_counts[fixed_slice_index] <= 0.0005:\\n self._generate_identity_transformation(\\\\\\n self.f['transf_center'](mIdx=moving_slice_index,\\n fIdx=fixed_slice_index))\\n self._logger.info(\\\"Blank moving slice found. f=%d,m=%d .\\\" % \\\\\\n (moving_slice_index, fixed_slice_index))\\n self._logger.info(\\\"An identity transform will be applied.\\\")\\n return False\\n\\n cog_transform_getter = pos_wrappers.align_by_center_of_gravity(\\n fixed_image = self.f['src_gray'](idx=fixed_slice_index),\\n moving_image = self.f['src_gray'](idx=moving_slice_index),\\n output_transformation = \\\\\\n self.f['transf_center'](mIdx=moving_slice_index,\\n fIdx=fixed_slice_index))\\n return copy.deepcopy(cog_transform_getter)\",\n \"def setup_annotations(self):\\n sbd_path = get_data_path('sbd')\\n target_path = pjoin(self.root, 'SegmentationClass/pre_encoded')\\n if not os.path.exists(target_path): os.makedirs(target_path)\\n path = pjoin(sbd_path, 'dataset/train.txt')\\n sbd_train_list = tuple(open(path, 'r'))\\n sbd_train_list = [id_.rstrip() for id_ in sbd_train_list]\\n train_aug = self.files['train'] + sbd_train_list\\n\\n # keep unique elements (stable)\\n train_aug = [train_aug[i] for i in \\\\\\n sorted(np.unique(train_aug, return_index=True)[1])]\\n self.files['train_aug'] = train_aug\\n set_diff = set(self.files['val']) - set(train_aug) # remove overlap\\n self.files['train_aug_val'] = list(set_diff)\\n\\n pre_encoded = glob.glob(pjoin(target_path, '*.png'))\\n expected = np.unique(self.files['train_aug'] + self.files['val']).size\\n\\n if len(pre_encoded) != expected:\\n print(\\\"Pre-encoding segmentation masks...\\\")\\n for ii in tqdm(sbd_train_list):\\n lbl_path = pjoin(sbd_path, 'dataset/cls', ii + '.mat')\\n data = io.loadmat(lbl_path)\\n lbl = data['GTcls'][0]['Segmentation'][0].astype(np.int32)\\n lbl = m.toimage(lbl, high=lbl.max(), low=lbl.min())\\n m.imsave(pjoin(target_path, ii + '.png'), lbl)\\n\\n for ii in tqdm(self.files['trainval']):\\n fname = ii + '.png'\\n lbl_path = pjoin(self.root, 'SegmentationClass', fname)\\n lbl = self.encode_segmap(m.imread(lbl_path))\\n lbl = m.toimage(lbl, high=lbl.max(), low=lbl.min())\\n m.imsave(pjoin(target_path, fname), lbl)\\n\\n assert expected == 9733, 'unexpected dataset sizes'\",\n \"def overlay_time_series(movie_info, time_series_data_path, output_dir, mouse_type):\\n if mouse_type is None:\\n print 'Error: Must provide --mouse_type when using overlay_time_series.'\\n sys.exit(1)\\n\\n #Place animation and overlay in two separate folders\\n output_dir = '/'.join(output_dir.split('/')[:-1])\\n overlay_dir = output_dir + '/Overlay/Standardized_post_SfN_aligned/'\\n animation_dir = output_dir + '/Time_Series_Animation/Standardized_post_Sfn_aligned/'\\n check_dir(overlay_dir)\\n check_dir(animation_dir)\\n\\n\\n #Generate animation of time series\\n format = '.mp4'\\n animation_filename = animation_dir + key + format\\n print \\\"animation_filename\\\", animation_filename\\n if not os.path.isfile(animation_filename):\\n make_time_series_animation(movie_info, animation_dir, \\n time_series_data_path,\\n mouse_type, format)\\n else:\\n print \\\"Animation file already exists: \\\", key\\n\\n #Overlay animation in corner of behavior video\\n movie_file = movie_info['movie_file']\\n overlay_filename = overlay_dir + key + format\\n if not os.path.isfile(overlay_filename):\\n start_time = movie_info['start_time']\\n\\n cmd = 'ffmpeg -ss '+str(start_time)+' -i '+movie_file+' -i '+animation_filename+' -filter_complex \\\\\\\"[0:v] setpts=PTS-STARTPTS, scale=640x480 [background]; [1:v] setpts=PTS-STARTPTS, scale=100x200 [upperleft]; [background][upperleft] overlay=shortest=1\\\\\\\" -c:v libx264 -y '+overlay_filename\\n args = shlex.split(cmd)\\n print args\\n p = subprocess.Popen(args, shell=False)\\n p.wait()\\n else:\\n print \\\"Overlay file already exists: \\\", key\\n\\n\\n return overlay_filename\",\n \"def align(self, align='left'):\\n if align not in ['left', 'center', 'right', 'full']:\\n raise ValueError('align must be \\\\'left\\\\', \\\\'center\\\\', \\\\'right\\\\' or \\\\'full\\\\'')\\n else:\\n self._write(self.__class__.__ESC + 'a' + self.__class__.__alignMap[align])\",\n \"def overlay_boxes(self, image, predictions):\\n labels = predictions.get_field(\\\"labels\\\")\\n boxes = predictions.bbox\\n\\n colors = self.compute_colors_for_labels(labels).tolist()\\n\\n for box, color in zip(boxes, colors):\\n box = box.to(torch.int64)\\n top_left, bottom_right = box[:2].tolist(), box[2:].tolist()\\n image = cv2.rectangle(\\n image, tuple(top_left), tuple(bottom_right), tuple(color), 1\\n )\\n\\n return image\",\n \"def overlay_boxes(self, image, predictions):\\n labels = predictions.get_field(\\\"labels\\\")\\n boxes = predictions.bbox\\n\\n colors = self.compute_colors_for_labels(labels).tolist()\\n\\n for box, color in zip(boxes, colors):\\n box = box.to(torch.int64)\\n top_left, bottom_right = box[:2].tolist(), box[2:].tolist()\\n image = cv2.rectangle(\\n image, tuple(top_left), tuple(bottom_right), tuple(color), 1\\n )\\n\\n return image\",\n \"def align(self):\\n return self[\\\"align\\\"]\",\n \"def align(self):\\n return self[\\\"align\\\"]\",\n \"def align(self):\\n return self[\\\"align\\\"]\",\n \"def minimal_align(self):\\n desired = int(PlatformVar(\\\"align\\\"))\\n for ii in range(len(self.__content)):\\n line = self.__content[ii]\\n match = re.match(r'.*\\\\.align\\\\s+(\\\\d+).*', line)\\n if match:\\n align = int(match.group(1))\\n # Due to GNU AS compatibility modes, .align may mean different things.\\n if osarch_is_amd64 or osarch_is_ia32():\\n if desired != align:\\n if is_verbose():\\n print(\\\"Replacing %i-byte alignment with %i-byte alignment.\\\" % (align, desired))\\n self.__content[ii] = \\\" .balign %i\\\\n\\\" % (desired)\\n else:\\n print(\\\"Replacing low-order bit alignment %i with %i-byte alignment.\\\" % (align, desired))\\n self.__content[ii] = \\\" .balign %i\\\\n\\\" % (desired)\",\n \"def set_overlay(self, image_path):\\n if not osp.isfile(image_path):\\n raise ValueError(\\\"Invalid background image '{}'\\\".format(image_path))\\n self._overlay_image = image_path\\n self._final = None # Force rebuild\",\n \"def make_overlay(proba_map, max_alpha=.8):\\n prob_overlay = np.ones(proba_map.shape + (4,))\\n prob_overlay[..., [0, 1]] = 0\\n prob_overlay[..., 3] = proba_map * max_alpha\\n return prob_overlay\",\n \"def adjust_position(self):\\n\\n # Adjust position for x-axis\\n r = self.rect.x % 30\\n if r != 0:\\n if r <= 16:\\n x = self.rect.x - r\\n else:\\n x = self.rect.x + (30 - r)\\n\\n else:\\n x = self.rect.x\\n\\n # Adjust position for y-axis\\n r = self.rect.y % 30\\n if r != 0:\\n if r <= 16:\\n y = self.rect.y - r\\n else:\\n y = self.rect.y + (30 - r)\\n else:\\n y = self.rect.y\\n\\n return x, y\",\n \"def setTranslationsInTiltSeries(self, TiltSeries_):\\n for (kk, proj) in enumerate(TiltSeries_._ProjectionList._list):\\n proj.setAlignmentTransX(self._alignmentTransX[kk])\\n proj.setAlignmentTransY(self._alignmentTransY[kk])\",\n \"def _rotate_img(self, results):\\n angle = self.angle\\n height, width = results['img_shape'][:2]\\n center = ((width - 1) * 0.5, (height - 1) * 0.5)\\n\\n # Compute rotation matrix\\n mat_rotation = cv2.getRotationMatrix2D(center, -angle, 1)\\n\\n # Compute height and width of new image after rotation\\n cos = np.abs(mat_rotation[0, 0])\\n sin = np.abs(mat_rotation[0, 1])\\n width_new = height * sin + width * cos\\n height_new = height * cos + width * sin\\n mat_rotation[0, 2] += (width_new - width) * 0.5\\n mat_rotation[1, 2] += (height_new - height) * 0.5\\n width_new = int(np.round(width_new))\\n height_new = int(np.round(height_new))\\n \\n # Rotate image\\n img_rotation = cv2.warpAffine(results['img'], mat_rotation, (width_new, height_new),\\n borderValue=self.borderValue)\\n results['img'] = img_rotation\\n results['img_shape'] = results['img'].shape\\n\\n # Rotate corresponding annotations: all boxes in bbox_fields\\n for key in results.get('bbox_fields', []):\\n gt_boxes_ret = []\\n for poly in results[key]:\\n rot_array = []\\n poly_length = len(poly)\\n\\n if poly_length == 4:\\n poly = [poly[0], poly[1], poly[2], poly[1], poly[2], poly[3], poly[0], poly[3]]\\n\\n # Convert to np.array of shape (:, 2)\\n for i in range(0, len(poly), 2):\\n rot_array.append(np.array([poly[i], poly[i + 1]]))\\n\\n # Rotate corresponding annotations\\n rot_array = np.array([rot_array])\\n rot_array = cv2.transform(rot_array, mat_rotation).squeeze().reshape(len(poly))\\n\\n if poly_length == 4:\\n x_coords = rot_array[0::2]\\n y_coords = rot_array[1::2]\\n rot_array = np.array([\\n np.min(x_coords),\\n np.min(y_coords),\\n np.max(x_coords),\\n np.max(y_coords)\\n ])\\n\\n gt_boxes_ret.append(rot_array)\\n if len(results[key]) > 0:\\n results[key] = gt_boxes_ret\\n\\n # Rotate gt_bboxes according to gt_poly_bboxes\\n if 'gt_bboxes' in results and 'gt_poly_bboxes' in results:\\n gt_bboxes = []\\n gt_bboxes_ignore = []\\n\\n for poly in results['gt_poly_bboxes']:\\n poly = np.array(poly, dtype=np.double)\\n x_coords = poly[0::2]\\n y_coords = poly[1::2]\\n aligned_poly = [\\n np.min(x_coords),\\n np.min(y_coords),\\n np.max(x_coords),\\n np.max(y_coords)\\n ]\\n gt_bboxes.append(aligned_poly)\\n\\n for poly in results['gt_poly_bboxes_ignore']:\\n poly = np.array(poly, dtype=np.double)\\n x_coords = poly[0::2]\\n y_coords = poly[1::2]\\n aligned_poly = [\\n np.min(x_coords),\\n np.min(y_coords),\\n np.max(x_coords),\\n np.max(y_coords)\\n ]\\n gt_bboxes_ignore.append(aligned_poly)\\n\\n if len(gt_bboxes) == 0:\\n gt_bboxes = np.zeros((0, 4), dtype=np.float32)\\n else:\\n gt_bboxes = np.array(gt_bboxes, dtype=np.float32)\\n\\n if len(gt_bboxes_ignore) == 0:\\n gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)\\n else:\\n gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)\\n\\n results['gt_bboxes'] = gt_bboxes\\n results['gt_bboxes_ignore'] = gt_bboxes_ignore\\n\\n # Rotate corresponding annotations: all boxes in cbbox_fields\\n for key in results.get('cbbox_fields', []):\\n gt_cboxes_ret = []\\n for instance in results[key]:\\n tmp_cboxes = []\\n for poly in instance:\\n rot_array = []\\n # Convert to np.array of shape (:, 2)\\n for i in range(0, len(poly), 2):\\n rot_array.append(np.array([poly[i], poly[i + 1]]))\\n rot_array = np.array([rot_array])\\n # Rotate corresponding annotations\\n rot_array = cv2.transform(rot_array, mat_rotation).squeeze().reshape(len(poly))\\n tmp_cboxes.append(rot_array)\\n gt_cboxes_ret.append(tmp_cboxes)\\n results[key] = gt_cboxes_ret\\n\\n # Rotate corresponding annotations: all masks in mask_fields\\n for key in results.get('mask_fields', []):\\n mask = results[key].masks.transpose((1, 2, 0))\\n if len(results[key].masks) == 0:\\n results[key] = results[key].resize((height_new, width_new))\\n else:\\n # Rotate mask\\n mask_rotation = cv2.warpAffine(mask, mat_rotation, (width_new, height_new),\\n borderValue=self.borderValue)\\n if mask_rotation.ndim == 2:\\n # case when only one mask, (h, w)\\n mask_rotation = mask_rotation[:, :, None] # (h, w, 1)\\n mask_rotation = mask_rotation.transpose((2, 0, 1))\\n results[key].masks = mask_rotation\\n results[key].height = height_new\\n results[key].width = width_new\",\n \"def setPosition(self):\\n self.data['pos-x'] = \\\"%s\\\" % self.x()\\n self.data['pos-y'] = \\\"%s\\\" % self.y()\",\n \"def get_aligned_image(self):\\n lines = self.find_lines()\\n self.rotate_crop_scale(lines)\\n\\n return self.image\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6678817","0.5036174","0.49780422","0.49720982","0.49529678","0.4905251","0.48996106","0.48916376","0.48693442","0.4828346","0.48276195","0.4773495","0.46798646","0.46748582","0.46645558","0.46387076","0.4636476","0.46264026","0.46152508","0.45992303","0.45765504","0.45659605","0.45617044","0.45574224","0.4540644","0.45254353","0.45201355","0.45130104","0.45100617","0.45033917","0.44853285","0.44819096","0.44767308","0.44659814","0.44625613","0.4451137","0.4447519","0.44470602","0.4439394","0.44374612","0.44101453","0.44076994","0.44076994","0.44076994","0.4407034","0.44040942","0.4401994","0.43954277","0.43945536","0.43855885","0.43787202","0.43619496","0.43569478","0.435532","0.43468115","0.43433207","0.4339965","0.43230763","0.4318536","0.4313676","0.4313655","0.4311661","0.4301412","0.42993107","0.42860225","0.42782986","0.42680168","0.42565426","0.42562428","0.4249586","0.42488077","0.4247655","0.4244623","0.42340046","0.42323843","0.4224703","0.4217399","0.4206792","0.4202858","0.42011827","0.41951898","0.41926125","0.41877338","0.41812932","0.4164851","0.41594","0.41591907","0.41561142","0.41561142","0.4153302","0.4153302","0.4153302","0.41493598","0.414682","0.41405126","0.41391528","0.41373304","0.41369793","0.41368684","0.41261157"],"string":"[\n \"0.6678817\",\n \"0.5036174\",\n \"0.49780422\",\n \"0.49720982\",\n \"0.49529678\",\n \"0.4905251\",\n \"0.48996106\",\n \"0.48916376\",\n \"0.48693442\",\n \"0.4828346\",\n \"0.48276195\",\n \"0.4773495\",\n \"0.46798646\",\n \"0.46748582\",\n \"0.46645558\",\n \"0.46387076\",\n \"0.4636476\",\n \"0.46264026\",\n \"0.46152508\",\n \"0.45992303\",\n \"0.45765504\",\n \"0.45659605\",\n \"0.45617044\",\n \"0.45574224\",\n \"0.4540644\",\n \"0.45254353\",\n \"0.45201355\",\n \"0.45130104\",\n \"0.45100617\",\n \"0.45033917\",\n \"0.44853285\",\n \"0.44819096\",\n \"0.44767308\",\n \"0.44659814\",\n \"0.44625613\",\n \"0.4451137\",\n \"0.4447519\",\n \"0.44470602\",\n \"0.4439394\",\n \"0.44374612\",\n \"0.44101453\",\n \"0.44076994\",\n \"0.44076994\",\n \"0.44076994\",\n \"0.4407034\",\n \"0.44040942\",\n \"0.4401994\",\n \"0.43954277\",\n \"0.43945536\",\n \"0.43855885\",\n \"0.43787202\",\n \"0.43619496\",\n \"0.43569478\",\n \"0.435532\",\n \"0.43468115\",\n \"0.43433207\",\n \"0.4339965\",\n \"0.43230763\",\n \"0.4318536\",\n \"0.4313676\",\n \"0.4313655\",\n \"0.4311661\",\n \"0.4301412\",\n \"0.42993107\",\n \"0.42860225\",\n \"0.42782986\",\n \"0.42680168\",\n \"0.42565426\",\n \"0.42562428\",\n \"0.4249586\",\n \"0.42488077\",\n \"0.4247655\",\n \"0.4244623\",\n \"0.42340046\",\n \"0.42323843\",\n \"0.4224703\",\n \"0.4217399\",\n \"0.4206792\",\n \"0.4202858\",\n \"0.42011827\",\n \"0.41951898\",\n \"0.41926125\",\n \"0.41877338\",\n \"0.41812932\",\n \"0.4164851\",\n \"0.41594\",\n \"0.41591907\",\n \"0.41561142\",\n \"0.41561142\",\n \"0.4153302\",\n \"0.4153302\",\n \"0.4153302\",\n \"0.41493598\",\n \"0.414682\",\n \"0.41405126\",\n \"0.41391528\",\n \"0.41373304\",\n \"0.41369793\",\n \"0.41368684\",\n \"0.41261157\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7055731"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76588,"cells":{"query":{"kind":"string","value":"Gets the overlay_scale of this GIFOutput."},"document":{"kind":"string","value":"def overlay_scale(self):\n return self._overlay_scale"},"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_scale(self):\n\n if not hasattr(self, \"scale\"):\n raise NotImplementedError(\"\"\"All end-use subclasses of Color should define\n a get_scale method.\"\"\")\n\n return self.scale","def scale(self):\n return self._scale","def scaling(self):\n return self._scaling","def scaling(self):\n return self._scaling","def scaling(self):\n return self.__scaling","def scale(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"scale\")","def get_loss_scale(self):\n return self._loss_scale","def scale_value(self):\n return self._scale_value[2]","def getScale(self):\n return _libsbml.Unit_getScale(self)","def scale(self) -> Tuple[float, float]:\n return self._scale","def scale_parameter(self):\n return self._scale_parameter","def showscale(self):\n return self[\"showscale\"]","def scale(self):\n return self._gev_bijector.scale","def GetScale(self):\n ...","def scale(self):\n return self.scale_factor / CONSTANTS.AU","def colorscale(self):\n return self[\"colorscale\"]","def colorscale(self):\n return self['colorscale']","def showscale(self):\n return self['showscale']","def get_scale(self):\r\n try: return self.scale[0], self.scale[1], self.scale[2]\r\n except: return self.scale, self.scale, self.scale","def scale(self):\n return self._a","def img_scale(self):\n return min(400, abs(self.size))","def scaling(self):\n return self.stacked._box_scaling[1]","def get_scale_op(self):\n\t\treturn self.variables.get('scale')","def getnscale(self):\n return self.nscale","def scale(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"scale\")","def loss_scale(self):\n return self._loss_scale","def scale(self) -> Optional[pulumi.Input['ScaleArgs']]:\n return pulumi.get(self, \"scale\")","def reversescale(self):\n return self[\"reversescale\"]","def scaling_adjustment(self):\n return self._scaling_adjustment","def getScale(self):\n return self.factor**self.turnOn","def reversescale(self):\n return self['reversescale']","def overlay_scale(self, overlay_scale):\n allowed_values = [\"fit\", \"fill\", \"none\"]\n if overlay_scale not in allowed_values:\n raise ValueError(\n \"Invalid value for `overlay_scale` ({0}), must be one of {1}\"\n .format(overlay_scale, allowed_values)\n )\n\n self._overlay_scale = overlay_scale","def get_instr_rescale(self):\n if self.gamepad is None: \n return self._harp_rescale_\n else:\n return self._gamepad_rescale_","def amplitude_scale(self):\n return self._amplitude_scale","def parallel_scale(self):\n return self.camera.parallel_scale","def pixel_scale(self):\n return np.abs(float(self.header[\"CDELT1\"]))","def get_zoom(self) -> float:\n transform = self.transform()\n cur_scale = (transform.m11(), transform.m22())\n return float(f\"{cur_scale[0] - 1.0:0.2f}\")","def _get_scaling(root):\n dpi = root.winfo_fpixels(\"1i\")\n scaling = dpi / 72.0\n logger.debug(\"dpi: %s, scaling: %s'\", dpi, scaling)\n return scaling","def autocolorscale(self):\n return self[\"autocolorscale\"]","def auto_scale_factor(self):\r\n return self.gref.auto_scale_factor","def get_scaling(self):\n if self.constrain_navigation:\n self.activate_navigation_constrain()\n return self.sx, self.sy","def get_scale():\r\n\r\n \r\n return 0.5","def scale_settings(self) -> pulumi.Output[Optional['outputs.ScaleSettingsResponse']]:\n return pulumi.get(self, \"scale_settings\")","def scale_settings(self) -> Optional['outputs.DeploymentScaleSettingsResponse']:\n return pulumi.get(self, \"scale_settings\")","def overlay(self):\n return self._overlay","def scale(self):\n return self.distribution.scale","def autocolorscale(self):\n return self['autocolorscale']","def getscales(self):\n return self.scales","def imageScale(scale):\n\t\treturn max(1, int(scale * (InterfaceTools.getCanvasSize()[0] / height)))","def getScale(self):\n \n dag_node = OpenMaya.MFnDagNode(self.thisObj)\n transform_node = OpenMaya.MFnTransform(dag_node.parent( 0 ))\n \n util = OpenMaya.MScriptUtil()\n util.createFromDouble(0.0, 0.0, 0.0)\n pointeur = util.asDoublePtr()\n transform_node.getScale(pointeur)\n \n sx = util.getDoubleArrayItem(pointeur, 0)\n sy = util.getDoubleArrayItem(pointeur, 1)\n sz = util.getDoubleArrayItem(pointeur, 2)\n\n return sx, sy, sz","def get_scale_anchor(self):\n return self.anchor_position_scale","def rolloff_scale(self):\n return self._rolloffscale","def scale_settings(self) -> Optional[pulumi.Input['ScaleSettingsArgs']]:\n return pulumi.get(self, \"scale_settings\")","def GetUserScale(*args, **kwargs):\n return _gdi_.DC_GetUserScale(*args, **kwargs)","def getScaled(self, scaleFactor=None):\n\t\tscaledSize = self.getScaledSize(scaleFactor)\n\n\t\tif min(scaledSize) > 0:\n\t\t\treturn self.currentPixbuf.scale_simple(scaledSize[0],\n\t\t\t\tscaledSize[1], gtk.gdk.INTERP_BILINEAR)\n\t\telse:\n\t\t\treturn gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, 1, 1)","def scaling(self) -> Optional['outputs.AiFeatureStoreOnlineServingConfigScaling']:\n return pulumi.get(self, \"scaling\")","def max_scale_image(self):\n maximum = np.argmax(self.transform, 0)\n return self.scale_array[maximum] * (self.support.sum(0) > 0)","def pix_size(self):\n return self._pix_size","def doppler_scale(self):\n return self._dopplerscale","def castSize(self, scale):\n return self.camera.sensorSize * scale","def _get_zoom(self) :\n \n # TODO : make it absolute zoom value : a zoom of 1 displays one data\n # pixel in one viewport pixel.\n \n return self._zoom","def get_scale_parameter(self):\n\n if self.scale_parameter == 0.0:\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\n return self.scale_parameter\n else:\n return self.scale_parameter","def fraction_full_scale(self):\n return self._fraction_full_scale","def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"max_scale_down_percentage\")","def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"max_scale_down_percentage\")","def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"max_scale_down_percentage\")","def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\n return pulumi.get(self, \"max_scale_down_percentage\")","def get_display_px(self):\n return self.image.size","def GetLogicalScale(*args, **kwargs):\n return _gdi_.DC_GetLogicalScale(*args, **kwargs)","def scaling_object(self):\n return self.__scaling_object","def plate_scale(self):\n\n return 206265 * uu.arcsec / (self.diameter.to('mm') * self.f)","def _get_target_scale(self, im_size_min, im_size_max, target_size, max_size):\n im_scale = float(target_size) / float(im_size_min)\n # Prevent the biggest axis from being more than max_size\n if np.round(im_scale * im_size_max) > max_size:\n im_scale = float(max_size) / float(im_size_max)\n return im_scale","def auto_scaling(self):\n return self.container['auto_scaling']","def get_scale_parameter(self):\r\n \r\n if self.scale_parameter == 0.0: \r\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\r\n gamma_func = special.gamma(shape_in_gamma_func)\r\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\r\n return self.scale_parameter\r\n else:\r\n return self.scale_parameter","def zoom(self):\n return self['zoom']","def scaling_config(self) -> pulumi.Output[Optional['outputs.EventSourceMappingScalingConfig']]:\n return pulumi.get(self, \"scaling_config\")","def interpolation(self):\n return self._image.interpolation","def get_size(self):\n return self._surf.get_size()","def minmax(self):\n return self._data_lim[self._n_overlay - 1]","def get_apply_scale(self, applyScaleFactor, scale_quality = 1.0):\n v = self.scale * self.scale_quality * scale_quality\n if applyScaleFactor:\n v *= self.scale_factor\n return v","def getValues(self):\n return [self.scale_min, self.scale_max]","def zoom(self) -> float:\n return self._zoom","def zoom(self):\n return self.container['zoom']","def max_zoom(self) -> float:\n return math.log(np.min(self.canvas_size) / REGION_DIM)","def temperature_scale(self) -> str:\r\n self._logger.debug(log_message_formatter(\r\n \"get\", f\"{self}\", \"temperature_scale\"))\r\n return self._temperature_scale","def scale(self):","def gpix(self):\n return self._gpix","def scaling_factor(self):\n bin_scale = self.spabins * self.spebins\n return bin_scale * self.int_time","def size(self) -> (float, float):\n\n return self.screen.get_surface().get_size()","def zoom(self):\n res = np.max(self.metadata[\"resolution\"])\n\n if self.atlas_name == \"allen_human_500um\":\n logger.debug(\n \"ATLAS: setting zoom manually for human atlas, atlas needs fixing\"\n )\n return 350\n else:\n return 40 / res","def _get_image_size(self):\n return (3, 224, 224)","def get_scale_parameter(self):\n\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self._scale_parameter = self._mean_fire_recurrence / gamma_func","def ratio(self):\n return float(self.max_width) / self.max_height","def unsetScale(self):\n return _libsbml.Unit_unsetScale(self)","def get_scale_factor(rec, stack):\n \n rec_pixel_size = get_pixel_size_rec(rec)\n stack_pixel_size = get_pixel_size_stack(stack)\n \n return rec_pixel_size / stack_pixel_size","def _get_scale_from_magzp(self, magzp):\n scale = 10.0**( 0.4*(self['magzp_ref']-magzp) )\n return scale","def max_capacity_per_scale(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"max_capacity_per_scale\")","def get_scaled_value_at(self, offset):\r\n return self.get_scaled_value(self.get_value_at(offset))","def getxscale(self) -> int:\n if not self.debug:\n # TODO: Verificar\n self.myFieldFox.write(\"TRAC:SPEC:AMPL:SCAL?\")\n ret = self.myFieldFox.read()\n else:\n ret = 'LOG'\n return ret","def _get_image_scale_subfolder(self):\n if self.im_scale <= 0.25:\n if self.im_scale <= 0.125:\n return \"Rectified_rescaled/0.125/\"\n else:\n return \"Rectified_rescaled/0.25/\"\n else:\n return \"Rectified/\""],"string":"[\n \"def get_scale(self):\\n\\n if not hasattr(self, \\\"scale\\\"):\\n raise NotImplementedError(\\\"\\\"\\\"All end-use subclasses of Color should define\\n a get_scale method.\\\"\\\"\\\")\\n\\n return self.scale\",\n \"def scale(self):\\n return self._scale\",\n \"def scaling(self):\\n return self._scaling\",\n \"def scaling(self):\\n return self._scaling\",\n \"def scaling(self):\\n return self.__scaling\",\n \"def scale(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def get_loss_scale(self):\\n return self._loss_scale\",\n \"def scale_value(self):\\n return self._scale_value[2]\",\n \"def getScale(self):\\n return _libsbml.Unit_getScale(self)\",\n \"def scale(self) -> Tuple[float, float]:\\n return self._scale\",\n \"def scale_parameter(self):\\n return self._scale_parameter\",\n \"def showscale(self):\\n return self[\\\"showscale\\\"]\",\n \"def scale(self):\\n return self._gev_bijector.scale\",\n \"def GetScale(self):\\n ...\",\n \"def scale(self):\\n return self.scale_factor / CONSTANTS.AU\",\n \"def colorscale(self):\\n return self[\\\"colorscale\\\"]\",\n \"def colorscale(self):\\n return self['colorscale']\",\n \"def showscale(self):\\n return self['showscale']\",\n \"def get_scale(self):\\r\\n try: return self.scale[0], self.scale[1], self.scale[2]\\r\\n except: return self.scale, self.scale, self.scale\",\n \"def scale(self):\\n return self._a\",\n \"def img_scale(self):\\n return min(400, abs(self.size))\",\n \"def scaling(self):\\n return self.stacked._box_scaling[1]\",\n \"def get_scale_op(self):\\n\\t\\treturn self.variables.get('scale')\",\n \"def getnscale(self):\\n return self.nscale\",\n \"def scale(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def loss_scale(self):\\n return self._loss_scale\",\n \"def scale(self) -> Optional[pulumi.Input['ScaleArgs']]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def reversescale(self):\\n return self[\\\"reversescale\\\"]\",\n \"def scaling_adjustment(self):\\n return self._scaling_adjustment\",\n \"def getScale(self):\\n return self.factor**self.turnOn\",\n \"def reversescale(self):\\n return self['reversescale']\",\n \"def overlay_scale(self, overlay_scale):\\n allowed_values = [\\\"fit\\\", \\\"fill\\\", \\\"none\\\"]\\n if overlay_scale not in allowed_values:\\n raise ValueError(\\n \\\"Invalid value for `overlay_scale` ({0}), must be one of {1}\\\"\\n .format(overlay_scale, allowed_values)\\n )\\n\\n self._overlay_scale = overlay_scale\",\n \"def get_instr_rescale(self):\\n if self.gamepad is None: \\n return self._harp_rescale_\\n else:\\n return self._gamepad_rescale_\",\n \"def amplitude_scale(self):\\n return self._amplitude_scale\",\n \"def parallel_scale(self):\\n return self.camera.parallel_scale\",\n \"def pixel_scale(self):\\n return np.abs(float(self.header[\\\"CDELT1\\\"]))\",\n \"def get_zoom(self) -> float:\\n transform = self.transform()\\n cur_scale = (transform.m11(), transform.m22())\\n return float(f\\\"{cur_scale[0] - 1.0:0.2f}\\\")\",\n \"def _get_scaling(root):\\n dpi = root.winfo_fpixels(\\\"1i\\\")\\n scaling = dpi / 72.0\\n logger.debug(\\\"dpi: %s, scaling: %s'\\\", dpi, scaling)\\n return scaling\",\n \"def autocolorscale(self):\\n return self[\\\"autocolorscale\\\"]\",\n \"def auto_scale_factor(self):\\r\\n return self.gref.auto_scale_factor\",\n \"def get_scaling(self):\\n if self.constrain_navigation:\\n self.activate_navigation_constrain()\\n return self.sx, self.sy\",\n \"def get_scale():\\r\\n\\r\\n \\r\\n return 0.5\",\n \"def scale_settings(self) -> pulumi.Output[Optional['outputs.ScaleSettingsResponse']]:\\n return pulumi.get(self, \\\"scale_settings\\\")\",\n \"def scale_settings(self) -> Optional['outputs.DeploymentScaleSettingsResponse']:\\n return pulumi.get(self, \\\"scale_settings\\\")\",\n \"def overlay(self):\\n return self._overlay\",\n \"def scale(self):\\n return self.distribution.scale\",\n \"def autocolorscale(self):\\n return self['autocolorscale']\",\n \"def getscales(self):\\n return self.scales\",\n \"def imageScale(scale):\\n\\t\\treturn max(1, int(scale * (InterfaceTools.getCanvasSize()[0] / height)))\",\n \"def getScale(self):\\n \\n dag_node = OpenMaya.MFnDagNode(self.thisObj)\\n transform_node = OpenMaya.MFnTransform(dag_node.parent( 0 ))\\n \\n util = OpenMaya.MScriptUtil()\\n util.createFromDouble(0.0, 0.0, 0.0)\\n pointeur = util.asDoublePtr()\\n transform_node.getScale(pointeur)\\n \\n sx = util.getDoubleArrayItem(pointeur, 0)\\n sy = util.getDoubleArrayItem(pointeur, 1)\\n sz = util.getDoubleArrayItem(pointeur, 2)\\n\\n return sx, sy, sz\",\n \"def get_scale_anchor(self):\\n return self.anchor_position_scale\",\n \"def rolloff_scale(self):\\n return self._rolloffscale\",\n \"def scale_settings(self) -> Optional[pulumi.Input['ScaleSettingsArgs']]:\\n return pulumi.get(self, \\\"scale_settings\\\")\",\n \"def GetUserScale(*args, **kwargs):\\n return _gdi_.DC_GetUserScale(*args, **kwargs)\",\n \"def getScaled(self, scaleFactor=None):\\n\\t\\tscaledSize = self.getScaledSize(scaleFactor)\\n\\n\\t\\tif min(scaledSize) > 0:\\n\\t\\t\\treturn self.currentPixbuf.scale_simple(scaledSize[0],\\n\\t\\t\\t\\tscaledSize[1], gtk.gdk.INTERP_BILINEAR)\\n\\t\\telse:\\n\\t\\t\\treturn gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, 1, 1)\",\n \"def scaling(self) -> Optional['outputs.AiFeatureStoreOnlineServingConfigScaling']:\\n return pulumi.get(self, \\\"scaling\\\")\",\n \"def max_scale_image(self):\\n maximum = np.argmax(self.transform, 0)\\n return self.scale_array[maximum] * (self.support.sum(0) > 0)\",\n \"def pix_size(self):\\n return self._pix_size\",\n \"def doppler_scale(self):\\n return self._dopplerscale\",\n \"def castSize(self, scale):\\n return self.camera.sensorSize * scale\",\n \"def _get_zoom(self) :\\n \\n # TODO : make it absolute zoom value : a zoom of 1 displays one data\\n # pixel in one viewport pixel.\\n \\n return self._zoom\",\n \"def get_scale_parameter(self):\\n\\n if self.scale_parameter == 0.0:\\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\\n return self.scale_parameter\\n else:\\n return self.scale_parameter\",\n \"def fraction_full_scale(self):\\n return self._fraction_full_scale\",\n \"def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"max_scale_down_percentage\\\")\",\n \"def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"max_scale_down_percentage\\\")\",\n \"def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"max_scale_down_percentage\\\")\",\n \"def max_scale_down_percentage(self) -> Optional[pulumi.Input[float]]:\\n return pulumi.get(self, \\\"max_scale_down_percentage\\\")\",\n \"def get_display_px(self):\\n return self.image.size\",\n \"def GetLogicalScale(*args, **kwargs):\\n return _gdi_.DC_GetLogicalScale(*args, **kwargs)\",\n \"def scaling_object(self):\\n return self.__scaling_object\",\n \"def plate_scale(self):\\n\\n return 206265 * uu.arcsec / (self.diameter.to('mm') * self.f)\",\n \"def _get_target_scale(self, im_size_min, im_size_max, target_size, max_size):\\n im_scale = float(target_size) / float(im_size_min)\\n # Prevent the biggest axis from being more than max_size\\n if np.round(im_scale * im_size_max) > max_size:\\n im_scale = float(max_size) / float(im_size_max)\\n return im_scale\",\n \"def auto_scaling(self):\\n return self.container['auto_scaling']\",\n \"def get_scale_parameter(self):\\r\\n \\r\\n if self.scale_parameter == 0.0: \\r\\n shape_in_gamma_func = float(1+(1/self.shape_parameter))\\r\\n gamma_func = special.gamma(shape_in_gamma_func)\\r\\n self.scale_parameter = (self.mean_fire_recurrence/gamma_func)\\r\\n return self.scale_parameter\\r\\n else:\\r\\n return self.scale_parameter\",\n \"def zoom(self):\\n return self['zoom']\",\n \"def scaling_config(self) -> pulumi.Output[Optional['outputs.EventSourceMappingScalingConfig']]:\\n return pulumi.get(self, \\\"scaling_config\\\")\",\n \"def interpolation(self):\\n return self._image.interpolation\",\n \"def get_size(self):\\n return self._surf.get_size()\",\n \"def minmax(self):\\n return self._data_lim[self._n_overlay - 1]\",\n \"def get_apply_scale(self, applyScaleFactor, scale_quality = 1.0):\\n v = self.scale * self.scale_quality * scale_quality\\n if applyScaleFactor:\\n v *= self.scale_factor\\n return v\",\n \"def getValues(self):\\n return [self.scale_min, self.scale_max]\",\n \"def zoom(self) -> float:\\n return self._zoom\",\n \"def zoom(self):\\n return self.container['zoom']\",\n \"def max_zoom(self) -> float:\\n return math.log(np.min(self.canvas_size) / REGION_DIM)\",\n \"def temperature_scale(self) -> str:\\r\\n self._logger.debug(log_message_formatter(\\r\\n \\\"get\\\", f\\\"{self}\\\", \\\"temperature_scale\\\"))\\r\\n return self._temperature_scale\",\n \"def scale(self):\",\n \"def gpix(self):\\n return self._gpix\",\n \"def scaling_factor(self):\\n bin_scale = self.spabins * self.spebins\\n return bin_scale * self.int_time\",\n \"def size(self) -> (float, float):\\n\\n return self.screen.get_surface().get_size()\",\n \"def zoom(self):\\n res = np.max(self.metadata[\\\"resolution\\\"])\\n\\n if self.atlas_name == \\\"allen_human_500um\\\":\\n logger.debug(\\n \\\"ATLAS: setting zoom manually for human atlas, atlas needs fixing\\\"\\n )\\n return 350\\n else:\\n return 40 / res\",\n \"def _get_image_size(self):\\n return (3, 224, 224)\",\n \"def get_scale_parameter(self):\\n\\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self._scale_parameter = self._mean_fire_recurrence / gamma_func\",\n \"def ratio(self):\\n return float(self.max_width) / self.max_height\",\n \"def unsetScale(self):\\n return _libsbml.Unit_unsetScale(self)\",\n \"def get_scale_factor(rec, stack):\\n \\n rec_pixel_size = get_pixel_size_rec(rec)\\n stack_pixel_size = get_pixel_size_stack(stack)\\n \\n return rec_pixel_size / stack_pixel_size\",\n \"def _get_scale_from_magzp(self, magzp):\\n scale = 10.0**( 0.4*(self['magzp_ref']-magzp) )\\n return scale\",\n \"def max_capacity_per_scale(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"max_capacity_per_scale\\\")\",\n \"def get_scaled_value_at(self, offset):\\r\\n return self.get_scaled_value(self.get_value_at(offset))\",\n \"def getxscale(self) -> int:\\n if not self.debug:\\n # TODO: Verificar\\n self.myFieldFox.write(\\\"TRAC:SPEC:AMPL:SCAL?\\\")\\n ret = self.myFieldFox.read()\\n else:\\n ret = 'LOG'\\n return ret\",\n \"def _get_image_scale_subfolder(self):\\n if self.im_scale <= 0.25:\\n if self.im_scale <= 0.125:\\n return \\\"Rectified_rescaled/0.125/\\\"\\n else:\\n return \\\"Rectified_rescaled/0.25/\\\"\\n else:\\n return \\\"Rectified/\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6790271","0.6653809","0.66482663","0.66482663","0.65947706","0.6566475","0.6556108","0.6550792","0.6483977","0.646856","0.64394736","0.64268297","0.6364694","0.6363281","0.635813","0.63503003","0.6337674","0.63340884","0.62737983","0.62683964","0.62609845","0.62545675","0.6230579","0.62122667","0.6209966","0.61223465","0.6110135","0.6071429","0.6032439","0.6019965","0.6005696","0.6002289","0.59846306","0.59630275","0.59414893","0.592122","0.58380485","0.5837953","0.58312035","0.5821699","0.5812036","0.579928","0.57786417","0.5760671","0.57458436","0.5734027","0.5729694","0.57247484","0.5703596","0.5667793","0.5652674","0.5645783","0.5635156","0.5627816","0.562094","0.5604089","0.553512","0.5527801","0.55154425","0.5489864","0.5479032","0.5469668","0.544418","0.54433066","0.54433066","0.54433066","0.54433066","0.54398227","0.5437825","0.54323286","0.5412269","0.5384648","0.5379593","0.53476375","0.52536464","0.5252984","0.5247663","0.52451956","0.5191269","0.51831615","0.51827216","0.51649505","0.51535195","0.5135842","0.5130965","0.51041394","0.51026","0.5100579","0.50594395","0.5058553","0.50489265","0.5040914","0.5040814","0.5034704","0.502588","0.5021977","0.50205076","0.500764","0.5004681","0.49785346"],"string":"[\n \"0.6790271\",\n \"0.6653809\",\n \"0.66482663\",\n \"0.66482663\",\n \"0.65947706\",\n \"0.6566475\",\n \"0.6556108\",\n \"0.6550792\",\n \"0.6483977\",\n \"0.646856\",\n \"0.64394736\",\n \"0.64268297\",\n \"0.6364694\",\n \"0.6363281\",\n \"0.635813\",\n \"0.63503003\",\n \"0.6337674\",\n \"0.63340884\",\n \"0.62737983\",\n \"0.62683964\",\n \"0.62609845\",\n \"0.62545675\",\n \"0.6230579\",\n \"0.62122667\",\n \"0.6209966\",\n \"0.61223465\",\n \"0.6110135\",\n \"0.6071429\",\n \"0.6032439\",\n \"0.6019965\",\n \"0.6005696\",\n \"0.6002289\",\n \"0.59846306\",\n \"0.59630275\",\n \"0.59414893\",\n \"0.592122\",\n \"0.58380485\",\n \"0.5837953\",\n \"0.58312035\",\n \"0.5821699\",\n \"0.5812036\",\n \"0.579928\",\n \"0.57786417\",\n \"0.5760671\",\n \"0.57458436\",\n \"0.5734027\",\n \"0.5729694\",\n \"0.57247484\",\n \"0.5703596\",\n \"0.5667793\",\n \"0.5652674\",\n \"0.5645783\",\n \"0.5635156\",\n \"0.5627816\",\n \"0.562094\",\n \"0.5604089\",\n \"0.553512\",\n \"0.5527801\",\n \"0.55154425\",\n \"0.5489864\",\n \"0.5479032\",\n \"0.5469668\",\n \"0.544418\",\n \"0.54433066\",\n \"0.54433066\",\n \"0.54433066\",\n \"0.54433066\",\n \"0.54398227\",\n \"0.5437825\",\n \"0.54323286\",\n \"0.5412269\",\n \"0.5384648\",\n \"0.5379593\",\n \"0.53476375\",\n \"0.52536464\",\n \"0.5252984\",\n \"0.5247663\",\n \"0.52451956\",\n \"0.5191269\",\n \"0.51831615\",\n \"0.51827216\",\n \"0.51649505\",\n \"0.51535195\",\n \"0.5135842\",\n \"0.5130965\",\n \"0.51041394\",\n \"0.51026\",\n \"0.5100579\",\n \"0.50594395\",\n \"0.5058553\",\n \"0.50489265\",\n \"0.5040914\",\n \"0.5040814\",\n \"0.5034704\",\n \"0.502588\",\n \"0.5021977\",\n \"0.50205076\",\n \"0.500764\",\n \"0.5004681\",\n \"0.49785346\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8657468"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76589,"cells":{"query":{"kind":"string","value":"Sets the overlay_scale of this GIFOutput."},"document":{"kind":"string","value":"def overlay_scale(self, overlay_scale):\n allowed_values = [\"fit\", \"fill\", \"none\"]\n if overlay_scale not in allowed_values:\n raise ValueError(\n \"Invalid value for `overlay_scale` ({0}), must be one of {1}\"\n .format(overlay_scale, allowed_values)\n )\n\n self._overlay_scale = overlay_scale"},"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 overlay_scale(self):\n return self._overlay_scale","def scale(self, scale):\n\n self._scale = scale","def scale(self, scale):\n\n self._scale = scale","def overlay(self, overlay):\n\n self._overlay = overlay","def with_scale_op(self, scale):\n\t\tself.variables['scale'] = scale\n\t\treturn self","def _scale_setter(self, value: float) -> None:\n self.uaxis.scale = value\n self.vaxis.scale = value","def set_scale(self, scale):\n scale = float(scale)\n if scale <= 1:\n raise ValueError('The scale parameter must exceed 1.')\n self._a = scale","def set_scale_control(self, scale_ctl=3):\n self._scale_ctl = scale_ctl","def scale(self, size):\n self._surf = pygame.transform.smoothscale(self._surf, size).convert_alpha()","def scale(self, scale):\n self.coords = self.coords * scale\n return self","def setscaling(self, scaling):\n\n self.__scaling = scaling","def scale(self, scale):\n \n scale_matrix = wf.scaleMatrix(scale, self.width/2, self.height/2, 0)\n self.transform(scale_matrix)","def _adjust_scale(self, value):\n if self._min_val <= value <= self._max_val:\n self._scale_var.set(value)\n self.update_label_text()","def parallel_scale(self, value):\n self.camera.parallel_scale = value\n self.Modified()","def setScale(self, sx, sy=None, sz=None):\n self.transform.setScale(sx, sy, sz)","def scale(self, size):\n self._surf = pygame.transform.smoothscale(self._surf,\n size).convert_alpha()\n self._version += 1\n return self","def setScale(self, *args):\n return _libsbml.Unit_setScale(self, *args)","def set_scaling(self, scaling):\n self.scaling = scaling\n self.eff_box_size = int(self.box_size*self.scaling+0.5)","def reset_scale(self) -> None:\n self._scale.set(self._start_val)","def scale(self, sf):\n self.scale(sf, sf)","def set_scale(self, xscale=None, yscale=None, zscale=None, reset_camera=True, render=True):\n if xscale is None:\n xscale = self.scale[0]\n if yscale is None:\n yscale = self.scale[1]\n if zscale is None:\n zscale = self.scale[2]\n self.scale = [xscale, yscale, zscale]\n\n # Reset all actors to match this scale\n for actor in self.actors.values():\n if hasattr(actor, 'SetScale'):\n actor.SetScale(self.scale)\n\n self.parent.render()\n if reset_camera:\n self.update_bounds_axes()\n self.reset_camera(render=render)\n self.Modified()","def set_overlay(self, image_path):\n if not osp.isfile(image_path):\n raise ValueError(\"Invalid background image '{}'\".format(image_path))\n self._overlay_image = image_path\n self._final = None # Force rebuild","def scale(self, scale):\n\t\tself._current_score *= scale","def autoScale(self):\n\t\tif self.autoscaleToggle:\n\t\t\tif not self.fullscreenToggle:\n\t\t\t\tmaxSize = (self.get_screen().get_width() - 100, self.get_screen().get_height() - 100)\n\t\t\telse:\n\t\t\t\tmaxSize = (self.get_screen().get_width(), self.get_screen().get_height())\n\t\t\timgSize = [self.currentPixbuf.get_width(), self.currentPixbuf.get_height()]\n\n\t\t\tif imgSize[0] > maxSize[0] or imgSize[1] > maxSize[1]:\n\t\t\t\tscaleFactor = 1.0 * maxSize[0] / imgSize[0]\n\t\t\t\tif imgSize[1] * scaleFactor > maxSize[1]:\n\t\t\t\t\tscaleFactor = 1.0 * maxSize[1] / imgSize[1]\n\t\t\t\tself.scaleFactor = scaleFactor\n\t\t\t\timgSize[0] = int(imgSize[0] * scaleFactor)\n\t\t\t\timgSize[1] = int(imgSize[1] * scaleFactor)","def scale(self, scale_factor: Union[float, Tuple[float, float]]):\n\n if isinstance(scale_factor, float):\n self.width *= scale_factor\n self.height *= scale_factor\n elif isinstance(scale_factor, tuple):\n scale_x, scale_y = scale_factor\n self.width *= scale_x\n self.height *= scale_y","def update_axis_scale(self, scale, axis='left'):\n self.plt.getAxis(axis).setScale(scale=scale)","def SetLogicalScale(*args, **kwargs):\n return _gdi_.DC_SetLogicalScale(*args, **kwargs)","def set_size(self, size=None):\n if not size:\n size = self.output_size\n self.img = cv2.resize(self.img, size)\n self.update_image()\n self.update_size()","def set_scale_factors_to_output_size(self):\n # Compute the scale_factor using rounded scaled image size.\n height = tf.shape(self._image)[0]\n width = tf.shape(self._image)[1]\n max_image_size = tf.to_float(tf.maximum(height, width))\n image_scale = tf.to_float(self._output_size) / max_image_size\n scaled_height = tf.to_int32(tf.to_float(height) * image_scale)\n scaled_width = tf.to_int32(tf.to_float(width) * image_scale)\n self._image_scale = image_scale\n self._scaled_height = scaled_height\n self._scaled_width = scaled_width","def scale(self, x, y, z) -> None:\n ...","def _onToggleScale(self, event):\r\n if self.get_yscale() == 'log':\r\n self.set_yscale('linear')\r\n else:\r\n self.set_yscale('log')\r\n self.subplot.figure.canvas.draw_idle()","def set_loss_scale_status(self, loss_scale_number, init_loss_scale):\n self.loss_scale_number = loss_scale_number\n inner_list = [P._DynamicLossScale(layer=x) for x in range(loss_scale_number + 1)] # pylint: disable=W0212\n self.layer_loss_scale = tuple(inner_list)\n self.dynamic_loss_scale = ParameterTuple(Parameter(Tensor(1, mstype.float32),\n name='layer_loss_scale_{}'.format(x), requires_grad=False)\n for x in range(loss_scale_number + 2))\n if isinstance(init_loss_scale, list):\n for i, value in enumerate(init_loss_scale):\n self.dynamic_loss_scale[i + 1].set_data(value)\n else:\n for i in range(self.loss_scale_number):\n self.dynamic_loss_scale[i + 1].set_data(init_loss_scale)","def setSurfaceColorScale(low,high):\n dislin.zscale(low,high)","def scale(self, scale_factor: Union[float, Tuple[float, float]]):\n\n if isinstance(scale_factor, float):\n self.x *= scale_factor\n self.y *= scale_factor\n self.width *= scale_factor\n self.height *= scale_factor\n\n elif isinstance(scale_factor, tuple):\n scale_x, scale_y = scale_factor\n self.x *= scale_x\n self.y *= scale_y\n self.width *= scale_x\n self.height *= scale_y","def set_image_overlays(self, condition):\n if not config['image_on'] or not self._target_filename:\n return\n initial_image = load_data_from_npz(self._target_filename,\n config['image_overlay_actuator'], str(condition),\n 'initial', 'image', default=None)\n target_image = load_data_from_npz(self._target_filename,\n config['image_overlay_actuator'], str(condition),\n 'target', 'image', default=None)\n self._image_visualizer.set_initial_image(initial_image,\n alpha=config['image_overlay_alpha'])\n self._image_visualizer.set_target_image(target_image,\n alpha=config['image_overlay_alpha'])","def on_scale_changed(self):\n\n options = self.get_options()\n\n label = \"Result: {0}x{1}\".format(int(options[\"width\"]),\n int(options[\"height\"]))\n\n self.scale_result.setText(label)","def scale(self) -> Optional[pulumi.Input['ScaleArgs']]:\n return pulumi.get(self, \"scale\")","def imageScale(scale):\n\t\treturn max(1, int(scale * (InterfaceTools.getCanvasSize()[0] / height)))","def scale2x(self) -> 'BaseImage':\n self._surface = pygame.transform.scale2x(self._surface)\n return self","def scale(self):","def Rescale(self):\r\n picWidth,picHeight = self.oldSize = self.GetSizeTuple()\r\n bitmap = self.scaled = self.bitmap\r\n if not bitmap: return\r\n imgWidth,imgHeight = bitmap.GetWidth(),bitmap.GetHeight()\r\n if self.scaling == 2 or (self.scaling == 1 and (imgWidth > picWidth or imgHeight > picHeight)):\r\n image = bitmap.ConvertToImage()\r\n factor = min(1.0*picWidth/imgWidth,1.0*picHeight/imgHeight)\r\n newWidth,newHeight = int(factor*imgWidth),int(factor*imgHeight)\r\n self.scaled = image.Scale(newWidth,newHeight).ConvertToBitmap()\r\n #self.scaled = image.Scale(newWidth,newHeight,wx.IMAGE_QUALITY_HIGH ).ConvertToBitmap()\r","def scaleBoard(self, scale):\n self.scaling = scale\n self.my_font.config(size=25 * self.scaling)\n self.reset_button.config(width=40 * self.scaling, height=40 * self.scaling, borderwidth=2 * self.scaling)\n self.board.updateBoardUI(self.scaling)","def set_load_based_auto_scaling(LayerId=None, Enable=None, UpScaling=None, DownScaling=None):\n pass","def scale(self, scale=1):\n self.x *= scale\n self.y *= scale\n self.width *= scale\n self.height *= scale\n\n # Always update the corners after operation\n self.update_corners()\n return","def on_scale (self):\n\t\tif self.has_started:\n\t\t\tself.init_buffers()\n\t\t\tself.redraw_foreground()\n\t\t\tself.redraw_background()\n\n\t\tif self.expand2 == _('Use a scrollbar'):\n\t\t\tself.width = int((self.icon_size * 2 * self.rows + ((self.border_size+self.shadow_size)*2)+15 ) + 24/self.scale)\n\t\t\tself.update_scrollbar()","def set_pid_scaling(config, gState):\n gState.axes_to_scale = config.get('PID_altitude_scale', 'axes').split()\n gState.alt_min = float(config.get('PID_altitude_scale', 'min'))\n gState.alt_max = float(config.get('PID_altitude_scale', 'max'))","def img_scale(self):\n return min(400, abs(self.size))","def _set_pixel_size(self) -> None:\n # Not Pansharpened images\n if self.band_combi == Sv1BandCombination.PMS:\n # TODO: manage default resolution for PAN band ?\n self.pixel_size = self._ms_res\n # Pansharpened images\n else:\n self.pixel_size = self._pan_res","def scale(self, sx, sy):\n frameWidth *= sx\n frameHeight *= sy\n repaint()","def scale(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"scale\")","def setScale(self, mode='ACC', scale=0):\r\n\t\tif mode.upper() == 'ACC':\r\n\t\t\treg = 0x1C\r\n\t\telif mode.upper() == 'GYR':\r\n\t\t\treg = 0x1B\t\t\r\n\t\telse:\r\n\t\t\treturn False\r\n\t\tcurrentVal = self.read(reg)\r\n\t\tcurrentVal = self.dec2BinList(currentVal)\r\n\t\tscale = self.dec2BinList(value=scale,bits=2)\r\n\t\tcurrentVal[3] = scale[0]\r\n\t\tcurrentVal[4] = scale[1]\r\n\t\tcurrentVal = self.binList2Dec(currentVal)\r\n\t\tself.write(reg, currentVal)","def __init__(self,scale):\n self.scale = scale","def reset_limits(self):\n self.autoscale = True\n self.pixels.autoscale()","def __init__(self, scale=False):\n self.scale = scale","def scale(self, factor):\n self.x *= factor\n self.y *= factor\n for a in self.annotations:\n a.scale(factor)","def scale(self, sx, sy):\n self._impl.scale(sx, sy)","def scale(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"scale\")","def scale_settings(self) -> pulumi.Output[Optional['outputs.ScaleSettingsResponse']]:\n return pulumi.get(self, \"scale_settings\")","def change_scaling(self, scales=None, offsets=None) -> None:\n self.points.change_scaling(scales, offsets)\n\n self.header.scales = scales\n self.header.offsets = offsets","def shell_scale_to_fit_changed(self, scale_to_fit):\n self.set_scale_to_fit(scale_to_fit)","def shell_scale_to_fit_changed(self, scale_to_fit):\n self.set_scale_to_fit(scale_to_fit)","def scale_it(val):\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])","def set_size(self, width, height):\r\n \r\n self.image = pygame.transform.scale(self.image, (width, height))\r\n self.rect = self.image.get_rect()","def tier_1080p(self, tier_1080p):\n\n self._tier_1080p = tier_1080p","def showscale(self):\n return self['showscale']","def showscale(self):\n return self[\"showscale\"]","def add_scale(self, scale=None, label=None, *, loc=\"auto\", color=\"k\", fontsize=\"x-small\"):\n if scale is None:\n scale = 5\n else:\n # convert to display units\n scale = scale * self.factor_for(self.projection[0])\n\n if label is None:\n unit = self.display_unit_for(self.projection[0])\n label = f\"{scale:g} {unit}\"\n\n return super(FloorPlot, self).add_scale(\n self.ax, scale, label=label, loc=loc, color=color, fontsize=fontsize\n )","def unsetScale(self):\n return _libsbml.Unit_unsetScale(self)","def setScaleMode(self, mode):\n if mode != self.__scale_mode and mode in (self.ScaleModeGlobal, self.ScaleModeLocal):\n self.__scale_mode = mode\n self.__scaled_datasets = None\n self.__axisDomains = None\n self.dataChanged.emit()","def update_loss_scale_status(self, layer, update_ratio):\n layer = layer + 1\n new_loss_scale = self.dynamic_loss_scale[layer] * update_ratio\n P.Assign()(self.dynamic_loss_scale[layer], new_loss_scale)\n return new_loss_scale","def scale(self, sc):\n daskD.wait(self.client.map(_call_scale, self.vecDask, sc=sc, pure=False))\n return self","def scale(self, scale_factor: float) -> None:\n self.tensor[:, :3] *= scale_factor","def clickAutoscale(self, event):\n self.axes.autoscale_view()","def scale(self, factor):\n self.b = factor * self.b","def scaleAll(self, scale):\n center = [self.width/2, self.height/2, 0, 0]\n matrix = self.scaleMatrix(scale, scale, scale)\n\n for wireframe in self.wireframes.values():\n wireframe.scale(center, matrix)","def Scale(*args, **kwargs):\n return _gdi_.GraphicsContext_Scale(*args, **kwargs)","def reset_limits(self):\n self.autoscale = True\n self.camera.autoscale()","def camera_scale(self, camera):\n cmd = '{}testCameraViewScale {}'.format(self.console, camera)\n self.write_command(cmd)","def update_colormap(self, to_overlay=None, **kwargs):\n if self._n_overlay >= 1:\n overlay = self._n_overlay - 1 if to_overlay is None else to_overlay\n # Define the colormap data :\n data_lim = self._data_lim[overlay]\n col = np.linspace(data_lim[0], data_lim[1], LUT_LEN)\n self._text2d_data[overlay, ...] = Colormap(**kwargs).to_rgba(col)\n self._text2d.set_data(self._text2d_data)\n self.update()","def __init__(self, output_size, spatial_scale=1.0):\n super().__init__()\n self.output_size = output_size\n self.spatial_scale = spatial_scale","def __init__(self, output_size, spatial_scale=1.0):\n super().__init__()\n self.output_size = output_size\n self.spatial_scale = spatial_scale","def set_scales(self):\r\n self.canvas.update()\r\n self.dxmin = self.dmargin\r\n self.dymin = self.dmargin\r\n self.dxmax = self.canvas.winfo_width() - self.dmargin - 1\r\n self.dymax = self.canvas.winfo_height() - self.dmargin - 1\r\n\r\n # Flip the Y coordinates to invert the result.\r\n if self.y_is_flipped:\r\n self.dymin, self.dymax = self.dymax, self.dymin\r\n\r\n self.xscale = (self.dxmax - self.dxmin) / (self.wxmax - self.wxmin)\r\n self.yscale = (self.dymax - self.dymin) / (self.wymax - self.wymin)\r\n\r\n # Calculate 1 pixel in world coordinates.\r\n self.xpix = 1 / self.xscale\r\n self.ypix = 1 / self.yscale","def scale(img, scale):\n return resize(img, x_scale=scale, y_scale=scale)","def scale(self):\n return self._scale","def __init__(self, size=800, scale=(3. / 4, 5. / 2)):\n assert isinstance(size, int)\n assert isinstance(scale, float) or isinstance(scale, tuple)\n self.size = size\n self.scale = scale if isinstance(scale, tuple) \\\n else (1 - scale, 1 + scale)","def SetInterpolationQuality(*args, **kwargs):\n return _gdi_.GraphicsContext_SetInterpolationQuality(*args, **kwargs)","def scale_settings(self) -> Optional[pulumi.Input['ScaleSettingsArgs']]:\n return pulumi.get(self, \"scale_settings\")","def set_rua_level(self, magnitude_coef: Union[int, float]) -> None:\n self.max_shapes = math.ceil(magnitude_coef * self.max_shapes)\n self.max_size = None if self.max_size is None else math.ceil(magnitude_coef * self.max_size)\n\n # Transparency range will keep the same minimum value, but reduce the maximum opacity based on the level.\n transparency_diff = self.transparency_range[1] - self.transparency_range[0]\n transparency_diff = transparency_diff * magnitude_coef\n self.transparency_range = (self.transparency_range[0], self.transparency_range[0] + transparency_diff)","def set_limits_minmax(self, zmin, zmax):\n self.pixels.set_clim(zmin, zmax)\n self.autoscale = False","def plane_scale(self, scale):\n cmd = '{}testPlaneScale {}'.format(self.console, scale)\n self.write_command(cmd)","def _zoomCamera(self, sizeChange):\n self.camSize -= sizeChange","def setOpacity(self, opa):\n if self._displayPjt:\n self._displayPjt.setOpacityPalette(opa)\n if self._displayUsr:\n self._displayUsr.setOpacityPalette(opa)\n if self._displayVtk:\n self._displayVtk.setOpacityPalette(opa)","def normalize_plot(self):\n\n kwargs = dict(stretch = self.stretch,\n vmin = self.vmin_button.get_value(),\n vmax = self.vmax_button.get_value())\n norm = aplpy.normalize.APLpyNormalize(**kwargs)\n self.parent.aplpy_plot.image.set_norm(norm)\n self.parent.aplpy_plot.refresh()","def y0_scale_siby1024(self, y0_scale_siby1024):\n\n self._y0_scale_siby1024 = y0_scale_siby1024","def scale(self, infile: str, outfile: str):\n\n with Image(filename=infile) as src:\n width, height = self.new_dimensions(src)\n with src.clone() as dest:\n dest.resize(width=width,height=height)\n logging.debug(\n f'Converted \"{infile}\" ({src.width}x{src.height})'\n f' -> \"{outfile}\" ({dest.width}x{dest.height})')\n dest.save(filename=outfile)","def scale(self):\n return self.scale_factor / CONSTANTS.AU","def set_view_max(self, view_max):\n try:\n view_max = float(view_max)\n self._view_max = view_max\n self.update_rgba()\n if self._cross_pos:\n self.update_orth_rgba()\n except ValueError:\n print\"view_max must be a number.\"","def Scale(*args, **kwargs):\n return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)","def setScaleAnimCurve(self, index, animCurve, view) -> None:\n ...","def resizeEvent(self, event):\n event.accept()\n self.overlay.resize(event.size())\n # Move gif to the center of the widget\n self.overlay.move(self.rect().center() - self.overlay.rect().center())"],"string":"[\n \"def overlay_scale(self):\\n return self._overlay_scale\",\n \"def scale(self, scale):\\n\\n self._scale = scale\",\n \"def scale(self, scale):\\n\\n self._scale = scale\",\n \"def overlay(self, overlay):\\n\\n self._overlay = overlay\",\n \"def with_scale_op(self, scale):\\n\\t\\tself.variables['scale'] = scale\\n\\t\\treturn self\",\n \"def _scale_setter(self, value: float) -> None:\\n self.uaxis.scale = value\\n self.vaxis.scale = value\",\n \"def set_scale(self, scale):\\n scale = float(scale)\\n if scale <= 1:\\n raise ValueError('The scale parameter must exceed 1.')\\n self._a = scale\",\n \"def set_scale_control(self, scale_ctl=3):\\n self._scale_ctl = scale_ctl\",\n \"def scale(self, size):\\n self._surf = pygame.transform.smoothscale(self._surf, size).convert_alpha()\",\n \"def scale(self, scale):\\n self.coords = self.coords * scale\\n return self\",\n \"def setscaling(self, scaling):\\n\\n self.__scaling = scaling\",\n \"def scale(self, scale):\\n \\n scale_matrix = wf.scaleMatrix(scale, self.width/2, self.height/2, 0)\\n self.transform(scale_matrix)\",\n \"def _adjust_scale(self, value):\\n if self._min_val <= value <= self._max_val:\\n self._scale_var.set(value)\\n self.update_label_text()\",\n \"def parallel_scale(self, value):\\n self.camera.parallel_scale = value\\n self.Modified()\",\n \"def setScale(self, sx, sy=None, sz=None):\\n self.transform.setScale(sx, sy, sz)\",\n \"def scale(self, size):\\n self._surf = pygame.transform.smoothscale(self._surf,\\n size).convert_alpha()\\n self._version += 1\\n return self\",\n \"def setScale(self, *args):\\n return _libsbml.Unit_setScale(self, *args)\",\n \"def set_scaling(self, scaling):\\n self.scaling = scaling\\n self.eff_box_size = int(self.box_size*self.scaling+0.5)\",\n \"def reset_scale(self) -> None:\\n self._scale.set(self._start_val)\",\n \"def scale(self, sf):\\n self.scale(sf, sf)\",\n \"def set_scale(self, xscale=None, yscale=None, zscale=None, reset_camera=True, render=True):\\n if xscale is None:\\n xscale = self.scale[0]\\n if yscale is None:\\n yscale = self.scale[1]\\n if zscale is None:\\n zscale = self.scale[2]\\n self.scale = [xscale, yscale, zscale]\\n\\n # Reset all actors to match this scale\\n for actor in self.actors.values():\\n if hasattr(actor, 'SetScale'):\\n actor.SetScale(self.scale)\\n\\n self.parent.render()\\n if reset_camera:\\n self.update_bounds_axes()\\n self.reset_camera(render=render)\\n self.Modified()\",\n \"def set_overlay(self, image_path):\\n if not osp.isfile(image_path):\\n raise ValueError(\\\"Invalid background image '{}'\\\".format(image_path))\\n self._overlay_image = image_path\\n self._final = None # Force rebuild\",\n \"def scale(self, scale):\\n\\t\\tself._current_score *= scale\",\n \"def autoScale(self):\\n\\t\\tif self.autoscaleToggle:\\n\\t\\t\\tif not self.fullscreenToggle:\\n\\t\\t\\t\\tmaxSize = (self.get_screen().get_width() - 100, self.get_screen().get_height() - 100)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmaxSize = (self.get_screen().get_width(), self.get_screen().get_height())\\n\\t\\t\\timgSize = [self.currentPixbuf.get_width(), self.currentPixbuf.get_height()]\\n\\n\\t\\t\\tif imgSize[0] > maxSize[0] or imgSize[1] > maxSize[1]:\\n\\t\\t\\t\\tscaleFactor = 1.0 * maxSize[0] / imgSize[0]\\n\\t\\t\\t\\tif imgSize[1] * scaleFactor > maxSize[1]:\\n\\t\\t\\t\\t\\tscaleFactor = 1.0 * maxSize[1] / imgSize[1]\\n\\t\\t\\t\\tself.scaleFactor = scaleFactor\\n\\t\\t\\t\\timgSize[0] = int(imgSize[0] * scaleFactor)\\n\\t\\t\\t\\timgSize[1] = int(imgSize[1] * scaleFactor)\",\n \"def scale(self, scale_factor: Union[float, Tuple[float, float]]):\\n\\n if isinstance(scale_factor, float):\\n self.width *= scale_factor\\n self.height *= scale_factor\\n elif isinstance(scale_factor, tuple):\\n scale_x, scale_y = scale_factor\\n self.width *= scale_x\\n self.height *= scale_y\",\n \"def update_axis_scale(self, scale, axis='left'):\\n self.plt.getAxis(axis).setScale(scale=scale)\",\n \"def SetLogicalScale(*args, **kwargs):\\n return _gdi_.DC_SetLogicalScale(*args, **kwargs)\",\n \"def set_size(self, size=None):\\n if not size:\\n size = self.output_size\\n self.img = cv2.resize(self.img, size)\\n self.update_image()\\n self.update_size()\",\n \"def set_scale_factors_to_output_size(self):\\n # Compute the scale_factor using rounded scaled image size.\\n height = tf.shape(self._image)[0]\\n width = tf.shape(self._image)[1]\\n max_image_size = tf.to_float(tf.maximum(height, width))\\n image_scale = tf.to_float(self._output_size) / max_image_size\\n scaled_height = tf.to_int32(tf.to_float(height) * image_scale)\\n scaled_width = tf.to_int32(tf.to_float(width) * image_scale)\\n self._image_scale = image_scale\\n self._scaled_height = scaled_height\\n self._scaled_width = scaled_width\",\n \"def scale(self, x, y, z) -> None:\\n ...\",\n \"def _onToggleScale(self, event):\\r\\n if self.get_yscale() == 'log':\\r\\n self.set_yscale('linear')\\r\\n else:\\r\\n self.set_yscale('log')\\r\\n self.subplot.figure.canvas.draw_idle()\",\n \"def set_loss_scale_status(self, loss_scale_number, init_loss_scale):\\n self.loss_scale_number = loss_scale_number\\n inner_list = [P._DynamicLossScale(layer=x) for x in range(loss_scale_number + 1)] # pylint: disable=W0212\\n self.layer_loss_scale = tuple(inner_list)\\n self.dynamic_loss_scale = ParameterTuple(Parameter(Tensor(1, mstype.float32),\\n name='layer_loss_scale_{}'.format(x), requires_grad=False)\\n for x in range(loss_scale_number + 2))\\n if isinstance(init_loss_scale, list):\\n for i, value in enumerate(init_loss_scale):\\n self.dynamic_loss_scale[i + 1].set_data(value)\\n else:\\n for i in range(self.loss_scale_number):\\n self.dynamic_loss_scale[i + 1].set_data(init_loss_scale)\",\n \"def setSurfaceColorScale(low,high):\\n dislin.zscale(low,high)\",\n \"def scale(self, scale_factor: Union[float, Tuple[float, float]]):\\n\\n if isinstance(scale_factor, float):\\n self.x *= scale_factor\\n self.y *= scale_factor\\n self.width *= scale_factor\\n self.height *= scale_factor\\n\\n elif isinstance(scale_factor, tuple):\\n scale_x, scale_y = scale_factor\\n self.x *= scale_x\\n self.y *= scale_y\\n self.width *= scale_x\\n self.height *= scale_y\",\n \"def set_image_overlays(self, condition):\\n if not config['image_on'] or not self._target_filename:\\n return\\n initial_image = load_data_from_npz(self._target_filename,\\n config['image_overlay_actuator'], str(condition),\\n 'initial', 'image', default=None)\\n target_image = load_data_from_npz(self._target_filename,\\n config['image_overlay_actuator'], str(condition),\\n 'target', 'image', default=None)\\n self._image_visualizer.set_initial_image(initial_image,\\n alpha=config['image_overlay_alpha'])\\n self._image_visualizer.set_target_image(target_image,\\n alpha=config['image_overlay_alpha'])\",\n \"def on_scale_changed(self):\\n\\n options = self.get_options()\\n\\n label = \\\"Result: {0}x{1}\\\".format(int(options[\\\"width\\\"]),\\n int(options[\\\"height\\\"]))\\n\\n self.scale_result.setText(label)\",\n \"def scale(self) -> Optional[pulumi.Input['ScaleArgs']]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def imageScale(scale):\\n\\t\\treturn max(1, int(scale * (InterfaceTools.getCanvasSize()[0] / height)))\",\n \"def scale2x(self) -> 'BaseImage':\\n self._surface = pygame.transform.scale2x(self._surface)\\n return self\",\n \"def scale(self):\",\n \"def Rescale(self):\\r\\n picWidth,picHeight = self.oldSize = self.GetSizeTuple()\\r\\n bitmap = self.scaled = self.bitmap\\r\\n if not bitmap: return\\r\\n imgWidth,imgHeight = bitmap.GetWidth(),bitmap.GetHeight()\\r\\n if self.scaling == 2 or (self.scaling == 1 and (imgWidth > picWidth or imgHeight > picHeight)):\\r\\n image = bitmap.ConvertToImage()\\r\\n factor = min(1.0*picWidth/imgWidth,1.0*picHeight/imgHeight)\\r\\n newWidth,newHeight = int(factor*imgWidth),int(factor*imgHeight)\\r\\n self.scaled = image.Scale(newWidth,newHeight).ConvertToBitmap()\\r\\n #self.scaled = image.Scale(newWidth,newHeight,wx.IMAGE_QUALITY_HIGH ).ConvertToBitmap()\\r\",\n \"def scaleBoard(self, scale):\\n self.scaling = scale\\n self.my_font.config(size=25 * self.scaling)\\n self.reset_button.config(width=40 * self.scaling, height=40 * self.scaling, borderwidth=2 * self.scaling)\\n self.board.updateBoardUI(self.scaling)\",\n \"def set_load_based_auto_scaling(LayerId=None, Enable=None, UpScaling=None, DownScaling=None):\\n pass\",\n \"def scale(self, scale=1):\\n self.x *= scale\\n self.y *= scale\\n self.width *= scale\\n self.height *= scale\\n\\n # Always update the corners after operation\\n self.update_corners()\\n return\",\n \"def on_scale (self):\\n\\t\\tif self.has_started:\\n\\t\\t\\tself.init_buffers()\\n\\t\\t\\tself.redraw_foreground()\\n\\t\\t\\tself.redraw_background()\\n\\n\\t\\tif self.expand2 == _('Use a scrollbar'):\\n\\t\\t\\tself.width = int((self.icon_size * 2 * self.rows + ((self.border_size+self.shadow_size)*2)+15 ) + 24/self.scale)\\n\\t\\t\\tself.update_scrollbar()\",\n \"def set_pid_scaling(config, gState):\\n gState.axes_to_scale = config.get('PID_altitude_scale', 'axes').split()\\n gState.alt_min = float(config.get('PID_altitude_scale', 'min'))\\n gState.alt_max = float(config.get('PID_altitude_scale', 'max'))\",\n \"def img_scale(self):\\n return min(400, abs(self.size))\",\n \"def _set_pixel_size(self) -> None:\\n # Not Pansharpened images\\n if self.band_combi == Sv1BandCombination.PMS:\\n # TODO: manage default resolution for PAN band ?\\n self.pixel_size = self._ms_res\\n # Pansharpened images\\n else:\\n self.pixel_size = self._pan_res\",\n \"def scale(self, sx, sy):\\n frameWidth *= sx\\n frameHeight *= sy\\n repaint()\",\n \"def scale(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def setScale(self, mode='ACC', scale=0):\\r\\n\\t\\tif mode.upper() == 'ACC':\\r\\n\\t\\t\\treg = 0x1C\\r\\n\\t\\telif mode.upper() == 'GYR':\\r\\n\\t\\t\\treg = 0x1B\\t\\t\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn False\\r\\n\\t\\tcurrentVal = self.read(reg)\\r\\n\\t\\tcurrentVal = self.dec2BinList(currentVal)\\r\\n\\t\\tscale = self.dec2BinList(value=scale,bits=2)\\r\\n\\t\\tcurrentVal[3] = scale[0]\\r\\n\\t\\tcurrentVal[4] = scale[1]\\r\\n\\t\\tcurrentVal = self.binList2Dec(currentVal)\\r\\n\\t\\tself.write(reg, currentVal)\",\n \"def __init__(self,scale):\\n self.scale = scale\",\n \"def reset_limits(self):\\n self.autoscale = True\\n self.pixels.autoscale()\",\n \"def __init__(self, scale=False):\\n self.scale = scale\",\n \"def scale(self, factor):\\n self.x *= factor\\n self.y *= factor\\n for a in self.annotations:\\n a.scale(factor)\",\n \"def scale(self, sx, sy):\\n self._impl.scale(sx, sy)\",\n \"def scale(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def scale_settings(self) -> pulumi.Output[Optional['outputs.ScaleSettingsResponse']]:\\n return pulumi.get(self, \\\"scale_settings\\\")\",\n \"def change_scaling(self, scales=None, offsets=None) -> None:\\n self.points.change_scaling(scales, offsets)\\n\\n self.header.scales = scales\\n self.header.offsets = offsets\",\n \"def shell_scale_to_fit_changed(self, scale_to_fit):\\n self.set_scale_to_fit(scale_to_fit)\",\n \"def shell_scale_to_fit_changed(self, scale_to_fit):\\n self.set_scale_to_fit(scale_to_fit)\",\n \"def scale_it(val):\\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])\",\n \"def set_size(self, width, height):\\r\\n \\r\\n self.image = pygame.transform.scale(self.image, (width, height))\\r\\n self.rect = self.image.get_rect()\",\n \"def tier_1080p(self, tier_1080p):\\n\\n self._tier_1080p = tier_1080p\",\n \"def showscale(self):\\n return self['showscale']\",\n \"def showscale(self):\\n return self[\\\"showscale\\\"]\",\n \"def add_scale(self, scale=None, label=None, *, loc=\\\"auto\\\", color=\\\"k\\\", fontsize=\\\"x-small\\\"):\\n if scale is None:\\n scale = 5\\n else:\\n # convert to display units\\n scale = scale * self.factor_for(self.projection[0])\\n\\n if label is None:\\n unit = self.display_unit_for(self.projection[0])\\n label = f\\\"{scale:g} {unit}\\\"\\n\\n return super(FloorPlot, self).add_scale(\\n self.ax, scale, label=label, loc=loc, color=color, fontsize=fontsize\\n )\",\n \"def unsetScale(self):\\n return _libsbml.Unit_unsetScale(self)\",\n \"def setScaleMode(self, mode):\\n if mode != self.__scale_mode and mode in (self.ScaleModeGlobal, self.ScaleModeLocal):\\n self.__scale_mode = mode\\n self.__scaled_datasets = None\\n self.__axisDomains = None\\n self.dataChanged.emit()\",\n \"def update_loss_scale_status(self, layer, update_ratio):\\n layer = layer + 1\\n new_loss_scale = self.dynamic_loss_scale[layer] * update_ratio\\n P.Assign()(self.dynamic_loss_scale[layer], new_loss_scale)\\n return new_loss_scale\",\n \"def scale(self, sc):\\n daskD.wait(self.client.map(_call_scale, self.vecDask, sc=sc, pure=False))\\n return self\",\n \"def scale(self, scale_factor: float) -> None:\\n self.tensor[:, :3] *= scale_factor\",\n \"def clickAutoscale(self, event):\\n self.axes.autoscale_view()\",\n \"def scale(self, factor):\\n self.b = factor * self.b\",\n \"def scaleAll(self, scale):\\n center = [self.width/2, self.height/2, 0, 0]\\n matrix = self.scaleMatrix(scale, scale, scale)\\n\\n for wireframe in self.wireframes.values():\\n wireframe.scale(center, matrix)\",\n \"def Scale(*args, **kwargs):\\n return _gdi_.GraphicsContext_Scale(*args, **kwargs)\",\n \"def reset_limits(self):\\n self.autoscale = True\\n self.camera.autoscale()\",\n \"def camera_scale(self, camera):\\n cmd = '{}testCameraViewScale {}'.format(self.console, camera)\\n self.write_command(cmd)\",\n \"def update_colormap(self, to_overlay=None, **kwargs):\\n if self._n_overlay >= 1:\\n overlay = self._n_overlay - 1 if to_overlay is None else to_overlay\\n # Define the colormap data :\\n data_lim = self._data_lim[overlay]\\n col = np.linspace(data_lim[0], data_lim[1], LUT_LEN)\\n self._text2d_data[overlay, ...] = Colormap(**kwargs).to_rgba(col)\\n self._text2d.set_data(self._text2d_data)\\n self.update()\",\n \"def __init__(self, output_size, spatial_scale=1.0):\\n super().__init__()\\n self.output_size = output_size\\n self.spatial_scale = spatial_scale\",\n \"def __init__(self, output_size, spatial_scale=1.0):\\n super().__init__()\\n self.output_size = output_size\\n self.spatial_scale = spatial_scale\",\n \"def set_scales(self):\\r\\n self.canvas.update()\\r\\n self.dxmin = self.dmargin\\r\\n self.dymin = self.dmargin\\r\\n self.dxmax = self.canvas.winfo_width() - self.dmargin - 1\\r\\n self.dymax = self.canvas.winfo_height() - self.dmargin - 1\\r\\n\\r\\n # Flip the Y coordinates to invert the result.\\r\\n if self.y_is_flipped:\\r\\n self.dymin, self.dymax = self.dymax, self.dymin\\r\\n\\r\\n self.xscale = (self.dxmax - self.dxmin) / (self.wxmax - self.wxmin)\\r\\n self.yscale = (self.dymax - self.dymin) / (self.wymax - self.wymin)\\r\\n\\r\\n # Calculate 1 pixel in world coordinates.\\r\\n self.xpix = 1 / self.xscale\\r\\n self.ypix = 1 / self.yscale\",\n \"def scale(img, scale):\\n return resize(img, x_scale=scale, y_scale=scale)\",\n \"def scale(self):\\n return self._scale\",\n \"def __init__(self, size=800, scale=(3. / 4, 5. / 2)):\\n assert isinstance(size, int)\\n assert isinstance(scale, float) or isinstance(scale, tuple)\\n self.size = size\\n self.scale = scale if isinstance(scale, tuple) \\\\\\n else (1 - scale, 1 + scale)\",\n \"def SetInterpolationQuality(*args, **kwargs):\\n return _gdi_.GraphicsContext_SetInterpolationQuality(*args, **kwargs)\",\n \"def scale_settings(self) -> Optional[pulumi.Input['ScaleSettingsArgs']]:\\n return pulumi.get(self, \\\"scale_settings\\\")\",\n \"def set_rua_level(self, magnitude_coef: Union[int, float]) -> None:\\n self.max_shapes = math.ceil(magnitude_coef * self.max_shapes)\\n self.max_size = None if self.max_size is None else math.ceil(magnitude_coef * self.max_size)\\n\\n # Transparency range will keep the same minimum value, but reduce the maximum opacity based on the level.\\n transparency_diff = self.transparency_range[1] - self.transparency_range[0]\\n transparency_diff = transparency_diff * magnitude_coef\\n self.transparency_range = (self.transparency_range[0], self.transparency_range[0] + transparency_diff)\",\n \"def set_limits_minmax(self, zmin, zmax):\\n self.pixels.set_clim(zmin, zmax)\\n self.autoscale = False\",\n \"def plane_scale(self, scale):\\n cmd = '{}testPlaneScale {}'.format(self.console, scale)\\n self.write_command(cmd)\",\n \"def _zoomCamera(self, sizeChange):\\n self.camSize -= sizeChange\",\n \"def setOpacity(self, opa):\\n if self._displayPjt:\\n self._displayPjt.setOpacityPalette(opa)\\n if self._displayUsr:\\n self._displayUsr.setOpacityPalette(opa)\\n if self._displayVtk:\\n self._displayVtk.setOpacityPalette(opa)\",\n \"def normalize_plot(self):\\n\\n kwargs = dict(stretch = self.stretch,\\n vmin = self.vmin_button.get_value(),\\n vmax = self.vmax_button.get_value())\\n norm = aplpy.normalize.APLpyNormalize(**kwargs)\\n self.parent.aplpy_plot.image.set_norm(norm)\\n self.parent.aplpy_plot.refresh()\",\n \"def y0_scale_siby1024(self, y0_scale_siby1024):\\n\\n self._y0_scale_siby1024 = y0_scale_siby1024\",\n \"def scale(self, infile: str, outfile: str):\\n\\n with Image(filename=infile) as src:\\n width, height = self.new_dimensions(src)\\n with src.clone() as dest:\\n dest.resize(width=width,height=height)\\n logging.debug(\\n f'Converted \\\"{infile}\\\" ({src.width}x{src.height})'\\n f' -> \\\"{outfile}\\\" ({dest.width}x{dest.height})')\\n dest.save(filename=outfile)\",\n \"def scale(self):\\n return self.scale_factor / CONSTANTS.AU\",\n \"def set_view_max(self, view_max):\\n try:\\n view_max = float(view_max)\\n self._view_max = view_max\\n self.update_rgba()\\n if self._cross_pos:\\n self.update_orth_rgba()\\n except ValueError:\\n print\\\"view_max must be a number.\\\"\",\n \"def Scale(*args, **kwargs):\\n return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)\",\n \"def setScaleAnimCurve(self, index, animCurve, view) -> None:\\n ...\",\n \"def resizeEvent(self, event):\\n event.accept()\\n self.overlay.resize(event.size())\\n # Move gif to the center of the widget\\n self.overlay.move(self.rect().center() - self.overlay.rect().center())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63258976","0.6225319","0.6225319","0.60859454","0.6069903","0.599363","0.5942604","0.59057343","0.5672578","0.55856156","0.55695605","0.5541849","0.54761684","0.54468507","0.5435712","0.543293","0.54186404","0.53943425","0.5391189","0.5248213","0.51808435","0.5132607","0.5128057","0.51275855","0.5118692","0.5107124","0.5102904","0.5046299","0.5030384","0.49595642","0.49429584","0.49240232","0.49096248","0.4903458","0.4891107","0.4886683","0.486397","0.48495224","0.4798976","0.47930735","0.4788302","0.47811645","0.47748035","0.474289","0.47392124","0.4721878","0.47172844","0.4710866","0.47085112","0.47054103","0.4703914","0.46980932","0.46934363","0.46920002","0.4691828","0.46751037","0.46704012","0.4648543","0.4638194","0.46366644","0.46366644","0.46352637","0.463043","0.4612598","0.46102425","0.4606945","0.46044847","0.4601234","0.4592946","0.45917654","0.45868987","0.4585314","0.4572974","0.4572539","0.4564635","0.45592147","0.45540085","0.45529658","0.45429057","0.45320842","0.45320842","0.45319477","0.45308533","0.45267165","0.4525772","0.45247528","0.45185468","0.45169526","0.4496851","0.44891387","0.44856963","0.44848403","0.44799614","0.4479314","0.44736072","0.44654348","0.44639155","0.44611803","0.4455441","0.44439384"],"string":"[\n \"0.63258976\",\n \"0.6225319\",\n \"0.6225319\",\n \"0.60859454\",\n \"0.6069903\",\n \"0.599363\",\n \"0.5942604\",\n \"0.59057343\",\n \"0.5672578\",\n \"0.55856156\",\n \"0.55695605\",\n \"0.5541849\",\n \"0.54761684\",\n \"0.54468507\",\n \"0.5435712\",\n \"0.543293\",\n \"0.54186404\",\n \"0.53943425\",\n \"0.5391189\",\n \"0.5248213\",\n \"0.51808435\",\n \"0.5132607\",\n \"0.5128057\",\n \"0.51275855\",\n \"0.5118692\",\n \"0.5107124\",\n \"0.5102904\",\n \"0.5046299\",\n \"0.5030384\",\n \"0.49595642\",\n \"0.49429584\",\n \"0.49240232\",\n \"0.49096248\",\n \"0.4903458\",\n \"0.4891107\",\n \"0.4886683\",\n \"0.486397\",\n \"0.48495224\",\n \"0.4798976\",\n \"0.47930735\",\n \"0.4788302\",\n \"0.47811645\",\n \"0.47748035\",\n \"0.474289\",\n \"0.47392124\",\n \"0.4721878\",\n \"0.47172844\",\n \"0.4710866\",\n \"0.47085112\",\n \"0.47054103\",\n \"0.4703914\",\n \"0.46980932\",\n \"0.46934363\",\n \"0.46920002\",\n \"0.4691828\",\n \"0.46751037\",\n \"0.46704012\",\n \"0.4648543\",\n \"0.4638194\",\n \"0.46366644\",\n \"0.46366644\",\n \"0.46352637\",\n \"0.463043\",\n \"0.4612598\",\n \"0.46102425\",\n \"0.4606945\",\n \"0.46044847\",\n \"0.4601234\",\n \"0.4592946\",\n \"0.45917654\",\n \"0.45868987\",\n \"0.4585314\",\n \"0.4572974\",\n \"0.4572539\",\n \"0.4564635\",\n \"0.45592147\",\n \"0.45540085\",\n \"0.45529658\",\n \"0.45429057\",\n \"0.45320842\",\n \"0.45320842\",\n \"0.45319477\",\n \"0.45308533\",\n \"0.45267165\",\n \"0.4525772\",\n \"0.45247528\",\n \"0.45185468\",\n \"0.45169526\",\n \"0.4496851\",\n \"0.44891387\",\n \"0.44856963\",\n \"0.44848403\",\n \"0.44799614\",\n \"0.4479314\",\n \"0.44736072\",\n \"0.44654348\",\n \"0.44639155\",\n \"0.44611803\",\n \"0.4455441\",\n \"0.44439384\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7558165"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76590,"cells":{"query":{"kind":"string","value":"Gets the label of this GIFOutput. This label is another way to identify this specific output. The label is returned in the response, but does not appear in the file name."},"document":{"kind":"string","value":"def label(self):\n return self._label"},"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 label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def GetLabel(self) -> str:\n return self._label","def GetLabel(self):\n \n return self.label_str","def _get_label(self):\n return self.label","def get_label(self):\n return self._label","def get_label(self):\n\n return self._label","def get_label(self):\n return self.label","def get_label(self):\n return self.label","def get_label(self):\n return self.label","def get_label(self):\n return self.label","def get_label(self):\n return self.job[self.label_key]","def get_label ( self ):\n return self.label","def GetLabel(self):\r\n\r\n return self._label","def label(self) -> str:\n return self[\"label\"]","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def get_label(self, ):\n return self.attrs.get(self.AttributeNames.LABEL, None)","def GetLabel(self):\r\n\r\n return self.label","def GetLabel(self):\r\n\r\n return self.label","def _get_label ( self ):\n if self._label is not None:\n return self._label\n return self.name","def get_label(self):\n return openmediavault.string.unescape_blank(\n self.get_udev_property('ID_FS_LABEL_ENC', '')\n )","def label(self):\n return self._label_","def label(self):\r\n return self._label","def label(self):\n return self.label_","def label(self) -> str:\n return self._underlying.label","def label(self) -> str:\r\n self._logger.debug(log_message_formatter(\r\n \"get\", f\"{self}\", \"label\"))\r\n return self._name","def get_label_name(self):\n command_type = self.get_type()\n if command_type == LABEL_COMMAND_TYPE:\n return self.command[1:-1] # ignores the () at the beginning and the end\n if command_type != EMPTY_COMMAND_TYPE: # increments the line number if it is not a blank line or a label\n self.__line_number += 1","def label_name(self) -> str:\n return pulumi.get(self, \"label_name\")","def get_label(filename:str) -> str:\n label = filename.split(\"/\")[-2]\n return label","def label(self):\r\n return self._name","def label(self):\n return self.__label","def label(self):\n return self.__label","def label(self) -> str:\r\n\r\n return self.__label","def _get_label(cls, file_name):\n if cls == \"neg\":\n return \"0\"\n else:\n return \"1\"\n # reg = _REGEX_\n # rmtch = reg.match(file_name)\n # if rmtch:\n # return rmtch.groupdict()[\"label\"]\n # else:\n # return \"unknown_positive\"","def get_name(self):\n return self._label","def label(self):\r\n return self._text","def label(self) -> str:\n return self.__parameters.label","def to_label(self):\n return self.label","def label(self):\n\n return self.identifier","def GetBitmapLabel(self):\n\n return self.bmpLabel","def Label(self, default=None):\n return self.data.get('label', default)","def Label(self, default=None):\n return self.data.get('label', default)","def getLabel(self):\n result = self.content[:12]\n if result == \"\":\n if self.tags:\n result = str(self.tags.first)\n return result","def get_labelname(self):\n return self.options['labelname']","def get_label(cls) -> str:\n return cls._meta.label_lower.split('.')[-1]","def version_label(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"version_label\")","def getLabel(self):\n return self.content[:12]","def label(self) -> str:\n return str(ffi.string(lib.SDL_GetKeyName(self.value)), encoding=\"utf-8\")","def _get_label(self):\n if self.model.name == '':\n return \"KPI\"\n return \"KPI: {} ({})\".format(self.model.name, self.model.objective)","def label(self):\n # type: () -> str\n labels = self.__class__.__labels__\n return force_str(labels.get(self.value, self.name))","def _get_label ( self ):\n if self._label is not None:\n return self._label\n return user_name_for( self.name )","def label(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"label\")","def label(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"label\")","def label(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"label\")","def label(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"label\")","def label(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"label\")","def label(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"label\")","def label(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"label\")","def label(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"label\")","def get_label(cls):\n return cls._type_name(cls.label)","def get_label(cls):\r\n return cls._type_name(cls.label)","def get_label(self, key):\n return self.labels.get(key, None)","def get_label(img_path):\n img_name = img_path.stem\n label_name = img_name + \".txt\"\n label_path = img_path.parent / label_name\n with open(label_path) as f:\n label = json.load(f)\n return label","def label_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"label_name\")","def getMetaLabel(self, idx):\n return self.label_dict[idx].decode(\"utf-8\")","def get_label(self):\n return ThreeCardPokerHand.all_labels[self.rank]","def get_label(self):\n oshape = (ctypes.c_uint * 2)()\n ostride = ctypes.c_uint()\n ret = cxnlib.CXNIOGetLabel(self.handle,\n oshape, ctypes.byref(ostride))\n return ctypes2numpyT(ret, [x for x in oshape], 'float32', ostride.value)","def label(self):\n return self._label_shape","def get_label(client, label):\n image_name = get_image_name()\n image = client.images.get(image_name)\n try:\n return image.labels[label]\n except KeyError:\n raise Exception(f\"Image should have a label '{label}'\")","def label(self):\n return ''","def get_label(image, model):\n x = Variable(image, volatile=True)\n label = model(x).data.max(1)[1].numpy()[0]\n # We have string labels for ImageNet\n if isinstance(model, torchvision.models.inception.Inception3):\n label_string = labels.get(label)\n return label_string\n return label","def label(self) -> Optional[str]:\n return self._itempage.labels.get(\"en\", None)","def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"labels\")","def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"labels\")","def image_name(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"image_name\")","def tests_ti_file_get_label(self):\n super().indicator_get_label()","def Label(self) -> str:","def name(self):\n return self._output_name","def getLabel(self):\n if self.__state & self.stClean:\n return self.__label\n else:\n raise SmiError('%s object not fully initialized' % self.__class__.__name__)","def get_label_name(label_id):\n if self._int_to_label == {}:\n print(\"ERROR\")\n print(\"Need to import data first\")\n else:\n label_name = self._int_to_label[label_id]\n\n return label_name","def getLabel(self, channel, group, inout=None, unitCode=0):\n if inout != None and group == \"E\":\n resp = self.XAPCommand(\"LABEL\", channel, group, inout, unitCode=unitCode)\n else:\n resp = self.XAPCommand(\"LABEL\", channel, group, unitCode=unitCode)\n return resp"],"string":"[\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def GetLabel(self) -> str:\\n return self._label\",\n \"def GetLabel(self):\\n \\n return self.label_str\",\n \"def _get_label(self):\\n return self.label\",\n \"def get_label(self):\\n return self._label\",\n \"def get_label(self):\\n\\n return self._label\",\n \"def get_label(self):\\n return self.label\",\n \"def get_label(self):\\n return self.label\",\n \"def get_label(self):\\n return self.label\",\n \"def get_label(self):\\n return self.label\",\n \"def get_label(self):\\n return self.job[self.label_key]\",\n \"def get_label ( self ):\\n return self.label\",\n \"def GetLabel(self):\\r\\n\\r\\n return self._label\",\n \"def label(self) -> str:\\n return self[\\\"label\\\"]\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def get_label(self, ):\\n return self.attrs.get(self.AttributeNames.LABEL, None)\",\n \"def GetLabel(self):\\r\\n\\r\\n return self.label\",\n \"def GetLabel(self):\\r\\n\\r\\n return self.label\",\n \"def _get_label ( self ):\\n if self._label is not None:\\n return self._label\\n return self.name\",\n \"def get_label(self):\\n return openmediavault.string.unescape_blank(\\n self.get_udev_property('ID_FS_LABEL_ENC', '')\\n )\",\n \"def label(self):\\n return self._label_\",\n \"def label(self):\\r\\n return self._label\",\n \"def label(self):\\n return self.label_\",\n \"def label(self) -> str:\\n return self._underlying.label\",\n \"def label(self) -> str:\\r\\n self._logger.debug(log_message_formatter(\\r\\n \\\"get\\\", f\\\"{self}\\\", \\\"label\\\"))\\r\\n return self._name\",\n \"def get_label_name(self):\\n command_type = self.get_type()\\n if command_type == LABEL_COMMAND_TYPE:\\n return self.command[1:-1] # ignores the () at the beginning and the end\\n if command_type != EMPTY_COMMAND_TYPE: # increments the line number if it is not a blank line or a label\\n self.__line_number += 1\",\n \"def label_name(self) -> str:\\n return pulumi.get(self, \\\"label_name\\\")\",\n \"def get_label(filename:str) -> str:\\n label = filename.split(\\\"/\\\")[-2]\\n return label\",\n \"def label(self):\\r\\n return self._name\",\n \"def label(self):\\n return self.__label\",\n \"def label(self):\\n return self.__label\",\n \"def label(self) -> str:\\r\\n\\r\\n return self.__label\",\n \"def _get_label(cls, file_name):\\n if cls == \\\"neg\\\":\\n return \\\"0\\\"\\n else:\\n return \\\"1\\\"\\n # reg = _REGEX_\\n # rmtch = reg.match(file_name)\\n # if rmtch:\\n # return rmtch.groupdict()[\\\"label\\\"]\\n # else:\\n # return \\\"unknown_positive\\\"\",\n \"def get_name(self):\\n return self._label\",\n \"def label(self):\\r\\n return self._text\",\n \"def label(self) -> str:\\n return self.__parameters.label\",\n \"def to_label(self):\\n return self.label\",\n \"def label(self):\\n\\n return self.identifier\",\n \"def GetBitmapLabel(self):\\n\\n return self.bmpLabel\",\n \"def Label(self, default=None):\\n return self.data.get('label', default)\",\n \"def Label(self, default=None):\\n return self.data.get('label', default)\",\n \"def getLabel(self):\\n result = self.content[:12]\\n if result == \\\"\\\":\\n if self.tags:\\n result = str(self.tags.first)\\n return result\",\n \"def get_labelname(self):\\n return self.options['labelname']\",\n \"def get_label(cls) -> str:\\n return cls._meta.label_lower.split('.')[-1]\",\n \"def version_label(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"version_label\\\")\",\n \"def getLabel(self):\\n return self.content[:12]\",\n \"def label(self) -> str:\\n return str(ffi.string(lib.SDL_GetKeyName(self.value)), encoding=\\\"utf-8\\\")\",\n \"def _get_label(self):\\n if self.model.name == '':\\n return \\\"KPI\\\"\\n return \\\"KPI: {} ({})\\\".format(self.model.name, self.model.objective)\",\n \"def label(self):\\n # type: () -> str\\n labels = self.__class__.__labels__\\n return force_str(labels.get(self.value, self.name))\",\n \"def _get_label ( self ):\\n if self._label is not None:\\n return self._label\\n return user_name_for( self.name )\",\n \"def label(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def get_label(cls):\\n return cls._type_name(cls.label)\",\n \"def get_label(cls):\\r\\n return cls._type_name(cls.label)\",\n \"def get_label(self, key):\\n return self.labels.get(key, None)\",\n \"def get_label(img_path):\\n img_name = img_path.stem\\n label_name = img_name + \\\".txt\\\"\\n label_path = img_path.parent / label_name\\n with open(label_path) as f:\\n label = json.load(f)\\n return label\",\n \"def label_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"label_name\\\")\",\n \"def getMetaLabel(self, idx):\\n return self.label_dict[idx].decode(\\\"utf-8\\\")\",\n \"def get_label(self):\\n return ThreeCardPokerHand.all_labels[self.rank]\",\n \"def get_label(self):\\n oshape = (ctypes.c_uint * 2)()\\n ostride = ctypes.c_uint()\\n ret = cxnlib.CXNIOGetLabel(self.handle,\\n oshape, ctypes.byref(ostride))\\n return ctypes2numpyT(ret, [x for x in oshape], 'float32', ostride.value)\",\n \"def label(self):\\n return self._label_shape\",\n \"def get_label(client, label):\\n image_name = get_image_name()\\n image = client.images.get(image_name)\\n try:\\n return image.labels[label]\\n except KeyError:\\n raise Exception(f\\\"Image should have a label '{label}'\\\")\",\n \"def label(self):\\n return ''\",\n \"def get_label(image, model):\\n x = Variable(image, volatile=True)\\n label = model(x).data.max(1)[1].numpy()[0]\\n # We have string labels for ImageNet\\n if isinstance(model, torchvision.models.inception.Inception3):\\n label_string = labels.get(label)\\n return label_string\\n return label\",\n \"def label(self) -> Optional[str]:\\n return self._itempage.labels.get(\\\"en\\\", None)\",\n \"def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def labels(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"labels\\\")\",\n \"def image_name(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"image_name\\\")\",\n \"def tests_ti_file_get_label(self):\\n super().indicator_get_label()\",\n \"def Label(self) -> str:\",\n \"def name(self):\\n return self._output_name\",\n \"def getLabel(self):\\n if self.__state & self.stClean:\\n return self.__label\\n else:\\n raise SmiError('%s object not fully initialized' % self.__class__.__name__)\",\n \"def get_label_name(label_id):\\n if self._int_to_label == {}:\\n print(\\\"ERROR\\\")\\n print(\\\"Need to import data first\\\")\\n else:\\n label_name = self._int_to_label[label_id]\\n\\n return label_name\",\n \"def getLabel(self, channel, group, inout=None, unitCode=0):\\n if inout != None and group == \\\"E\\\":\\n resp = self.XAPCommand(\\\"LABEL\\\", channel, group, inout, unitCode=unitCode)\\n else:\\n resp = self.XAPCommand(\\\"LABEL\\\", channel, group, unitCode=unitCode)\\n return resp\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7676132","0.7676132","0.7676132","0.72346693","0.72052455","0.7165676","0.7153336","0.7116317","0.709397","0.709397","0.709397","0.709397","0.7070629","0.70703095","0.69807523","0.6979013","0.69762206","0.69762206","0.69762206","0.69762206","0.69762206","0.69762206","0.69762206","0.6972037","0.6962565","0.6962565","0.69537127","0.6941511","0.6922171","0.6886545","0.6827127","0.68057144","0.6784912","0.6763314","0.67596626","0.67278785","0.6713884","0.6703155","0.6703155","0.66584414","0.66516453","0.66439766","0.6636535","0.6619737","0.66102827","0.6609755","0.6608618","0.65314376","0.65314376","0.6530303","0.6524685","0.6521142","0.6518079","0.6514305","0.64887136","0.6480805","0.6447131","0.64372367","0.6432756","0.6432756","0.6432756","0.6432756","0.6394009","0.6394009","0.6394009","0.6394009","0.6394009","0.6394009","0.6394009","0.6362259","0.63470507","0.63341","0.631191","0.62613606","0.6247971","0.6242247","0.6213117","0.6206211","0.619334","0.61727625","0.61600596","0.6157331","0.6142215","0.6142215","0.6129026","0.61282074","0.6121466","0.61194456","0.61063987","0.6099471","0.60718864"],"string":"[\n \"0.7676132\",\n \"0.7676132\",\n \"0.7676132\",\n \"0.72346693\",\n \"0.72052455\",\n \"0.7165676\",\n \"0.7153336\",\n \"0.7116317\",\n \"0.709397\",\n \"0.709397\",\n \"0.709397\",\n \"0.709397\",\n \"0.7070629\",\n \"0.70703095\",\n \"0.69807523\",\n \"0.6979013\",\n \"0.69762206\",\n \"0.69762206\",\n \"0.69762206\",\n \"0.69762206\",\n \"0.69762206\",\n \"0.69762206\",\n \"0.69762206\",\n \"0.6972037\",\n \"0.6962565\",\n \"0.6962565\",\n \"0.69537127\",\n \"0.6941511\",\n \"0.6922171\",\n \"0.6886545\",\n \"0.6827127\",\n \"0.68057144\",\n \"0.6784912\",\n \"0.6763314\",\n \"0.67596626\",\n \"0.67278785\",\n \"0.6713884\",\n \"0.6703155\",\n \"0.6703155\",\n \"0.66584414\",\n \"0.66516453\",\n \"0.66439766\",\n \"0.6636535\",\n \"0.6619737\",\n \"0.66102827\",\n \"0.6609755\",\n \"0.6608618\",\n \"0.65314376\",\n \"0.65314376\",\n \"0.6530303\",\n \"0.6524685\",\n \"0.6521142\",\n \"0.6518079\",\n \"0.6514305\",\n \"0.64887136\",\n \"0.6480805\",\n \"0.6447131\",\n \"0.64372367\",\n \"0.6432756\",\n \"0.6432756\",\n \"0.6432756\",\n \"0.6432756\",\n \"0.6394009\",\n \"0.6394009\",\n \"0.6394009\",\n \"0.6394009\",\n \"0.6394009\",\n \"0.6394009\",\n \"0.6394009\",\n \"0.6362259\",\n \"0.63470507\",\n \"0.63341\",\n \"0.631191\",\n \"0.62613606\",\n \"0.6247971\",\n \"0.6242247\",\n \"0.6213117\",\n \"0.6206211\",\n \"0.619334\",\n \"0.61727625\",\n \"0.61600596\",\n \"0.6157331\",\n \"0.6142215\",\n \"0.6142215\",\n \"0.6129026\",\n \"0.61282074\",\n \"0.6121466\",\n \"0.61194456\",\n \"0.61063987\",\n \"0.6099471\",\n \"0.60718864\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69314796"},"document_rank":{"kind":"string","value":"36"}}},{"rowIdx":76591,"cells":{"query":{"kind":"string","value":"Sets the label of this GIFOutput. This label is another way to identify this specific output. The label is returned in the response, but does not appear in the file name."},"document":{"kind":"string","value":"def label(self, label):\n\n self._label = label"},"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 SetLabel(self, label):\r\n\r\n self.label = label","def set_label(self, value: str = \"nowhere\"):\r\n self._logger.info(log_message_formatter(\r\n \"set\", f\"{self}\", \"label\"))\r\n self._name = value","def label(self, label: str):\n\n self._label = label","def SetLabel(self, label):\r\n\r\n self._label = label","def set_label(self, label):\n\n self._label = label","def setLabel(self, label):\r\n\t\tself.label = label","def setLabel(self, label):\r\n\t\tself.label = label","def setLabel(self, label):\r\n\t\tself.label = label","def write_label(self, label: str) -> None:\n self._write(f'({self._file_name}${label})')","def SetLabel(self, label):\n \n self.Freeze()\n self.label_str = label\n self.label.SetLabel(label)\n self.Layout()\n self.Thaw()","def set_label(self, value):\n self._set_one_attribute(self.AttributeNames.LABEL, value)\n return self","def set_label(self, label_config):\n self.label_config = label_config","def label(self, value: str):\n self._label = value","def label(self, value):\n\t\tself._label = value","def set_label(self, text):\n self._label = text","def writeLabel(self, label):\r\n\r\n # Label declaration.\r\n self.filename.write(\"({}:{})\\n\".format(self.actualFile.upper(), label.upper()))","def SetLabel(self, s):\r\n\r\n self.label = s","def _set_label(self, input_label):\n self.label = input_label\n return self.label","def set_label(self):\n try:\n self.get_mask()\n except ex.excError:\n pass\n self.label = \"netns %s %s/%s %s@%s\" % (self.mode, self.ipname, to_cidr(self.mask), self.ipdev, self.container_rid)","def setLabel(self, channel, group, label, inout=None, unitCode=0):\n if inout != None and group == \"E\":\n resp = self.XAPCommand(\"LABEL\", channel, group, inout, label, unitCode=unitCode)\n else:\n resp = self.XAPCommand(\"LABEL\", channel, group, label, unitCode=unitCode)\n return resp","def label(self, label: str):\n if label is None:\n raise ValueError(\"Invalid value for `label`, must not be `None`\")\n\n self._label = label","def label(self, label: str):\n if label is None:\n raise ValueError(\"Invalid value for `label`, must not be `None`\")\n\n self._label = label","def label(self, label):\n if label is None:\n raise ValueError(\"Invalid value for `label`, must not be `None`\")\n\n self._label = label","def set_label(self):\n try:\n self.get_mask()\n except ex.excError:\n pass\n try:\n self.getaddr()\n addr = self.addr\n except ex.excError:\n addr = self.ipname\n self.label = \"%s/%s %s/%s\" % (addr, to_cidr(self.mask), self.ipdev, self.ipdevExt)\n if self.ipname != addr:\n self.label += \" \" + self.ipname","def UpdateLabel(self) -> _n_6_t_0:","def write_label(self, label):\n self._write_line('label ' + label) # TODO generate unique labels?","def setLabel(self, desc):\n self.label = desc","def set_labelname(self, labelname):\n self.options['labelname'] = labelname","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")","def _assign_label(self, format):\n cht_tmpl = self.out_label_tmpl\n return cht_tmpl.substitute(format)","def set_label(self, parser):\n name = parser.get_label_name()\n if name is not None:\n self.__add_new_label(name, parser.get_line_number())","def _load_img_label(self):\n name = self._launch_file_b()\n self._img_label.configure(text=name)","def cg_label(self, cmd):\n label = self.makeLabel(cmd)\n self.asm(f\"({label})\")","def rename_label(self, *args):\n return _ida_hexrays.vdui_t_rename_label(self, *args)","def setLabel(self, *args):\n return _libsbml.GeneProduct_setLabel(self, *args)","def set_label(self, label):\n self._remove_child_widget(self._label)\n self._add_child_widget(label)\n self._label = label\n self.update(self._label)","def label(self, label):\n if label is None:\n raise ValueError(\"Invalid value for `label`, must not be `None`\") # noqa: E501\n\n self._label = label","def setLabel(self, label):\n if self.cursor:\n self.cursor.label = label","def setLabelInfo(self, label, strInfo): # real signature unknown; restored from __doc__\n pass","def set_label(self, key: str, value: str):\n self.labels[key] = value","def setLabel(*args):","def setLabel(*args):","def setLabel(*args):","def setLabel(*args):","def setLabel(*args):","def _format_label(self, lbl, plot_src):\n lbl.text = \"{0:}\".format(plot_src.name)","def label(self) -> str:\n return self[\"label\"]","def add_label(self, label):\n status = self.ocp.add_label(resource_name=self.name, label=label)\n self.reload()\n return status","def setName(self, name):\n\t\tself.label.setText(name)","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def label(self) -> str:\n return self._label","def set_label_text (self, text):\n if text: self.label.set_label(text)","def _apply_label(self, label):\n data = {\n \"name\" : label.title,\n \"description\" : label.desc,\n \"color\" : label.color\n }\n resp = self._post(\n self._base + \"/labels\", data=self._format_data(data))","def label(self) -> str:\r\n\r\n return self.__label","def setLabel( self, cCtrlName, cLabel ):\n self.setControlModelProperty( cCtrlName, \"Label\", cLabel )","def SetLabel(self, label):\r\n\r\n self._strLabel = label\r\n self._pButton.SetLabel(self.GetBtnLabel())\r\n self._pButton.SetInitialSize()\r\n self._pButton.Refresh()\r\n\r\n self.Layout()","def default_label(self, label: str):\n self.settings[\"default_label\"] = label","def setLabelAnno(self,anno):\n self.label_anno.setText(f'Anno: {anno}')","def set_label(self, x=None, y=None):\n\n if x:\n self.axes.set_xlabel(x)\n if y:\n self.axes.set_ylabel(y)","def set_label(self, label):\n self._label.SetForegroundColour((0, 0, 0))\n self._label.SetLabel(label)\n self._label.SetFont(wx.NORMAL_FONT)\n # Don't seem to get automatic layout calls inside toolbars\n self.Layout()","def label_name(self) -> str:\n return pulumi.get(self, \"label_name\")","def label(self):\n return ''","def labels(self, labels):\n self._instructions_setter('LABEL', labels)","def GetLabel(self) -> str:\n return self._label","def label(self):\r\n return self._label","def _get_label(self):\n return self.label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def label(self):\n return self._label","def bb_labelname(hit):\n try:\n real_name = hit.group(1)\n L = Label.objects.get(name=real_name)\n T = loader.get_template('webview/t/label.html')\n C = Context({ 'L' : L })\n return T.render(C)\n except:\n # This will throw if the requested label is spelt incorrectly, or doesnt exist\n return '<img src=\"/static/transmit.png\" alt=\"Invalid Label\" border=\"0\" /> %s' % (real_name)","def label(self, label):\n if self.local_vars_configuration.client_side_validation and label is None: # noqa: E501\n raise ValueError(\"Invalid value for `label`, must not be `None`\") # noqa: E501\n\n self._label = label","def print_label(self, package_num=None):\r\n if package_num:\r\n packages = [self.shipment.response.CompletedShipmentDetail.CompletedPackageDetails[package_num]]\r\n else:\r\n packages = self.shipment.response.CompletedShipmentDetail.CompletedPackageDetails\r\n\r\n for package in packages:\r\n label_binary = binascii.a2b_base64(package.Label.Parts[0].Image)\r\n self._print_base64(label_binary)","def label(self) -> str:\n return self.__parameters.label","def get_label ( self ):\n return self.label","def setYLabel(self, label):\n self.__y_label__ = label","def GetLabel(self):\n \n return self.label_str"],"string":"[\n \"def SetLabel(self, label):\\r\\n\\r\\n self.label = label\",\n \"def set_label(self, value: str = \\\"nowhere\\\"):\\r\\n self._logger.info(log_message_formatter(\\r\\n \\\"set\\\", f\\\"{self}\\\", \\\"label\\\"))\\r\\n self._name = value\",\n \"def label(self, label: str):\\n\\n self._label = label\",\n \"def SetLabel(self, label):\\r\\n\\r\\n self._label = label\",\n \"def set_label(self, label):\\n\\n self._label = label\",\n \"def setLabel(self, label):\\r\\n\\t\\tself.label = label\",\n \"def setLabel(self, label):\\r\\n\\t\\tself.label = label\",\n \"def setLabel(self, label):\\r\\n\\t\\tself.label = label\",\n \"def write_label(self, label: str) -> None:\\n self._write(f'({self._file_name}${label})')\",\n \"def SetLabel(self, label):\\n \\n self.Freeze()\\n self.label_str = label\\n self.label.SetLabel(label)\\n self.Layout()\\n self.Thaw()\",\n \"def set_label(self, value):\\n self._set_one_attribute(self.AttributeNames.LABEL, value)\\n return self\",\n \"def set_label(self, label_config):\\n self.label_config = label_config\",\n \"def label(self, value: str):\\n self._label = value\",\n \"def label(self, value):\\n\\t\\tself._label = value\",\n \"def set_label(self, text):\\n self._label = text\",\n \"def writeLabel(self, label):\\r\\n\\r\\n # Label declaration.\\r\\n self.filename.write(\\\"({}:{})\\\\n\\\".format(self.actualFile.upper(), label.upper()))\",\n \"def SetLabel(self, s):\\r\\n\\r\\n self.label = s\",\n \"def _set_label(self, input_label):\\n self.label = input_label\\n return self.label\",\n \"def set_label(self):\\n try:\\n self.get_mask()\\n except ex.excError:\\n pass\\n self.label = \\\"netns %s %s/%s %s@%s\\\" % (self.mode, self.ipname, to_cidr(self.mask), self.ipdev, self.container_rid)\",\n \"def setLabel(self, channel, group, label, inout=None, unitCode=0):\\n if inout != None and group == \\\"E\\\":\\n resp = self.XAPCommand(\\\"LABEL\\\", channel, group, inout, label, unitCode=unitCode)\\n else:\\n resp = self.XAPCommand(\\\"LABEL\\\", channel, group, label, unitCode=unitCode)\\n return resp\",\n \"def label(self, label: str):\\n if label is None:\\n raise ValueError(\\\"Invalid value for `label`, must not be `None`\\\")\\n\\n self._label = label\",\n \"def label(self, label: str):\\n if label is None:\\n raise ValueError(\\\"Invalid value for `label`, must not be `None`\\\")\\n\\n self._label = label\",\n \"def label(self, label):\\n if label is None:\\n raise ValueError(\\\"Invalid value for `label`, must not be `None`\\\")\\n\\n self._label = label\",\n \"def set_label(self):\\n try:\\n self.get_mask()\\n except ex.excError:\\n pass\\n try:\\n self.getaddr()\\n addr = self.addr\\n except ex.excError:\\n addr = self.ipname\\n self.label = \\\"%s/%s %s/%s\\\" % (addr, to_cidr(self.mask), self.ipdev, self.ipdevExt)\\n if self.ipname != addr:\\n self.label += \\\" \\\" + self.ipname\",\n \"def UpdateLabel(self) -> _n_6_t_0:\",\n \"def write_label(self, label):\\n self._write_line('label ' + label) # TODO generate unique labels?\",\n \"def setLabel(self, desc):\\n self.label = desc\",\n \"def set_labelname(self, labelname):\\n self.options['labelname'] = labelname\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def label(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"label\\\")\",\n \"def _assign_label(self, format):\\n cht_tmpl = self.out_label_tmpl\\n return cht_tmpl.substitute(format)\",\n \"def set_label(self, parser):\\n name = parser.get_label_name()\\n if name is not None:\\n self.__add_new_label(name, parser.get_line_number())\",\n \"def _load_img_label(self):\\n name = self._launch_file_b()\\n self._img_label.configure(text=name)\",\n \"def cg_label(self, cmd):\\n label = self.makeLabel(cmd)\\n self.asm(f\\\"({label})\\\")\",\n \"def rename_label(self, *args):\\n return _ida_hexrays.vdui_t_rename_label(self, *args)\",\n \"def setLabel(self, *args):\\n return _libsbml.GeneProduct_setLabel(self, *args)\",\n \"def set_label(self, label):\\n self._remove_child_widget(self._label)\\n self._add_child_widget(label)\\n self._label = label\\n self.update(self._label)\",\n \"def label(self, label):\\n if label is None:\\n raise ValueError(\\\"Invalid value for `label`, must not be `None`\\\") # noqa: E501\\n\\n self._label = label\",\n \"def setLabel(self, label):\\n if self.cursor:\\n self.cursor.label = label\",\n \"def setLabelInfo(self, label, strInfo): # real signature unknown; restored from __doc__\\n pass\",\n \"def set_label(self, key: str, value: str):\\n self.labels[key] = value\",\n \"def setLabel(*args):\",\n \"def setLabel(*args):\",\n \"def setLabel(*args):\",\n \"def setLabel(*args):\",\n \"def setLabel(*args):\",\n \"def _format_label(self, lbl, plot_src):\\n lbl.text = \\\"{0:}\\\".format(plot_src.name)\",\n \"def label(self) -> str:\\n return self[\\\"label\\\"]\",\n \"def add_label(self, label):\\n status = self.ocp.add_label(resource_name=self.name, label=label)\\n self.reload()\\n return status\",\n \"def setName(self, name):\\n\\t\\tself.label.setText(name)\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def label(self) -> str:\\n return self._label\",\n \"def set_label_text (self, text):\\n if text: self.label.set_label(text)\",\n \"def _apply_label(self, label):\\n data = {\\n \\\"name\\\" : label.title,\\n \\\"description\\\" : label.desc,\\n \\\"color\\\" : label.color\\n }\\n resp = self._post(\\n self._base + \\\"/labels\\\", data=self._format_data(data))\",\n \"def label(self) -> str:\\r\\n\\r\\n return self.__label\",\n \"def setLabel( self, cCtrlName, cLabel ):\\n self.setControlModelProperty( cCtrlName, \\\"Label\\\", cLabel )\",\n \"def SetLabel(self, label):\\r\\n\\r\\n self._strLabel = label\\r\\n self._pButton.SetLabel(self.GetBtnLabel())\\r\\n self._pButton.SetInitialSize()\\r\\n self._pButton.Refresh()\\r\\n\\r\\n self.Layout()\",\n \"def default_label(self, label: str):\\n self.settings[\\\"default_label\\\"] = label\",\n \"def setLabelAnno(self,anno):\\n self.label_anno.setText(f'Anno: {anno}')\",\n \"def set_label(self, x=None, y=None):\\n\\n if x:\\n self.axes.set_xlabel(x)\\n if y:\\n self.axes.set_ylabel(y)\",\n \"def set_label(self, label):\\n self._label.SetForegroundColour((0, 0, 0))\\n self._label.SetLabel(label)\\n self._label.SetFont(wx.NORMAL_FONT)\\n # Don't seem to get automatic layout calls inside toolbars\\n self.Layout()\",\n \"def label_name(self) -> str:\\n return pulumi.get(self, \\\"label_name\\\")\",\n \"def label(self):\\n return ''\",\n \"def labels(self, labels):\\n self._instructions_setter('LABEL', labels)\",\n \"def GetLabel(self) -> str:\\n return self._label\",\n \"def label(self):\\r\\n return self._label\",\n \"def _get_label(self):\\n return self.label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def label(self):\\n return self._label\",\n \"def bb_labelname(hit):\\n try:\\n real_name = hit.group(1)\\n L = Label.objects.get(name=real_name)\\n T = loader.get_template('webview/t/label.html')\\n C = Context({ 'L' : L })\\n return T.render(C)\\n except:\\n # This will throw if the requested label is spelt incorrectly, or doesnt exist\\n return '<img src=\\\"/static/transmit.png\\\" alt=\\\"Invalid Label\\\" border=\\\"0\\\" /> %s' % (real_name)\",\n \"def label(self, label):\\n if self.local_vars_configuration.client_side_validation and label is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `label`, must not be `None`\\\") # noqa: E501\\n\\n self._label = label\",\n \"def print_label(self, package_num=None):\\r\\n if package_num:\\r\\n packages = [self.shipment.response.CompletedShipmentDetail.CompletedPackageDetails[package_num]]\\r\\n else:\\r\\n packages = self.shipment.response.CompletedShipmentDetail.CompletedPackageDetails\\r\\n\\r\\n for package in packages:\\r\\n label_binary = binascii.a2b_base64(package.Label.Parts[0].Image)\\r\\n self._print_base64(label_binary)\",\n \"def label(self) -> str:\\n return self.__parameters.label\",\n \"def get_label ( self ):\\n return self.label\",\n \"def setYLabel(self, label):\\n self.__y_label__ = label\",\n \"def GetLabel(self):\\n \\n return self.label_str\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7037132","0.7015011","0.6995444","0.69905746","0.6945674","0.69194204","0.69194204","0.69194204","0.6830198","0.6777393","0.6766795","0.67664","0.6736288","0.6702227","0.6684909","0.6660016","0.66550493","0.66285706","0.6598174","0.6524958","0.65165377","0.65165377","0.6509795","0.6440991","0.64131457","0.6389271","0.63678795","0.63435304","0.63287854","0.63287854","0.63287854","0.6276466","0.6266976","0.6240907","0.62055355","0.61936074","0.6108341","0.6094807","0.60754555","0.6066892","0.6041817","0.6036814","0.6013532","0.6013532","0.6013532","0.6013532","0.6013532","0.60051984","0.5934738","0.59125525","0.5905495","0.58929455","0.58929455","0.58929455","0.58929455","0.58929455","0.58929455","0.58929455","0.58876526","0.588622","0.58830076","0.5857136","0.585592","0.5850594","0.58299583","0.5827787","0.58107364","0.5803737","0.5746163","0.57368827","0.5728878","0.56784195","0.56720513","0.5663525","0.5663525","0.5663525","0.5663525","0.5663525","0.5663525","0.5663525","0.5663525","0.5663525","0.5663525","0.5661196","0.5649912","0.564911","0.5646223","0.56394726","0.5637529","0.56278497"],"string":"[\n \"0.7037132\",\n \"0.7015011\",\n \"0.6995444\",\n \"0.69905746\",\n \"0.6945674\",\n \"0.69194204\",\n \"0.69194204\",\n \"0.69194204\",\n \"0.6830198\",\n \"0.6777393\",\n \"0.6766795\",\n \"0.67664\",\n \"0.6736288\",\n \"0.6702227\",\n \"0.6684909\",\n \"0.6660016\",\n \"0.66550493\",\n \"0.66285706\",\n \"0.6598174\",\n \"0.6524958\",\n \"0.65165377\",\n \"0.65165377\",\n \"0.6509795\",\n \"0.6440991\",\n \"0.64131457\",\n \"0.6389271\",\n \"0.63678795\",\n \"0.63435304\",\n \"0.63287854\",\n \"0.63287854\",\n \"0.63287854\",\n \"0.6276466\",\n \"0.6266976\",\n \"0.6240907\",\n \"0.62055355\",\n \"0.61936074\",\n \"0.6108341\",\n \"0.6094807\",\n \"0.60754555\",\n \"0.6066892\",\n \"0.6041817\",\n \"0.6036814\",\n \"0.6013532\",\n \"0.6013532\",\n \"0.6013532\",\n \"0.6013532\",\n \"0.6013532\",\n \"0.60051984\",\n \"0.5934738\",\n \"0.59125525\",\n \"0.5905495\",\n \"0.58929455\",\n \"0.58929455\",\n \"0.58929455\",\n \"0.58929455\",\n \"0.58929455\",\n \"0.58929455\",\n \"0.58929455\",\n \"0.58876526\",\n \"0.588622\",\n \"0.58830076\",\n \"0.5857136\",\n \"0.585592\",\n \"0.5850594\",\n \"0.58299583\",\n \"0.5827787\",\n \"0.58107364\",\n \"0.5803737\",\n \"0.5746163\",\n \"0.57368827\",\n \"0.5728878\",\n \"0.56784195\",\n \"0.56720513\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5663525\",\n \"0.5661196\",\n \"0.5649912\",\n \"0.564911\",\n \"0.5646223\",\n \"0.56394726\",\n \"0.5637529\",\n \"0.56278497\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6942709"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":76592,"cells":{"query":{"kind":"string","value":"Returns the model properties as a dict"},"document":{"kind":"string","value":"def to_dict(self):\n result = {}\n\n for attr, _ in six.iteritems(self.swagger_types):\n value = getattr(self, attr)\n if isinstance(value, list):\n result[attr] = list(map(\n lambda x: x.to_dict() if hasattr(x, \"to_dict\") else x,\n value\n ))\n elif hasattr(value, \"to_dict\"):\n result[attr] = value.to_dict()\n elif isinstance(value, dict):\n result[attr] = dict(map(\n lambda item: (item[0], item[1].to_dict())\n if hasattr(item[1], \"to_dict\") else item,\n value.items()\n ))\n else:\n result[attr] = value\n\n return result"},"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 to_dict(self):\n return self.properties","def to_dict(self):\n return self.properties","def get_properties(self):\n return self.properties","def asdict(self):\n return self._prop_dict","def json(self):\n rv = {\n prop: getattr(self, prop)\n for prop in self.__properties__\n if prop in vars(self)\n }\n rv.update(self._props)\n return rv","def get_properties(self):\n return self.properties","def get_properties():","def getProperties():","def properties(self):\r\n if self._properties is None:\r\n res = self._con.get(self._url, {'f':'json'})\r\n self._properties = PropertyMap(res)\r\n return self._properties","def properties(self):\r\n if self._properties is None:\r\n res = self._con.get(self._url, {'f':'json'})\r\n self._properties = PropertyMap(res)\r\n return self._properties","def getProperties(self):\n return self.properties","def __properties__(self) -> dict:\r\n parameters = [\r\n d for d in dir(self) if (d[0] != \"_\") and (d.count(\"set\") == 0)\r\n and (d.count(\"_c\") == 0) and (d.count(\"_f\") == 0)\r\n ]\r\n\r\n return self.__as_json__(parameters)","def json_properties(self):\n attributes = []\n all = vars(self)\n for var in all:\n if var[:1] != '_':\n attributes.append(var)\n if isinstance(self, db.Model):\n properties = self.properties().keys()\n for property in properties:\n if property[:1] != '_':\n attributes.append(property)\n return attributes","def properties(self) -> Any:\n return pulumi.get(self, \"properties\")","def _properties(self) -> dict[str, dict[str, str]]:\n schema = self.schema(by_alias=False)\n if schema.get('properties') is not None:\n return schema.get('properties', {})\n return schema.get('definitions', {}).get(self.__class__.__name__, {}).get('properties', {})","def get_model_properties(self):\n properties = {}\n\n filename = self._get_data_filename(\"modelargs.json\")\n with open(filename, \"r\") as f:\n results = json.loads(f.read())\n properties[\"image_size\"] = results.get(\"image_size\")\n properties[\"num_classes\"] = results.get(\"num_classes\")\n properties[\"model\"] = results.get(\"model\")\n properties[\"name\"] = results.get(\"name\")\n properties[\"filter_size\"] = results.get(\"filter_size\", 3)\n properties[\"increase_factor\"] = results.get(\"increase_factor\", 0)\n self.model = properties[\"name\"] # regardless of the name of the folder, this will get the proper model name (i.e. <modelname>.cntk)\n\n # optional property\n properties[\"trainer\"] = results.get(\"trainer\", \"CNTK 2.2\")\n\n self._ensure_model_file()\n properties[\"size_mb\"] = round(os.path.getsize(self.model_file) / (1000 * 1000))\n\n return properties","def as_dict(self):\n result = {}\n for attr in self.__attr:\n result[attr] = getattr(self, attr)\n return result","def to_dict_model(self) -> dict:\n return dict((key, getattr(self, key)) for key in self.__mapper__.c.keys())","def get_properties():\n properties = dict()\n properties['size'] = list()\n properties['color'] = list()\n properties['quality'] = list()\n u = models.Size.query.all()\n for i in u:\n properties['size'].append(i.size_name)\n u = models.Color.query.all()\n for i in u:\n properties['color'].append(i.color_name)\n u = models.Quality.query.all()\n for i in u:\n properties['quality'].append(i.quality_name)\n return make_response(jsonify(properties))","def get_modelDict(self):\n return self.__modelDict","def attributes(self):\n return dict(self.__attributes)","def properties(self):\n return self._properties","def properties(self):\n return self._properties","def to_dict(self):\n result = {}\n for p in self.json_properties():\n value = getattr(self, p)\n if isinstance(value, datetime.datetime):\n value = value.strftime('%s%f')[:-3]\n result[Jsonifiable.transform_to_camelcase(p)] = value\n return result","def properties(self):\n return self._props","def properties(self):\n pass","def to_dict(self):\n d = {}\n for attr in self.__class__.attributes:\n d[attr] = getattr(self, attr)\n return d","def properties_get(self):\n return self._get('properties')","def _collect_properties(self):\n properties = {\n 'userid': self.user_id,\n 'title': self.get_fullname()\n }\n if not self.ogds_user:\n return properties\n\n for attribute_name in self.ogds_user_attributes:\n value = getattr(self.ogds_user, attribute_name)\n properties[attribute_name] = value\n return properties","def getPropertyDict(self):\n \n d = self.getChild('__properties')\n if d:\n return d.getDict()\n else:\n return {}","def get_attributes(self):\n return dict(self.attributes) # return the attributes","def get_attributes(self):\n return dict(self.attributes) # return the attributes","def get_attributes(self):\n return dict(self.attributes) # return the attributes","def to_dict(self, include=None):\n _MODEL = type(self)\n repr_dict = {}\n if include is None:\n include = []\n for name, prop in _MODEL._properties.iteritems():\n if hasattr(prop, 'public') and getattr(prop, 'public', False):\n include.append(name)\n\n for name in include:\n # check if this property is even allowed to be public\n # or has a value set\n if not hasattr(self, name):\n continue\n\n value = getattr(self, name)\n if type(getattr(_MODEL, name)) == ndb.StructuredProperty:\n if isinstance(value, list):\n items = []\n for item in value:\n items.append(item.to_dict(include=None))\n repr_dict[name] = items\n else:\n repr_dict[name] = value.to_dict(include=None)\n elif isinstance(value, date):\n repr_dict[name] = value.isoformat()\n elif isinstance(value, ndb.Key):\n repr_dict[name] = value.urlsafe()\n else:\n repr_dict[name] = value\n\n if self._key:\n repr_dict['key'] = self.get_key_urlsafe()\n return repr_dict","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k == 'POSSIBLE_METHODS':\n continue\n if k == 'keysamplers':\n properties[k] = [i.to_dict() for i in self.__dict__[k] if hasattr(i,'to_dict')]\n elif k in {'pooler'}:\n properties[k] = self.__dict__[k].to_dict()\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def get_all_properties(cls):\n return ['key', 'id'] + _.keys(cls._properties)","def get_properties(self):\n return self.name, self.author, self.description, self.fmu_type, self.version, self.guid, self.tool, self.numStates","def properties(self):\n\n return self._properties","def ToDict(self):\n atributes_dictionary = {}\n for key, value in self.__dict__.iteritems():\n atributes_dictionary[key] = value\n return atributes_dictionary","def properties(self):","def properties(self):","def properties(self):","def modelPropertiesDictionary(sql_row_list):\n \n properties_dictionary = \\\n {\n \"id\": sql_row_list[0],\n \"name\": sql_row_list[1],\n \"last_deploy_timestamp\": sql_row_list[2],\n \"active_version\": sql_row_list[3],\n \"build_id\": sql_row_list[4]\n };\n\n return properties_dictionary;","def as_dict(self):\n data = dict()\n for name in self.fields:\n val = getattr(self, name)\n if isinstance(val, Model):\n val = val.as_dict()\n elif isinstance(val, list) and val and isinstance(val[0], Model):\n val = [sub.as_dict() for sub in val]\n data[name] = val\n return data","def to_dict(self):\n if self._dict is not None:\n return self._dict\n\n result = {}\n for key in self.ATTRIBUTES:\n value = getattr(self, key)\n if value:\n result[key] = value\n self._dict = result\n return result","def properties(self) -> Optional[Mapping[str, str]]:\n return pulumi.get(self, \"properties\")","def properties(self) -> Optional[Mapping[str, str]]:\n return pulumi.get(self, \"properties\")","def to_dict(self):\n _dict = {}\n for f in self._meta.fields:\n if f.name == 'created':\n _dict[f.name] = str(f.value_from_object(self))\n else:\n _dict[f.name] = f.value_from_object(self)\n\n return _dict","def to_dict(self):\r\n return self.__dict__","def properties(self):\n return None","def properties(self):\n return None","def to_dict(self):\n return attr.asdict(self)","def as_dict(self):\n return self.__dict__","def _get_model_state(self) -> dict:\n return dict(model=self.model, kwargs=self._model_kwargs)","def dictify(self):\n return {\n \"name\" : self.name,\n \"lastname\" : self.lastname,\n \"phone\" : self.phone,\n \"email\" : self.email\n }","def to_dict(self):\n return {\n \"id\": self.id,\n \"name\": self.name,\n # \"created_by\": self.created_by,\n # \"created_on\": self.created_on,\n # \"modified_by\": self.modified_by,\n # \"modified_on\": self.modified_on\n }","def properties(self):\r\n return resources.Properties(self)","def attributes(self):\n params = self.model.param_array\n return {'parameters': params}","def properties(self, pk):\n return JsonResponse(self._get_properties(pk))","def to_dict(self):\n return vars(self)","def to_dict(self):\n\n # Check if is the right instance.\n if isinstance(self, db.Model):\n # construct a dictionary from column names and values.\n dict_representation = {c.name: getattr(self, c.name) for c in self.__table__.columns}\n return dict_representation\n else:\n raise AttributeError(type(self).__name__ + \" is not instance of \" + db.Model.__name__)","def bson_properties(self):\n return []","def to_dict(self):\n return {\n \"id\": self.id,\n \"name\": self.name\n }","def get_dict(self):\n return","def to_dict(self):\n return to_dict(self.__dict__)","def to_json(self):\n properties = self.to_dict()\n if isinstance(self, db.Model):\n properties['id'] = unicode(self.key().id())\n return json.dumps(properties)","def to_dict(self):","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def to_dict(self):\n return self.__dict__","def get_attributes(self) -> Dict[str, str]:\n pass","def config(self) -> ModelConfigDict:\n return self.config_obj.to_dict()","def properties(self):\n return self.properties_with_uid[1:]","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k in {'idsSoFar'}:\n continue\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k in {'idsSoFar'}:\n continue\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def to_dict(self):\n properties = {}\n for k in self.__dict__:\n if k in {'idsSoFar'}:\n continue\n else:\n properties[k] = deepcopy(self.__dict__[k])\n return properties","def serialise(self):\n return {\n 'id': self.id,\n 'category_id': self.category_id,\n 'name': self.name,\n 'description': self.description,\n 'quantity': self.quantity,\n 'price': self.price,\n 'user_id': self.user_id\n }","def getPropertiesAll():","def get_all_properties(self) -> dict:\n return self._request(\n \"post\",\n URL,\n json=attr.asdict(\n Body(\"getAllProperties\", API_VERSION),\n filter=attr.filters.exclude(attr.fields(Body).params),\n ),\n )","def model_info(self):\n if not self._model_info:\n self._load_model_info()\n try:\n data = json.loads(self._model_info)\n except (TypeError, ValueError):\n data = {}\n return data","def to_dict(self):\n return {\n 'name': self.get_name(),\n 'description': self.get_description()\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def serialize(self):\n return {\n 'id' : self.id,\n 'name' : self.name,\n }","def as_dict(self):\n return self.__dict__","def to_dict(self):\r\n\r\n return {\r\n 'product_id': self.product_id,\r\n 'product_name': self.product_name\r\n }","def serialize(self):\n return {\n 'name' : self.name,\n 'id' : self.id,\n }","def asdict(self):\n return attr.asdict(self)","def to_dict(self) -> dict:","def getDict(self):\n res = {}\n for attr, value in self.__dict__.iteritems():\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\n res[attr] = value\n elif isinstance(attr, datetime.datetime):\n res[attr] = value.isoformat('-')\n \n return res","def attributes(self):\n return self.__dict.keys()","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def dict(self):\n return self.__dict__","def as_dict(self):\n return {c.key: getattr(self, c.key)\n for c in inspect(self).mapper.column_attrs}"],"string":"[\n \"def to_dict(self):\\n return self.properties\",\n \"def to_dict(self):\\n return self.properties\",\n \"def get_properties(self):\\n return self.properties\",\n \"def asdict(self):\\n return self._prop_dict\",\n \"def json(self):\\n rv = {\\n prop: getattr(self, prop)\\n for prop in self.__properties__\\n if prop in vars(self)\\n }\\n rv.update(self._props)\\n return rv\",\n \"def get_properties(self):\\n return self.properties\",\n \"def get_properties():\",\n \"def getProperties():\",\n \"def properties(self):\\r\\n if self._properties is None:\\r\\n res = self._con.get(self._url, {'f':'json'})\\r\\n self._properties = PropertyMap(res)\\r\\n return self._properties\",\n \"def properties(self):\\r\\n if self._properties is None:\\r\\n res = self._con.get(self._url, {'f':'json'})\\r\\n self._properties = PropertyMap(res)\\r\\n return self._properties\",\n \"def getProperties(self):\\n return self.properties\",\n \"def __properties__(self) -> dict:\\r\\n parameters = [\\r\\n d for d in dir(self) if (d[0] != \\\"_\\\") and (d.count(\\\"set\\\") == 0)\\r\\n and (d.count(\\\"_c\\\") == 0) and (d.count(\\\"_f\\\") == 0)\\r\\n ]\\r\\n\\r\\n return self.__as_json__(parameters)\",\n \"def json_properties(self):\\n attributes = []\\n all = vars(self)\\n for var in all:\\n if var[:1] != '_':\\n attributes.append(var)\\n if isinstance(self, db.Model):\\n properties = self.properties().keys()\\n for property in properties:\\n if property[:1] != '_':\\n attributes.append(property)\\n return attributes\",\n \"def properties(self) -> Any:\\n return pulumi.get(self, \\\"properties\\\")\",\n \"def _properties(self) -> dict[str, dict[str, str]]:\\n schema = self.schema(by_alias=False)\\n if schema.get('properties') is not None:\\n return schema.get('properties', {})\\n return schema.get('definitions', {}).get(self.__class__.__name__, {}).get('properties', {})\",\n \"def get_model_properties(self):\\n properties = {}\\n\\n filename = self._get_data_filename(\\\"modelargs.json\\\")\\n with open(filename, \\\"r\\\") as f:\\n results = json.loads(f.read())\\n properties[\\\"image_size\\\"] = results.get(\\\"image_size\\\")\\n properties[\\\"num_classes\\\"] = results.get(\\\"num_classes\\\")\\n properties[\\\"model\\\"] = results.get(\\\"model\\\")\\n properties[\\\"name\\\"] = results.get(\\\"name\\\")\\n properties[\\\"filter_size\\\"] = results.get(\\\"filter_size\\\", 3)\\n properties[\\\"increase_factor\\\"] = results.get(\\\"increase_factor\\\", 0)\\n self.model = properties[\\\"name\\\"] # regardless of the name of the folder, this will get the proper model name (i.e. <modelname>.cntk)\\n\\n # optional property\\n properties[\\\"trainer\\\"] = results.get(\\\"trainer\\\", \\\"CNTK 2.2\\\")\\n\\n self._ensure_model_file()\\n properties[\\\"size_mb\\\"] = round(os.path.getsize(self.model_file) / (1000 * 1000))\\n\\n return properties\",\n \"def as_dict(self):\\n result = {}\\n for attr in self.__attr:\\n result[attr] = getattr(self, attr)\\n return result\",\n \"def to_dict_model(self) -> dict:\\n return dict((key, getattr(self, key)) for key in self.__mapper__.c.keys())\",\n \"def get_properties():\\n properties = dict()\\n properties['size'] = list()\\n properties['color'] = list()\\n properties['quality'] = list()\\n u = models.Size.query.all()\\n for i in u:\\n properties['size'].append(i.size_name)\\n u = models.Color.query.all()\\n for i in u:\\n properties['color'].append(i.color_name)\\n u = models.Quality.query.all()\\n for i in u:\\n properties['quality'].append(i.quality_name)\\n return make_response(jsonify(properties))\",\n \"def get_modelDict(self):\\n return self.__modelDict\",\n \"def attributes(self):\\n return dict(self.__attributes)\",\n \"def properties(self):\\n return self._properties\",\n \"def properties(self):\\n return self._properties\",\n \"def to_dict(self):\\n result = {}\\n for p in self.json_properties():\\n value = getattr(self, p)\\n if isinstance(value, datetime.datetime):\\n value = value.strftime('%s%f')[:-3]\\n result[Jsonifiable.transform_to_camelcase(p)] = value\\n return result\",\n \"def properties(self):\\n return self._props\",\n \"def properties(self):\\n pass\",\n \"def to_dict(self):\\n d = {}\\n for attr in self.__class__.attributes:\\n d[attr] = getattr(self, attr)\\n return d\",\n \"def properties_get(self):\\n return self._get('properties')\",\n \"def _collect_properties(self):\\n properties = {\\n 'userid': self.user_id,\\n 'title': self.get_fullname()\\n }\\n if not self.ogds_user:\\n return properties\\n\\n for attribute_name in self.ogds_user_attributes:\\n value = getattr(self.ogds_user, attribute_name)\\n properties[attribute_name] = value\\n return properties\",\n \"def getPropertyDict(self):\\n \\n d = self.getChild('__properties')\\n if d:\\n return d.getDict()\\n else:\\n return {}\",\n \"def get_attributes(self):\\n return dict(self.attributes) # return the attributes\",\n \"def get_attributes(self):\\n return dict(self.attributes) # return the attributes\",\n \"def get_attributes(self):\\n return dict(self.attributes) # return the attributes\",\n \"def to_dict(self, include=None):\\n _MODEL = type(self)\\n repr_dict = {}\\n if include is None:\\n include = []\\n for name, prop in _MODEL._properties.iteritems():\\n if hasattr(prop, 'public') and getattr(prop, 'public', False):\\n include.append(name)\\n\\n for name in include:\\n # check if this property is even allowed to be public\\n # or has a value set\\n if not hasattr(self, name):\\n continue\\n\\n value = getattr(self, name)\\n if type(getattr(_MODEL, name)) == ndb.StructuredProperty:\\n if isinstance(value, list):\\n items = []\\n for item in value:\\n items.append(item.to_dict(include=None))\\n repr_dict[name] = items\\n else:\\n repr_dict[name] = value.to_dict(include=None)\\n elif isinstance(value, date):\\n repr_dict[name] = value.isoformat()\\n elif isinstance(value, ndb.Key):\\n repr_dict[name] = value.urlsafe()\\n else:\\n repr_dict[name] = value\\n\\n if self._key:\\n repr_dict['key'] = self.get_key_urlsafe()\\n return repr_dict\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k == 'POSSIBLE_METHODS':\\n continue\\n if k == 'keysamplers':\\n properties[k] = [i.to_dict() for i in self.__dict__[k] if hasattr(i,'to_dict')]\\n elif k in {'pooler'}:\\n properties[k] = self.__dict__[k].to_dict()\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def get_all_properties(cls):\\n return ['key', 'id'] + _.keys(cls._properties)\",\n \"def get_properties(self):\\n return self.name, self.author, self.description, self.fmu_type, self.version, self.guid, self.tool, self.numStates\",\n \"def properties(self):\\n\\n return self._properties\",\n \"def ToDict(self):\\n atributes_dictionary = {}\\n for key, value in self.__dict__.iteritems():\\n atributes_dictionary[key] = value\\n return atributes_dictionary\",\n \"def properties(self):\",\n \"def properties(self):\",\n \"def properties(self):\",\n \"def modelPropertiesDictionary(sql_row_list):\\n \\n properties_dictionary = \\\\\\n {\\n \\\"id\\\": sql_row_list[0],\\n \\\"name\\\": sql_row_list[1],\\n \\\"last_deploy_timestamp\\\": sql_row_list[2],\\n \\\"active_version\\\": sql_row_list[3],\\n \\\"build_id\\\": sql_row_list[4]\\n };\\n\\n return properties_dictionary;\",\n \"def as_dict(self):\\n data = dict()\\n for name in self.fields:\\n val = getattr(self, name)\\n if isinstance(val, Model):\\n val = val.as_dict()\\n elif isinstance(val, list) and val and isinstance(val[0], Model):\\n val = [sub.as_dict() for sub in val]\\n data[name] = val\\n return data\",\n \"def to_dict(self):\\n if self._dict is not None:\\n return self._dict\\n\\n result = {}\\n for key in self.ATTRIBUTES:\\n value = getattr(self, key)\\n if value:\\n result[key] = value\\n self._dict = result\\n return result\",\n \"def properties(self) -> Optional[Mapping[str, str]]:\\n return pulumi.get(self, \\\"properties\\\")\",\n \"def properties(self) -> Optional[Mapping[str, str]]:\\n return pulumi.get(self, \\\"properties\\\")\",\n \"def to_dict(self):\\n _dict = {}\\n for f in self._meta.fields:\\n if f.name == 'created':\\n _dict[f.name] = str(f.value_from_object(self))\\n else:\\n _dict[f.name] = f.value_from_object(self)\\n\\n return _dict\",\n \"def to_dict(self):\\r\\n return self.__dict__\",\n \"def properties(self):\\n return None\",\n \"def properties(self):\\n return None\",\n \"def to_dict(self):\\n return attr.asdict(self)\",\n \"def as_dict(self):\\n return self.__dict__\",\n \"def _get_model_state(self) -> dict:\\n return dict(model=self.model, kwargs=self._model_kwargs)\",\n \"def dictify(self):\\n return {\\n \\\"name\\\" : self.name,\\n \\\"lastname\\\" : self.lastname,\\n \\\"phone\\\" : self.phone,\\n \\\"email\\\" : self.email\\n }\",\n \"def to_dict(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name,\\n # \\\"created_by\\\": self.created_by,\\n # \\\"created_on\\\": self.created_on,\\n # \\\"modified_by\\\": self.modified_by,\\n # \\\"modified_on\\\": self.modified_on\\n }\",\n \"def properties(self):\\r\\n return resources.Properties(self)\",\n \"def attributes(self):\\n params = self.model.param_array\\n return {'parameters': params}\",\n \"def properties(self, pk):\\n return JsonResponse(self._get_properties(pk))\",\n \"def to_dict(self):\\n return vars(self)\",\n \"def to_dict(self):\\n\\n # Check if is the right instance.\\n if isinstance(self, db.Model):\\n # construct a dictionary from column names and values.\\n dict_representation = {c.name: getattr(self, c.name) for c in self.__table__.columns}\\n return dict_representation\\n else:\\n raise AttributeError(type(self).__name__ + \\\" is not instance of \\\" + db.Model.__name__)\",\n \"def bson_properties(self):\\n return []\",\n \"def to_dict(self):\\n return {\\n \\\"id\\\": self.id,\\n \\\"name\\\": self.name\\n }\",\n \"def get_dict(self):\\n return\",\n \"def to_dict(self):\\n return to_dict(self.__dict__)\",\n \"def to_json(self):\\n properties = self.to_dict()\\n if isinstance(self, db.Model):\\n properties['id'] = unicode(self.key().id())\\n return json.dumps(properties)\",\n \"def to_dict(self):\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\n return self.__dict__\",\n \"def get_attributes(self) -> Dict[str, str]:\\n pass\",\n \"def config(self) -> ModelConfigDict:\\n return self.config_obj.to_dict()\",\n \"def properties(self):\\n return self.properties_with_uid[1:]\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k in {'idsSoFar'}:\\n continue\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k in {'idsSoFar'}:\\n continue\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def to_dict(self):\\n properties = {}\\n for k in self.__dict__:\\n if k in {'idsSoFar'}:\\n continue\\n else:\\n properties[k] = deepcopy(self.__dict__[k])\\n return properties\",\n \"def serialise(self):\\n return {\\n 'id': self.id,\\n 'category_id': self.category_id,\\n 'name': self.name,\\n 'description': self.description,\\n 'quantity': self.quantity,\\n 'price': self.price,\\n 'user_id': self.user_id\\n }\",\n \"def getPropertiesAll():\",\n \"def get_all_properties(self) -> dict:\\n return self._request(\\n \\\"post\\\",\\n URL,\\n json=attr.asdict(\\n Body(\\\"getAllProperties\\\", API_VERSION),\\n filter=attr.filters.exclude(attr.fields(Body).params),\\n ),\\n )\",\n \"def model_info(self):\\n if not self._model_info:\\n self._load_model_info()\\n try:\\n data = json.loads(self._model_info)\\n except (TypeError, ValueError):\\n data = {}\\n return data\",\n \"def to_dict(self):\\n return {\\n 'name': self.get_name(),\\n 'description': self.get_description()\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def serialize(self):\\n return {\\n 'id' : self.id,\\n 'name' : self.name,\\n }\",\n \"def as_dict(self):\\n return self.__dict__\",\n \"def to_dict(self):\\r\\n\\r\\n return {\\r\\n 'product_id': self.product_id,\\r\\n 'product_name': self.product_name\\r\\n }\",\n \"def serialize(self):\\n return {\\n 'name' : self.name,\\n 'id' : self.id,\\n }\",\n \"def asdict(self):\\n return attr.asdict(self)\",\n \"def to_dict(self) -> dict:\",\n \"def getDict(self):\\n res = {}\\n for attr, value in self.__dict__.iteritems():\\n if type(attr) is IntType or type(attr) is StringType or type(attr) is LongType or type(attr) is UnicodeType:\\n res[attr] = value\\n elif isinstance(attr, datetime.datetime):\\n res[attr] = value.isoformat('-')\\n \\n return res\",\n \"def attributes(self):\\n return self.__dict.keys()\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def dict(self):\\n return self.__dict__\",\n \"def as_dict(self):\\n return {c.key: getattr(self, c.key)\\n for c in inspect(self).mapper.column_attrs}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7751993","0.7751993","0.73391134","0.7334895","0.7297356","0.727818","0.7159078","0.71578115","0.71494967","0.71494967","0.71283495","0.71275014","0.7122587","0.71079814","0.7060394","0.7043251","0.7034103","0.70233124","0.69635814","0.69586295","0.690053","0.6881568","0.6881568","0.6857664","0.68415916","0.68122137","0.680096","0.67914945","0.6757063","0.6753585","0.6741746","0.6741746","0.6741746","0.6735291","0.67126125","0.6697801","0.6695801","0.6689893","0.6680752","0.66802895","0.66802895","0.66802895","0.66547817","0.66495687","0.6633999","0.6619567","0.6619567","0.66156983","0.66049474","0.6590706","0.6590706","0.6590206","0.6587873","0.65861845","0.65822417","0.65794736","0.65792733","0.657747","0.6571183","0.65662557","0.65637356","0.6539919","0.65396816","0.65283066","0.65252614","0.6513477","0.65098846","0.65077883","0.65077883","0.65077883","0.65077883","0.65077883","0.65077883","0.6507418","0.6505772","0.65015876","0.64951885","0.64951885","0.64951885","0.64857763","0.6474329","0.6469453","0.64684683","0.6453606","0.6453024","0.6453024","0.6430734","0.6429058","0.6426903","0.64215595","0.64201874","0.6417152","0.6414739","0.6411571","0.6411571","0.6411571","0.6411571","0.6411571","0.6411571","0.6411571","0.64035517"],"string":"[\n \"0.7751993\",\n \"0.7751993\",\n \"0.73391134\",\n \"0.7334895\",\n \"0.7297356\",\n \"0.727818\",\n \"0.7159078\",\n \"0.71578115\",\n \"0.71494967\",\n \"0.71494967\",\n \"0.71283495\",\n \"0.71275014\",\n \"0.7122587\",\n \"0.71079814\",\n \"0.7060394\",\n \"0.7043251\",\n \"0.7034103\",\n \"0.70233124\",\n \"0.69635814\",\n \"0.69586295\",\n \"0.690053\",\n \"0.6881568\",\n \"0.6881568\",\n \"0.6857664\",\n \"0.68415916\",\n \"0.68122137\",\n \"0.680096\",\n \"0.67914945\",\n \"0.6757063\",\n \"0.6753585\",\n \"0.6741746\",\n \"0.6741746\",\n \"0.6741746\",\n \"0.6735291\",\n \"0.67126125\",\n \"0.6697801\",\n \"0.6695801\",\n \"0.6689893\",\n \"0.6680752\",\n \"0.66802895\",\n \"0.66802895\",\n \"0.66802895\",\n \"0.66547817\",\n \"0.66495687\",\n \"0.6633999\",\n \"0.6619567\",\n \"0.6619567\",\n \"0.66156983\",\n \"0.66049474\",\n \"0.6590706\",\n \"0.6590706\",\n \"0.6590206\",\n \"0.6587873\",\n \"0.65861845\",\n \"0.65822417\",\n \"0.65794736\",\n \"0.65792733\",\n \"0.657747\",\n \"0.6571183\",\n \"0.65662557\",\n \"0.65637356\",\n \"0.6539919\",\n \"0.65396816\",\n \"0.65283066\",\n \"0.65252614\",\n \"0.6513477\",\n \"0.65098846\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.65077883\",\n \"0.6507418\",\n \"0.6505772\",\n \"0.65015876\",\n \"0.64951885\",\n \"0.64951885\",\n \"0.64951885\",\n \"0.64857763\",\n \"0.6474329\",\n \"0.6469453\",\n \"0.64684683\",\n \"0.6453606\",\n \"0.6453024\",\n \"0.6453024\",\n \"0.6430734\",\n \"0.6429058\",\n \"0.6426903\",\n \"0.64215595\",\n \"0.64201874\",\n \"0.6417152\",\n \"0.6414739\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.6411571\",\n \"0.64035517\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76593,"cells":{"query":{"kind":"string","value":"Returns the string representation of the model"},"document":{"kind":"string","value":"def to_str(self):\n return pprint.pformat(self.to_dict())"},"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 __str__(self):\n return super().__str__() + self.model.__str__()","def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n model_fields = get_model_fields(\n opts.model,\n foreign=False,\n m2m=False,\n exclude=self.exclude_from_str\n )\n # TODO: replace the above with the below to remove the get_model_fields call:\n # model_fields = [\n # f for f in opts.get_fields()\n # if f.concrete\n # and not (f.primary_key or f.is_relation or f.name in self.exclude_from_str)\n # ]\n result = \" \".join(\n [\n str(fld.value_from_object(self))\n for fld in model_fields\n if fld.value_from_object(self)\n ]\n )\n return result.strip() or super().__str__()","def __str__(self):\n return '%s%s' % (self.name, ' - %s' % self.model if self.model else '')","def __str__(self):\n model = self._meta.verbose_name.title()\n return f\"{model:s}: {self.name:s}\"","def __str__(self):\n model = self._meta.verbose_name.title()\n return f\"{model:s}: {self.name:s}\"","def __repr__(self):\n\n mod = f\"{self.__class__.__name__} Model\"\n try:\n mod += f': {self.filename}'\n except AttributeError:\n pass\n s = [mod]\n for name, v in self.metadata.items():\n s += [f\"{name:16} : {v}\"]\n return '\\n'.join(s)","def __str__(self):\n \n res = ['>>> Model %(model_name)s <<<']\n res.append('')\n res.append('Independent parameters:')\n res.append('-----------------------')\n res.append('')","def __str__(self):\n return \"DataModel(name={},attributes={},description={})\".format(\n self.name, {a.name: str(a) for a in self.attributes}, self.description\n )","def model_info(self) -> str:\n return self._model_info(self.model).decode(\"utf-8\")","def __str__(self):\n return str(self.serialize())","def __str__ (self) :\n\n return self.as_string()","def __str__(self):\n\n return self.toString()","def __str__(self):\n msg = [\n f'{self.model=}',\n f'{self.field=}',\n f'{self.fxx=}',\n f'{self.date=}',\n f'{self.priority=}',\n ]\n return '\\n'.join(msg)","def __str__(self):\n model = self._meta.verbose_name.title()\n title = self.extended_object.get_title()\n return f\"{model:s}: {title:s}\"","def __repr__(self):\n return grid_search_to_str(self.model)","def __str__(self):\n return self.toString()","def __str__(self):\n return str(self.__dict__)","def __str__(self):\n return str(self.__dict__)","def to_representation(self) -> str:\n raise NotImplementedError()","def __str__(self):\n return str(self.obj)","def __str__(self):\n return self.make_flat()","def dump_model(self):","def __str__(self):\n return str(self.__dict__['_obj'])","def __str__(self) -> str:\n model_str = [\"\\nModel info:\\n\", \" Unimodal encoder:\\n\"]\n\n for modality in range(self.num_modalities):\n model_str.append(f\" ({modality + 1}) {self.unimodal_encoder[modality]}\")\n\n model_str.append(\"\\n\\n Unimodal decoder:\\n\")\n for modality in range(self.num_modalities):\n model_str.append(f\" ({modality + 1}) {self.unimodal_decoder[modality]}\")\n\n if self.multimodal_decoder is not None:\n model_str.append(\"\\n\\n Multimodal decoder:\\n\")\n model_str.append(f\" {self.multimodal_decoder}\")\n\n return \"\".join(model_str)","def __repr__(self):\n s = 'text model name: ' + self.name + '\\n'\n s += ' number of words: ' + str(len(self.words)) + '\\n'\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\n'\n s += ' number of stems: ' + str(len(self.stems)) + '\\n'\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\n'\n s += ' most common words: ' + str(self.common_word) + '\\n'\n\n return s","def to_string(self):\r\n return self.__str__()","def __repr__(self):\n return '<ModelSignature(model_name=%r)>' % self.model_name","def __repr__(self):\n return '<ModelSignature(model_name=%r)>' % self.model_name","def __str__(self):\n return str(self.get_data())","def __str__(self):\n return f\"model {self._name}\"","def __str__(self):\n\n return self.raw_field","def __repr__(self):\n \n s = 'text model name: ' + self.name + '\\n' \n s += ' number of words: ' + str(len(self.words)) + '\\n'\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\n'\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\n'\n s += ' number of word stems: ' + str(len(self.stems)) + '\\n'\n s += ' number of commas counts: ' + str(len(self.commas_per_sentence)) + '\\n'\n return s","def serialize(self):\n\n\t\treturn str(self)","def __str__(self):\n return self.get_str()","def serialize(self):\n\n return str(self)","def __str__(self) -> str:\n if self.name_field:\n return str(getattr(self, self.name_field))\n # noinspection PyUnresolvedReferences\n data = [\n # Collect the string representations of related objects.\n # getattr(self, fk_field.attname) and\n # fk_field.value_from_object(self) would only return the primary\n # key of the related object.\n str(getattr(self, fk_field.name))\n for fk_field in get_model_fields(\n self._meta.model, base=False, foreign=True, m2m=False\n )\n if not fk_field.null\n ]\n if len(data) < 2:\n # Cannot build a more meaningful representation than the default.\n return super().__str__()\n else:\n template = \"{}\" + \" ({})\" * (len(data) - 1)\n return template.format(*data)","def __str__(self):\n return self.s","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __str__(self):\n return self.__repr__()","def __repr__(self):\n\n # info string\n info = self.model.__repr__()\n info += \"\\n=========================\\n\"\n info += f\"Train data length:\\t\\t{ len(self.train_dataset) }\\n\"\n info += f\"Eval sata length:\\t\\t{ len(self.eval_dataset) }\\n\"\n info += f\"Optimizer:\\t\\t\\t\\t{ str(self.optimizer).split('(')[0] }\\n\"\n info += f\"Criterion:\\t\\t\\t\\t{ str(self.criterion).split('(')[0] }\\n\"\n info += f\"Training Environment:\\t{ self.device.type }\\n\"\n info += f\"Show information:\\t\\t{ 'True' if self.info else 'False' }\\n\"\n info += \"=========================\\n\"\n\n return info","def __repr__(self):\n s = 'text model name: ' + self.name + '\\n'\n s += ' number of words: ' + str(len(self.words)) + '\\n'\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\n'\n s += ' number of stems: ' + str(len(self.stems)) + '\\n'\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths))\\\n + '\\n'\n s += ' number of punctuation types: ' + str(len(self.punctuation))\n return s","def dumps(self, indent=0):\n outstr = \" \"*indent + \"MewloDbModel object '{0}' attribute values:\\n\".format(self.__class__.__name__)\n public_props = (name for name in dir(object) if not name.startswith('_'))\n for name in public_props:\n outstr += \" \"*indent + \"{0}: {1}\\n\".format(name, str(getattr(self,name)))\n return outstr","def __str__(self):\n model = self._meta.verbose_name.title()\n title = self.title or str(_(\"Empty title\"))\n\n return f\"{model:s}: {title:s}\"","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()","def __repr__(self):\n return self.to_str()"],"string":"[\n \"def __str__(self):\\n return super().__str__() + self.model.__str__()\",\n \"def __str__(self) -> str:\\n # noinspection PyUnresolvedReferences\\n opts = self._meta\\n if self.name_field:\\n result = str(opts.get_field(self.name_field).value_from_object(self))\\n else:\\n model_fields = get_model_fields(\\n opts.model,\\n foreign=False,\\n m2m=False,\\n exclude=self.exclude_from_str\\n )\\n # TODO: replace the above with the below to remove the get_model_fields call:\\n # model_fields = [\\n # f for f in opts.get_fields()\\n # if f.concrete\\n # and not (f.primary_key or f.is_relation or f.name in self.exclude_from_str)\\n # ]\\n result = \\\" \\\".join(\\n [\\n str(fld.value_from_object(self))\\n for fld in model_fields\\n if fld.value_from_object(self)\\n ]\\n )\\n return result.strip() or super().__str__()\",\n \"def __str__(self):\\n return '%s%s' % (self.name, ' - %s' % self.model if self.model else '')\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n return f\\\"{model:s}: {self.name:s}\\\"\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n return f\\\"{model:s}: {self.name:s}\\\"\",\n \"def __repr__(self):\\n\\n mod = f\\\"{self.__class__.__name__} Model\\\"\\n try:\\n mod += f': {self.filename}'\\n except AttributeError:\\n pass\\n s = [mod]\\n for name, v in self.metadata.items():\\n s += [f\\\"{name:16} : {v}\\\"]\\n return '\\\\n'.join(s)\",\n \"def __str__(self):\\n \\n res = ['>>> Model %(model_name)s <<<']\\n res.append('')\\n res.append('Independent parameters:')\\n res.append('-----------------------')\\n res.append('')\",\n \"def __str__(self):\\n return \\\"DataModel(name={},attributes={},description={})\\\".format(\\n self.name, {a.name: str(a) for a in self.attributes}, self.description\\n )\",\n \"def model_info(self) -> str:\\n return self._model_info(self.model).decode(\\\"utf-8\\\")\",\n \"def __str__(self):\\n return str(self.serialize())\",\n \"def __str__ (self) :\\n\\n return self.as_string()\",\n \"def __str__(self):\\n\\n return self.toString()\",\n \"def __str__(self):\\n msg = [\\n f'{self.model=}',\\n f'{self.field=}',\\n f'{self.fxx=}',\\n f'{self.date=}',\\n f'{self.priority=}',\\n ]\\n return '\\\\n'.join(msg)\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n title = self.extended_object.get_title()\\n return f\\\"{model:s}: {title:s}\\\"\",\n \"def __repr__(self):\\n return grid_search_to_str(self.model)\",\n \"def __str__(self):\\n return self.toString()\",\n \"def __str__(self):\\n return str(self.__dict__)\",\n \"def __str__(self):\\n return str(self.__dict__)\",\n \"def to_representation(self) -> str:\\n raise NotImplementedError()\",\n \"def __str__(self):\\n return str(self.obj)\",\n \"def __str__(self):\\n return self.make_flat()\",\n \"def dump_model(self):\",\n \"def __str__(self):\\n return str(self.__dict__['_obj'])\",\n \"def __str__(self) -> str:\\n model_str = [\\\"\\\\nModel info:\\\\n\\\", \\\" Unimodal encoder:\\\\n\\\"]\\n\\n for modality in range(self.num_modalities):\\n model_str.append(f\\\" ({modality + 1}) {self.unimodal_encoder[modality]}\\\")\\n\\n model_str.append(\\\"\\\\n\\\\n Unimodal decoder:\\\\n\\\")\\n for modality in range(self.num_modalities):\\n model_str.append(f\\\" ({modality + 1}) {self.unimodal_decoder[modality]}\\\")\\n\\n if self.multimodal_decoder is not None:\\n model_str.append(\\\"\\\\n\\\\n Multimodal decoder:\\\\n\\\")\\n model_str.append(f\\\" {self.multimodal_decoder}\\\")\\n\\n return \\\"\\\".join(model_str)\",\n \"def __repr__(self):\\n s = 'text model name: ' + self.name + '\\\\n'\\n s += ' number of words: ' + str(len(self.words)) + '\\\\n'\\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\\\n'\\n s += ' number of stems: ' + str(len(self.stems)) + '\\\\n'\\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\\\n'\\n s += ' most common words: ' + str(self.common_word) + '\\\\n'\\n\\n return s\",\n \"def to_string(self):\\r\\n return self.__str__()\",\n \"def __repr__(self):\\n return '<ModelSignature(model_name=%r)>' % self.model_name\",\n \"def __repr__(self):\\n return '<ModelSignature(model_name=%r)>' % self.model_name\",\n \"def __str__(self):\\n return str(self.get_data())\",\n \"def __str__(self):\\n return f\\\"model {self._name}\\\"\",\n \"def __str__(self):\\n\\n return self.raw_field\",\n \"def __repr__(self):\\n \\n s = 'text model name: ' + self.name + '\\\\n' \\n s += ' number of words: ' + str(len(self.words)) + '\\\\n'\\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\\\n'\\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths)) + '\\\\n'\\n s += ' number of word stems: ' + str(len(self.stems)) + '\\\\n'\\n s += ' number of commas counts: ' + str(len(self.commas_per_sentence)) + '\\\\n'\\n return s\",\n \"def serialize(self):\\n\\n\\t\\treturn str(self)\",\n \"def __str__(self):\\n return self.get_str()\",\n \"def serialize(self):\\n\\n return str(self)\",\n \"def __str__(self) -> str:\\n if self.name_field:\\n return str(getattr(self, self.name_field))\\n # noinspection PyUnresolvedReferences\\n data = [\\n # Collect the string representations of related objects.\\n # getattr(self, fk_field.attname) and\\n # fk_field.value_from_object(self) would only return the primary\\n # key of the related object.\\n str(getattr(self, fk_field.name))\\n for fk_field in get_model_fields(\\n self._meta.model, base=False, foreign=True, m2m=False\\n )\\n if not fk_field.null\\n ]\\n if len(data) < 2:\\n # Cannot build a more meaningful representation than the default.\\n return super().__str__()\\n else:\\n template = \\\"{}\\\" + \\\" ({})\\\" * (len(data) - 1)\\n return template.format(*data)\",\n \"def __str__(self):\\n return self.s\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __str__(self):\\n return self.__repr__()\",\n \"def __repr__(self):\\n\\n # info string\\n info = self.model.__repr__()\\n info += \\\"\\\\n=========================\\\\n\\\"\\n info += f\\\"Train data length:\\\\t\\\\t{ len(self.train_dataset) }\\\\n\\\"\\n info += f\\\"Eval sata length:\\\\t\\\\t{ len(self.eval_dataset) }\\\\n\\\"\\n info += f\\\"Optimizer:\\\\t\\\\t\\\\t\\\\t{ str(self.optimizer).split('(')[0] }\\\\n\\\"\\n info += f\\\"Criterion:\\\\t\\\\t\\\\t\\\\t{ str(self.criterion).split('(')[0] }\\\\n\\\"\\n info += f\\\"Training Environment:\\\\t{ self.device.type }\\\\n\\\"\\n info += f\\\"Show information:\\\\t\\\\t{ 'True' if self.info else 'False' }\\\\n\\\"\\n info += \\\"=========================\\\\n\\\"\\n\\n return info\",\n \"def __repr__(self):\\n s = 'text model name: ' + self.name + '\\\\n'\\n s += ' number of words: ' + str(len(self.words)) + '\\\\n'\\n s += ' number of word lengths: ' + str(len(self.word_lengths)) + '\\\\n'\\n s += ' number of stems: ' + str(len(self.stems)) + '\\\\n'\\n s += ' number of sentence lengths: ' + str(len(self.sentence_lengths))\\\\\\n + '\\\\n'\\n s += ' number of punctuation types: ' + str(len(self.punctuation))\\n return s\",\n \"def dumps(self, indent=0):\\n outstr = \\\" \\\"*indent + \\\"MewloDbModel object '{0}' attribute values:\\\\n\\\".format(self.__class__.__name__)\\n public_props = (name for name in dir(object) if not name.startswith('_'))\\n for name in public_props:\\n outstr += \\\" \\\"*indent + \\\"{0}: {1}\\\\n\\\".format(name, str(getattr(self,name)))\\n return outstr\",\n \"def __str__(self):\\n model = self._meta.verbose_name.title()\\n title = self.title or str(_(\\\"Empty title\\\"))\\n\\n return f\\\"{model:s}: {title:s}\\\"\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\",\n \"def __repr__(self):\\n return self.to_str()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.85856134","0.7814518","0.77898884","0.7751367","0.7751367","0.7712228","0.76981676","0.76700574","0.7651133","0.7597206","0.75800353","0.7568254","0.7538184","0.75228703","0.7515832","0.7498764","0.74850684","0.74850684","0.7467648","0.74488163","0.7442643","0.74416703","0.7433768","0.7411771","0.7405439","0.7379557","0.7361716","0.7361716","0.732774","0.7325511","0.732528","0.73097324","0.73078936","0.73001266","0.7296789","0.7292791","0.7289445","0.7287187","0.7287187","0.7287187","0.7287187","0.7287187","0.7279803","0.7261615","0.7250399","0.7244789","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068","0.7223068"],"string":"[\n \"0.85856134\",\n \"0.7814518\",\n \"0.77898884\",\n \"0.7751367\",\n \"0.7751367\",\n \"0.7712228\",\n \"0.76981676\",\n \"0.76700574\",\n \"0.7651133\",\n \"0.7597206\",\n \"0.75800353\",\n \"0.7568254\",\n \"0.7538184\",\n \"0.75228703\",\n \"0.7515832\",\n \"0.7498764\",\n \"0.74850684\",\n \"0.74850684\",\n \"0.7467648\",\n \"0.74488163\",\n \"0.7442643\",\n \"0.74416703\",\n \"0.7433768\",\n \"0.7411771\",\n \"0.7405439\",\n \"0.7379557\",\n \"0.7361716\",\n \"0.7361716\",\n \"0.732774\",\n \"0.7325511\",\n \"0.732528\",\n \"0.73097324\",\n \"0.73078936\",\n \"0.73001266\",\n \"0.7296789\",\n \"0.7292791\",\n \"0.7289445\",\n \"0.7287187\",\n \"0.7287187\",\n \"0.7287187\",\n \"0.7287187\",\n \"0.7287187\",\n \"0.7279803\",\n \"0.7261615\",\n \"0.7250399\",\n \"0.7244789\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\",\n \"0.7223068\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76594,"cells":{"query":{"kind":"string","value":"For `print` and `pprint`"},"document":{"kind":"string","value":"def __repr__(self):\n return self.to_str()"},"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 pprint(*args, **kwargs):\n if PRINTING:\n print(*args, **kwargs)","def print_out():\n pass","def custom_print(*objects):\n print(*objects, sep=OFS, end=ORS)","def _print(self, *args):\n return _ida_hexrays.vd_printer_t__print(self, *args)","def _printable(self):\n pass","def _print_custom(self):\n pass","def pprint(self):\n # just here for defining the interface; work is done in subclasses\n pass","def pypprint(*args, **kwargs): # type: ignore\n from typing import Iterable\n\n if len(args) != 1:\n print(*args, **kwargs)\n return\n x = args[0]\n if isinstance(x, dict):\n for k, v in x.items():\n print(f\"{k}:\", v, **kwargs)\n elif isinstance(x, Iterable) and not isinstance(x, str):\n for i in x:\n print(i, **kwargs)\n else:\n print(x, **kwargs)","def print(*args, **kwargs):\n with P_LOCK:\n __builtins__.print(*args, **kwargs)","def print(self):\n # Your implementation here","def p(value):\n pp.pprint(value)","def static_print(*args, __p=print, **kwargs):\n __p(*args, **kwargs)","def print(self, *args, **kwargs):\n print(*args, **kwargs)","def pprint(self):\n print(self.pprint_str())","def pprint(obj):\n for argname in sorted([x for x in dir(obj) if not x.startswith('__')]):\n # Skip callables\n if hasattr(getattr(obj, argname), '__call__'):\n continue\n print(\"{} : {}\".format(argname, getattr(obj, argname)))","def print_(self, s: str) -> None:","def my_pprint(obj, intend = 0):\n if isinstance(obj, dict):\n for key, value in obj.items():\n print(intend*\" \"+str(key)+\" : \")\n my_pprint(value, intend = intend + 4)\n print()\n elif isinstance(obj, list):\n for value in obj:\n my_pprint(value, intend = intend + 4)\n print()\n elif isinstance(obj, bytes):\n print(\"<binary data>\")\n \n else:\n try:\n print(intend*\" \"+str(obj))\n except UnicodeDecodeError:\n print(intend*\" \"\"<?>\")","def test_print(chikin):\n chikin.print()","def _print(self, text):\n\t\tif self.verbose:\n\t\t\tprint text","def out(*args):\r\n print(*args)","def __pprint(object, stream=None, indent=1, width=80, depth=None):\n printer = PrettyPrinterExt(\n stream=stream, indent=indent, width=width, depth=depth)\n printer.pprint(object)","def DumpPprint(data):\n #NOTE(g): Import is done here, instead of the top of the file, to not require this module if it is not used\n import pprint\n \n text = pprint.pformat(data)\n \n return text","def repl_print_statements():\n pass","def test_03_pass_print(self):\n print('Hello World!')","def p(self):\n self.printstdout = True","def print(*args, **kwargs):\n new_args = []\n for arg in args:\n if builtins.isinstance(arg, models.Point):\n new_args.append(\"({0}, {1})\".format(arg.x, arg.y))\n else:\n new_args.append(arg)\n\n builtins.print(*new_args, **kwargs)","def real_print(*args, **kwargs):\n\n kwargs.setdefault('file', real_stdout)\n _python_print_function(*args, **kwargs)","def to_print_out(self):\n self.error_throw('output')\n\n if self.rank_method == methods_of_ranking[3]: #'diversified_ranking'\n self.output_div('print')\n else:\n self.output('print')","def debug_print(debug_data):\n if DEBUG_MODE == \"true\":\n pp.pprint(debug_data)","def print(self):\r\n self.print_avec_separateur()","def pprint(self):\r\n for i in self.items():\r\n print '%s => %r'%i","def pprint(self, parameter_s=''):\n ptformatter = self.shell.display_formatter.formatters['text/plain']\n ptformatter.pprint = bool(1 - ptformatter.pprint)\n print('Pretty printing has been turned',\n ['OFF','ON'][ptformatter.pprint])","def print(self):\n print(self.pretty_str())","def test_print4(self):\n writer = StringIO()\n collatz_print(writer, 1, 1, 1)\n self.assertEqual(writer.getvalue(), \"1 1 1\\n\")","def eprint(*args, **kwargs):\n\tprint(*args, file=sys.stderr, **kwargs)","def _print(self, *args, **kwargs) -> None:\n # Only print in verbose mode\n if self._verbose:\n arglist = list(args)\n arglist[0] = f\"[buddy-{self._experiment_name}] {args[0]}\"\n print(*arglist, **kwargs)","def use_pypprint_for_implicit_print(self) -> None:\n if self.implicit_print is not None:\n self.implicit_print.func.id = \"pypprint\" # type: ignore\n # Make sure we import it later\n self.undefined.add(\"pypprint\")","def test_print(self):\n writer = StringIO()\n collatz_print(writer, 1, 10, 20)\n self.assertEqual(writer.getvalue(), \"1 10 20\\n\")","def pprint(self):\n return pformat(repr(self))","def printer(message):\n if VERBOSITY:\n pprint(message)","def rec_print(p):\n if len(p) == 0:\n return\n t = p.pop(0)\n print t\n rec_print(p)","def printc(*a, **kw):\n print(*a, **kw)","def pformat(object):\r\n return PrettyPrinter().pformat(object)","def pr(x):\n Card.print_pretty_cards(x)","def debug_print(self, *content):\n if self.debug:\n print(*content)","def pprint(object, stream=None):\r\n printer = PrettyPrinter(stream=stream)\r\n printer.pprint(object)","def safe_print(*objs, errors=\"replace\"):\n\tprint(*(to_stdout(str(o), errors) for o in objs))","def magic_Pprint(self, parameter_s=''):\n \n self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint\n print 'Pretty printing has been turned', \\\n ['OFF','ON'][self.shell.outputcache.Pprint]","def print_output(tree):\n print_value(tree)\n print_tree(tree)","def _Print(self, t):\n self.RaiseError(t, \"Print not supported\")","def vprint(*args, **kwargs ):\n\n forceprint = False\n for key in kwargs:\n if key == \"forceprint\":\n forceprint =kwargs[key]\n \n line = ''\n if debug or forceprint : \n for arg in args:\n line += str(arg) +\" \"\n log = open(exepath + 'pyframe.log', 'a') \n log.write(line + \"\\n\")\n log.close() \n print line","def eprint(*pargs, **kargs):\n print('\\u001b[31m', end='', file=sys.stderr)\n print(*pargs, file=sys.stderr, **kargs)\n print('\\u001b[0m', end='', file=sys.stderr)","def printer(obj, ident=''):\n import inspect\n print ident + obj.__class__.__name__.upper()\n ident += ' '\n lists = []\n for name in dir(obj):\n elem = getattr(obj, name)\n if isinstance(elem, list) and name != u'decoded_content':\n lists.append(elem)\n elif not inspect.ismethod(elem):\n if not name.startswith('__'):\n if name == u'data' and elem:\n print ident + u'data = '\n printer(elem, ident + ' ')\n else:\n print ident + u'%s\\t= %s' % (name, getattr(obj, name))\n for l in lists:\n for i in l:\n printer(i, ident + ' ')","def printer(obj, ident=''):\n import inspect\n print ident + obj.__class__.__name__.upper()\n ident += ' '\n lists = []\n for name in dir(obj):\n elem = getattr(obj, name)\n if isinstance(elem, list) and name != u'decoded_content':\n lists.append(elem)\n elif not inspect.ismethod(elem):\n if not name.startswith('__'):\n if name == u'data' and elem:\n print ident + u'data = '\n printer(elem, ident + ' ')\n else:\n print ident + u'%s\\t= %s' % (name, getattr(obj, name))\n for l in lists:\n for i in l:\n printer(i, ident + ' ')","def _print(self, *args):\n return _ida_hexrays.qstring_printer_t__print(self, *args)","def pprint(self):\n def pprintStr(node):\n s = \"(\" + str(node.value) \n for action in node.children:\n s = s + \", \" + pprintStr(node.children[action])\n s = s + \")\"\n return s\n\n print pprintStr(self)","def hook_print():\n sys.stdout = PrintHook()","def cmdPrint( self, *args):\n return self.cmd( *args, **{ 'verbose': True } )","def print_list(self):\r\n pass","def debugprint(obj, depth=-1, print_type=False,\r\n file=None, ids='CHAR', stop_on_name=False):\r\n if file == 'str':\r\n _file = StringIO()\r\n elif file is None:\r\n _file = sys.stdout\r\n else:\r\n _file = file\r\n done = dict()\r\n results_to_print = []\r\n order = []\r\n if isinstance(obj, gof.Variable):\r\n results_to_print.append(obj)\r\n elif isinstance(obj, gof.Apply):\r\n results_to_print.extend(obj.outputs)\r\n elif isinstance(obj, Function):\r\n results_to_print.extend(obj.maker.fgraph.outputs)\r\n order = obj.maker.fgraph.toposort()\r\n elif isinstance(obj, (list, tuple)):\r\n results_to_print.extend(obj)\r\n elif isinstance(obj, gof.FunctionGraph):\r\n results_to_print.extend(obj.outputs)\r\n order = obj.toposort()\r\n elif isinstance(obj, (int, long, float, numpy.ndarray)):\r\n print obj\r\n else:\r\n raise TypeError(\"debugprint cannot print an object of this type\", obj)\r\n for r in results_to_print:\r\n debugmode.debugprint(r, depth=depth, done=done, print_type=print_type,\r\n file=_file, order=order, ids=ids,\r\n stop_on_name=stop_on_name)\r\n if file is _file:\r\n return file\r\n elif file == 'str':\r\n return _file.getvalue()\r\n else:\r\n _file.flush()","def _get_print_fn(file=sys.stdout):\n def _print_fn(op, xin,):\n for attr in op.attrs:\n temp = getattr(xin, attr)\n if callable(temp):\n pmsg = temp()\n else:\n pmsg = temp\n print(op.message, attr, '=', pmsg, file=file)\n return _print_fn","def test_print1(self):\n writer = StringIO()\n collatz_print(writer, 100, 200, 125)\n self.assertEqual(writer.getvalue(), \"100 200 125\\n\")","def printOutput(self):\n pass","def _print(self, *args):\n return _ida_hexrays.cnumber_t__print(self, *args)","def setPrint():\n (e,d,sr,sw) = codecs.lookup('utf-8')\n unicode_to_utf8 = sw(sys.stdout)\n sys.stdout = unicode_to_utf8","def print(*args, sep=\" \"):\n pass","def pr(string, verbose):\n if(verbose):\n print(string)","def printv(self, *arg):\n if self.verbose:\n print(*arg)","def print(self):\n\n print(self)","def _p(self, *args, level=2, **kwargs):\n if self._verbosity >= level:\n print(*args, **kwargs)","def test_print2(self):\n writer = StringIO()\n collatz_print(writer, 201, 210, 89)\n self.assertEqual(writer.getvalue(), \"201 210 89\\n\")","def print_pointers(self):\n\n ### FILL IN ###","def foo_printer(self):\n print(\"\\nHi I'm {}\".format(self.foo))","def printed(method):\n\t\tdef wrapper(cls, *args):\n\t\t\tif cls.verbose:\n\t\t\t\treturn method(cls, *args)\n\t\treturn wrapper","def print_me(self, tabs=0, tab=' '):\n pre = tab*tabs\n print(pre+'Producer:')\n print(pre+' produces:', self._produces)\n print(pre+' consumes:', self._consumes)\n print(pre+' transfer:', self._transfer)\n print(pre+' capacity:', self._capacity)","def _print(cls, quad):\n\t\tprint(\"\\nLIGHT OUTPUT:\\n<<<<{}>>>>\".format(ast.literal_eval(str(cls.get_address_value(quad.result)))))\n\t\tprint(\"END\")\n\n\t\tvar = cls.get_address_value(quad.result)\n\t\tif isinstance(var, collections.Iterable):\n\t\t\tprint(\"DEEP COPY\")\n\t\t\tcls.print_queue.enqueue(copy.deepcopy(var))\n\t\telse:\n\t\t\tcls.print_queue.enqueue(var)","def printout(*args, **kwargs):\n console_print(sys.stdout, *args, **kwargs)","def pprint(x):\n if is_theano_object(x):\n return _gettheano().printing.pprint(x)\n else:\n return str(x)","def PrettyPrint(self):\r\n print(self.data)\r\n return","def print(self):\n self.print_avec_separateur(\" \")","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def eprint(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)","def pprint_helper(self, angle, indent):\n # just here for defining the interface; work is done in subclasses\n pass","def _pprint(params, offset=0, printer=repr):\n # Do a multi-line justified repr:\n param_names = [p for p in params.keys() if p is not \"cost\"]\n param_names.sort()\n\n params_list = list()\n this_line_length = offset\n line_sep = ',\\n' + (1 + offset // 2) * ' '\n for i, name in enumerate(param_names):\n value = params[name]\n if isinstance(value, float):\n this_repr = '%s=%s' % (name, str(value))\n else:\n this_repr = '%s=%s' % (name, printer(value))\n if len(this_repr) > 500:\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\n if i > 0:\n if (this_line_length + len(this_repr) >= 75 or '\\n' in this_repr):\n params_list.append(line_sep)\n this_line_length = len(line_sep)\n else:\n params_list.append(', ')\n this_line_length += 2\n params_list.append(this_repr)\n this_line_length += len(this_repr)\n # options = np.get_printoptions()\n # np.set_printoptions(**options)\n lines = ''.join(params_list)\n # Strip trailing space to avoid nightmare in doctests\n lines = '\\n'.join(l.rstrip(' ') for l in lines.split('\\n'))\n return lines","def init_printing(pretty_print=True, order=None, use_unicode=None):\n if pretty_print:\n stringify_func = lambda arg: pretty(arg, order=order, use_unicode=use_unicode)\n else:\n stringify_func = sstrrepr\n\n try:\n import IPython\n\n ip = IPython.ipapi.get()\n\n if ip is not None:\n def result_display(self, arg):\n \"\"\"IPython's pretty-printer display hook.\n\n This function was adapted from:\n\n ipython/IPython/hooks.py:155\n\n \"\"\"\n if self.rc.pprint:\n out = stringify_func(arg)\n\n if '\\n' in out:\n print\n\n print out\n else:\n print repr(arg)\n\n ip.set_hook('result_display', result_display)\n return\n except ImportError:\n pass\n\n import __builtin__, sys\n\n def displayhook(arg):\n \"\"\"Python's pretty-printer display hook.\n\n This function was adapted from:\n\n http://www.python.org/dev/peps/pep-0217/\n\n \"\"\"\n if arg is not None:\n __builtin__._ = None\n print stringify_func(arg)\n __builtin__._ = arg\n\n sys.displayhook = displayhook","def print_verbose(self) -> None:\n print(self)\n if self.meta is not None:\n print(self.meta.__repr__())","def _print(self, *args):\n return _ida_hexrays.cinsn_t__print(self, *args)","def my_print(self):\n if self.__size == 0:\n print(\"\")\n return\n [print(\"\") for x in range(0, self.__position[1])]\n for i in range(0, self.__size):\n [print(\" \", end=\"\") for i in range(0, self.__position[0])]\n [print(\"#\", end=\"\") for j in range(0, self.__size)]\n print(\"\")","def sequential_print_statements():\n pass","def print_post():\n print('| | |'),","def print_(*args, **kwargs):\r\n fp = kwargs.pop(\"file\", sys.stdout)\r\n if fp is None:\r\n return\r\n def write(data):\r\n if not isinstance(data, basestring):\r\n data = str(data)\r\n fp.write(data)\r\n want_unicode = False\r\n sep = kwargs.pop(\"sep\", None)\r\n if sep is not None:\r\n if isinstance(sep, unicode):\r\n want_unicode = True\r\n elif not isinstance(sep, str):\r\n raise TypeError(\"sep must be None or a string\")\r\n end = kwargs.pop(\"end\", None)\r\n if end is not None:\r\n if isinstance(end, unicode):\r\n want_unicode = True\r\n elif not isinstance(end, str):\r\n raise TypeError(\"end must be None or a string\")\r\n if kwargs:\r\n raise TypeError(\"invalid keyword arguments to print()\")\r\n if not want_unicode:\r\n for arg in args:\r\n if isinstance(arg, unicode):\r\n want_unicode = True\r\n break\r\n if want_unicode:\r\n newline = unicode(\"\\n\")\r\n space = unicode(\" \")\r\n else:\r\n newline = \"\\n\"\r\n space = \" \"\r\n if sep is None:\r\n sep = space\r\n if end is None:\r\n end = newline\r\n for i, arg in enumerate(args):\r\n if i:\r\n write(sep)\r\n write(arg)\r\n write(end)","def print_(*args, **kwargs):\r\n fp = kwargs.pop(\"file\", sys.stdout)\r\n if fp is None:\r\n return\r\n def write(data):\r\n if not isinstance(data, basestring):\r\n data = str(data)\r\n fp.write(data)\r\n want_unicode = False\r\n sep = kwargs.pop(\"sep\", None)\r\n if sep is not None:\r\n if isinstance(sep, unicode):\r\n want_unicode = True\r\n elif not isinstance(sep, str):\r\n raise TypeError(\"sep must be None or a string\")\r\n end = kwargs.pop(\"end\", None)\r\n if end is not None:\r\n if isinstance(end, unicode):\r\n want_unicode = True\r\n elif not isinstance(end, str):\r\n raise TypeError(\"end must be None or a string\")\r\n if kwargs:\r\n raise TypeError(\"invalid keyword arguments to print()\")\r\n if not want_unicode:\r\n for arg in args:\r\n if isinstance(arg, unicode):\r\n want_unicode = True\r\n break\r\n if want_unicode:\r\n newline = unicode(\"\\n\")\r\n space = unicode(\" \")\r\n else:\r\n newline = \"\\n\"\r\n space = \" \"\r\n if sep is None:\r\n sep = space\r\n if end is None:\r\n end = newline\r\n for i, arg in enumerate(args):\r\n if i:\r\n write(sep)\r\n write(arg)\r\n write(end)","def debugprint(r, prefix='', depth=-1, done=None, print_type=False,\r\n file=sys.stdout, print_destroy_map=False,\r\n print_view_map=False, order=None, ids='CHAR',\r\n stop_on_name=False, prefix_child=None):\r\n if depth == 0:\r\n return\r\n\r\n if order is None:\r\n order = []\r\n\r\n if done is None:\r\n done = dict()\r\n\r\n if print_type:\r\n type_str = ' <%s>' % r.type\r\n else:\r\n type_str = ''\r\n\r\n if prefix_child is None:\r\n prefix_child = prefix\r\n\r\n def get_id_str(obj):\r\n if obj in done:\r\n id_str = done[obj]\r\n elif ids == \"id\":\r\n id_str = \"[@%s]\" % str(id(r))\r\n elif ids == \"int\":\r\n id_str = \"[@%s]\" % str(len(done))\r\n elif ids == \"CHAR\":\r\n id_str = \"[@%s]\" % char_from_number(len(done))\r\n elif ids == \"\":\r\n id_str = \"\"\r\n done[obj] = id_str\r\n return id_str\r\n\r\n if hasattr(r.owner, 'op'):\r\n # this variable is the output of computation,\r\n # so just print out the apply\r\n a = r.owner\r\n\r\n r_name = getattr(r, 'name', '')\r\n # normally if the name isn't set, it'll be None, so\r\n # r_name is None here\r\n if r_name is None:\r\n r_name = ''\r\n\r\n if print_destroy_map:\r\n destroy_map_str = str(getattr(r.owner.op, 'destroy_map', ''))\r\n else:\r\n destroy_map_str = ''\r\n\r\n if print_view_map:\r\n view_map_str = str(getattr(r.owner.op, 'view_map', ''))\r\n else:\r\n view_map_str = ''\r\n if destroy_map_str and destroy_map_str != '{}':\r\n destroy_map_str = 'd=' + destroy_map_str\r\n if view_map_str and view_map_str != '{}':\r\n view_map_str = 'v=' + view_map_str\r\n\r\n o = ''\r\n if order:\r\n o = str(order.index(r.owner))\r\n already_printed = a in done # get_id_str put it in the dict\r\n id_str = get_id_str(a)\r\n\r\n if len(a.outputs) == 1:\r\n print >> file, '%s%s %s%s \\'%s\\' %s %s %s' % (prefix, a.op,\r\n id_str,\r\n type_str, r_name,\r\n destroy_map_str,\r\n view_map_str,\r\n o)\r\n else:\r\n print >> file, '%s%s.%i %s%s \\'%s\\' %s %s %s' % (prefix, a.op,\r\n a.outputs.index(r),\r\n id_str, type_str,\r\n r_name,\r\n destroy_map_str,\r\n view_map_str,\r\n o)\r\n if not already_printed:\r\n if (not stop_on_name or\r\n not (hasattr(r, 'name') and r.name is not None)):\r\n new_prefix = prefix_child + ' |'\r\n new_prefix_child = prefix_child + ' |'\r\n for idx, i in enumerate(a.inputs):\r\n if idx == len(a.inputs) - 1:\r\n new_prefix_child = prefix_child + ' '\r\n\r\n debugprint(i, new_prefix, depth=depth - 1, done=done,\r\n print_type=print_type, file=file, order=order,\r\n ids=ids, stop_on_name=stop_on_name,\r\n prefix_child=new_prefix_child)\r\n else:\r\n #this is an input variable\r\n id_str = get_id_str(r)\r\n print >> file, '%s%s %s%s' % (prefix, r, id_str, type_str)\r\n\r\n return file","def bpprint(self, out=None):\n if out is None:\n out = sys.stdout\n print(self.bpformat(), file=out)","def vprint(expr, **settings):\n\n outstr = vsprint(expr, **settings)\n\n import builtins\n if (outstr != 'None'):\n builtins._ = outstr\n print(outstr)","def print_(*args, **kwargs):\n fp = kwargs.pop(\"file\", sys.stdout)\n if fp is None:\n return\n\n def write(data):\n if not isinstance(data, basestring):\n data = str(data)\n fp.write(data)\n want_unicode = False\n sep = kwargs.pop(\"sep\", None)\n if sep is not None:\n if isinstance(sep, unicode):\n want_unicode = True\n elif not isinstance(sep, str):\n raise TypeError(\"sep must be None or a string\")\n end = kwargs.pop(\"end\", None)\n if end is not None:\n if isinstance(end, unicode):\n want_unicode = True\n elif not isinstance(end, str):\n raise TypeError(\"end must be None or a string\")\n if kwargs:\n raise TypeError(\"invalid keyword arguments to print()\")\n if not want_unicode:\n for arg in args:\n if isinstance(arg, unicode):\n want_unicode = True\n break\n if want_unicode:\n newline = unicode(\"\\n\")\n space = unicode(\" \")\n else:\n newline = \"\\n\"\n space = \" \"\n if sep is None:\n sep = space\n if end is None:\n end = newline\n for i, arg in enumerate(args):\n if i:\n write(sep)\n write(arg)\n write(end)","def _pprint(params, offset=0, printer=repr):\n # Do a multi-line justified repr:\n options = numpy.get_printoptions()\n numpy.set_printoptions(precision=5, threshold=64, edgeitems=2)\n params_list = list()\n this_line_length = offset\n line_sep = ',\\n' + (1 + offset // 2) * ' '\n for i, (k, v) in enumerate(sorted(params.items())):\n if isinstance(v, float):\n # use str for representing floating point numbers\n # this way we get consistent representation across\n # architectures and versions.\n this_repr = '%s=%s' % (k, str(v))\n else:\n # use repr of the rest\n this_repr = '%s=%s' % (k, printer(v))\n if len(this_repr) > 500:\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\n if i > 0:\n if this_line_length + len(this_repr) >= 75 or '\\n' in this_repr:\n params_list.append(line_sep)\n this_line_length = len(line_sep)\n else:\n params_list.append(', ')\n this_line_length += 2\n params_list.append(this_repr)\n this_line_length += len(this_repr)\n\n numpy.set_printoptions(**options)\n lines = ''.join(params_list)\n # Strip trailing space to avoid nightmare in doctests\n lines = '\\n'.join(l.rstrip(' ') for l in lines.split('\\n'))\n return lines"],"string":"[\n \"def pprint(*args, **kwargs):\\n if PRINTING:\\n print(*args, **kwargs)\",\n \"def print_out():\\n pass\",\n \"def custom_print(*objects):\\n print(*objects, sep=OFS, end=ORS)\",\n \"def _print(self, *args):\\n return _ida_hexrays.vd_printer_t__print(self, *args)\",\n \"def _printable(self):\\n pass\",\n \"def _print_custom(self):\\n pass\",\n \"def pprint(self):\\n # just here for defining the interface; work is done in subclasses\\n pass\",\n \"def pypprint(*args, **kwargs): # type: ignore\\n from typing import Iterable\\n\\n if len(args) != 1:\\n print(*args, **kwargs)\\n return\\n x = args[0]\\n if isinstance(x, dict):\\n for k, v in x.items():\\n print(f\\\"{k}:\\\", v, **kwargs)\\n elif isinstance(x, Iterable) and not isinstance(x, str):\\n for i in x:\\n print(i, **kwargs)\\n else:\\n print(x, **kwargs)\",\n \"def print(*args, **kwargs):\\n with P_LOCK:\\n __builtins__.print(*args, **kwargs)\",\n \"def print(self):\\n # Your implementation here\",\n \"def p(value):\\n pp.pprint(value)\",\n \"def static_print(*args, __p=print, **kwargs):\\n __p(*args, **kwargs)\",\n \"def print(self, *args, **kwargs):\\n print(*args, **kwargs)\",\n \"def pprint(self):\\n print(self.pprint_str())\",\n \"def pprint(obj):\\n for argname in sorted([x for x in dir(obj) if not x.startswith('__')]):\\n # Skip callables\\n if hasattr(getattr(obj, argname), '__call__'):\\n continue\\n print(\\\"{} : {}\\\".format(argname, getattr(obj, argname)))\",\n \"def print_(self, s: str) -> None:\",\n \"def my_pprint(obj, intend = 0):\\n if isinstance(obj, dict):\\n for key, value in obj.items():\\n print(intend*\\\" \\\"+str(key)+\\\" : \\\")\\n my_pprint(value, intend = intend + 4)\\n print()\\n elif isinstance(obj, list):\\n for value in obj:\\n my_pprint(value, intend = intend + 4)\\n print()\\n elif isinstance(obj, bytes):\\n print(\\\"<binary data>\\\")\\n \\n else:\\n try:\\n print(intend*\\\" \\\"+str(obj))\\n except UnicodeDecodeError:\\n print(intend*\\\" \\\"\\\"<?>\\\")\",\n \"def test_print(chikin):\\n chikin.print()\",\n \"def _print(self, text):\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint text\",\n \"def out(*args):\\r\\n print(*args)\",\n \"def __pprint(object, stream=None, indent=1, width=80, depth=None):\\n printer = PrettyPrinterExt(\\n stream=stream, indent=indent, width=width, depth=depth)\\n printer.pprint(object)\",\n \"def DumpPprint(data):\\n #NOTE(g): Import is done here, instead of the top of the file, to not require this module if it is not used\\n import pprint\\n \\n text = pprint.pformat(data)\\n \\n return text\",\n \"def repl_print_statements():\\n pass\",\n \"def test_03_pass_print(self):\\n print('Hello World!')\",\n \"def p(self):\\n self.printstdout = True\",\n \"def print(*args, **kwargs):\\n new_args = []\\n for arg in args:\\n if builtins.isinstance(arg, models.Point):\\n new_args.append(\\\"({0}, {1})\\\".format(arg.x, arg.y))\\n else:\\n new_args.append(arg)\\n\\n builtins.print(*new_args, **kwargs)\",\n \"def real_print(*args, **kwargs):\\n\\n kwargs.setdefault('file', real_stdout)\\n _python_print_function(*args, **kwargs)\",\n \"def to_print_out(self):\\n self.error_throw('output')\\n\\n if self.rank_method == methods_of_ranking[3]: #'diversified_ranking'\\n self.output_div('print')\\n else:\\n self.output('print')\",\n \"def debug_print(debug_data):\\n if DEBUG_MODE == \\\"true\\\":\\n pp.pprint(debug_data)\",\n \"def print(self):\\r\\n self.print_avec_separateur()\",\n \"def pprint(self):\\r\\n for i in self.items():\\r\\n print '%s => %r'%i\",\n \"def pprint(self, parameter_s=''):\\n ptformatter = self.shell.display_formatter.formatters['text/plain']\\n ptformatter.pprint = bool(1 - ptformatter.pprint)\\n print('Pretty printing has been turned',\\n ['OFF','ON'][ptformatter.pprint])\",\n \"def print(self):\\n print(self.pretty_str())\",\n \"def test_print4(self):\\n writer = StringIO()\\n collatz_print(writer, 1, 1, 1)\\n self.assertEqual(writer.getvalue(), \\\"1 1 1\\\\n\\\")\",\n \"def eprint(*args, **kwargs):\\n\\tprint(*args, file=sys.stderr, **kwargs)\",\n \"def _print(self, *args, **kwargs) -> None:\\n # Only print in verbose mode\\n if self._verbose:\\n arglist = list(args)\\n arglist[0] = f\\\"[buddy-{self._experiment_name}] {args[0]}\\\"\\n print(*arglist, **kwargs)\",\n \"def use_pypprint_for_implicit_print(self) -> None:\\n if self.implicit_print is not None:\\n self.implicit_print.func.id = \\\"pypprint\\\" # type: ignore\\n # Make sure we import it later\\n self.undefined.add(\\\"pypprint\\\")\",\n \"def test_print(self):\\n writer = StringIO()\\n collatz_print(writer, 1, 10, 20)\\n self.assertEqual(writer.getvalue(), \\\"1 10 20\\\\n\\\")\",\n \"def pprint(self):\\n return pformat(repr(self))\",\n \"def printer(message):\\n if VERBOSITY:\\n pprint(message)\",\n \"def rec_print(p):\\n if len(p) == 0:\\n return\\n t = p.pop(0)\\n print t\\n rec_print(p)\",\n \"def printc(*a, **kw):\\n print(*a, **kw)\",\n \"def pformat(object):\\r\\n return PrettyPrinter().pformat(object)\",\n \"def pr(x):\\n Card.print_pretty_cards(x)\",\n \"def debug_print(self, *content):\\n if self.debug:\\n print(*content)\",\n \"def pprint(object, stream=None):\\r\\n printer = PrettyPrinter(stream=stream)\\r\\n printer.pprint(object)\",\n \"def safe_print(*objs, errors=\\\"replace\\\"):\\n\\tprint(*(to_stdout(str(o), errors) for o in objs))\",\n \"def magic_Pprint(self, parameter_s=''):\\n \\n self.shell.outputcache.Pprint = 1 - self.shell.outputcache.Pprint\\n print 'Pretty printing has been turned', \\\\\\n ['OFF','ON'][self.shell.outputcache.Pprint]\",\n \"def print_output(tree):\\n print_value(tree)\\n print_tree(tree)\",\n \"def _Print(self, t):\\n self.RaiseError(t, \\\"Print not supported\\\")\",\n \"def vprint(*args, **kwargs ):\\n\\n forceprint = False\\n for key in kwargs:\\n if key == \\\"forceprint\\\":\\n forceprint =kwargs[key]\\n \\n line = ''\\n if debug or forceprint : \\n for arg in args:\\n line += str(arg) +\\\" \\\"\\n log = open(exepath + 'pyframe.log', 'a') \\n log.write(line + \\\"\\\\n\\\")\\n log.close() \\n print line\",\n \"def eprint(*pargs, **kargs):\\n print('\\\\u001b[31m', end='', file=sys.stderr)\\n print(*pargs, file=sys.stderr, **kargs)\\n print('\\\\u001b[0m', end='', file=sys.stderr)\",\n \"def printer(obj, ident=''):\\n import inspect\\n print ident + obj.__class__.__name__.upper()\\n ident += ' '\\n lists = []\\n for name in dir(obj):\\n elem = getattr(obj, name)\\n if isinstance(elem, list) and name != u'decoded_content':\\n lists.append(elem)\\n elif not inspect.ismethod(elem):\\n if not name.startswith('__'):\\n if name == u'data' and elem:\\n print ident + u'data = '\\n printer(elem, ident + ' ')\\n else:\\n print ident + u'%s\\\\t= %s' % (name, getattr(obj, name))\\n for l in lists:\\n for i in l:\\n printer(i, ident + ' ')\",\n \"def printer(obj, ident=''):\\n import inspect\\n print ident + obj.__class__.__name__.upper()\\n ident += ' '\\n lists = []\\n for name in dir(obj):\\n elem = getattr(obj, name)\\n if isinstance(elem, list) and name != u'decoded_content':\\n lists.append(elem)\\n elif not inspect.ismethod(elem):\\n if not name.startswith('__'):\\n if name == u'data' and elem:\\n print ident + u'data = '\\n printer(elem, ident + ' ')\\n else:\\n print ident + u'%s\\\\t= %s' % (name, getattr(obj, name))\\n for l in lists:\\n for i in l:\\n printer(i, ident + ' ')\",\n \"def _print(self, *args):\\n return _ida_hexrays.qstring_printer_t__print(self, *args)\",\n \"def pprint(self):\\n def pprintStr(node):\\n s = \\\"(\\\" + str(node.value) \\n for action in node.children:\\n s = s + \\\", \\\" + pprintStr(node.children[action])\\n s = s + \\\")\\\"\\n return s\\n\\n print pprintStr(self)\",\n \"def hook_print():\\n sys.stdout = PrintHook()\",\n \"def cmdPrint( self, *args):\\n return self.cmd( *args, **{ 'verbose': True } )\",\n \"def print_list(self):\\r\\n pass\",\n \"def debugprint(obj, depth=-1, print_type=False,\\r\\n file=None, ids='CHAR', stop_on_name=False):\\r\\n if file == 'str':\\r\\n _file = StringIO()\\r\\n elif file is None:\\r\\n _file = sys.stdout\\r\\n else:\\r\\n _file = file\\r\\n done = dict()\\r\\n results_to_print = []\\r\\n order = []\\r\\n if isinstance(obj, gof.Variable):\\r\\n results_to_print.append(obj)\\r\\n elif isinstance(obj, gof.Apply):\\r\\n results_to_print.extend(obj.outputs)\\r\\n elif isinstance(obj, Function):\\r\\n results_to_print.extend(obj.maker.fgraph.outputs)\\r\\n order = obj.maker.fgraph.toposort()\\r\\n elif isinstance(obj, (list, tuple)):\\r\\n results_to_print.extend(obj)\\r\\n elif isinstance(obj, gof.FunctionGraph):\\r\\n results_to_print.extend(obj.outputs)\\r\\n order = obj.toposort()\\r\\n elif isinstance(obj, (int, long, float, numpy.ndarray)):\\r\\n print obj\\r\\n else:\\r\\n raise TypeError(\\\"debugprint cannot print an object of this type\\\", obj)\\r\\n for r in results_to_print:\\r\\n debugmode.debugprint(r, depth=depth, done=done, print_type=print_type,\\r\\n file=_file, order=order, ids=ids,\\r\\n stop_on_name=stop_on_name)\\r\\n if file is _file:\\r\\n return file\\r\\n elif file == 'str':\\r\\n return _file.getvalue()\\r\\n else:\\r\\n _file.flush()\",\n \"def _get_print_fn(file=sys.stdout):\\n def _print_fn(op, xin,):\\n for attr in op.attrs:\\n temp = getattr(xin, attr)\\n if callable(temp):\\n pmsg = temp()\\n else:\\n pmsg = temp\\n print(op.message, attr, '=', pmsg, file=file)\\n return _print_fn\",\n \"def test_print1(self):\\n writer = StringIO()\\n collatz_print(writer, 100, 200, 125)\\n self.assertEqual(writer.getvalue(), \\\"100 200 125\\\\n\\\")\",\n \"def printOutput(self):\\n pass\",\n \"def _print(self, *args):\\n return _ida_hexrays.cnumber_t__print(self, *args)\",\n \"def setPrint():\\n (e,d,sr,sw) = codecs.lookup('utf-8')\\n unicode_to_utf8 = sw(sys.stdout)\\n sys.stdout = unicode_to_utf8\",\n \"def print(*args, sep=\\\" \\\"):\\n pass\",\n \"def pr(string, verbose):\\n if(verbose):\\n print(string)\",\n \"def printv(self, *arg):\\n if self.verbose:\\n print(*arg)\",\n \"def print(self):\\n\\n print(self)\",\n \"def _p(self, *args, level=2, **kwargs):\\n if self._verbosity >= level:\\n print(*args, **kwargs)\",\n \"def test_print2(self):\\n writer = StringIO()\\n collatz_print(writer, 201, 210, 89)\\n self.assertEqual(writer.getvalue(), \\\"201 210 89\\\\n\\\")\",\n \"def print_pointers(self):\\n\\n ### FILL IN ###\",\n \"def foo_printer(self):\\n print(\\\"\\\\nHi I'm {}\\\".format(self.foo))\",\n \"def printed(method):\\n\\t\\tdef wrapper(cls, *args):\\n\\t\\t\\tif cls.verbose:\\n\\t\\t\\t\\treturn method(cls, *args)\\n\\t\\treturn wrapper\",\n \"def print_me(self, tabs=0, tab=' '):\\n pre = tab*tabs\\n print(pre+'Producer:')\\n print(pre+' produces:', self._produces)\\n print(pre+' consumes:', self._consumes)\\n print(pre+' transfer:', self._transfer)\\n print(pre+' capacity:', self._capacity)\",\n \"def _print(cls, quad):\\n\\t\\tprint(\\\"\\\\nLIGHT OUTPUT:\\\\n<<<<{}>>>>\\\".format(ast.literal_eval(str(cls.get_address_value(quad.result)))))\\n\\t\\tprint(\\\"END\\\")\\n\\n\\t\\tvar = cls.get_address_value(quad.result)\\n\\t\\tif isinstance(var, collections.Iterable):\\n\\t\\t\\tprint(\\\"DEEP COPY\\\")\\n\\t\\t\\tcls.print_queue.enqueue(copy.deepcopy(var))\\n\\t\\telse:\\n\\t\\t\\tcls.print_queue.enqueue(var)\",\n \"def printout(*args, **kwargs):\\n console_print(sys.stdout, *args, **kwargs)\",\n \"def pprint(x):\\n if is_theano_object(x):\\n return _gettheano().printing.pprint(x)\\n else:\\n return str(x)\",\n \"def PrettyPrint(self):\\r\\n print(self.data)\\r\\n return\",\n \"def print(self):\\n self.print_avec_separateur(\\\" \\\")\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def eprint(*args, **kwargs):\\n print(*args, file=sys.stderr, **kwargs)\",\n \"def pprint_helper(self, angle, indent):\\n # just here for defining the interface; work is done in subclasses\\n pass\",\n \"def _pprint(params, offset=0, printer=repr):\\n # Do a multi-line justified repr:\\n param_names = [p for p in params.keys() if p is not \\\"cost\\\"]\\n param_names.sort()\\n\\n params_list = list()\\n this_line_length = offset\\n line_sep = ',\\\\n' + (1 + offset // 2) * ' '\\n for i, name in enumerate(param_names):\\n value = params[name]\\n if isinstance(value, float):\\n this_repr = '%s=%s' % (name, str(value))\\n else:\\n this_repr = '%s=%s' % (name, printer(value))\\n if len(this_repr) > 500:\\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\\n if i > 0:\\n if (this_line_length + len(this_repr) >= 75 or '\\\\n' in this_repr):\\n params_list.append(line_sep)\\n this_line_length = len(line_sep)\\n else:\\n params_list.append(', ')\\n this_line_length += 2\\n params_list.append(this_repr)\\n this_line_length += len(this_repr)\\n # options = np.get_printoptions()\\n # np.set_printoptions(**options)\\n lines = ''.join(params_list)\\n # Strip trailing space to avoid nightmare in doctests\\n lines = '\\\\n'.join(l.rstrip(' ') for l in lines.split('\\\\n'))\\n return lines\",\n \"def init_printing(pretty_print=True, order=None, use_unicode=None):\\n if pretty_print:\\n stringify_func = lambda arg: pretty(arg, order=order, use_unicode=use_unicode)\\n else:\\n stringify_func = sstrrepr\\n\\n try:\\n import IPython\\n\\n ip = IPython.ipapi.get()\\n\\n if ip is not None:\\n def result_display(self, arg):\\n \\\"\\\"\\\"IPython's pretty-printer display hook.\\n\\n This function was adapted from:\\n\\n ipython/IPython/hooks.py:155\\n\\n \\\"\\\"\\\"\\n if self.rc.pprint:\\n out = stringify_func(arg)\\n\\n if '\\\\n' in out:\\n print\\n\\n print out\\n else:\\n print repr(arg)\\n\\n ip.set_hook('result_display', result_display)\\n return\\n except ImportError:\\n pass\\n\\n import __builtin__, sys\\n\\n def displayhook(arg):\\n \\\"\\\"\\\"Python's pretty-printer display hook.\\n\\n This function was adapted from:\\n\\n http://www.python.org/dev/peps/pep-0217/\\n\\n \\\"\\\"\\\"\\n if arg is not None:\\n __builtin__._ = None\\n print stringify_func(arg)\\n __builtin__._ = arg\\n\\n sys.displayhook = displayhook\",\n \"def print_verbose(self) -> None:\\n print(self)\\n if self.meta is not None:\\n print(self.meta.__repr__())\",\n \"def _print(self, *args):\\n return _ida_hexrays.cinsn_t__print(self, *args)\",\n \"def my_print(self):\\n if self.__size == 0:\\n print(\\\"\\\")\\n return\\n [print(\\\"\\\") for x in range(0, self.__position[1])]\\n for i in range(0, self.__size):\\n [print(\\\" \\\", end=\\\"\\\") for i in range(0, self.__position[0])]\\n [print(\\\"#\\\", end=\\\"\\\") for j in range(0, self.__size)]\\n print(\\\"\\\")\",\n \"def sequential_print_statements():\\n pass\",\n \"def print_post():\\n print('| | |'),\",\n \"def print_(*args, **kwargs):\\r\\n fp = kwargs.pop(\\\"file\\\", sys.stdout)\\r\\n if fp is None:\\r\\n return\\r\\n def write(data):\\r\\n if not isinstance(data, basestring):\\r\\n data = str(data)\\r\\n fp.write(data)\\r\\n want_unicode = False\\r\\n sep = kwargs.pop(\\\"sep\\\", None)\\r\\n if sep is not None:\\r\\n if isinstance(sep, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(sep, str):\\r\\n raise TypeError(\\\"sep must be None or a string\\\")\\r\\n end = kwargs.pop(\\\"end\\\", None)\\r\\n if end is not None:\\r\\n if isinstance(end, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(end, str):\\r\\n raise TypeError(\\\"end must be None or a string\\\")\\r\\n if kwargs:\\r\\n raise TypeError(\\\"invalid keyword arguments to print()\\\")\\r\\n if not want_unicode:\\r\\n for arg in args:\\r\\n if isinstance(arg, unicode):\\r\\n want_unicode = True\\r\\n break\\r\\n if want_unicode:\\r\\n newline = unicode(\\\"\\\\n\\\")\\r\\n space = unicode(\\\" \\\")\\r\\n else:\\r\\n newline = \\\"\\\\n\\\"\\r\\n space = \\\" \\\"\\r\\n if sep is None:\\r\\n sep = space\\r\\n if end is None:\\r\\n end = newline\\r\\n for i, arg in enumerate(args):\\r\\n if i:\\r\\n write(sep)\\r\\n write(arg)\\r\\n write(end)\",\n \"def print_(*args, **kwargs):\\r\\n fp = kwargs.pop(\\\"file\\\", sys.stdout)\\r\\n if fp is None:\\r\\n return\\r\\n def write(data):\\r\\n if not isinstance(data, basestring):\\r\\n data = str(data)\\r\\n fp.write(data)\\r\\n want_unicode = False\\r\\n sep = kwargs.pop(\\\"sep\\\", None)\\r\\n if sep is not None:\\r\\n if isinstance(sep, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(sep, str):\\r\\n raise TypeError(\\\"sep must be None or a string\\\")\\r\\n end = kwargs.pop(\\\"end\\\", None)\\r\\n if end is not None:\\r\\n if isinstance(end, unicode):\\r\\n want_unicode = True\\r\\n elif not isinstance(end, str):\\r\\n raise TypeError(\\\"end must be None or a string\\\")\\r\\n if kwargs:\\r\\n raise TypeError(\\\"invalid keyword arguments to print()\\\")\\r\\n if not want_unicode:\\r\\n for arg in args:\\r\\n if isinstance(arg, unicode):\\r\\n want_unicode = True\\r\\n break\\r\\n if want_unicode:\\r\\n newline = unicode(\\\"\\\\n\\\")\\r\\n space = unicode(\\\" \\\")\\r\\n else:\\r\\n newline = \\\"\\\\n\\\"\\r\\n space = \\\" \\\"\\r\\n if sep is None:\\r\\n sep = space\\r\\n if end is None:\\r\\n end = newline\\r\\n for i, arg in enumerate(args):\\r\\n if i:\\r\\n write(sep)\\r\\n write(arg)\\r\\n write(end)\",\n \"def debugprint(r, prefix='', depth=-1, done=None, print_type=False,\\r\\n file=sys.stdout, print_destroy_map=False,\\r\\n print_view_map=False, order=None, ids='CHAR',\\r\\n stop_on_name=False, prefix_child=None):\\r\\n if depth == 0:\\r\\n return\\r\\n\\r\\n if order is None:\\r\\n order = []\\r\\n\\r\\n if done is None:\\r\\n done = dict()\\r\\n\\r\\n if print_type:\\r\\n type_str = ' <%s>' % r.type\\r\\n else:\\r\\n type_str = ''\\r\\n\\r\\n if prefix_child is None:\\r\\n prefix_child = prefix\\r\\n\\r\\n def get_id_str(obj):\\r\\n if obj in done:\\r\\n id_str = done[obj]\\r\\n elif ids == \\\"id\\\":\\r\\n id_str = \\\"[@%s]\\\" % str(id(r))\\r\\n elif ids == \\\"int\\\":\\r\\n id_str = \\\"[@%s]\\\" % str(len(done))\\r\\n elif ids == \\\"CHAR\\\":\\r\\n id_str = \\\"[@%s]\\\" % char_from_number(len(done))\\r\\n elif ids == \\\"\\\":\\r\\n id_str = \\\"\\\"\\r\\n done[obj] = id_str\\r\\n return id_str\\r\\n\\r\\n if hasattr(r.owner, 'op'):\\r\\n # this variable is the output of computation,\\r\\n # so just print out the apply\\r\\n a = r.owner\\r\\n\\r\\n r_name = getattr(r, 'name', '')\\r\\n # normally if the name isn't set, it'll be None, so\\r\\n # r_name is None here\\r\\n if r_name is None:\\r\\n r_name = ''\\r\\n\\r\\n if print_destroy_map:\\r\\n destroy_map_str = str(getattr(r.owner.op, 'destroy_map', ''))\\r\\n else:\\r\\n destroy_map_str = ''\\r\\n\\r\\n if print_view_map:\\r\\n view_map_str = str(getattr(r.owner.op, 'view_map', ''))\\r\\n else:\\r\\n view_map_str = ''\\r\\n if destroy_map_str and destroy_map_str != '{}':\\r\\n destroy_map_str = 'd=' + destroy_map_str\\r\\n if view_map_str and view_map_str != '{}':\\r\\n view_map_str = 'v=' + view_map_str\\r\\n\\r\\n o = ''\\r\\n if order:\\r\\n o = str(order.index(r.owner))\\r\\n already_printed = a in done # get_id_str put it in the dict\\r\\n id_str = get_id_str(a)\\r\\n\\r\\n if len(a.outputs) == 1:\\r\\n print >> file, '%s%s %s%s \\\\'%s\\\\' %s %s %s' % (prefix, a.op,\\r\\n id_str,\\r\\n type_str, r_name,\\r\\n destroy_map_str,\\r\\n view_map_str,\\r\\n o)\\r\\n else:\\r\\n print >> file, '%s%s.%i %s%s \\\\'%s\\\\' %s %s %s' % (prefix, a.op,\\r\\n a.outputs.index(r),\\r\\n id_str, type_str,\\r\\n r_name,\\r\\n destroy_map_str,\\r\\n view_map_str,\\r\\n o)\\r\\n if not already_printed:\\r\\n if (not stop_on_name or\\r\\n not (hasattr(r, 'name') and r.name is not None)):\\r\\n new_prefix = prefix_child + ' |'\\r\\n new_prefix_child = prefix_child + ' |'\\r\\n for idx, i in enumerate(a.inputs):\\r\\n if idx == len(a.inputs) - 1:\\r\\n new_prefix_child = prefix_child + ' '\\r\\n\\r\\n debugprint(i, new_prefix, depth=depth - 1, done=done,\\r\\n print_type=print_type, file=file, order=order,\\r\\n ids=ids, stop_on_name=stop_on_name,\\r\\n prefix_child=new_prefix_child)\\r\\n else:\\r\\n #this is an input variable\\r\\n id_str = get_id_str(r)\\r\\n print >> file, '%s%s %s%s' % (prefix, r, id_str, type_str)\\r\\n\\r\\n return file\",\n \"def bpprint(self, out=None):\\n if out is None:\\n out = sys.stdout\\n print(self.bpformat(), file=out)\",\n \"def vprint(expr, **settings):\\n\\n outstr = vsprint(expr, **settings)\\n\\n import builtins\\n if (outstr != 'None'):\\n builtins._ = outstr\\n print(outstr)\",\n \"def print_(*args, **kwargs):\\n fp = kwargs.pop(\\\"file\\\", sys.stdout)\\n if fp is None:\\n return\\n\\n def write(data):\\n if not isinstance(data, basestring):\\n data = str(data)\\n fp.write(data)\\n want_unicode = False\\n sep = kwargs.pop(\\\"sep\\\", None)\\n if sep is not None:\\n if isinstance(sep, unicode):\\n want_unicode = True\\n elif not isinstance(sep, str):\\n raise TypeError(\\\"sep must be None or a string\\\")\\n end = kwargs.pop(\\\"end\\\", None)\\n if end is not None:\\n if isinstance(end, unicode):\\n want_unicode = True\\n elif not isinstance(end, str):\\n raise TypeError(\\\"end must be None or a string\\\")\\n if kwargs:\\n raise TypeError(\\\"invalid keyword arguments to print()\\\")\\n if not want_unicode:\\n for arg in args:\\n if isinstance(arg, unicode):\\n want_unicode = True\\n break\\n if want_unicode:\\n newline = unicode(\\\"\\\\n\\\")\\n space = unicode(\\\" \\\")\\n else:\\n newline = \\\"\\\\n\\\"\\n space = \\\" \\\"\\n if sep is None:\\n sep = space\\n if end is None:\\n end = newline\\n for i, arg in enumerate(args):\\n if i:\\n write(sep)\\n write(arg)\\n write(end)\",\n \"def _pprint(params, offset=0, printer=repr):\\n # Do a multi-line justified repr:\\n options = numpy.get_printoptions()\\n numpy.set_printoptions(precision=5, threshold=64, edgeitems=2)\\n params_list = list()\\n this_line_length = offset\\n line_sep = ',\\\\n' + (1 + offset // 2) * ' '\\n for i, (k, v) in enumerate(sorted(params.items())):\\n if isinstance(v, float):\\n # use str for representing floating point numbers\\n # this way we get consistent representation across\\n # architectures and versions.\\n this_repr = '%s=%s' % (k, str(v))\\n else:\\n # use repr of the rest\\n this_repr = '%s=%s' % (k, printer(v))\\n if len(this_repr) > 500:\\n this_repr = this_repr[:300] + '...' + this_repr[-100:]\\n if i > 0:\\n if this_line_length + len(this_repr) >= 75 or '\\\\n' in this_repr:\\n params_list.append(line_sep)\\n this_line_length = len(line_sep)\\n else:\\n params_list.append(', ')\\n this_line_length += 2\\n params_list.append(this_repr)\\n this_line_length += len(this_repr)\\n\\n numpy.set_printoptions(**options)\\n lines = ''.join(params_list)\\n # Strip trailing space to avoid nightmare in doctests\\n lines = '\\\\n'.join(l.rstrip(' ') for l in lines.split('\\\\n'))\\n return lines\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7557754","0.7338058","0.6987503","0.69850004","0.69455147","0.6924971","0.6898882","0.6898829","0.6815187","0.68062454","0.6751603","0.6749909","0.67452943","0.67000484","0.66911054","0.66751033","0.6657706","0.6609648","0.6608622","0.66017973","0.6562991","0.6560865","0.6554805","0.649593","0.64731634","0.6448662","0.6411248","0.6340241","0.63400245","0.63358384","0.6331737","0.6316116","0.6313924","0.62977034","0.62975013","0.6284986","0.6279888","0.62717646","0.62663245","0.6265194","0.62618846","0.62594306","0.6256649","0.62497824","0.62497526","0.6245382","0.62440735","0.6242415","0.6238787","0.6216302","0.62085056","0.62080246","0.62051076","0.62051076","0.6194695","0.61890143","0.61849797","0.61842763","0.6170019","0.6161897","0.61604846","0.6154518","0.61532277","0.61516184","0.6147849","0.61384815","0.6138325","0.6130806","0.6128508","0.61266017","0.61144286","0.6112656","0.6101359","0.61006933","0.6096824","0.60822785","0.6077609","0.60714436","0.60607946","0.6059338","0.60556734","0.60556734","0.60556734","0.60556734","0.60556734","0.60556734","0.60439265","0.60366803","0.6033661","0.6031575","0.60295063","0.60251975","0.60180503","0.60044754","0.6001282","0.6001282","0.6000467","0.5995928","0.5992179","0.5978578","0.5978398"],"string":"[\n \"0.7557754\",\n \"0.7338058\",\n \"0.6987503\",\n \"0.69850004\",\n \"0.69455147\",\n \"0.6924971\",\n \"0.6898882\",\n \"0.6898829\",\n \"0.6815187\",\n \"0.68062454\",\n \"0.6751603\",\n \"0.6749909\",\n \"0.67452943\",\n \"0.67000484\",\n \"0.66911054\",\n \"0.66751033\",\n \"0.6657706\",\n \"0.6609648\",\n \"0.6608622\",\n \"0.66017973\",\n \"0.6562991\",\n \"0.6560865\",\n \"0.6554805\",\n \"0.649593\",\n \"0.64731634\",\n \"0.6448662\",\n \"0.6411248\",\n \"0.6340241\",\n \"0.63400245\",\n \"0.63358384\",\n \"0.6331737\",\n \"0.6316116\",\n \"0.6313924\",\n \"0.62977034\",\n \"0.62975013\",\n \"0.6284986\",\n \"0.6279888\",\n \"0.62717646\",\n \"0.62663245\",\n \"0.6265194\",\n \"0.62618846\",\n \"0.62594306\",\n \"0.6256649\",\n \"0.62497824\",\n \"0.62497526\",\n \"0.6245382\",\n \"0.62440735\",\n \"0.6242415\",\n \"0.6238787\",\n \"0.6216302\",\n \"0.62085056\",\n \"0.62080246\",\n \"0.62051076\",\n \"0.62051076\",\n \"0.6194695\",\n \"0.61890143\",\n \"0.61849797\",\n \"0.61842763\",\n \"0.6170019\",\n \"0.6161897\",\n \"0.61604846\",\n \"0.6154518\",\n \"0.61532277\",\n \"0.61516184\",\n \"0.6147849\",\n \"0.61384815\",\n \"0.6138325\",\n \"0.6130806\",\n \"0.6128508\",\n \"0.61266017\",\n \"0.61144286\",\n \"0.6112656\",\n \"0.6101359\",\n \"0.61006933\",\n \"0.6096824\",\n \"0.60822785\",\n \"0.6077609\",\n \"0.60714436\",\n \"0.60607946\",\n \"0.6059338\",\n \"0.60556734\",\n \"0.60556734\",\n \"0.60556734\",\n \"0.60556734\",\n \"0.60556734\",\n \"0.60556734\",\n \"0.60439265\",\n \"0.60366803\",\n \"0.6033661\",\n \"0.6031575\",\n \"0.60295063\",\n \"0.60251975\",\n \"0.60180503\",\n \"0.60044754\",\n \"0.6001282\",\n \"0.6001282\",\n \"0.6000467\",\n \"0.5995928\",\n \"0.5992179\",\n \"0.5978578\",\n \"0.5978398\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76595,"cells":{"query":{"kind":"string","value":"Returns true if both objects are equal"},"document":{"kind":"string","value":"def __eq__(self, other):\n if not isinstance(other, GIFOutput):\n return False\n\n return self.__dict__ == other.__dict__"},"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 __eq__(self, other):\n return are_equal(self, other)","def __eq__(self, other):\n return are_equal(self, other)","def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False","def __eq__(self, other):\n if isinstance(self, other.__class__):\n return self.__dict__ == other.__dict__\n return False","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.__dict__ == other.__dict__\n return False","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.__dict__ == other.__dict__\n return False","def __eq__(self, other):\r\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n # Ensure same class and values match\n if isinstance(other, self.__class__):\n return self.__dict__ == other.__dict__\n else:\n return False","def is_equal(self, a, b):\n return a is b","def is_equal(self, a, b):\n return a == b","def __eq__(self, other):\n return self is other","def __eq__(self, other):\n return self is other","def __eq__(self, other):\r\n if isinstance(other, self.__class__):\r\n return self.__dict__ == other.__dict__\r\n else:\r\n return False","def is_equal(o1: object, o2: object) -> bool:\n if o1 is None and o2 is None:\n return True\n if o1 is None:\n return False\n return o1 == o2","def __eq__(self,other):\n return self is other","def is_equal(self, a, b):\n return a.X[0] == b.X[0]","def __eq__(self, other):\n return type(self) == type(other) and self.id == other.id","def __eq__(self, other) -> bool:\n if json.dumps(self.data,sort_keys=True) == json.dumps(other.data,sort_keys=True):\n return True\n else:\n return False","def __eq__(self, other):\n if not isinstance(other, Single2HaObject):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.__dict__ == other","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.__hash__() == other.__hash__()\n return False","def __eq__(self, other):\n if self.__class__ != other.__class__:\n return False\n if self.primary != other.primary:\n return False\n return True","def __eq__(self, other) -> bool:\n if other is None:\n return False\n return self.__hash__() == other.__hash__()","def __eq__(self, other):\n if not isinstance(other, ObjectInfo):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self: _TT, other: object) -> bool:\n return self.eq(other) # type: ignore","def __eq__(self, other):\n return id(self) == id(other)","def __eq__(self, other) -> bool:\n return type(self) == type(other) and \\\n self._id == other.id and \\\n self.code == other.code and \\\n self.name == other.name and \\\n self.gender == other.gender and \\\n self.date_of_birth == other.date_of_birth","def equals(self, other): # -> bool:\n ...","def equals(self, obj: object) -> bool:\n ...","def __eq__(self, other):\n for attr in self._attrs_to_save:\n try:\n if getattr(self, attr) != getattr(other, attr):\n return False\n except AttributeError:\n return False\n return True","def __eq__(self, other):\n if type(other) is type(self):\n return (self.x == other.x and self.y == other.y and self.z == other.z)\n return False","def __eq__(self, other):\n if isinstance(other, self.__class__):\n return self.x == other.x and self.y == other.y\n return False","def __eq__(self, other: object) -> bool:\n if not isinstance(other, self.__class__):\n return NotImplemented\n\n return (\n self.name,\n self.submit_at,\n self.subreddit,\n self.title,\n self.body_template,\n ) == (\n other.name,\n other.submit_at,\n other.subreddit,\n other.title,\n other.body_template,\n )","def __eq__(self, other):\n # Check that we share the same class as this object\n if not isinstance(other, type(self)):\n return False\n\n return hash(self) == hash(other)","def __eq__(self, other):\n if not isinstance(other, PreviewObjectAutofill):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return equal(self, other)","def __eq__(self, other: Any) -> bool:\n return self.__class__ is other.__class__ and self.identifier == other.identifier","def __eq__(self, other):\n return self.__id == other.get_id()","def __eq__ (self, other):\n if type(self) == type(other):\n return self._m == other._m\n else:\n return False","def __eq__(self, other):\n if not isinstance(other, Referent):\n return False\n\n return self.__dict__ == other.__dict__","def __eq__(self, other):\n return self.properties == other.properties","def __eq__(self, other):\n return self.items() == other.items()","def __eq__(self, other):\n return hash(self) == hash(other)","def __eq__(self, other):\n return hash(self) == hash(other)","def __eq__(self, other):\n return hash(self) == hash(other)","def __eq__(self, other):\n return self.x == other.x and self.y == other.y","def __eq__(self, other):\n\n if self is other:\n return True\n return hash(self) == hash(other)","def __eq__(self, other):\n if other._field1 == self._field1:\n return True\n return False","def same_as(self, other):\n return super().__eq__(other)","def __eq__(self, other):\n try:\n return other and \\\n self.id == other.id\n\n except AttributeError:\n return False","def __eq__(self, other):\r\n\t\treturn self._to_pylist() == other._to_pylist()","def __eq__(self, other):\n if not isinstance(other, Fiddle):\n return False\n\n return self.__dict__ == other.__dict__"],"string":"[\n \"def __eq__(self, other):\\n return are_equal(self, other)\",\n \"def __eq__(self, other):\\n return are_equal(self, other)\",\n \"def __eq__(self,other):\\n try: return self.object==other.object and isinstance(self,type(other))\\n except: return False\",\n \"def __eq__(self, other):\\n if isinstance(self, other.__class__):\\n return self.__dict__ == other.__dict__\\n return False\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.__dict__ == other.__dict__\\n return False\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.__dict__ == other.__dict__\\n return False\",\n \"def __eq__(self, other):\\r\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n # Ensure same class and values match\\n if isinstance(other, self.__class__):\\n return self.__dict__ == other.__dict__\\n else:\\n return False\",\n \"def is_equal(self, a, b):\\n return a is b\",\n \"def is_equal(self, a, b):\\n return a == b\",\n \"def __eq__(self, other):\\n return self is other\",\n \"def __eq__(self, other):\\n return self is other\",\n \"def __eq__(self, other):\\r\\n if isinstance(other, self.__class__):\\r\\n return self.__dict__ == other.__dict__\\r\\n else:\\r\\n return False\",\n \"def is_equal(o1: object, o2: object) -> bool:\\n if o1 is None and o2 is None:\\n return True\\n if o1 is None:\\n return False\\n return o1 == o2\",\n \"def __eq__(self,other):\\n return self is other\",\n \"def is_equal(self, a, b):\\n return a.X[0] == b.X[0]\",\n \"def __eq__(self, other):\\n return type(self) == type(other) and self.id == other.id\",\n \"def __eq__(self, other) -> bool:\\n if json.dumps(self.data,sort_keys=True) == json.dumps(other.data,sort_keys=True):\\n return True\\n else:\\n return False\",\n \"def __eq__(self, other):\\n if not isinstance(other, Single2HaObject):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.__dict__ == other\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.__hash__() == other.__hash__()\\n return False\",\n \"def __eq__(self, other):\\n if self.__class__ != other.__class__:\\n return False\\n if self.primary != other.primary:\\n return False\\n return True\",\n \"def __eq__(self, other) -> bool:\\n if other is None:\\n return False\\n return self.__hash__() == other.__hash__()\",\n \"def __eq__(self, other):\\n if not isinstance(other, ObjectInfo):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self: _TT, other: object) -> bool:\\n return self.eq(other) # type: ignore\",\n \"def __eq__(self, other):\\n return id(self) == id(other)\",\n \"def __eq__(self, other) -> bool:\\n return type(self) == type(other) and \\\\\\n self._id == other.id and \\\\\\n self.code == other.code and \\\\\\n self.name == other.name and \\\\\\n self.gender == other.gender and \\\\\\n self.date_of_birth == other.date_of_birth\",\n \"def equals(self, other): # -> bool:\\n ...\",\n \"def equals(self, obj: object) -> bool:\\n ...\",\n \"def __eq__(self, other):\\n for attr in self._attrs_to_save:\\n try:\\n if getattr(self, attr) != getattr(other, attr):\\n return False\\n except AttributeError:\\n return False\\n return True\",\n \"def __eq__(self, other):\\n if type(other) is type(self):\\n return (self.x == other.x and self.y == other.y and self.z == other.z)\\n return False\",\n \"def __eq__(self, other):\\n if isinstance(other, self.__class__):\\n return self.x == other.x and self.y == other.y\\n return False\",\n \"def __eq__(self, other: object) -> bool:\\n if not isinstance(other, self.__class__):\\n return NotImplemented\\n\\n return (\\n self.name,\\n self.submit_at,\\n self.subreddit,\\n self.title,\\n self.body_template,\\n ) == (\\n other.name,\\n other.submit_at,\\n other.subreddit,\\n other.title,\\n other.body_template,\\n )\",\n \"def __eq__(self, other):\\n # Check that we share the same class as this object\\n if not isinstance(other, type(self)):\\n return False\\n\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n if not isinstance(other, PreviewObjectAutofill):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return equal(self, other)\",\n \"def __eq__(self, other: Any) -> bool:\\n return self.__class__ is other.__class__ and self.identifier == other.identifier\",\n \"def __eq__(self, other):\\n return self.__id == other.get_id()\",\n \"def __eq__ (self, other):\\n if type(self) == type(other):\\n return self._m == other._m\\n else:\\n return False\",\n \"def __eq__(self, other):\\n if not isinstance(other, Referent):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def __eq__(self, other):\\n return self.properties == other.properties\",\n \"def __eq__(self, other):\\n return self.items() == other.items()\",\n \"def __eq__(self, other):\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n return self.x == other.x and self.y == other.y\",\n \"def __eq__(self, other):\\n\\n if self is other:\\n return True\\n return hash(self) == hash(other)\",\n \"def __eq__(self, other):\\n if other._field1 == self._field1:\\n return True\\n return False\",\n \"def same_as(self, other):\\n return super().__eq__(other)\",\n \"def __eq__(self, other):\\n try:\\n return other and \\\\\\n self.id == other.id\\n\\n except AttributeError:\\n return False\",\n \"def __eq__(self, other):\\r\\n\\t\\treturn self._to_pylist() == other._to_pylist()\",\n \"def __eq__(self, other):\\n if not isinstance(other, Fiddle):\\n return False\\n\\n return self.__dict__ == other.__dict__\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8088132","0.8088132","0.8054589","0.7982687","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.79670393","0.7961088","0.7961088","0.79433626","0.79303336","0.7926563","0.7897525","0.78826123","0.78826123","0.78806067","0.7872423","0.7868354","0.78668815","0.7825702","0.7819993","0.78162885","0.78078854","0.78068274","0.7796298","0.7794721","0.7784825","0.77790844","0.7769397","0.77534705","0.7746211","0.7741107","0.77282816","0.7725766","0.7719537","0.770273","0.7685999","0.7677552","0.76739407","0.7664857","0.76557016","0.7655046","0.76282835","0.7625795","0.76242626","0.76237214","0.76237214","0.76237214","0.7617347","0.7600536","0.7599156","0.7595863","0.75945824","0.7594092","0.75899327"],"string":"[\n \"0.8088132\",\n \"0.8088132\",\n \"0.8054589\",\n \"0.7982687\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.79670393\",\n \"0.7961088\",\n \"0.7961088\",\n \"0.79433626\",\n \"0.79303336\",\n \"0.7926563\",\n \"0.7897525\",\n \"0.78826123\",\n \"0.78826123\",\n \"0.78806067\",\n \"0.7872423\",\n \"0.7868354\",\n \"0.78668815\",\n \"0.7825702\",\n \"0.7819993\",\n \"0.78162885\",\n \"0.78078854\",\n \"0.78068274\",\n \"0.7796298\",\n \"0.7794721\",\n \"0.7784825\",\n \"0.77790844\",\n \"0.7769397\",\n \"0.77534705\",\n \"0.7746211\",\n \"0.7741107\",\n \"0.77282816\",\n \"0.7725766\",\n \"0.7719537\",\n \"0.770273\",\n \"0.7685999\",\n \"0.7677552\",\n \"0.76739407\",\n \"0.7664857\",\n \"0.76557016\",\n \"0.7655046\",\n \"0.76282835\",\n \"0.7625795\",\n \"0.76242626\",\n \"0.76237214\",\n \"0.76237214\",\n \"0.76237214\",\n \"0.7617347\",\n \"0.7600536\",\n \"0.7599156\",\n \"0.7595863\",\n \"0.75945824\",\n \"0.7594092\",\n \"0.75899327\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76596,"cells":{"query":{"kind":"string","value":"Returns true if both objects are not equal"},"document":{"kind":"string","value":"def __ne__(self, other):\n return not self == other"},"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 __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True","def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)","def __ne__(self, other) -> bool:\n return not self.__eq__(other)","def __eq__(self, other):\n return not self.__ne__(other)","def __ne__(self, other):\n if self.__eq__(other):\n return False\n return True","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n # type: (object) -> bool\n return not self == other","def __ne__(self, other):\n # type: (object) -> bool\n return not self == other","def __ne__(self, other):\n # type: (object) -> bool\n return not self == other","def __ne__(self, other):\r\n return not self == other","def __ne__(self, other):\r\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__(self, other):\n return not self == other","def __ne__ (self, other):\n return not self == other"],"string":"[\n \"def __ne__(self, other: object) -> bool:\\n if self.__eq__(other):\\n return False\\n return True\",\n \"def __ne__(self, other: object) -> bool:\\n return not self.__eq__(other)\",\n \"def __ne__(self, other) -> bool:\\n return not self.__eq__(other)\",\n \"def __eq__(self, other):\\n return not self.__ne__(other)\",\n \"def __ne__(self, other):\\n if self.__eq__(other):\\n return False\\n return True\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n # type: (object) -> bool\\n return not self == other\",\n \"def __ne__(self, other):\\n # type: (object) -> bool\\n return not self == other\",\n \"def __ne__(self, other):\\n # type: (object) -> bool\\n return not self == other\",\n \"def __ne__(self, other):\\r\\n return not self == other\",\n \"def __ne__(self, other):\\r\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__(self, other):\\n return not self == other\",\n \"def __ne__ (self, other):\\n return not self == other\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.845611","0.8391477","0.8144138","0.81410587","0.8132492","0.8093973","0.80920255","0.80920255","0.80920255","0.8085325","0.8085325","0.8076365","0.8076365","0.8065748"],"string":"[\n \"0.845611\",\n \"0.8391477\",\n \"0.8144138\",\n \"0.81410587\",\n \"0.8132492\",\n \"0.8093973\",\n \"0.80920255\",\n \"0.80920255\",\n \"0.80920255\",\n \"0.8085325\",\n \"0.8085325\",\n \"0.8076365\",\n \"0.8076365\",\n \"0.8065748\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76597,"cells":{"query":{"kind":"string","value":"Returns the start state for the search problem."},"document":{"kind":"string","value":"def getStartState(self):\n util.raiseNotDefined()"},"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 getStartState(self):\n return self._start_loc","def getStartState(self):\n\t\tutil.raiseNotDefined()","def getStartState(self):\n\t\tutil.raiseNotDefined()","def getStartState(self):\r\n\t\tutil.raiseNotDefined()","def get_start_state(self):\n util.raiseNotDefined()","def get_start_state(self):\r\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\n util.raiseNotDefined()","def getStartState(self):\r\n util.raiseNotDefined()","def getStartState(self):\n \n pass","def getStartState(self):\n \"\"\" A state space can be the start coordinates and a list to hold visited corners\"\"\"\n return (self.startingPosition, [])\n # util.raiseNotDefined()","def getStartState(self):\n \"*** YOUR CODE HERE ***\"\n return self.startFoodPosition\n # util.raiseNotDefined()","def getStartState(self):\n #return (self.position, self.food.copy())\n return self.position","def get_state(self):\n return STAR_STATES[self.state][0]","def get_state(self):\n return STAR_STATES[self.state][0]","def getStartState(self):\n return self._bot","def getStartState(self):\n return self._bot","def initialstate(self):\n return self.problem.initialstate","def get_start_state(self):\r\n return (\r\n # Keeps track of the time associated with this state for error checking.\r\n tf.zeros([], dtype=tf.int64),\r\n # The previous observation or prediction.\r\n tf.zeros([self.num_features], dtype=self.dtype),\r\n # The state of the RNNCell (batch dimension removed since this parent\r\n # class will broadcast).\r\n [tf.squeeze(state_element, axis=0)\r\n for state_element\r\n in self._lstm_cell.zero_state(batch_size=1, dtype=self.dtype)])","def get_start_loc(self) -> Tuple[int, int]:\n assert self.pos_marker\n return self.pos_marker.working_loc","def _get_state(self):\n start = self.design.first_unassigned_site\n return self.target.padded_encoding[\n start : start + 2 * self._env_config.state_radius + 1\n ]","def extract_start_state(self):\n time = rospy.get_time()\n ref_time = time - self.last_time\n future_time = ref_time + self.update_rate\n\n return df.compute_output3D(self.solution, self.order, self.time[self.index], future_time)","def hgvs_start(self):\n try:\n return self.hp.parse(self.term).posedit.pos.start\n except hgvs.exceptions.HGVSParseError:\n # Log me\n # print(self.term)\n return None","def proof_state_from_search(self, node) -> predictions.ProofState:\n return predictions.ProofState(goal=str(node.goal.conclusion))","def _get_start(self):\n return self._start","def get_start(self):\n return self._start","def get_initial_state(self):\n return self.get_state(self.get_initial_observation())","def startingState(self):\n # Returns starting position and 4 false because no corners are visited yet\n return (self.startingPosition, (False, False, False, False))","def solution_state(self):\n return self._solution_state","def start(self):\n try:\n return self.index[0]\n except:\n pass","def get_start_node(self):\n return self._start","def requested_state(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"requested_state\")","def state(self):\n result = self.getResult()\n return result.state","def start(self) -> pos.Pos:\n return self.__start","def breadth_first_search(problem):\r\n \"*** YOUR CODE HERE ***\"\r\n fringe = []\r\n path = set()\r\n final = []\r\n acts = dict()\r\n state = problem.get_start_state()\r\n fringe.append(state)\r\n\r\n while (True):\r\n state = fringe[0]\r\n del fringe[0]\r\n path.add(state)\r\n states = problem.get_successors(state)\r\n acts[state] = states[:]\r\n if problem.is_goal_state(state):\r\n break\r\n\r\n #states = problem.get_successors(state)\r\n for stat in states:\r\n if stat[0] not in path and stat[0] not in fringe:\r\n fringe.append(stat[0])\r\n\r\n while (True):\r\n if state == problem.get_start_state():\r\n break\r\n for key, val in acts.items():\r\n for va in val:\r\n if va[0] == state:\r\n final.append(va[1])\r\n state = key\r\n break\r\n else:\r\n continue\r\n break\r\n\r\n final.reverse()\r\n\r\n return final","def tinyMazeSearch(problem):\n\n print \"Start:\", problem.getStartState()\n print \"Is the start a goal?\", problem.isGoalState(problem.getStartState())\n print \"Start's successors:\", problem.getSuccessors(problem.getStartState()) # delete this later, otherwise the start state\n # will count as expanded twice!\n print 'problem', problem\n\n\n from pac.game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [e, e, w, s, w, w, s, w]","def registerInitialState(self, state):\n if self.searchFunction == None: raise Exception(\"No search function provided for SearchAgent\")\n starttime = time.time()\n problem = self.searchType(state) # Makes a new search problem\n self.actions = self.searchFunction(problem) # Find a path\n totalCost = problem.getCostOfActions(self.actions)\n print('[R16] Path found with total cost g(x) of '+str(totalCost)+ ' in '+str(time.time() - starttime)+'s')\n if '_expanded' in dir(problem): print('[R13] Search nodes expanded: '+ str(problem._expanded))\n if '_visitedlist' in dir(problem): print('[R13] Nodes visited: ' + str(problem._visitedlist))\n if '_path' in dir(problem): print('[R13] Solution states: ' + str(len(problem._path)) + ' - ' + str(problem._path))\n if '_actions' in dir(problem): print('[R14] Solution actions: ' + str(problem._actions))","def _query_start_get(self):\n return self._query_start","def getStart(self):\n return self._start","def start_state():\n return chess.Board()","def initial_state(self):\n\n return self._state()","def getState():\n # TODO: this isn't nearly as meaningful as it used to be","def start_word(self):\n return self._start","def start(self) -> Vertex:\n return self._start","def start_loc(self) -> str:\n return self._start_loc","def getstate(self):\r\n return SparseGP.getstate(self) + [self.init]","def get_random_start_state(self) -> State:\n if len(self.blocks) <= state_enumeration_limit:\n rnd = random.randint(0, len(self.allStates) - 1)\n return self.allStates[rnd]\n else:\n return self.generate_random_start_state()","def start(self) -> int:\n return self._start","def start(self) -> int:\n return self._start","def state(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"state\")","def start(self,startState=None):\n if not startState or not (startState in [x[0] for x in self._states]):\n raise ValueError(\"Not a valid start state\")\n self.currentState = startState","def start(self,startState=None):\n if not startState or not (startState in [x[0] for x in self._states]):\n raise ValueError(\"Not a valid start state\")\n self.currentState = startState","def starting_position(self) -> aws_cdk.aws_lambda.StartingPosition:\n return self._values.get('starting_position')","def starting_position(self) -> aws_cdk.aws_lambda.StartingPosition:\n return self._values.get('starting_position')","def starting_position(self) -> aws_cdk.aws_lambda.StartingPosition:\n return self._values.get('starting_position')","def starting_position(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"starting_position\")","def state_initial(self):\n return self.states_initial()[0]","def current_state():\n global current_state\n while current_state is None:\n pass\n return current_state"],"string":"[\n \"def getStartState(self):\\n return self._start_loc\",\n \"def getStartState(self):\\n\\t\\tutil.raiseNotDefined()\",\n \"def getStartState(self):\\n\\t\\tutil.raiseNotDefined()\",\n \"def getStartState(self):\\r\\n\\t\\tutil.raiseNotDefined()\",\n \"def get_start_state(self):\\n util.raiseNotDefined()\",\n \"def get_start_state(self):\\r\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\r\\n util.raiseNotDefined()\",\n \"def getStartState(self):\\n \\n pass\",\n \"def getStartState(self):\\n \\\"\\\"\\\" A state space can be the start coordinates and a list to hold visited corners\\\"\\\"\\\"\\n return (self.startingPosition, [])\\n # util.raiseNotDefined()\",\n \"def getStartState(self):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.startFoodPosition\\n # util.raiseNotDefined()\",\n \"def getStartState(self):\\n #return (self.position, self.food.copy())\\n return self.position\",\n \"def get_state(self):\\n return STAR_STATES[self.state][0]\",\n \"def get_state(self):\\n return STAR_STATES[self.state][0]\",\n \"def getStartState(self):\\n return self._bot\",\n \"def getStartState(self):\\n return self._bot\",\n \"def initialstate(self):\\n return self.problem.initialstate\",\n \"def get_start_state(self):\\r\\n return (\\r\\n # Keeps track of the time associated with this state for error checking.\\r\\n tf.zeros([], dtype=tf.int64),\\r\\n # The previous observation or prediction.\\r\\n tf.zeros([self.num_features], dtype=self.dtype),\\r\\n # The state of the RNNCell (batch dimension removed since this parent\\r\\n # class will broadcast).\\r\\n [tf.squeeze(state_element, axis=0)\\r\\n for state_element\\r\\n in self._lstm_cell.zero_state(batch_size=1, dtype=self.dtype)])\",\n \"def get_start_loc(self) -> Tuple[int, int]:\\n assert self.pos_marker\\n return self.pos_marker.working_loc\",\n \"def _get_state(self):\\n start = self.design.first_unassigned_site\\n return self.target.padded_encoding[\\n start : start + 2 * self._env_config.state_radius + 1\\n ]\",\n \"def extract_start_state(self):\\n time = rospy.get_time()\\n ref_time = time - self.last_time\\n future_time = ref_time + self.update_rate\\n\\n return df.compute_output3D(self.solution, self.order, self.time[self.index], future_time)\",\n \"def hgvs_start(self):\\n try:\\n return self.hp.parse(self.term).posedit.pos.start\\n except hgvs.exceptions.HGVSParseError:\\n # Log me\\n # print(self.term)\\n return None\",\n \"def proof_state_from_search(self, node) -> predictions.ProofState:\\n return predictions.ProofState(goal=str(node.goal.conclusion))\",\n \"def _get_start(self):\\n return self._start\",\n \"def get_start(self):\\n return self._start\",\n \"def get_initial_state(self):\\n return self.get_state(self.get_initial_observation())\",\n \"def startingState(self):\\n # Returns starting position and 4 false because no corners are visited yet\\n return (self.startingPosition, (False, False, False, False))\",\n \"def solution_state(self):\\n return self._solution_state\",\n \"def start(self):\\n try:\\n return self.index[0]\\n except:\\n pass\",\n \"def get_start_node(self):\\n return self._start\",\n \"def requested_state(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"requested_state\\\")\",\n \"def state(self):\\n result = self.getResult()\\n return result.state\",\n \"def start(self) -> pos.Pos:\\n return self.__start\",\n \"def breadth_first_search(problem):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n fringe = []\\r\\n path = set()\\r\\n final = []\\r\\n acts = dict()\\r\\n state = problem.get_start_state()\\r\\n fringe.append(state)\\r\\n\\r\\n while (True):\\r\\n state = fringe[0]\\r\\n del fringe[0]\\r\\n path.add(state)\\r\\n states = problem.get_successors(state)\\r\\n acts[state] = states[:]\\r\\n if problem.is_goal_state(state):\\r\\n break\\r\\n\\r\\n #states = problem.get_successors(state)\\r\\n for stat in states:\\r\\n if stat[0] not in path and stat[0] not in fringe:\\r\\n fringe.append(stat[0])\\r\\n\\r\\n while (True):\\r\\n if state == problem.get_start_state():\\r\\n break\\r\\n for key, val in acts.items():\\r\\n for va in val:\\r\\n if va[0] == state:\\r\\n final.append(va[1])\\r\\n state = key\\r\\n break\\r\\n else:\\r\\n continue\\r\\n break\\r\\n\\r\\n final.reverse()\\r\\n\\r\\n return final\",\n \"def tinyMazeSearch(problem):\\n\\n print \\\"Start:\\\", problem.getStartState()\\n print \\\"Is the start a goal?\\\", problem.isGoalState(problem.getStartState())\\n print \\\"Start's successors:\\\", problem.getSuccessors(problem.getStartState()) # delete this later, otherwise the start state\\n # will count as expanded twice!\\n print 'problem', problem\\n\\n\\n from pac.game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [e, e, w, s, w, w, s, w]\",\n \"def registerInitialState(self, state):\\n if self.searchFunction == None: raise Exception(\\\"No search function provided for SearchAgent\\\")\\n starttime = time.time()\\n problem = self.searchType(state) # Makes a new search problem\\n self.actions = self.searchFunction(problem) # Find a path\\n totalCost = problem.getCostOfActions(self.actions)\\n print('[R16] Path found with total cost g(x) of '+str(totalCost)+ ' in '+str(time.time() - starttime)+'s')\\n if '_expanded' in dir(problem): print('[R13] Search nodes expanded: '+ str(problem._expanded))\\n if '_visitedlist' in dir(problem): print('[R13] Nodes visited: ' + str(problem._visitedlist))\\n if '_path' in dir(problem): print('[R13] Solution states: ' + str(len(problem._path)) + ' - ' + str(problem._path))\\n if '_actions' in dir(problem): print('[R14] Solution actions: ' + str(problem._actions))\",\n \"def _query_start_get(self):\\n return self._query_start\",\n \"def getStart(self):\\n return self._start\",\n \"def start_state():\\n return chess.Board()\",\n \"def initial_state(self):\\n\\n return self._state()\",\n \"def getState():\\n # TODO: this isn't nearly as meaningful as it used to be\",\n \"def start_word(self):\\n return self._start\",\n \"def start(self) -> Vertex:\\n return self._start\",\n \"def start_loc(self) -> str:\\n return self._start_loc\",\n \"def getstate(self):\\r\\n return SparseGP.getstate(self) + [self.init]\",\n \"def get_random_start_state(self) -> State:\\n if len(self.blocks) <= state_enumeration_limit:\\n rnd = random.randint(0, len(self.allStates) - 1)\\n return self.allStates[rnd]\\n else:\\n return self.generate_random_start_state()\",\n \"def start(self) -> int:\\n return self._start\",\n \"def start(self) -> int:\\n return self._start\",\n \"def state(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"state\\\")\",\n \"def start(self,startState=None):\\n if not startState or not (startState in [x[0] for x in self._states]):\\n raise ValueError(\\\"Not a valid start state\\\")\\n self.currentState = startState\",\n \"def start(self,startState=None):\\n if not startState or not (startState in [x[0] for x in self._states]):\\n raise ValueError(\\\"Not a valid start state\\\")\\n self.currentState = startState\",\n \"def starting_position(self) -> aws_cdk.aws_lambda.StartingPosition:\\n return self._values.get('starting_position')\",\n \"def starting_position(self) -> aws_cdk.aws_lambda.StartingPosition:\\n return self._values.get('starting_position')\",\n \"def starting_position(self) -> aws_cdk.aws_lambda.StartingPosition:\\n return self._values.get('starting_position')\",\n \"def starting_position(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"starting_position\\\")\",\n \"def state_initial(self):\\n return self.states_initial()[0]\",\n \"def current_state():\\n global current_state\\n while current_state is None:\\n pass\\n return current_state\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75840217","0.7533028","0.7533028","0.7457706","0.7429071","0.7384781","0.7342245","0.7342245","0.7342245","0.7342245","0.7342245","0.7342245","0.7342245","0.7342245","0.7342245","0.7339077","0.69931024","0.6990535","0.6884872","0.6682311","0.6666652","0.6666652","0.65654427","0.65654427","0.654529","0.63328445","0.63114345","0.6211382","0.61792886","0.61757547","0.61146706","0.60979766","0.6060797","0.60594827","0.6052531","0.60230833","0.5996756","0.59688205","0.5962378","0.5957781","0.59436184","0.5909692","0.59045535","0.58970535","0.58787555","0.5875249","0.5873609","0.58290446","0.5827138","0.58124053","0.5802268","0.5786154","0.57784474","0.5772945","0.5772809","0.5772809","0.5760392","0.5758352","0.5758352","0.5746519","0.5746519","0.5746519","0.5739241","0.57286316","0.57199067"],"string":"[\n \"0.75840217\",\n \"0.7533028\",\n \"0.7533028\",\n \"0.7457706\",\n \"0.7429071\",\n \"0.7384781\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7342245\",\n \"0.7339077\",\n \"0.69931024\",\n \"0.6990535\",\n \"0.6884872\",\n \"0.6682311\",\n \"0.6666652\",\n \"0.6666652\",\n \"0.65654427\",\n \"0.65654427\",\n \"0.654529\",\n \"0.63328445\",\n \"0.63114345\",\n \"0.6211382\",\n \"0.61792886\",\n \"0.61757547\",\n \"0.61146706\",\n \"0.60979766\",\n \"0.6060797\",\n \"0.60594827\",\n \"0.6052531\",\n \"0.60230833\",\n \"0.5996756\",\n \"0.59688205\",\n \"0.5962378\",\n \"0.5957781\",\n \"0.59436184\",\n \"0.5909692\",\n \"0.59045535\",\n \"0.58970535\",\n \"0.58787555\",\n \"0.5875249\",\n \"0.5873609\",\n \"0.58290446\",\n \"0.5827138\",\n \"0.58124053\",\n \"0.5802268\",\n \"0.5786154\",\n \"0.57784474\",\n \"0.5772945\",\n \"0.5772809\",\n \"0.5772809\",\n \"0.5760392\",\n \"0.5758352\",\n \"0.5758352\",\n \"0.5746519\",\n \"0.5746519\",\n \"0.5746519\",\n \"0.5739241\",\n \"0.57286316\",\n \"0.57199067\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74203616"},"document_rank":{"kind":"string","value":"37"}}},{"rowIdx":76598,"cells":{"query":{"kind":"string","value":"Returns a sequence of moves that solves tinyMaze. For any other maze, the sequence of moves will be incorrect, so only use this for tinyMaze."},"document":{"kind":"string","value":"def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s, s, w, s, w, w, s, w]"},"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 tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n\n return [s, s, n, s, w, s, w, w, s, w]","def tinyMazeSearch(problem):\n from game import Directions\n\n s = Directions.SOUTH\n w = Directions.WEST\n return [s, s, w, s, w, w, s, w]","def tinyMazeSearch(problem):\r\n from game import Directions\r\n s = Directions.SOUTH\r\n w = Directions.WEST\r\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s, s, w, s, w, w, s, w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s, s, w, s, w, w, s, w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s, s, w, s, w, w, s, w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def tinyMazeSearch(problem):\r\n\tfrom game import Directions\r\n\ts = Directions.SOUTH\r\n\tw = Directions.WEST\r\n\treturn [s, s, w, s, w, w, s, w]","def tinyMazeSearch(problem):\n\tfrom game import Directions\n\ts = Directions.SOUTH\n\tw = Directions.WEST\n\treturn [s, s, w, s, w, w, s, w]","def moves(self):\n\n # define a full range, which we can compare against columns,\n # rows, or blocks. they're all the same when stored as sets.\n line = set(range(1, 10))\n moves = []\n\n # iterate every cell on the board\n for row in range(0, 9):\n for col in range(0, 9):\n\n # ignore this cell if it's already filled\n i = self._index(col, row)\n if self.data[i] is not None:\n continue\n\n # fetch the adjacent cells\n row_values = set(self._row(row))\n col_values = set(self._column(col))\n bck_values = set(self._block(col, row))\n\n # subtract the values present in the adjacent cells\n # (since this cell *can't* be of any of those values),\n # to leave the list of possibilities for this cell\n missing = line.difference(row_values, col_values, bck_values)\n\n # if there's only *one* possibility, we've found the\n # solution to this cell\n if len(missing) == 1:\n moves.append((col, row, missing.pop()))\n\n return moves","def tinyMazeSearch(problem):\n\n print \"Start:\", problem.getStartState()\n print \"Is the start a goal?\", problem.isGoalState(problem.getStartState())\n print \"Start's successors:\", problem.getSuccessors(problem.getStartState()) # delete this later, otherwise the start state\n # will count as expanded twice!\n print 'problem', problem\n\n\n from pac.game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [e, e, w, s, w, w, s, w]","def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n print \"I am here!!!\"\n return [s, s, w, s, w, w, s, w]","def tinyMazeSearch(problem):\n print \"ahahaha\"\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n return [s,s,w,s,w,w,s,w]","def moves(self):\n\n moves = list()\n\n for row in range(HEIGHT):\n for col in range(WIDTH):\n\n move = (row, col)\n\n if self.board[row][col] == 9:\n moves.append(move)\n\n if self.board[row][col] == 1 or self.board[row][col] == 2:\n\n move = (row - 1, col)\n\n if self.board[row - 1][col] == 1 or self.board[row - 1][col] == 2:\n\n pass\n\n else:\n\n moves.append(move)\n\n return moves","def legalMoves(self):\n moves = []\n indexOfZero = self.tiles.index(0)\n \n if indexOfZero == 0:\n moves.append('Down')\n moves.append('Right')\n elif indexOfZero == 1:\n moves.append('Down')\n moves.append('Left')\n moves.append('Right')\n elif indexOfZero == 2:\n moves.append('Down')\n moves.append('Left')\n elif indexOfZero == 3:\n moves.append('Up')\n moves.append('Down')\n moves.append('Right')\n elif indexOfZero == 4:\n moves.append('Up')\n moves.append('Down')\n moves.append('Left')\n moves.append('Right')\n elif indexOfZero == 5:\n moves.append('Up')\n moves.append('Down')\n moves.append('Left')\n elif indexOfZero == 6:\n moves.append('Up')\n moves.append('Right')\n elif indexOfZero == 7:\n moves.append('Up')\n moves.append('Left')\n moves.append('Right')\n elif indexOfZero == 8:\n moves.append('Up')\n moves.append('Left')\n else:\n print('something wrong with board')\n return moves","def get_all_moves(self):\n # 2d matrix of true/false, true if something can be placed\n legal_move_board = []\n possible_move_list = []\n for row in range(self.size):\n move_row = []\n for col in range(self.size):\n empty = self.board[row][col].state == PegState.EMPTY\n move_row.append(empty)\n if empty:\n possible_move_list.append((row, col))\n legal_move_board.append(move_row)\n \n # every position where something can be placed (list of tuples) (Combined with above)\n \"\"\" possible_move_list = []\n for row in range(self.size):\n for col in range(self.size):\n if legal_move_board[row][col] == True:\n possible_move_list.append((row, col))\n \"\"\"\n return legal_move_board, possible_move_list","def moves(self):\n move_list = []\n for direction in Maze.possible_directions:\n move = Maze.dirs_to_moves[direction]\n if (0 <= (self.location[0]+move[0]) < len(self.grid) and\n 0 <= (self.location[1]+move[1]) < len(self.grid[0]) and\n self.grid[self.location[0]+move[0]][self.location[1]+move[1]] != 'X'):\n move_list.append(move)\n\n return move_list","def get_legal_moves(self):\n moves = []\n if self.player_locations[self.whose_turn] is None:\n return self.get_blank_locations()\n matrix = [(1,0), (-1,0), (0,1), (0,-1), (1,1), (1,-1), (-1, 1), (-1,-1)]\n\n for dx, dy in matrix:\n x,y = self.player_locations[self.whose_turn]\n while x+dx <= xdim and x+dx >= 0 and y+dy <= ydim and y+dy >= 0:\n x = x+dx\n y = y+dx\n if self.board[x][y] : break\n moves.append((x,y))\n return moves","def solve_maze(self):\n initial_maze_loc = self.maze.location\n curr_coord = initial_maze_loc\n solution_path_directions = []\n #print(\"in solve_maze:\")\n\n # The agent always chooses the next location with the highest Q value.\n # With this strategy, the agent aims to reach the goal using the\n # most optimal path possible.\n while (self.grid[curr_coord[0]][curr_coord[1]] != 'G' and\n self.grid[curr_coord[0]][curr_coord[1]] != 'E'):\n possible_moves = self.maze.moves()\n\n # Find the next best move.\n best_next_move = (0,0)\n best_next_move_q = float('-inf')\n for move in possible_moves:\n if self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]] >= best_next_move_q:\n best_next_move = move\n best_next_move_q = self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]]\n\n direction = self.maze.moves_to_dirs[best_next_move]\n solution_path_directions.append(direction)\n curr_coord = (curr_coord[0]+best_next_move[0], curr_coord[1]+best_next_move[1])\n self.maze.location = curr_coord\n self.maze.location = initial_maze_loc # reset maze location to initial coord.\n\n return solution_path_directions","def mazeTest():\r\n\tmyMaze = Maze()\r\n\tmyMaze.addCoordinate(1,0,0)\r\n\tmyMaze.addCoordinate(1,1,0)\r\n\tmyMaze.addCoordinate(7,1,0)\r\n\tmyMaze.addCoordinate(1,2,0)\r\n\tmyMaze.addCoordinate(2,2,0)\r\n\tmyMaze.addCoordinate(3,2,0)\r\n\tmyMaze.addCoordinate(4,2,0)\r\n\tmyMaze.addCoordinate(6,2,0)\r\n\tmyMaze.addCoordinate(7,2,0)\r\n\tmyMaze.addCoordinate(4,3,0)\r\n\tmyMaze.addCoordinate(7,3,0)\r\n\tmyMaze.addCoordinate(4,4,0)\r\n\tmyMaze.addCoordinate(7,4,0)\r\n\tmyMaze.addCoordinate(3,5,0)\r\n\tmyMaze.addCoordinate(4,5,0)\r\n\tmyMaze.addCoordinate(7,5,0)\r\n\tmyMaze.addCoordinate(1,6,0)\r\n\tmyMaze.addCoordinate(2,6,0)\r\n\tmyMaze.addCoordinate(3,6,0)\r\n\tmyMaze.addCoordinate(4,6,0)\r\n\tmyMaze.addCoordinate(5,6,0)\r\n\tmyMaze.addCoordinate(6,6,0)\r\n\tmyMaze.addCoordinate(7,6,0)\r\n\tmyMaze.addCoordinate(5,7,0)\r\n\tmyMaze.printMaze()\r\n\tprint(myMaze.findRoute(x1=1, y1=0, x2=5, y2=7))","def solution(self):\n return [node.move for node in self.path()[1:]]","def generate_possible_moves(self):\r\n\t\t# Moves:\r\n\t\t# 0 - North\r\n\t\t# 1 - East\r\n\t\t# 2 - South\r\n\t\t# 3 - West\r\n\r\n\t\tmoves = []\r\n\r\n\t\tif self.x != 0:\r\n\t\t\tmoves.append(0)\r\n\t\tif self.y != self.n-1:\r\n\t\t\tmoves.append(1)\r\n\t\tif self.x != self.n-1:\r\n\t\t\tmoves.append(2)\r\n\t\tif self.y != 0:\r\n\t\t\tmoves.append(3)\r\n\r\n\t\treturn moves","def find_next_moves(self):\n # iterate through all cells, and group them with upper cells and left\n # cells\n\n # generate separated cells then merge the them with same neighbours\n matrix_rows = len(self.status)\n if matrix_rows == 0:\n matrix_cols = 0\n else:\n matrix_cols = len(self.status[0])\n matrix = []\n for i in range(matrix_rows):\n matrix.append([[(i, j)] for j in range(matrix_cols)])\n # merge coordinations\n for i in range(matrix_rows):\n for j in range(matrix_cols):\n if self.status[i][j] != '':\n # is same with right cell?\n if j < matrix_cols - 1 and self.status[i][j] == self.status[i][j + 1]:\n new_item = matrix[i][j] + matrix[i][j + 1]\n matrix[i][j] = matrix[i][j + 1] = new_item\n # is same with down cell?\n if i < matrix_rows - 1 and self.status[i][j] == self.status[i + 1][j]:\n new_item = matrix[i][j] + matrix[i + 1][j]\n matrix[i][j] = matrix[i + 1][j] = new_item\n\n # filter out all unvalid results\n result = []\n # filter out all single-cell groups\n for i in range(matrix_rows):\n for j in range(matrix_cols):\n if (len(matrix[i][j]) > 1 and\n matrix[i][j] not in result):\n result.append(matrix[i][j])\n\n # filter sublists\n result = sorted(result, key=len, reverse=True)\n changed = True\n while changed:\n changed = False\n for i in range(len(result)):\n for j in range(i + 1, len(result)):\n if set(result[i]).issuperset(set(result[j])):\n result.remove(result[j])\n changed = True\n break\n if changed:\n break\n\n if result:\n for i in result:\n yield (self.convert_coordinations(i),\n len(i) * len(i) * 5,\n self.calc_new_status(i))\n else:\n left_cells = sum([len(i) - i.count('') for i in self.status])\n left_cells_score = 2000 - 20 * left_cells * left_cells\n if left_cells_score < 0:\n left_cells_score = 0\n for i in self.parents:\n i.children[self] = [(i.children[self][0][0] + left_cells_score,\n i.children[self][0][1],\n i.children[self][0][2])]","def get_possible_moves(self, board: np.ndarray):\n board_size = board.shape[0]\n moves = []\n if abs(self.value) == 1:\n if self.start_row <= 2:\n directions = [np.array((1, -1)), np.array((1, 1))]\n else:\n directions = [np.array((-1, 1)), np.array((-1, -1))]\n else:\n directions = [np.array((-1, 1)), np.array((1, 1)), np.array((-1, -1)), np.array((1, -1))]\n for direction in directions:\n within_board = True\n i = 1\n while within_board:\n coord = self.coord + direction * i\n within_board = _check_if_position_on_board(coord, board_size)\n # break if first step is already out of board\n if not within_board:\n break\n value_board = board[coord[0], coord[1]]\n # break if there is a stone of them same player in the way\n if value_board < 0 and self.value < 0 or value_board > 0 and self.value > 0:\n break\n # if there is no stone, than add this to move list.\n if value_board == 0:\n moves += [{\"old_coord\": self.coord, \"new_coord\": coord, \"jumped_stones\": [], \"jumped_values\": 0,\n \"move_coords\": [coord]}]\n # if there is a stone of the enemy\n if (value_board < 0 < self.value) or (self.value < 0 < value_board):\n # check if it can be jumped\n coord_jump = coord + direction\n move_coords = [coord_jump.copy()]\n within_board_after_jump = _check_if_position_on_board(coord_jump, board_size)\n # break if place behind stone is out of border\n if not within_board_after_jump:\n break\n value_board_jump = board[coord_jump[0], coord_jump[1]]\n jumped_stones = []\n # break if there is no free place\n if value_board_jump != 0:\n break\n jumped_stones += [coord]\n moves_tmp = self.jump_chain(directions, board, coord_jump, value_board, jumped_stones, move_coords)\n if len(moves_tmp) > 0:\n moves += moves_tmp\n else:\n moves += [{\"old_coord\": self.coord, \"new_coord\": coord_jump, \"jumped_stones\": jumped_stones,\n \"jumped_values\": abs(value_board), \"move_coords\": [coord_jump]}]\n i += 1\n # break if normal stone, because they can only move one field\n if abs(self.value) == 1:\n break\n return moves","def moves(self, board_state):\n # pos_moves = generate_moves(board_state) # Naive moves function here\n blacks = board_state.search_board('B')\n # Generate the possible moves required to kill the first black piece\n # on the board\n pos_moves = sorted_generate_moves_piece(board_state, blacks[0])\n return pos_moves","def find_moves(self):\n\n from itertools import product\n free_position = self.find_free()\n return [list(free_position+i) for i in [[0,1],[1,0],[-1,0],[0,-1]] if tuple(i+free_position) in product(range(self.size),repeat=2)]","def solve(self, maze: Maze) -> List[Cell]:\n self.maze = maze\n path = self.solve_maze()\n self.maze = None\n return path","def get_available_moves(self):\n available = []\n row, col = tuple(self.current_pos)\n if row - 1 >= 0 and self.maze[row - 1][col] != 'x':\n available.append('n')\n if row + 1 < len(self.maze) and self.maze[row + 1][col] != 'x':\n available.append('s')\n if col - 1 >= 0 and self.maze[row][col - 1] != 'x':\n available.append('w')\n if col + 1 < len(self.maze[row]) and self.maze[row][col + 1] != 'x':\n available.append('e')\n return available","def __find_all_moves(self, tower) -> list:\r\n choice = []\r\n for height in range(1,len(tower.tower)-2):\r\n for index in range(1,4):\r\n if self.stat_brain.is_valid(height, index, tower):\r\n choice.append((height, index))\r\n \r\n r.shuffle(choice)\r\n return choice","def solve (M, cpos, move): \n if move == 64:\n print (\"\\n\\nmove: \", move)\n print (\"sum: \", sum(M))\n pprint (M)\n #exit()\n for next in get_moves(cpos, M):\n solve(ulist(M, next, move+1), next, move+1)","def get_next_moves2(self):\n moves = []\n for i in range(len(self.board)):\n for j in range(len(self.board[i])):\n if self.board[i][j] == \"\" and self.move_makes_box(i, j):\n next_board = copy.deepcopy(self.board)\n next_board[i][j] = colors[self.turn] + self.turn + \"\\u001b[0m\"\n next_turn = get_opponent(self.turn)\n moves.append(DotsAndBoxesState(next_board, next_turn))\n return moves","def solve_maze(self):\r\n # if there is no maze to solve, cut the method\r\n if not self.generated:\r\n return None\r\n\r\n # initialize with empty path at starting cell\r\n self.path = dict()\r\n current = self.start\r\n\r\n # loop until the ending cell is reached\r\n while True:\r\n while True:\r\n # choose valid direction\r\n # must remain in the grid\r\n # also must not cross a wall\r\n dirNum = random.randint(0,3)\r\n adjacent = self.get_next_cell(current,dirNum,1)\r\n if self.is_valid_direction(current,dirNum):\r\n hasWall = (self.grid[adjacent[0]][adjacent[1]] == 0)\r\n if not hasWall:\r\n break\r\n # add cell and direction to path\r\n self.path[current] = dirNum\r\n\r\n # get next cell\r\n current = self.get_next_cell(current,dirNum,2)\r\n if current == self.end: \r\n break # break if ending cell is reached\r\n\r\n # go to start of path\r\n current = self.start\r\n self.solution.append(current)\r\n # loop until end of path is reached\r\n while not (current == self.end):\r\n dirNum = self.path[current] # get direction\r\n # add adjacent and crossed cells to solution\r\n crossed = self.get_next_cell(current,dirNum,1)\r\n current = self.get_next_cell(current,dirNum,2)\r\n self.solution.append(crossed)\r\n self.solution.append(current)\r\n\r\n self.path = dict()","def openMoves(self):\n arr = []\n for y in range(0,HEIGHT):\n for x in range(0,WIDTH):\n t = self.getPawn(x,y)\n if(t!=None):\n for z in range(-1,2):\n if(self.legalMove(t,z)):\n #move , #newState\n arr.append((t,z))\n return arr","def get_moves(self):\n moves = []\n i, j = self._get_coordinates(0) # blank space\n\n if i > 0:\n moves.append(Puzzle(self._swap(i, j, i - 1, j))) # move up\n\n if j < self.PUZZLE_NUM_COLUMNS - 1:\n moves.append(Puzzle(self._swap(i, j, i, j + 1))) # move right\n\n if j > 0:\n moves.append(Puzzle(self._swap(i, j, i, j - 1))) # move left\n\n if i < self.PUZZLE_NUM_ROWS - 1:\n moves.append(Puzzle(self._swap(i, j, i + 1, j))) # move down\n\n return moves","def get_goat_possible_moves(self) -> List:\n moves = []\n for pos in self.get_all_positions():\n if pos.is_goat():\n addr_from = pos.address\n for addr_to in pos.piece.get_valid_moves():\n moves.append((addr_from, addr_to))\n\n return moves","def maze():\r\n #size, speed, starting point\r\n turtle.pensize(5)\r\n turtle.speed(0)\r\n turtle.ht()\r\n turtle.penup()\r\n turtle.goto(-300,-300)\r\n turtle.pendown()\r\n left(90)\r\n\r\n #main square\r\n forward(600)\r\n right(90)\r\n forward(270)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(300)\r\n right(90)\r\n forward(600)\r\n right(90)\r\n forward(270)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(300)\r\n backward(30)\r\n\r\n \"\"\"Code for all the columns in the maze\"\"\"\r\n #column 1\r\n right(90)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n #column 1(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n turtle.pendown()\r\n\r\n #column 2\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(150)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n #column 2(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 3\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n #column 3(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 4\r\n forward(60)\r\n turtle.pendown()\r\n forward(210)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n #column 4(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 5\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n #column 5(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 6\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n #column 6(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 7\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(120)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n #column 7(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 8\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n #column 8(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 9\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(120)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(120)\r\n turtle.penup()\r\n forward(120)\r\n #column 9(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 10\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n #column 10(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 11\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(240)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #column 11(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 12\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(120)\r\n turtle.pendown()\r\n forward(180)\r\n turtle.penup()\r\n forward(30)\r\n #column 13(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 14\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n #column 14(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 15\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(180)\r\n #column 15(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 16\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n #column 16(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 17\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(120)\r\n #column 17(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 18\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(180)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n #column 18(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #column 19\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(180)\r\n turtle.penup()\r\n forward(180)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n #column 19(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #column 20\r\n forward(60)\r\n turtle.pendown()\r\n forward(180)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n #column 20(end)\r\n\r\n left(90)\r\n forward(570)\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n\r\n \"\"\"Code for all the rows in the maze\"\"\"\r\n #row 1\r\n forward(90)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(120)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(90)\r\n #row 1(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 2\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(150)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #row 2(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 3\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(210)\r\n turtle.penup()\r\n forward(120)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #row 3(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 4\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(150)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n #row 4(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 5\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n #row 5(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 6\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(150)\r\n #row 6(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 7\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #row 7(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 8\r\n forward(30)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n #row 8(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 9\r\n forward(30)\r\n turtle.pendown()\r\n forward(180)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(150)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n #row 9(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 10\r\n forward(60)\r\n turtle.pendown()\r\n forward(120)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #row 10(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 11\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(150)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n #row 11(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 12\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(180)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #row 12(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 13\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(120)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n #row 13(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 14\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #row 14(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 15\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(90)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n #row 15(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 16\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(120)\r\n turtle.penup()\r\n forward(150)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n #row 16(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 17\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(90)\r\n #row 17(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n\r\n #row 18\r\n forward(30)\r\n turtle.pendown()\r\n forward(120)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(90)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(120)\r\n turtle.penup()\r\n forward(30)\r\n #row 18(end)\r\n\r\n left(90)\r\n forward(30)\r\n left(90)\r\n\r\n #row 19\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(60)\r\n turtle.penup()\r\n forward(120)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(30)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n forward(60)\r\n turtle.pendown()\r\n forward(30)\r\n turtle.penup()\r\n #row 19(end)\r\n\r\n right(90)\r\n forward(30)\r\n right(90)\r\n forward(285)\r\n right(90)\r\n turtle.pendown()\r\n turtle.st()\r\n turtle.color(\"red\")\r\n\r\n print (\"Welcome to the maze! Choose your path!\")\r\n print (\"\\nUse W, A, S, D or arrow keys to move around the maze.\")\r\n print (\"Press I to write down the movement manually.\")\r\n print\r\n print (\"CAUTION!!!\")\r\n print (\"The Walls of the maze are NOT an obstacle.\")\r\n print (\"Please avoid going through them at any time\")\r\n print (\"for the purpose of your own entertainment in this program.\")","def get_next_moves1(self):\n moves = []\n for i in range(len(self.board)):\n for j in range(len(self.board[i])):\n if self.board[i][j] == \"\":\n next_board = copy.deepcopy(self.board)\n next_board[i][j] = colors[self.turn] + self.turn + \"\\u001b[0m\"\n next_turn = get_opponent(self.turn)\n moves.append(DotsAndBoxesState(next_board, next_turn))\n return moves","def moves(self, teleport=False):\n recv = [(self._size[y][x] - self._used[y][x], x, y)\n for x in range(self.xsize) for y in range(self.ysize)]\n recv.sort(reverse=True)\n send = [(self._used[y][x], x, y)\n for x in range(self.xsize) for y in range(self.ysize)\n if self._used[y][x] > 0]\n send.sort()\n # print(\"recv: {}...\".format(str(recv[:5])))\n # print(\"send: {}...\".format(str(send[:5])))\n moves = []\n for avail, x1, y1 in recv:\n for used, x0, y0 in send:\n if avail < used:\n break\n if teleport or (x0 == x1 and abs(y0 - y1) == 1) or (\n y0 == y1 and abs(x0 - x1) == 1):\n self.apply((x0, y0), (x1, y1))\n moves.append((self.score(), self.key(), self.save(), list(self.history)))\n self.undo()\n return moves","def get_moves_for_square(self, square):\n (x,y) = square\n\n # determine the color of the piece.\n color = self[x][y]\n\n # skip empty source squares.\n if color==0:\n return []\n\n # search all possible directions.\n moves = []\n for direction in self.__directions:\n move = self._discover_move(square, direction)\n if move:\n # print(square,move,direction)\n moves.append(move)\n\n # return the generated move list\n return moves","def moves(self):\n move_list = list()\n for i in range(self.n):\n row = self.queens[i][0]\n col = self.queens[i][1]\n for rd in [-1,0,1]:\n for cd in [-1,0,1]:\n if (rd == 0) and (cd == 0):\n continue\n new_pos = [row+rd, col+cd]\n if (new_pos[0] >= 0) and (new_pos[0] < self.n) and (new_pos[1] >= 0) and (new_pos[1] < self.n):\n if not new_pos in self.queens: \n move_list.append([i, new_pos])\n\n return move_list","def solve_puzzle(self):\n # move zero tile to the lower right corner\n row, col = self.current_position(0, 0)\n movements = \"d\" * (self.get_height() - 1 - row) + \"r\" * (\n self.get_width() - 1 - col)\n self.update_puzzle(movements)\n # solve rowid from 2 by row\n for row in range(self.get_height() - 1, 1, -1):\n for col in range(self.get_width() - 1, -1, -1):\n assert self.lower_row_invariant(row, col)\n if col == 0:\n movements += self.solve_col0_tile(row)\n assert self.lower_row_invariant(row - 1,\n self.get_width() - 1)\n else:\n movements += self.solve_interior_tile(row, col)\n assert self.lower_row_invariant(row, col - 1)\n # solve the uppermost two rows by column\n for col in range(self.get_width() - 1, 1, -1):\n for row in range(1, -1, -1):\n if row == 0:\n assert self.row0_invariant(col)\n movements += self.solve_row0_tile(col)\n assert self.row1_invariant(col - 1)\n else:\n assert self.row1_invariant(col)\n movements += self.solve_row1_tile(col)\n assert self.row0_invariant(col)\n movements += self.solve_2x2()\n return movements","def getAllValidMoves(x0, y0):\n deltas = [\n (-2, -1),\n (-2, +1),\n (+2, -1),\n (+2, +1),\n (-1, -2),\n (-1, +2),\n (+1, -2),\n (+1, +2),\n ]\n validPositions = []\n\n for (x, y) in deltas:\n xCandidate = x0 + x\n yCandidate = y0 + y\n if 0 < xCandidate < 8 and 0 < yCandidate < 8:\n validPositions.append([xCandidate, yCandidate])\n\n return validPositions","def solve_maze(self, maze):\n \"\"\"this means: always follow a given path to a junction and from there try a direction at random\"\"\"\n \"\"\"caution: this algorithms may take longer than anticipated (since it is random)\"\"\"\n self.maze = maze\n self.path = []\n if maze.get_entrance() is None or maze.get_exit() is None:\n self.log.error('Entrance or Exit is missing')\n raise Exception('Entrance or Exit is missing')\n cell = maze.get_entrance()\n self.path.append(cell)\n while self.path[-1] != maze.get_exit():\n self.__decide_next__()\n self.__clean_path__()\n return self.path","def solve_maze(self) -> List[Cell]:\n self.prev_cells = {}\n self.junction_graph = self.construct_junction_graph()\n self.junction_graph.depth_first_search(self.maze.start_cell, self.junction_visitor)\n\n end_cell = self.maze.end_cell\n path = [end_cell]\n prev_cell = end_cell\n cell = self.prev_cells.get(end_cell)\n\n while path[-1] != self.maze.start_cell:\n if Direction.between(prev_cell, cell) is None:\n # fill in corridors\n direction = self.junction_direction(prev_cell, cell)\n neighbor = self.maze.neighbor(prev_cell, direction)\n while neighbor != cell:\n path.append(neighbor)\n neighbor = self.maze.neighbor(neighbor, direction)\n path.append(cell)\n prev_cell = cell\n cell = self.prev_cells.get(cell)\n\n return list(reversed(path))","def get_all_possible_moves(self):\r\n moves = []\r\n for i in range(8):\r\n for j in range(8):\r\n color = self.board[i][j][0]\r\n if (color == 'b' and not self.turn_white) or (color == 'w' and self.turn_white):\r\n p_type = self.board[i][j][1]\r\n if p_type == 'r':\r\n self.get_rook_moves(i, j, moves)\r\n elif p_type == 'k':\r\n self.get_king_moves(i, j, moves)\r\n elif p_type == 'q':\r\n self.get_queen_moves(i, j, moves)\r\n elif p_type == 'p':\r\n self.get_pawn_moves(i, j, moves)\r\n elif p_type == 'b':\r\n self.get_bishop_moves(i, j, moves)\r\n elif p_type == 'n':\r\n self.get_knight_moves(i, j, moves)\r\n return moves","def get_all_moves(self, board, player):\n result = []\n for startx in range(8):\n for starty in range(8):\n for destx in range(8):\n for desty in range(8):\n if self.is_legal_move(board, [startx, starty], [destx, desty], player):\n result.append([[startx, starty], [destx, desty]])\n return result","def minMoves(maze, x, y):\n\n def maze_guard():\n \"\"\"Guard function to block oversized dimensions\"\"\"\n cell_guard = all([1 <= len(row) <= 100 for row in maze])\n row_guard = 1 <= len(maze) <= 100\n return cell_guard and row_guard\n\n def walk_maze(finish):\n \"\"\"Walks the maze, finding the shortest path including all coins.\n Finishes when reach the coordenate finish, a tuple with row and\n column numbers\n \"\"\"\n i, j = (0, 0)\n result = -1\n weight = -1\n while nodes:\n i, j, path, coins = nodes.popleft()\n cell = maze[i][j]\n if (i, j) == finish:\n weight, result = check_result(coins, path, weight, result)\n elif cell != 1:\n adjacent_nodes(i, j, path, coins)\n\n return result\n\n def adjacent_nodes(i, j, path, coins):\n \"\"\"Adds the node in positions i, j, with its path added to\n accumulated path. The path is transformed into a binary\n number, i.e, 2 ** (i * n + j), being n the number of rows\n in the maze matrix.\n \"\"\"\n def neighbour(x, y):\n this_path = 2 ** (i * n + j)\n if not this_path & path:\n coin = coins + 1 if maze[i][j] == 2 else coins\n nodes.append((x, y, path + this_path, coin))\n\n coord = [(i + 1, j, i + 1 < n), (i - 1, j, i - 1 >= 0),\n (i, j + 1, j + 1 < m), (i, j - 1, j - 1 >= 0)]\n _ = [neighbour(x, y) for x, y, test in coord if test]\n\n if not maze_guard():\n return -1\n\n n = len(maze)\n m = len(maze[0])\n nodes = deque([(0, 0, 0, 0)])\n return walk_maze((x, y))","def _get_easy_move(self):\n # Two lists keep track of regular moves and paths of possible jumps\n moves = []\n required_jumps = []\n for row in range(self._checkers.dimension):\n for col in range(self._checkers.dimension):\n # Check same color pieces as player to see if they can jump.\n if self._checkers.get(row, col) == self._player:\n path_made = False\n found_jumps = []\n # i represents an option of direction to check\n for i in range(3):\n current_path = []\n # Builds a path of jumps by checking for a jump each\n # move\n while (not path_made):\n jumps = self.check_for_jump(self._player, row, col)\n if jumps == []:\n path_made = True\n break\n current_path += (jumps)\n incrow = 0\n inccol = 0\n # South west and east\n if i == 0:\n incrow = 2\n inccol = 2\n elif i == 1:\n incrow = 2\n incrow = -2\n # North west and east\n elif i == 2:\n incrow = -2\n inccol = -2\n elif i == 3:\n incrow = -2\n incrow = 2\n row += incrow\n col += inccol\n found_jumps.append(current_path)\n if len(found_jumps) > 0:\n # If there is at least one path then we append it\n # to the list of jumps\n required_jumps += found_jumps\n else:\n # Checks if a move can be made in each direction\n north_west = self._checkers.get(row - 1, col - 1)\n north_east = self._checkers.get(row - 1, col + 1)\n south_west = self._checkers.get(row + 1, col + 1)\n south_east = self._checkers.get(row + 1, col - 1)\n if north_west == CheckersBoard.empty:\n moves.append(Move(row, col, -1, -1))\n if north_east == CheckersBoard.empty:\n moves.append(Move(row, col, -1, 1))\n if south_west == CheckersBoard.empty:\n moves.append(Move(row, col, 1, 1))\n if south_east == CheckersBoard.empty:\n moves.append(Move(row, col, 1, -1))\n # A random move is calculated for the lists of moves\n # If a move can be made we prioritize the list with possible moves\n random_index = 0\n if len(required_jumps) != 0:\n random_index = random.randint(0, len(required_jumps))\n move_path = required_jumps[random_index]\n return move_path\n else:\n random_index = random.randint(0, len(moves))\n move = moves[random_index]\n return [move]","def make_random_move(self):\n # get copy of the empty board\n board = set([(i, j) for i in range(self.height) for j in range(self.width)])\n\n for move in board:\n if not move in self.moves_made and not move in self.mines:\n return move\n\n return None","def legal_moves(self):\n moves = \"\"\n swappable = self.swappable_positions\n empty_position = self.get_position(0)\n\n for s in swappable:\n pos_diff = empty_position[0] - s[0], empty_position[1] - s[1]\n if pos_diff[0] > 0:\n moves += \"U\"\n elif pos_diff[0] < 0:\n moves += \"D\"\n elif pos_diff[1] > 0:\n moves += \"L\"\n elif pos_diff[1] < 0:\n moves += \"R\"\n\n return moves","def get_valid_moves(self):\n if self.king:\n valid_moves = [[self.row + 1, self.col + 1],\n [self.row + 1, self.col - 1],\n [self.row - 1, self.col - 1],\n [self.row - 1, self.col + 1]]\n else:\n if self.player == 1:\n valid_moves = [[self.row + 1, self.col + 1],\n [self.row + 1, self.col - 1]]\n else:\n valid_moves = [[self.row - 1, self.col - 1],\n [self.row - 1, self.col + 1]]\n return valid_moves","def get_legal_moves(self):\n # for each square in the castle figure out if an moves can occur from it.\n moves = []\n allowed = [self.turn]\n if self.turn == DEFENDER:\n allowed.extend((KING, CASTLE_OCCUPIED))\n it = np.nditer(self.board_state, flags=['multi_index'])\n while not it.finished:\n index = it.multi_index\n curr_loc = it[0]\n if curr_loc in allowed:\n moves.extend(self.get_legal_move_piece(curr_loc, index))\n it.iternext()\n return moves","def ai_move():\n\tinitial_state = map(get_filled_edges, rects)\n\tpossible_moves = []\n\tfor index, filled_edges in enumerate(initial_state):\n\t\tif filled_edges == 0:\n\t\t\tpossible_moves.extend([(index, i) for i in 'ltrb'])\n\t\telif filled_edges == 1:\n\t\t\tpossible_moves.extend(one_filled_edge(index))\n\t\telif filled_edges == 2:\n\t\t\tpossible_moves.extend(two_filled_edge(index))\n\t\telif filled_edges == 3:\n\t\t\tpossible_moves.extend(three_filled_edge(index))\n\tprint possible_moves\n\tpossible_decisions = []\n\tfor move in possible_moves:\n\t\tfinal_state = apply_move(move)\n\t\tpossible_decisions.append(is_feasible(initial_state, final_state))\n\tprint possible_decisions\n\t# randomizing when some decisions have the same weight\n\tmax_weight = max(possible_decisions)\n\t# list of indices which have the same weight\n\tmax_indices = []\n\tfor index, weight in enumerate(possible_decisions):\n\t\tif weight == max_weight:\n\t\t\tmax_indices.append(index)\n\tx = choice(max_indices)\n\tprint x\n\treturn possible_moves[x]\n\t# return possible_moves[possible_decisions.index(max(possible_decisions))]","def solve_puzzle(self):\r\n # initialize some values and start tile at bottom right corner\r\n col = self.get_width() - 1\r\n row = self.get_height() - 1\r\n move = \"\"\r\n curr_row, curr_col = self.current_position(0, 0)\r\n move_to_target = abs(curr_col - col) * \"r\" + abs(curr_row - row) * \"d\"\r\n self.update_puzzle(move_to_target)\r\n move += move_to_target\r\n\r\n # apply solver methods\r\n for dummy_i in range(row, 1, -1):\r\n for dummy_j in range(col, 0, -1):\r\n move += self.solve_interior_tile(dummy_i, dummy_j)\r\n move += self.solve_col0_tile(dummy_i)\r\n \r\n for dummy_j in range(col, 1, -1):\r\n move += self.solve_row1_tile(dummy_j)\r\n move += self.solve_row0_tile(dummy_j)\r\n \r\n move += self.solve_2x2()\r\n return move","def get_possible_moves(self) -> list:\n p1_count = 0\n p2_count = 0\n ley_line_total = (self.side_length + 1) * 3\n for itype in self.current_ley_lines:\n for line in itype:\n if line[0] == '1':\n p1_count += 1\n if line[0] == '2':\n p2_count += 1\n if p1_count >= ley_line_total / 2 or p2_count >= ley_line_total / 2:\n return []\n moves = []\n for letter in self.current_board:\n if letter.isalpha():\n moves.append(letter)\n return moves","def get_valid_moves(self):\r\n validMoves = []\r\n\r\n for x in range(BOARD_SIZE):\r\n for y in range(BOARD_SIZE):\r\n pos = np.array([x,y])\r\n if self.board[pos[0],pos[1]] == 0:\r\n if(self.update_board(pos,_testing=True)):\r\n validMoves.append(pos)\r\n\r\n return validMoves","def get_moves(self):\n grid = self.model.grid\n # List of agents we can't overlap with\n no_overlap = [\"wall\", \"human\", \"zombie\"]\n\n if self.agent_type == \"zombie\" or \\\n (\"AvoidingZombie\" not in self.states and os.environ[\"mode\"] == \"5\"):\n no_overlap.append(\"road\")\n\n # Always give the option to stay on your current location(stand still)\n all_cells = self.neighbors()\n free_cells = [self.pos]\n\n # Get rid of cells that we may not move to by iterating through all\n # cells next to the agent, and only adding non-occupied cells\n for cell in all_cells:\n cell_occupied = False\n x, y = cell.pos\n # If there are agents in the current cell, and we are not allowed\n # to overlap with any of those agents, the cell is occupied.\n # Only add cells which are not occupied.\n if not grid.is_cell_empty((x, y)):\n for agent in grid[x][y]:\n if agent.agent_type in no_overlap:\n cell_occupied = True\n break\n if not cell_occupied:\n free_cells.append((x, y))\n return free_cells","def checkMoves(self,board):\n possibleMoves = []\n\n for c in xrange(0,8):\n for r in xrange(0,8):\n if board.isValidMove(self.tile,c,r):\n possibleMoves.append(c+r*8)\n\n return possibleMoves","def neighboring_states(self):\n index = self.state.index(0)\n\n if index == 0:\n return [self.move(movement) for movement in ['down', 'right']]\n elif index == 1:\n return [self.move(movement) for movement in ['down', 'left', 'right']]\n elif index == 2:\n return [self.move(movement) for movement in ['down', 'left']]\n elif index == 3:\n return [self.move(movement) for movement in ['up', 'down', 'right']]\n elif index == 4:\n return [self.move(movement) for movement in ['up', 'down', 'left', 'right']]\n elif index == 5:\n return [self.move(movement) for movement in ['up', 'down', 'left']]\n elif index == 6:\n return [self.move(movement) for movement in ['up', 'right']]\n elif index == 7:\n return [self.move(movement) for movement in ['up', 'left', 'right']]\n else:\n # index == 8\n return [self.move(movement) for movement in ['up', 'left']]","def possible_moves(self): \n return [a + 1 for a, b in enumerate(self.board) if b == 0]","def test_maze_move_6(self):\n maze_template = [['#', '#', '#', '#', '#', '#', '#'], \n ['#', '.', '.', '.', '.', '.', '#'], \n ['#', '.', '#', '#', '#', '.', '#'], \n ['#', '.', '.', '@', '#', '.', '#'], \n ['#', '@', '#', '.', '@', '.', '#'], \n ['#', '#', '#', '#', '#', '#', '#']]\n rat_J = a2.Rat(a2.RAT_1_CHAR, 1, 1)\n rat_P = a2.Rat(a2.RAT_2_CHAR, 1, 4)\n\n maze = a2.Maze(maze_template, rat_J, rat_P)\n old_sprout_count = maze.num_sprouts_left\n\n maze.move(rat_J, a2.DOWN, a2.NO_CHANGE)\n\n self.assertEqual(maze.num_sprouts_left, old_sprout_count)","def get_legal_moves(self, color):\n moves = [] # stores the legal moves.\n # Get all the squares with pieces of the given color.\n for x in range(self.n):\n for y in range(self.n):\n if self[x][y]==0:\n moves.append((x,y))\n return moves","def get_square_moves(self, moves):\r\n return self.board.get_square_moves(moves)"],"string":"[\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n\\n return [s, s, n, s, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s, s, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\r\\n from game import Directions\\r\\n s = Directions.SOUTH\\r\\n w = Directions.WEST\\r\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s, s, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s, s, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s, s, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def tinyMazeSearch(problem):\\r\\n\\tfrom game import Directions\\r\\n\\ts = Directions.SOUTH\\r\\n\\tw = Directions.WEST\\r\\n\\treturn [s, s, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\n\\tfrom game import Directions\\n\\ts = Directions.SOUTH\\n\\tw = Directions.WEST\\n\\treturn [s, s, w, s, w, w, s, w]\",\n \"def moves(self):\\n\\n # define a full range, which we can compare against columns,\\n # rows, or blocks. they're all the same when stored as sets.\\n line = set(range(1, 10))\\n moves = []\\n\\n # iterate every cell on the board\\n for row in range(0, 9):\\n for col in range(0, 9):\\n\\n # ignore this cell if it's already filled\\n i = self._index(col, row)\\n if self.data[i] is not None:\\n continue\\n\\n # fetch the adjacent cells\\n row_values = set(self._row(row))\\n col_values = set(self._column(col))\\n bck_values = set(self._block(col, row))\\n\\n # subtract the values present in the adjacent cells\\n # (since this cell *can't* be of any of those values),\\n # to leave the list of possibilities for this cell\\n missing = line.difference(row_values, col_values, bck_values)\\n\\n # if there's only *one* possibility, we've found the\\n # solution to this cell\\n if len(missing) == 1:\\n moves.append((col, row, missing.pop()))\\n\\n return moves\",\n \"def tinyMazeSearch(problem):\\n\\n print \\\"Start:\\\", problem.getStartState()\\n print \\\"Is the start a goal?\\\", problem.isGoalState(problem.getStartState())\\n print \\\"Start's successors:\\\", problem.getSuccessors(problem.getStartState()) # delete this later, otherwise the start state\\n # will count as expanded twice!\\n print 'problem', problem\\n\\n\\n from pac.game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [e, e, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n print \\\"I am here!!!\\\"\\n return [s, s, w, s, w, w, s, w]\",\n \"def tinyMazeSearch(problem):\\n print \\\"ahahaha\\\"\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n return [s,s,w,s,w,w,s,w]\",\n \"def moves(self):\\n\\n moves = list()\\n\\n for row in range(HEIGHT):\\n for col in range(WIDTH):\\n\\n move = (row, col)\\n\\n if self.board[row][col] == 9:\\n moves.append(move)\\n\\n if self.board[row][col] == 1 or self.board[row][col] == 2:\\n\\n move = (row - 1, col)\\n\\n if self.board[row - 1][col] == 1 or self.board[row - 1][col] == 2:\\n\\n pass\\n\\n else:\\n\\n moves.append(move)\\n\\n return moves\",\n \"def legalMoves(self):\\n moves = []\\n indexOfZero = self.tiles.index(0)\\n \\n if indexOfZero == 0:\\n moves.append('Down')\\n moves.append('Right')\\n elif indexOfZero == 1:\\n moves.append('Down')\\n moves.append('Left')\\n moves.append('Right')\\n elif indexOfZero == 2:\\n moves.append('Down')\\n moves.append('Left')\\n elif indexOfZero == 3:\\n moves.append('Up')\\n moves.append('Down')\\n moves.append('Right')\\n elif indexOfZero == 4:\\n moves.append('Up')\\n moves.append('Down')\\n moves.append('Left')\\n moves.append('Right')\\n elif indexOfZero == 5:\\n moves.append('Up')\\n moves.append('Down')\\n moves.append('Left')\\n elif indexOfZero == 6:\\n moves.append('Up')\\n moves.append('Right')\\n elif indexOfZero == 7:\\n moves.append('Up')\\n moves.append('Left')\\n moves.append('Right')\\n elif indexOfZero == 8:\\n moves.append('Up')\\n moves.append('Left')\\n else:\\n print('something wrong with board')\\n return moves\",\n \"def get_all_moves(self):\\n # 2d matrix of true/false, true if something can be placed\\n legal_move_board = []\\n possible_move_list = []\\n for row in range(self.size):\\n move_row = []\\n for col in range(self.size):\\n empty = self.board[row][col].state == PegState.EMPTY\\n move_row.append(empty)\\n if empty:\\n possible_move_list.append((row, col))\\n legal_move_board.append(move_row)\\n \\n # every position where something can be placed (list of tuples) (Combined with above)\\n \\\"\\\"\\\" possible_move_list = []\\n for row in range(self.size):\\n for col in range(self.size):\\n if legal_move_board[row][col] == True:\\n possible_move_list.append((row, col))\\n \\\"\\\"\\\"\\n return legal_move_board, possible_move_list\",\n \"def moves(self):\\n move_list = []\\n for direction in Maze.possible_directions:\\n move = Maze.dirs_to_moves[direction]\\n if (0 <= (self.location[0]+move[0]) < len(self.grid) and\\n 0 <= (self.location[1]+move[1]) < len(self.grid[0]) and\\n self.grid[self.location[0]+move[0]][self.location[1]+move[1]] != 'X'):\\n move_list.append(move)\\n\\n return move_list\",\n \"def get_legal_moves(self):\\n moves = []\\n if self.player_locations[self.whose_turn] is None:\\n return self.get_blank_locations()\\n matrix = [(1,0), (-1,0), (0,1), (0,-1), (1,1), (1,-1), (-1, 1), (-1,-1)]\\n\\n for dx, dy in matrix:\\n x,y = self.player_locations[self.whose_turn]\\n while x+dx <= xdim and x+dx >= 0 and y+dy <= ydim and y+dy >= 0:\\n x = x+dx\\n y = y+dx\\n if self.board[x][y] : break\\n moves.append((x,y))\\n return moves\",\n \"def solve_maze(self):\\n initial_maze_loc = self.maze.location\\n curr_coord = initial_maze_loc\\n solution_path_directions = []\\n #print(\\\"in solve_maze:\\\")\\n\\n # The agent always chooses the next location with the highest Q value.\\n # With this strategy, the agent aims to reach the goal using the\\n # most optimal path possible.\\n while (self.grid[curr_coord[0]][curr_coord[1]] != 'G' and\\n self.grid[curr_coord[0]][curr_coord[1]] != 'E'):\\n possible_moves = self.maze.moves()\\n\\n # Find the next best move.\\n best_next_move = (0,0)\\n best_next_move_q = float('-inf')\\n for move in possible_moves:\\n if self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]] >= best_next_move_q:\\n best_next_move = move\\n best_next_move_q = self.qtable[curr_coord[0]+move[0]][curr_coord[1]+move[1]]\\n\\n direction = self.maze.moves_to_dirs[best_next_move]\\n solution_path_directions.append(direction)\\n curr_coord = (curr_coord[0]+best_next_move[0], curr_coord[1]+best_next_move[1])\\n self.maze.location = curr_coord\\n self.maze.location = initial_maze_loc # reset maze location to initial coord.\\n\\n return solution_path_directions\",\n \"def mazeTest():\\r\\n\\tmyMaze = Maze()\\r\\n\\tmyMaze.addCoordinate(1,0,0)\\r\\n\\tmyMaze.addCoordinate(1,1,0)\\r\\n\\tmyMaze.addCoordinate(7,1,0)\\r\\n\\tmyMaze.addCoordinate(1,2,0)\\r\\n\\tmyMaze.addCoordinate(2,2,0)\\r\\n\\tmyMaze.addCoordinate(3,2,0)\\r\\n\\tmyMaze.addCoordinate(4,2,0)\\r\\n\\tmyMaze.addCoordinate(6,2,0)\\r\\n\\tmyMaze.addCoordinate(7,2,0)\\r\\n\\tmyMaze.addCoordinate(4,3,0)\\r\\n\\tmyMaze.addCoordinate(7,3,0)\\r\\n\\tmyMaze.addCoordinate(4,4,0)\\r\\n\\tmyMaze.addCoordinate(7,4,0)\\r\\n\\tmyMaze.addCoordinate(3,5,0)\\r\\n\\tmyMaze.addCoordinate(4,5,0)\\r\\n\\tmyMaze.addCoordinate(7,5,0)\\r\\n\\tmyMaze.addCoordinate(1,6,0)\\r\\n\\tmyMaze.addCoordinate(2,6,0)\\r\\n\\tmyMaze.addCoordinate(3,6,0)\\r\\n\\tmyMaze.addCoordinate(4,6,0)\\r\\n\\tmyMaze.addCoordinate(5,6,0)\\r\\n\\tmyMaze.addCoordinate(6,6,0)\\r\\n\\tmyMaze.addCoordinate(7,6,0)\\r\\n\\tmyMaze.addCoordinate(5,7,0)\\r\\n\\tmyMaze.printMaze()\\r\\n\\tprint(myMaze.findRoute(x1=1, y1=0, x2=5, y2=7))\",\n \"def solution(self):\\n return [node.move for node in self.path()[1:]]\",\n \"def generate_possible_moves(self):\\r\\n\\t\\t# Moves:\\r\\n\\t\\t# 0 - North\\r\\n\\t\\t# 1 - East\\r\\n\\t\\t# 2 - South\\r\\n\\t\\t# 3 - West\\r\\n\\r\\n\\t\\tmoves = []\\r\\n\\r\\n\\t\\tif self.x != 0:\\r\\n\\t\\t\\tmoves.append(0)\\r\\n\\t\\tif self.y != self.n-1:\\r\\n\\t\\t\\tmoves.append(1)\\r\\n\\t\\tif self.x != self.n-1:\\r\\n\\t\\t\\tmoves.append(2)\\r\\n\\t\\tif self.y != 0:\\r\\n\\t\\t\\tmoves.append(3)\\r\\n\\r\\n\\t\\treturn moves\",\n \"def find_next_moves(self):\\n # iterate through all cells, and group them with upper cells and left\\n # cells\\n\\n # generate separated cells then merge the them with same neighbours\\n matrix_rows = len(self.status)\\n if matrix_rows == 0:\\n matrix_cols = 0\\n else:\\n matrix_cols = len(self.status[0])\\n matrix = []\\n for i in range(matrix_rows):\\n matrix.append([[(i, j)] for j in range(matrix_cols)])\\n # merge coordinations\\n for i in range(matrix_rows):\\n for j in range(matrix_cols):\\n if self.status[i][j] != '':\\n # is same with right cell?\\n if j < matrix_cols - 1 and self.status[i][j] == self.status[i][j + 1]:\\n new_item = matrix[i][j] + matrix[i][j + 1]\\n matrix[i][j] = matrix[i][j + 1] = new_item\\n # is same with down cell?\\n if i < matrix_rows - 1 and self.status[i][j] == self.status[i + 1][j]:\\n new_item = matrix[i][j] + matrix[i + 1][j]\\n matrix[i][j] = matrix[i + 1][j] = new_item\\n\\n # filter out all unvalid results\\n result = []\\n # filter out all single-cell groups\\n for i in range(matrix_rows):\\n for j in range(matrix_cols):\\n if (len(matrix[i][j]) > 1 and\\n matrix[i][j] not in result):\\n result.append(matrix[i][j])\\n\\n # filter sublists\\n result = sorted(result, key=len, reverse=True)\\n changed = True\\n while changed:\\n changed = False\\n for i in range(len(result)):\\n for j in range(i + 1, len(result)):\\n if set(result[i]).issuperset(set(result[j])):\\n result.remove(result[j])\\n changed = True\\n break\\n if changed:\\n break\\n\\n if result:\\n for i in result:\\n yield (self.convert_coordinations(i),\\n len(i) * len(i) * 5,\\n self.calc_new_status(i))\\n else:\\n left_cells = sum([len(i) - i.count('') for i in self.status])\\n left_cells_score = 2000 - 20 * left_cells * left_cells\\n if left_cells_score < 0:\\n left_cells_score = 0\\n for i in self.parents:\\n i.children[self] = [(i.children[self][0][0] + left_cells_score,\\n i.children[self][0][1],\\n i.children[self][0][2])]\",\n \"def get_possible_moves(self, board: np.ndarray):\\n board_size = board.shape[0]\\n moves = []\\n if abs(self.value) == 1:\\n if self.start_row <= 2:\\n directions = [np.array((1, -1)), np.array((1, 1))]\\n else:\\n directions = [np.array((-1, 1)), np.array((-1, -1))]\\n else:\\n directions = [np.array((-1, 1)), np.array((1, 1)), np.array((-1, -1)), np.array((1, -1))]\\n for direction in directions:\\n within_board = True\\n i = 1\\n while within_board:\\n coord = self.coord + direction * i\\n within_board = _check_if_position_on_board(coord, board_size)\\n # break if first step is already out of board\\n if not within_board:\\n break\\n value_board = board[coord[0], coord[1]]\\n # break if there is a stone of them same player in the way\\n if value_board < 0 and self.value < 0 or value_board > 0 and self.value > 0:\\n break\\n # if there is no stone, than add this to move list.\\n if value_board == 0:\\n moves += [{\\\"old_coord\\\": self.coord, \\\"new_coord\\\": coord, \\\"jumped_stones\\\": [], \\\"jumped_values\\\": 0,\\n \\\"move_coords\\\": [coord]}]\\n # if there is a stone of the enemy\\n if (value_board < 0 < self.value) or (self.value < 0 < value_board):\\n # check if it can be jumped\\n coord_jump = coord + direction\\n move_coords = [coord_jump.copy()]\\n within_board_after_jump = _check_if_position_on_board(coord_jump, board_size)\\n # break if place behind stone is out of border\\n if not within_board_after_jump:\\n break\\n value_board_jump = board[coord_jump[0], coord_jump[1]]\\n jumped_stones = []\\n # break if there is no free place\\n if value_board_jump != 0:\\n break\\n jumped_stones += [coord]\\n moves_tmp = self.jump_chain(directions, board, coord_jump, value_board, jumped_stones, move_coords)\\n if len(moves_tmp) > 0:\\n moves += moves_tmp\\n else:\\n moves += [{\\\"old_coord\\\": self.coord, \\\"new_coord\\\": coord_jump, \\\"jumped_stones\\\": jumped_stones,\\n \\\"jumped_values\\\": abs(value_board), \\\"move_coords\\\": [coord_jump]}]\\n i += 1\\n # break if normal stone, because they can only move one field\\n if abs(self.value) == 1:\\n break\\n return moves\",\n \"def moves(self, board_state):\\n # pos_moves = generate_moves(board_state) # Naive moves function here\\n blacks = board_state.search_board('B')\\n # Generate the possible moves required to kill the first black piece\\n # on the board\\n pos_moves = sorted_generate_moves_piece(board_state, blacks[0])\\n return pos_moves\",\n \"def find_moves(self):\\n\\n from itertools import product\\n free_position = self.find_free()\\n return [list(free_position+i) for i in [[0,1],[1,0],[-1,0],[0,-1]] if tuple(i+free_position) in product(range(self.size),repeat=2)]\",\n \"def solve(self, maze: Maze) -> List[Cell]:\\n self.maze = maze\\n path = self.solve_maze()\\n self.maze = None\\n return path\",\n \"def get_available_moves(self):\\n available = []\\n row, col = tuple(self.current_pos)\\n if row - 1 >= 0 and self.maze[row - 1][col] != 'x':\\n available.append('n')\\n if row + 1 < len(self.maze) and self.maze[row + 1][col] != 'x':\\n available.append('s')\\n if col - 1 >= 0 and self.maze[row][col - 1] != 'x':\\n available.append('w')\\n if col + 1 < len(self.maze[row]) and self.maze[row][col + 1] != 'x':\\n available.append('e')\\n return available\",\n \"def __find_all_moves(self, tower) -> list:\\r\\n choice = []\\r\\n for height in range(1,len(tower.tower)-2):\\r\\n for index in range(1,4):\\r\\n if self.stat_brain.is_valid(height, index, tower):\\r\\n choice.append((height, index))\\r\\n \\r\\n r.shuffle(choice)\\r\\n return choice\",\n \"def solve (M, cpos, move): \\n if move == 64:\\n print (\\\"\\\\n\\\\nmove: \\\", move)\\n print (\\\"sum: \\\", sum(M))\\n pprint (M)\\n #exit()\\n for next in get_moves(cpos, M):\\n solve(ulist(M, next, move+1), next, move+1)\",\n \"def get_next_moves2(self):\\n moves = []\\n for i in range(len(self.board)):\\n for j in range(len(self.board[i])):\\n if self.board[i][j] == \\\"\\\" and self.move_makes_box(i, j):\\n next_board = copy.deepcopy(self.board)\\n next_board[i][j] = colors[self.turn] + self.turn + \\\"\\\\u001b[0m\\\"\\n next_turn = get_opponent(self.turn)\\n moves.append(DotsAndBoxesState(next_board, next_turn))\\n return moves\",\n \"def solve_maze(self):\\r\\n # if there is no maze to solve, cut the method\\r\\n if not self.generated:\\r\\n return None\\r\\n\\r\\n # initialize with empty path at starting cell\\r\\n self.path = dict()\\r\\n current = self.start\\r\\n\\r\\n # loop until the ending cell is reached\\r\\n while True:\\r\\n while True:\\r\\n # choose valid direction\\r\\n # must remain in the grid\\r\\n # also must not cross a wall\\r\\n dirNum = random.randint(0,3)\\r\\n adjacent = self.get_next_cell(current,dirNum,1)\\r\\n if self.is_valid_direction(current,dirNum):\\r\\n hasWall = (self.grid[adjacent[0]][adjacent[1]] == 0)\\r\\n if not hasWall:\\r\\n break\\r\\n # add cell and direction to path\\r\\n self.path[current] = dirNum\\r\\n\\r\\n # get next cell\\r\\n current = self.get_next_cell(current,dirNum,2)\\r\\n if current == self.end: \\r\\n break # break if ending cell is reached\\r\\n\\r\\n # go to start of path\\r\\n current = self.start\\r\\n self.solution.append(current)\\r\\n # loop until end of path is reached\\r\\n while not (current == self.end):\\r\\n dirNum = self.path[current] # get direction\\r\\n # add adjacent and crossed cells to solution\\r\\n crossed = self.get_next_cell(current,dirNum,1)\\r\\n current = self.get_next_cell(current,dirNum,2)\\r\\n self.solution.append(crossed)\\r\\n self.solution.append(current)\\r\\n\\r\\n self.path = dict()\",\n \"def openMoves(self):\\n arr = []\\n for y in range(0,HEIGHT):\\n for x in range(0,WIDTH):\\n t = self.getPawn(x,y)\\n if(t!=None):\\n for z in range(-1,2):\\n if(self.legalMove(t,z)):\\n #move , #newState\\n arr.append((t,z))\\n return arr\",\n \"def get_moves(self):\\n moves = []\\n i, j = self._get_coordinates(0) # blank space\\n\\n if i > 0:\\n moves.append(Puzzle(self._swap(i, j, i - 1, j))) # move up\\n\\n if j < self.PUZZLE_NUM_COLUMNS - 1:\\n moves.append(Puzzle(self._swap(i, j, i, j + 1))) # move right\\n\\n if j > 0:\\n moves.append(Puzzle(self._swap(i, j, i, j - 1))) # move left\\n\\n if i < self.PUZZLE_NUM_ROWS - 1:\\n moves.append(Puzzle(self._swap(i, j, i + 1, j))) # move down\\n\\n return moves\",\n \"def get_goat_possible_moves(self) -> List:\\n moves = []\\n for pos in self.get_all_positions():\\n if pos.is_goat():\\n addr_from = pos.address\\n for addr_to in pos.piece.get_valid_moves():\\n moves.append((addr_from, addr_to))\\n\\n return moves\",\n \"def maze():\\r\\n #size, speed, starting point\\r\\n turtle.pensize(5)\\r\\n turtle.speed(0)\\r\\n turtle.ht()\\r\\n turtle.penup()\\r\\n turtle.goto(-300,-300)\\r\\n turtle.pendown()\\r\\n left(90)\\r\\n\\r\\n #main square\\r\\n forward(600)\\r\\n right(90)\\r\\n forward(270)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(300)\\r\\n right(90)\\r\\n forward(600)\\r\\n right(90)\\r\\n forward(270)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(300)\\r\\n backward(30)\\r\\n\\r\\n \\\"\\\"\\\"Code for all the columns in the maze\\\"\\\"\\\"\\r\\n #column 1\\r\\n right(90)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 1(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n turtle.pendown()\\r\\n\\r\\n #column 2\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(150)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 2(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 3\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 3(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 4\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(210)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 4(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 5\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n #column 5(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 6\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 6(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 7\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 7(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 8\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 8(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 9\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(120)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n #column 9(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 10\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n #column 10(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 11\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(240)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #column 11(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 12\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n turtle.pendown()\\r\\n forward(180)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 13(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 14\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n #column 14(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 15\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(180)\\r\\n #column 15(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 16\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 16(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 17\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n #column 17(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 18\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(180)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n #column 18(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #column 19\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(180)\\r\\n turtle.penup()\\r\\n forward(180)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 19(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #column 20\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(180)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #column 20(end)\\r\\n\\r\\n left(90)\\r\\n forward(570)\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"Code for all the rows in the maze\\\"\\\"\\\"\\r\\n #row 1\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n #row 1(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 2\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(150)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #row 2(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 3\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(210)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #row 3(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 4\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(150)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n #row 4(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 5\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n #row 5(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 6\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(150)\\r\\n #row 6(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 7\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #row 7(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 8\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n #row 8(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 9\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(180)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(150)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n #row 9(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 10\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(120)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #row 10(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 11\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(150)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n #row 11(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 12\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(180)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #row 12(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 13\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n #row 13(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 14\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #row 14(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 15\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(90)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n #row 15(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 16\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(120)\\r\\n turtle.penup()\\r\\n forward(150)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #row 16(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 17\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n #row 17(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n\\r\\n #row 18\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(120)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(90)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(120)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n #row 18(end)\\r\\n\\r\\n left(90)\\r\\n forward(30)\\r\\n left(90)\\r\\n\\r\\n #row 19\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(60)\\r\\n turtle.penup()\\r\\n forward(120)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(30)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n forward(60)\\r\\n turtle.pendown()\\r\\n forward(30)\\r\\n turtle.penup()\\r\\n #row 19(end)\\r\\n\\r\\n right(90)\\r\\n forward(30)\\r\\n right(90)\\r\\n forward(285)\\r\\n right(90)\\r\\n turtle.pendown()\\r\\n turtle.st()\\r\\n turtle.color(\\\"red\\\")\\r\\n\\r\\n print (\\\"Welcome to the maze! Choose your path!\\\")\\r\\n print (\\\"\\\\nUse W, A, S, D or arrow keys to move around the maze.\\\")\\r\\n print (\\\"Press I to write down the movement manually.\\\")\\r\\n print\\r\\n print (\\\"CAUTION!!!\\\")\\r\\n print (\\\"The Walls of the maze are NOT an obstacle.\\\")\\r\\n print (\\\"Please avoid going through them at any time\\\")\\r\\n print (\\\"for the purpose of your own entertainment in this program.\\\")\",\n \"def get_next_moves1(self):\\n moves = []\\n for i in range(len(self.board)):\\n for j in range(len(self.board[i])):\\n if self.board[i][j] == \\\"\\\":\\n next_board = copy.deepcopy(self.board)\\n next_board[i][j] = colors[self.turn] + self.turn + \\\"\\\\u001b[0m\\\"\\n next_turn = get_opponent(self.turn)\\n moves.append(DotsAndBoxesState(next_board, next_turn))\\n return moves\",\n \"def moves(self, teleport=False):\\n recv = [(self._size[y][x] - self._used[y][x], x, y)\\n for x in range(self.xsize) for y in range(self.ysize)]\\n recv.sort(reverse=True)\\n send = [(self._used[y][x], x, y)\\n for x in range(self.xsize) for y in range(self.ysize)\\n if self._used[y][x] > 0]\\n send.sort()\\n # print(\\\"recv: {}...\\\".format(str(recv[:5])))\\n # print(\\\"send: {}...\\\".format(str(send[:5])))\\n moves = []\\n for avail, x1, y1 in recv:\\n for used, x0, y0 in send:\\n if avail < used:\\n break\\n if teleport or (x0 == x1 and abs(y0 - y1) == 1) or (\\n y0 == y1 and abs(x0 - x1) == 1):\\n self.apply((x0, y0), (x1, y1))\\n moves.append((self.score(), self.key(), self.save(), list(self.history)))\\n self.undo()\\n return moves\",\n \"def get_moves_for_square(self, square):\\n (x,y) = square\\n\\n # determine the color of the piece.\\n color = self[x][y]\\n\\n # skip empty source squares.\\n if color==0:\\n return []\\n\\n # search all possible directions.\\n moves = []\\n for direction in self.__directions:\\n move = self._discover_move(square, direction)\\n if move:\\n # print(square,move,direction)\\n moves.append(move)\\n\\n # return the generated move list\\n return moves\",\n \"def moves(self):\\n move_list = list()\\n for i in range(self.n):\\n row = self.queens[i][0]\\n col = self.queens[i][1]\\n for rd in [-1,0,1]:\\n for cd in [-1,0,1]:\\n if (rd == 0) and (cd == 0):\\n continue\\n new_pos = [row+rd, col+cd]\\n if (new_pos[0] >= 0) and (new_pos[0] < self.n) and (new_pos[1] >= 0) and (new_pos[1] < self.n):\\n if not new_pos in self.queens: \\n move_list.append([i, new_pos])\\n\\n return move_list\",\n \"def solve_puzzle(self):\\n # move zero tile to the lower right corner\\n row, col = self.current_position(0, 0)\\n movements = \\\"d\\\" * (self.get_height() - 1 - row) + \\\"r\\\" * (\\n self.get_width() - 1 - col)\\n self.update_puzzle(movements)\\n # solve rowid from 2 by row\\n for row in range(self.get_height() - 1, 1, -1):\\n for col in range(self.get_width() - 1, -1, -1):\\n assert self.lower_row_invariant(row, col)\\n if col == 0:\\n movements += self.solve_col0_tile(row)\\n assert self.lower_row_invariant(row - 1,\\n self.get_width() - 1)\\n else:\\n movements += self.solve_interior_tile(row, col)\\n assert self.lower_row_invariant(row, col - 1)\\n # solve the uppermost two rows by column\\n for col in range(self.get_width() - 1, 1, -1):\\n for row in range(1, -1, -1):\\n if row == 0:\\n assert self.row0_invariant(col)\\n movements += self.solve_row0_tile(col)\\n assert self.row1_invariant(col - 1)\\n else:\\n assert self.row1_invariant(col)\\n movements += self.solve_row1_tile(col)\\n assert self.row0_invariant(col)\\n movements += self.solve_2x2()\\n return movements\",\n \"def getAllValidMoves(x0, y0):\\n deltas = [\\n (-2, -1),\\n (-2, +1),\\n (+2, -1),\\n (+2, +1),\\n (-1, -2),\\n (-1, +2),\\n (+1, -2),\\n (+1, +2),\\n ]\\n validPositions = []\\n\\n for (x, y) in deltas:\\n xCandidate = x0 + x\\n yCandidate = y0 + y\\n if 0 < xCandidate < 8 and 0 < yCandidate < 8:\\n validPositions.append([xCandidate, yCandidate])\\n\\n return validPositions\",\n \"def solve_maze(self, maze):\\n \\\"\\\"\\\"this means: always follow a given path to a junction and from there try a direction at random\\\"\\\"\\\"\\n \\\"\\\"\\\"caution: this algorithms may take longer than anticipated (since it is random)\\\"\\\"\\\"\\n self.maze = maze\\n self.path = []\\n if maze.get_entrance() is None or maze.get_exit() is None:\\n self.log.error('Entrance or Exit is missing')\\n raise Exception('Entrance or Exit is missing')\\n cell = maze.get_entrance()\\n self.path.append(cell)\\n while self.path[-1] != maze.get_exit():\\n self.__decide_next__()\\n self.__clean_path__()\\n return self.path\",\n \"def solve_maze(self) -> List[Cell]:\\n self.prev_cells = {}\\n self.junction_graph = self.construct_junction_graph()\\n self.junction_graph.depth_first_search(self.maze.start_cell, self.junction_visitor)\\n\\n end_cell = self.maze.end_cell\\n path = [end_cell]\\n prev_cell = end_cell\\n cell = self.prev_cells.get(end_cell)\\n\\n while path[-1] != self.maze.start_cell:\\n if Direction.between(prev_cell, cell) is None:\\n # fill in corridors\\n direction = self.junction_direction(prev_cell, cell)\\n neighbor = self.maze.neighbor(prev_cell, direction)\\n while neighbor != cell:\\n path.append(neighbor)\\n neighbor = self.maze.neighbor(neighbor, direction)\\n path.append(cell)\\n prev_cell = cell\\n cell = self.prev_cells.get(cell)\\n\\n return list(reversed(path))\",\n \"def get_all_possible_moves(self):\\r\\n moves = []\\r\\n for i in range(8):\\r\\n for j in range(8):\\r\\n color = self.board[i][j][0]\\r\\n if (color == 'b' and not self.turn_white) or (color == 'w' and self.turn_white):\\r\\n p_type = self.board[i][j][1]\\r\\n if p_type == 'r':\\r\\n self.get_rook_moves(i, j, moves)\\r\\n elif p_type == 'k':\\r\\n self.get_king_moves(i, j, moves)\\r\\n elif p_type == 'q':\\r\\n self.get_queen_moves(i, j, moves)\\r\\n elif p_type == 'p':\\r\\n self.get_pawn_moves(i, j, moves)\\r\\n elif p_type == 'b':\\r\\n self.get_bishop_moves(i, j, moves)\\r\\n elif p_type == 'n':\\r\\n self.get_knight_moves(i, j, moves)\\r\\n return moves\",\n \"def get_all_moves(self, board, player):\\n result = []\\n for startx in range(8):\\n for starty in range(8):\\n for destx in range(8):\\n for desty in range(8):\\n if self.is_legal_move(board, [startx, starty], [destx, desty], player):\\n result.append([[startx, starty], [destx, desty]])\\n return result\",\n \"def minMoves(maze, x, y):\\n\\n def maze_guard():\\n \\\"\\\"\\\"Guard function to block oversized dimensions\\\"\\\"\\\"\\n cell_guard = all([1 <= len(row) <= 100 for row in maze])\\n row_guard = 1 <= len(maze) <= 100\\n return cell_guard and row_guard\\n\\n def walk_maze(finish):\\n \\\"\\\"\\\"Walks the maze, finding the shortest path including all coins.\\n Finishes when reach the coordenate finish, a tuple with row and\\n column numbers\\n \\\"\\\"\\\"\\n i, j = (0, 0)\\n result = -1\\n weight = -1\\n while nodes:\\n i, j, path, coins = nodes.popleft()\\n cell = maze[i][j]\\n if (i, j) == finish:\\n weight, result = check_result(coins, path, weight, result)\\n elif cell != 1:\\n adjacent_nodes(i, j, path, coins)\\n\\n return result\\n\\n def adjacent_nodes(i, j, path, coins):\\n \\\"\\\"\\\"Adds the node in positions i, j, with its path added to\\n accumulated path. The path is transformed into a binary\\n number, i.e, 2 ** (i * n + j), being n the number of rows\\n in the maze matrix.\\n \\\"\\\"\\\"\\n def neighbour(x, y):\\n this_path = 2 ** (i * n + j)\\n if not this_path & path:\\n coin = coins + 1 if maze[i][j] == 2 else coins\\n nodes.append((x, y, path + this_path, coin))\\n\\n coord = [(i + 1, j, i + 1 < n), (i - 1, j, i - 1 >= 0),\\n (i, j + 1, j + 1 < m), (i, j - 1, j - 1 >= 0)]\\n _ = [neighbour(x, y) for x, y, test in coord if test]\\n\\n if not maze_guard():\\n return -1\\n\\n n = len(maze)\\n m = len(maze[0])\\n nodes = deque([(0, 0, 0, 0)])\\n return walk_maze((x, y))\",\n \"def _get_easy_move(self):\\n # Two lists keep track of regular moves and paths of possible jumps\\n moves = []\\n required_jumps = []\\n for row in range(self._checkers.dimension):\\n for col in range(self._checkers.dimension):\\n # Check same color pieces as player to see if they can jump.\\n if self._checkers.get(row, col) == self._player:\\n path_made = False\\n found_jumps = []\\n # i represents an option of direction to check\\n for i in range(3):\\n current_path = []\\n # Builds a path of jumps by checking for a jump each\\n # move\\n while (not path_made):\\n jumps = self.check_for_jump(self._player, row, col)\\n if jumps == []:\\n path_made = True\\n break\\n current_path += (jumps)\\n incrow = 0\\n inccol = 0\\n # South west and east\\n if i == 0:\\n incrow = 2\\n inccol = 2\\n elif i == 1:\\n incrow = 2\\n incrow = -2\\n # North west and east\\n elif i == 2:\\n incrow = -2\\n inccol = -2\\n elif i == 3:\\n incrow = -2\\n incrow = 2\\n row += incrow\\n col += inccol\\n found_jumps.append(current_path)\\n if len(found_jumps) > 0:\\n # If there is at least one path then we append it\\n # to the list of jumps\\n required_jumps += found_jumps\\n else:\\n # Checks if a move can be made in each direction\\n north_west = self._checkers.get(row - 1, col - 1)\\n north_east = self._checkers.get(row - 1, col + 1)\\n south_west = self._checkers.get(row + 1, col + 1)\\n south_east = self._checkers.get(row + 1, col - 1)\\n if north_west == CheckersBoard.empty:\\n moves.append(Move(row, col, -1, -1))\\n if north_east == CheckersBoard.empty:\\n moves.append(Move(row, col, -1, 1))\\n if south_west == CheckersBoard.empty:\\n moves.append(Move(row, col, 1, 1))\\n if south_east == CheckersBoard.empty:\\n moves.append(Move(row, col, 1, -1))\\n # A random move is calculated for the lists of moves\\n # If a move can be made we prioritize the list with possible moves\\n random_index = 0\\n if len(required_jumps) != 0:\\n random_index = random.randint(0, len(required_jumps))\\n move_path = required_jumps[random_index]\\n return move_path\\n else:\\n random_index = random.randint(0, len(moves))\\n move = moves[random_index]\\n return [move]\",\n \"def make_random_move(self):\\n # get copy of the empty board\\n board = set([(i, j) for i in range(self.height) for j in range(self.width)])\\n\\n for move in board:\\n if not move in self.moves_made and not move in self.mines:\\n return move\\n\\n return None\",\n \"def legal_moves(self):\\n moves = \\\"\\\"\\n swappable = self.swappable_positions\\n empty_position = self.get_position(0)\\n\\n for s in swappable:\\n pos_diff = empty_position[0] - s[0], empty_position[1] - s[1]\\n if pos_diff[0] > 0:\\n moves += \\\"U\\\"\\n elif pos_diff[0] < 0:\\n moves += \\\"D\\\"\\n elif pos_diff[1] > 0:\\n moves += \\\"L\\\"\\n elif pos_diff[1] < 0:\\n moves += \\\"R\\\"\\n\\n return moves\",\n \"def get_valid_moves(self):\\n if self.king:\\n valid_moves = [[self.row + 1, self.col + 1],\\n [self.row + 1, self.col - 1],\\n [self.row - 1, self.col - 1],\\n [self.row - 1, self.col + 1]]\\n else:\\n if self.player == 1:\\n valid_moves = [[self.row + 1, self.col + 1],\\n [self.row + 1, self.col - 1]]\\n else:\\n valid_moves = [[self.row - 1, self.col - 1],\\n [self.row - 1, self.col + 1]]\\n return valid_moves\",\n \"def get_legal_moves(self):\\n # for each square in the castle figure out if an moves can occur from it.\\n moves = []\\n allowed = [self.turn]\\n if self.turn == DEFENDER:\\n allowed.extend((KING, CASTLE_OCCUPIED))\\n it = np.nditer(self.board_state, flags=['multi_index'])\\n while not it.finished:\\n index = it.multi_index\\n curr_loc = it[0]\\n if curr_loc in allowed:\\n moves.extend(self.get_legal_move_piece(curr_loc, index))\\n it.iternext()\\n return moves\",\n \"def ai_move():\\n\\tinitial_state = map(get_filled_edges, rects)\\n\\tpossible_moves = []\\n\\tfor index, filled_edges in enumerate(initial_state):\\n\\t\\tif filled_edges == 0:\\n\\t\\t\\tpossible_moves.extend([(index, i) for i in 'ltrb'])\\n\\t\\telif filled_edges == 1:\\n\\t\\t\\tpossible_moves.extend(one_filled_edge(index))\\n\\t\\telif filled_edges == 2:\\n\\t\\t\\tpossible_moves.extend(two_filled_edge(index))\\n\\t\\telif filled_edges == 3:\\n\\t\\t\\tpossible_moves.extend(three_filled_edge(index))\\n\\tprint possible_moves\\n\\tpossible_decisions = []\\n\\tfor move in possible_moves:\\n\\t\\tfinal_state = apply_move(move)\\n\\t\\tpossible_decisions.append(is_feasible(initial_state, final_state))\\n\\tprint possible_decisions\\n\\t# randomizing when some decisions have the same weight\\n\\tmax_weight = max(possible_decisions)\\n\\t# list of indices which have the same weight\\n\\tmax_indices = []\\n\\tfor index, weight in enumerate(possible_decisions):\\n\\t\\tif weight == max_weight:\\n\\t\\t\\tmax_indices.append(index)\\n\\tx = choice(max_indices)\\n\\tprint x\\n\\treturn possible_moves[x]\\n\\t# return possible_moves[possible_decisions.index(max(possible_decisions))]\",\n \"def solve_puzzle(self):\\r\\n # initialize some values and start tile at bottom right corner\\r\\n col = self.get_width() - 1\\r\\n row = self.get_height() - 1\\r\\n move = \\\"\\\"\\r\\n curr_row, curr_col = self.current_position(0, 0)\\r\\n move_to_target = abs(curr_col - col) * \\\"r\\\" + abs(curr_row - row) * \\\"d\\\"\\r\\n self.update_puzzle(move_to_target)\\r\\n move += move_to_target\\r\\n\\r\\n # apply solver methods\\r\\n for dummy_i in range(row, 1, -1):\\r\\n for dummy_j in range(col, 0, -1):\\r\\n move += self.solve_interior_tile(dummy_i, dummy_j)\\r\\n move += self.solve_col0_tile(dummy_i)\\r\\n \\r\\n for dummy_j in range(col, 1, -1):\\r\\n move += self.solve_row1_tile(dummy_j)\\r\\n move += self.solve_row0_tile(dummy_j)\\r\\n \\r\\n move += self.solve_2x2()\\r\\n return move\",\n \"def get_possible_moves(self) -> list:\\n p1_count = 0\\n p2_count = 0\\n ley_line_total = (self.side_length + 1) * 3\\n for itype in self.current_ley_lines:\\n for line in itype:\\n if line[0] == '1':\\n p1_count += 1\\n if line[0] == '2':\\n p2_count += 1\\n if p1_count >= ley_line_total / 2 or p2_count >= ley_line_total / 2:\\n return []\\n moves = []\\n for letter in self.current_board:\\n if letter.isalpha():\\n moves.append(letter)\\n return moves\",\n \"def get_valid_moves(self):\\r\\n validMoves = []\\r\\n\\r\\n for x in range(BOARD_SIZE):\\r\\n for y in range(BOARD_SIZE):\\r\\n pos = np.array([x,y])\\r\\n if self.board[pos[0],pos[1]] == 0:\\r\\n if(self.update_board(pos,_testing=True)):\\r\\n validMoves.append(pos)\\r\\n\\r\\n return validMoves\",\n \"def get_moves(self):\\n grid = self.model.grid\\n # List of agents we can't overlap with\\n no_overlap = [\\\"wall\\\", \\\"human\\\", \\\"zombie\\\"]\\n\\n if self.agent_type == \\\"zombie\\\" or \\\\\\n (\\\"AvoidingZombie\\\" not in self.states and os.environ[\\\"mode\\\"] == \\\"5\\\"):\\n no_overlap.append(\\\"road\\\")\\n\\n # Always give the option to stay on your current location(stand still)\\n all_cells = self.neighbors()\\n free_cells = [self.pos]\\n\\n # Get rid of cells that we may not move to by iterating through all\\n # cells next to the agent, and only adding non-occupied cells\\n for cell in all_cells:\\n cell_occupied = False\\n x, y = cell.pos\\n # If there are agents in the current cell, and we are not allowed\\n # to overlap with any of those agents, the cell is occupied.\\n # Only add cells which are not occupied.\\n if not grid.is_cell_empty((x, y)):\\n for agent in grid[x][y]:\\n if agent.agent_type in no_overlap:\\n cell_occupied = True\\n break\\n if not cell_occupied:\\n free_cells.append((x, y))\\n return free_cells\",\n \"def checkMoves(self,board):\\n possibleMoves = []\\n\\n for c in xrange(0,8):\\n for r in xrange(0,8):\\n if board.isValidMove(self.tile,c,r):\\n possibleMoves.append(c+r*8)\\n\\n return possibleMoves\",\n \"def neighboring_states(self):\\n index = self.state.index(0)\\n\\n if index == 0:\\n return [self.move(movement) for movement in ['down', 'right']]\\n elif index == 1:\\n return [self.move(movement) for movement in ['down', 'left', 'right']]\\n elif index == 2:\\n return [self.move(movement) for movement in ['down', 'left']]\\n elif index == 3:\\n return [self.move(movement) for movement in ['up', 'down', 'right']]\\n elif index == 4:\\n return [self.move(movement) for movement in ['up', 'down', 'left', 'right']]\\n elif index == 5:\\n return [self.move(movement) for movement in ['up', 'down', 'left']]\\n elif index == 6:\\n return [self.move(movement) for movement in ['up', 'right']]\\n elif index == 7:\\n return [self.move(movement) for movement in ['up', 'left', 'right']]\\n else:\\n # index == 8\\n return [self.move(movement) for movement in ['up', 'left']]\",\n \"def possible_moves(self): \\n return [a + 1 for a, b in enumerate(self.board) if b == 0]\",\n \"def test_maze_move_6(self):\\n maze_template = [['#', '#', '#', '#', '#', '#', '#'], \\n ['#', '.', '.', '.', '.', '.', '#'], \\n ['#', '.', '#', '#', '#', '.', '#'], \\n ['#', '.', '.', '@', '#', '.', '#'], \\n ['#', '@', '#', '.', '@', '.', '#'], \\n ['#', '#', '#', '#', '#', '#', '#']]\\n rat_J = a2.Rat(a2.RAT_1_CHAR, 1, 1)\\n rat_P = a2.Rat(a2.RAT_2_CHAR, 1, 4)\\n\\n maze = a2.Maze(maze_template, rat_J, rat_P)\\n old_sprout_count = maze.num_sprouts_left\\n\\n maze.move(rat_J, a2.DOWN, a2.NO_CHANGE)\\n\\n self.assertEqual(maze.num_sprouts_left, old_sprout_count)\",\n \"def get_legal_moves(self, color):\\n moves = [] # stores the legal moves.\\n # Get all the squares with pieces of the given color.\\n for x in range(self.n):\\n for y in range(self.n):\\n if self[x][y]==0:\\n moves.append((x,y))\\n return moves\",\n \"def get_square_moves(self, moves):\\r\\n return self.board.get_square_moves(moves)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7175067","0.71658105","0.7148162","0.7116588","0.7116588","0.7116588","0.7103733","0.7103733","0.7103733","0.7103733","0.7103733","0.7103733","0.7103733","0.7101113","0.7101113","0.7101113","0.7101113","0.7101113","0.7101113","0.7101113","0.7101113","0.7059857","0.7022471","0.68683547","0.6799181","0.6728683","0.671171","0.6494422","0.64748037","0.63396084","0.63371855","0.6327829","0.63079745","0.62369174","0.62246823","0.62205535","0.6165897","0.61386263","0.61122155","0.6096328","0.60686487","0.60668284","0.6065604","0.60275215","0.6023685","0.6020272","0.6008468","0.6004909","0.6003913","0.59986246","0.59663314","0.5961283","0.59406304","0.5916764","0.5912783","0.59120715","0.5899589","0.5899237","0.5889329","0.5888472","0.5872567","0.58443266","0.58232665","0.5821647","0.57964367","0.5794203","0.57920414","0.5791615","0.5779105","0.5765726","0.57564574","0.5744357","0.57429904","0.57403696","0.57369405","0.5735866","0.57307434"],"string":"[\n \"0.7175067\",\n \"0.71658105\",\n \"0.7148162\",\n \"0.7116588\",\n \"0.7116588\",\n \"0.7116588\",\n \"0.7103733\",\n \"0.7103733\",\n \"0.7103733\",\n \"0.7103733\",\n \"0.7103733\",\n \"0.7103733\",\n \"0.7103733\",\n \"0.7101113\",\n \"0.7101113\",\n \"0.7101113\",\n \"0.7101113\",\n \"0.7101113\",\n \"0.7101113\",\n \"0.7101113\",\n \"0.7101113\",\n \"0.7059857\",\n \"0.7022471\",\n \"0.68683547\",\n \"0.6799181\",\n \"0.6728683\",\n \"0.671171\",\n \"0.6494422\",\n \"0.64748037\",\n \"0.63396084\",\n \"0.63371855\",\n \"0.6327829\",\n \"0.63079745\",\n \"0.62369174\",\n \"0.62246823\",\n \"0.62205535\",\n \"0.6165897\",\n \"0.61386263\",\n \"0.61122155\",\n \"0.6096328\",\n \"0.60686487\",\n \"0.60668284\",\n \"0.6065604\",\n \"0.60275215\",\n \"0.6023685\",\n \"0.6020272\",\n \"0.6008468\",\n \"0.6004909\",\n \"0.6003913\",\n \"0.59986246\",\n \"0.59663314\",\n \"0.5961283\",\n \"0.59406304\",\n \"0.5916764\",\n \"0.5912783\",\n \"0.59120715\",\n \"0.5899589\",\n \"0.5899237\",\n \"0.5889329\",\n \"0.5888472\",\n \"0.5872567\",\n \"0.58443266\",\n \"0.58232665\",\n \"0.5821647\",\n \"0.57964367\",\n \"0.5794203\",\n \"0.57920414\",\n \"0.5791615\",\n \"0.5779105\",\n \"0.5765726\",\n \"0.57564574\",\n \"0.5744357\",\n \"0.57429904\",\n \"0.57403696\",\n \"0.57369405\",\n \"0.5735866\",\n \"0.57307434\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7095842"},"document_rank":{"kind":"string","value":"44"}}},{"rowIdx":76599,"cells":{"query":{"kind":"string","value":"Search the deepest nodes in the search tree first. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm. To get started, you might want to try some of these simple commands to"},"document":{"kind":"string","value":"def depthFirstSearch(problem):\n\n # Initialization\n startState = problem.getStartState()\n # print \"Start:\", startState\n\n if problem.isGoalState(startState):\n return [] # No action needed\n\n route = util.Stack()\n closed = set([startState])\n stack = util.Stack() # DFS use stack\n\n # print problem.getSuccessors(startState)\n \n for successor in problem.getSuccessors(startState):\n # Use list(old_list) to make a copy of current route\n stack.push((successor, list(route.list)))\n \n # Tree search\n while not stack.isEmpty():\n #print stack.list\n ((currentState, action, cost), route.list) = stack.pop()\n\n if currentState in closed:\n continue # Skip the residue of expanded states in the stack\n\n # print \"Go \", action\n # print \"In \", currentState\n route.push(action)\n\n if problem.isGoalState(currentState): # Check for goal condition\n # print route.list\n # util.pause()\n return route.list # Return the route\n \n # Current state is not goal state\n closed.add(currentState)\n for successor in problem.getSuccessors(currentState):\n if successor[0] in closed:\n # print \"-Closed \", successor\n continue # this state is already expanded\n \n # print \"-Open \", successor\n # Use list(old_list) to make a copy of current route\n stack.push((successor, list(route.list)))"},"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 depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n class Node:\n def __init__(self, state, parent, action, pathCost):\n self.state = state #state of the game\n self.parent = parent #parent of the node\n self.action = action #action that led to that node\n self.pathCost = pathCost #total cost of tha path until that node\n\n def solution(self): #return the path to the goal node\n path = [] #path is a list of actions\n tempNode = self #temp node is the goal node\n while tempNode.state != problem.getStartState(): #until we get to the initial node\n path.insert(0, tempNode.action) #insert at the start of the list\n tempNode = tempNode.parent #go to the parent of the node\n return path #return list of actions\n\n def childNode(successor, parent, action, stepCost):\n pathCost = parent.pathCost + stepCost #total cost is the total cost of the parent + the cost of the last action\n child = Node(successor, parent, action, pathCost) #create new child node\n return child\n\n initialNode = Node(problem.getStartState(), None, None, 0) #create initial node with start state and no parent\n if problem.isGoalState(initialNode.state):\n return initialNode.solution()\n\n frontier = util.Stack() #dfs uses a stack\n frontier.push(initialNode) #insert initial node to the stack\n explored = set() #explored nodes are added to a set\n\n while not frontier.isEmpty(): #while stack is not empty\n nextNode = frontier.pop() #extract the last node entered\n explored.add(nextNode.state) #add the state of the node to the explored set\n for successor, action, stepCost in problem.getSuccessors(nextNode.state): #for every successor create a new child\n child = childNode(successor, nextNode, action, stepCost)\n if child.state not in explored and child not in frontier.list: #if child is not already explored or is not in the stack\n if problem.isGoalState(child.state): # if node is goal node we return the path of actions\n return child.solution()\n frontier.push(child) #insert it into the stack\n\n return [] #if stack is empty\n util.raiseNotDefined()","def depthFirstSearch(problem):\n #print \"Start:\", problem.getStartState()\n #print \"Is the start a goal?\", problem.isGoalState(problem.getStartState())\n #print \"Start's successors:\", problem.getSuccessors(problem.getStartState())\n \n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n e = Directions.EAST\n\n #created a frontier Stack for DFS\n #Here the stack acts as a LIFO stack\n neighbourNodes = util.Stack()\n #created a list of moves which will be returned in then end\n moves = []\n #pushed the start node and empty moves list, onto the frontier stack\n neighbourNodes.push((problem.getStartState(),moves))\n #this is a set of nodes which have been seen, to avoid adding nodes already visited \n seenNodes = set()\n #condition evaluated based on the existence of elements in the frontier stack\n while not neighbourNodes.isEmpty():\n #last node in the stack is popped and its state and action is stored\n poppedNodeState, poppedNodeAction = neighbourNodes.pop()\n #condition to check if the node is already been visited\n if(poppedNodeState in seenNodes):\n #if yes then it just skips the iteration using the continue statement\n continue\n #condition to check if the current node is the goal node\n if problem.isGoalState(poppedNodeState):\n #if yes then return the action or moves to be performed list\n return poppedNodeAction\n #if not visited before then node is added to the seenNodes set\n seenNodes.add(poppedNodeState)\n #loop to parse the successor nodes and check and add them to the frontier stack\n for state, action, cost in problem.getSuccessors(poppedNodeState):\n #checking if the successor node has already been visited before\n if(state in seenNodes):\n #if yes then it skips that node\n continue\n #else it adds that successor along with it action appeneded with the already existing actions\n neighbourNodes.push((state, poppedNodeAction+[action]))\n #the list of moves if finally returned\n return moves\n #util.raiseNotDefined()","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n from util import Stack\n\n frontier = Stack()\n explored = []\n actions = []\n\n class node:\n def __init__(self, path, dad, action):\n self.path = path\n self.dad = dad\n self.action = action\n\n start = node(problem.getStartState(),'','')\n frontier.push(start)\n\n while frontier.isEmpty() == False:\n path = frontier.pop()\n successors = problem.getSuccessors(path.path)\n explored.append(path)\n for vertex in successors:\n achou = False\n for path_ex in explored:\n if vertex[0] == path_ex.path:\n achou = True\n if achou == False:\n successor = node(vertex[0],path.path,vertex[1])\n frontier.push(successor)\n if problem.isGoalState(successor.path):\n while len(explored) > 0:\n ant = explored.pop()\n if ant.path == successor.dad:\n actions.append(successor.action)\n successor = ant\n actions.reverse()\n return actions","def mcts_search(self, state):\n assert state.current_player() == self.player\n root = SearchNode(None, 1)\n for _ in range(self.max_simulations):\n visit_path, working_state = self._apply_tree_policy(root, state)\n if working_state.is_terminal():\n node_value = working_state.player_return(self.player)\n else:\n node_value = self.evaluator.evaluate(\n working_state, self.player, self._random_state)\n\n for node in visit_path:\n node.total_reward += node_value * node.player_sign\n node.explore_count += 1\n\n most_visited = root.most_visited_child()\n\n if self.verbose:\n print(\"Root:\", root.to_str())\n print(\"Children:\")\n print(root.children_str(working_state))\n print(\"Children of chosen:\")\n chosen_state = state.clone()\n chosen_state.apply_action(most_visited.action)\n print(most_visited.children_str(chosen_state))\n\n return most_visited.action","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n visited_nodes = []\n start_node = problem.getStartState()\n visited_nodes.append(start_node)\n curr_node = start_node\n q = util.Queue()\n directions = util.Queue()\n q.push(curr_node)\n goal_found = problem.isGoalState(curr_node)\n\n while not goal_found:\n nxt_node_list = problem.getSuccessors(curr_node)\n nxt_node_found = False\n\n # Check if a child can be found which has not been visited\n for node in nxt_node_list:\n nxt_node = node[0]\n move = node[1]\n if nxt_node not in visited_nodes:\n nxt_node_found = True # mark that a child node has been found\n q.push(nxt_node) # add the node in the tree\n directions.push(move) # add the direction\n visited_nodes.append(nxt_node) # mark the node as visited\n break\n\n # If child not found, go to parent\n if not nxt_node_found:\n q.list.pop(0)\n directions.list.pop(0)\n\n if q.isEmpty(): break\n\n curr_node = q.list[0]\n goal_found = problem.isGoalState(curr_node)\n\n final_moves = []\n while not directions.isEmpty():\n final_moves.append(directions.pop())\n \n return final_moves\n #util.raiseNotDefined()","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n mystack = util.Stack()\n startNode = (problem.getStartState(), '', 0, [])\n mystack.push(startNode)\n visited = set()\n while mystack :\n node = mystack.pop()\n state, action, cost, path = node\n if state not in visited :\n visited.add(state)\n if problem.isGoalState(state) :\n path = path + [(state, action)]\n break;\n succNodes = problem.expand(state)\n for succNode in succNodes :\n succState, succAction, succCost = succNode\n newNode = (succState, succAction, cost + succCost, path + [(state, action)])\n mystack.push(newNode)\n actions = [action[1] for action in path]\n del actions[0]\n return actions","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n frontier = util.Stack()\n start_node = problem.getStartState()\n\n if problem.isGoalState(start_node):\n return ['Stop']\n frontier.push((start_node,[]))\n explored = set()\n while True:\n if frontier.isEmpty():\n return []\n node = frontier.pop()\n explored.add(node[0])\n for successor in problem.getSuccessors(node[0]):\n nextState, action, cost = successor\n if nextState in explored or nextState in [f[0] for f in frontier.list]:\n continue\n actions = node[1][:]\n actions.append(action)\n new_node = (nextState, actions)\n if problem.isGoalState(new_node[0]):\n return new_node[1]\n frontier.push(new_node)\n #print frontier.list\n return []","def search(self):\r\n #get the initial state\r\n initialState = State()\r\n \r\n #create root node\r\n rootNode = Node(initialState)\r\n \r\n #show the search tree explored so far\r\n treeplot = TreePlot()\r\n treeplot.generateDiagram(rootNode, rootNode)\r\n \r\n #perform search from root node\r\n self.performBacktrackSearch(rootNode, rootNode)\r\n \r\n rootNode.printTree()","def solve(problem):\n\n # *** YOUR CODE HERE ***\n\n # The core of Iterative Deepening Search are iterations of Depth Limited\n # Search with given increasing depth.\n\n # A recursive version of Depth Limited Search\n def depth_limited_search(problem, limit):\n \"\"\"\n Return a list of nodes we traversed (or None).\n :param problem: the starting set up.\n :param limit: a given numeric depth limit.\n :return: a list of nodes.\n \"\"\"\n\n # in this case, we simply use a list to keep track of nodes we\n # traversed, instead of the data structure, Stack.\n path = list()\n visited = set() # as before, to prevent duplicated nodes\n root = problem.get_initial_state()\n\n def rec_dls(state, action, depth):\n\n visited.add(state)\n\n # if it is a goal\n if problem.goal_test(state):\n path.append((state, action))\n return path\n\n # or if it reaches a certain depth, but not a goal\n elif depth == 0:\n visited.remove(state)\n return None\n\n else:\n path.append([state, action])\n for successor, action, cost in problem.get_successors(state):\n if successor not in visited:\n # recursively expands the deepest node\n res = rec_dls(successor, action, depth-1)\n if res is not None:\n return res\n path.pop()\n visited.remove(state)\n\n # \"Stared From the Bottom\" (root)\n result = rec_dls(root, 'None', limit)\n # return the path if the we DID have achieved something\n if result is not None:\n return path\n\n import sys\n for depth in range(sys.maxsize): # depth from 0 to infinity\n print(\"Lower-bound of the optimal cost is {}\".format(depth))\n res2 = depth_limited_search(problem, depth)\n if res2 is not None:\n action_list = list()\n for move in res2:\n action_list.append(move[1]) # recall index 0 is the parent\n # do not forget a None returned in iteration 0 (with depth 0)\n action_list.remove('None')\n return action_list","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n startState = problem.getStartState()\n visitedNodes = []\n actions = []\n fringe = util.Stack()\n cost = 0 \n if (problem.isGoalState(startState) == True):#if startState is the goalState\n return actions\n else :\n # Data Type Format : (currentState,actions,cost) based on errors I got :\\\n fringe.push((startState,actions,cost))\n while (fringe.isEmpty() == False) :\n currentState , actions , cost = fringe.pop()\n if(problem.isGoalState(currentState)):\n return actions\n \n elif ((currentState in visitedNodes) == False ):\n visitedNodes.append(currentState)\n currentNodeSuccessors = problem.getSuccessors(currentState)\n for node in currentNodeSuccessors :\n state , action , cost = node\n if ( (state in visitedNodes) == False ):\n newNode = (state , actions + [action] , cost)\n fringe.push(newNode)\n \n util.raiseNotDefined()","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n '''\n print \"Start:\", problem.getStartState()\n print \"Is the start a goal?\", problem.isGoalState((2,2))\n print \"Start's successors:\", problem.getSuccessors((1,1))\n suc=problem.getSuccessors(problem.getStartState())\n actionList=[]\n stateList=[]\n import random\n randomNum=random.randrange(0,len(suc),1)\n \n \n print len(suc)\n #for i in range(1000):\n while not problem.isGoalState(suc[randomNum][0]):\n\tprint randomNum\n\trandomNum=random.randrange(0,len(suc),1)\n\trandomAction=suc[randomNum][1]\n\t\n \t#print randomNum\n\tif suc[randomNum][0] not in stateList:\n\t\tstateList.append(suc[randomNum][0])\n\t\tactionList.append(randomAction)\n \t\tsuc=problem.getSuccessors(suc[randomNum][0]) \n \n #actionList.append(suc[randomNum][0])\n #if kiki==0:\n print actionList\n \n return actionList\n\n\n #util.raiseNotDefined()\n '''\n return DFS(problem,problem.getStartState(),[])","def depthFirstSearch(problem):\n\n\n \"*** YOUR CODE HERE ***\"\n st = util.Stack()\n strt = problem.getStartState()\n st.push(strt) \n visited = []\n came_from ={}\n came_from [strt] =(None,None)\n\n while not st.isEmpty():\n state = st.pop()\n if state in visited :\n continue\n visited.append(state)\n if problem.isGoalState(state) :\n break\n nodes = problem.getSuccessors(state)\n for (successor,action,cost) in nodes:\n if successor not in visited :\n st.push(successor)\n came_from[successor] = (state , action) \n \n # exit while\n actions = []\n while(state != strt) :\n (parent,action) =came_from[state]\n state = parent\n actions.append(action)\n actions.reverse()\n return actions","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n \n #Stack to hold the node that have been visited along with the path taken from the start node to reach that node.\n stack = Stack()\n #Set to hold the node explored.\n explorednode = set()\n #Get the start node.\n startnode = problem.getStartState()\n #Push the starting node on the Stack along with an empty set to know the direction in order to reach the node.\n stack.push((startnode,[]))\n #Loop till the stack is empty\n while stack.isEmpty() is not True:\n #Pop the currentnode and the direction from the stack\n currentnode, direction = stack.pop()\n #We will now add the node to set of explored node.\n explorednode.add(currentnode)\n #If the node is the goal. We made it!!\n if problem.isGoalState(currentnode):\n #print currentnode, direction\n #The direction holds the way to reach till the goal from the start node.\n #print direction\n return direction\n #Loop for each successor(child) of the current node.\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\n #If the successor(child) is not explored\n if successor not in explorednode:\n #Add the successor to the stack along with the path to reach it.\n stack.push((successor, direction + [action]))","def dfs( self ):\n\n #print self.state; \n #print self.visited;\n SearchProblem.stateVisited= SearchProblem.stateVisited+1 \n \n if self.stop: # check class variable and stop searching...\n return;\n\n for action in self.edges(): # consider each edge leading out of this node\n\n action.destination.path = self.path + str(action.label); \n # get the label associated with the\n # action and append it to the path\n # string\n\n action.destination.visited = self.visited.copy();\n # make copy of source node's visited set\n # and use it as destination node's\n # visited set\n\n action.destination.visited.add( repr(action.destination.state) );\n\n if action.destination.is_target(): \n # check if destination of edge is target node\n action.destination.target_found(); # perform target found action\n if not self.continue_search(): # stop searching if not required\n SearchProblem.stop = True; # set class variable to record that we\n break; # are done\n\n if repr(action.destination.state) in self.visited:\n continue; # skip if we've visited this one before\n\n action.destination.dfs(); # resume recursive search ","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n #util.Stack() = LIFO for DFS\n #travel down path until end of line unlike BFS, backtrack until there is another path\n\n visited = []\n\n frontier = util.Stack()\n frontier.push( (problem.getStartState(), []) ) \n\n while not frontier.isEmpty():\n node,actions = frontier.pop()\n\n if problem.isGoalState(node):\n return actions\n\n visited.append(node)\n\n for coord,direction,cost in problem.getSuccessors(node):\n if not coord in visited:\n frontier.push((coord, actions + [direction]))\n\n return []","def depthFirstSearch(problem):\n\t#print(\"Start:\", problem.getStartState())\n\t#print(\"Is the start a goal?\", problem.isGoalState(problem.getStartState()))\n\t#print(\"Start's successors:\", problem.getSuccessors(problem.getStartState()))\n\t\n\n\t\"*** YOUR CODE HERE ***\"\n\n\t# Create the stack, and visited array to keep track of visited nodes.\n\tdfsStack = util.Stack()\n\tvisited = []\n\t# Get the first state in the graph, push to the stack\n\tfirst = problem.getStartState()\n\tdfsStack.push([first, [], 0])\n\n\t# While the stack is not empty, pop the first node from the stack, and check if that state\n # is the goal state. If so, return the actions for that node. Otherwise, append that state\n # to the visited array, get its successors, and push them to the stack.\n\twhile not dfsStack.isEmpty():\n\t\tNewNode = dfsStack.pop()\n\t\tif((problem.isGoalState(NewNode[0]) == True)):\n\t\t\treturn NewNode[1]\n\t\tif(NewNode[0] not in visited):\n\t\t\tvisited.append(NewNode[0])\n\t\t\tfor NextNode in problem.getSuccessors(NewNode[0]):\n\t\t\t\tif NextNode[0] not in visited:\n\t\t\t\t\tdfsStack.push((NextNode[0], NewNode[1] + [NextNode[1]], NextNode[2]))","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n # initialize frontier using initial state of problem\n current_state = problem.getStartState()\n frontier = util.Stack()\n frontier.push(current_state)\n\n # initialize explored set to be empty\n explored_set = []\n\n # a dictionary to save how to get to certain states from initial state\n actions_list = {current_state:[]}\n\n # loop while we still have unexplored nodes\n while not frontier.isEmpty():\n\n # choose a leaf node and remove it from frontier\n leaf_node = frontier.pop()\n\n # return the solution if it is the goal state\n if problem.isGoalState(leaf_node):\n return actions_list[leaf_node]\n\n # add the node to explored set\n explored_set.append(leaf_node)\n\n # expand the chosen node\n # and add to the frontier if not in frontier and explored set\n for successor in problem.getSuccessors(leaf_node):\n child, action, _ = successor\n if child not in explored_set and child not in frontier.list:\n frontier.push(child)\n actions_list[child] = actions_list[leaf_node] + [action]\n else:\n # search through all but still can't find a solution -> failed!\n return 'failure'","def _search(self, node: Node, search_depth: int = 1) -> (float, list):\n if not node.children or search_depth == 0:\n return node.tot_reward / node.num_samples, []\n elif search_depth == 1:\n max_val = -math.inf\n max_actions = []\n for action, child in node.children.items():\n node_val = child.tot_reward / child.num_samples\n if node_val > max_val:\n max_val = node_val\n max_actions = [action]\n elif node_val == max_val:\n max_actions.append(action)\n max_action = random.choice(max_actions)\n child = node.children[max_action]\n return child.tot_reward / child.num_samples, [max_action]\n best_reward = -math.inf\n best_act_seq = []\n for action, child in node.children.items():\n child_reward, child_act_seq = self._search(child, search_depth - 1)\n if child_reward > best_reward:\n best_act_seq = [action] + child_act_seq\n best_reward = child_reward\n return best_reward, best_act_seq","def graph_search(self, initial_path, goal):\n nodes_considered = 0\n frontier = PathPriorityQueue([Path(initial_path, 0)])\n explored = set()\n while True:\n if frontier.is_empty():\n return \"FAIL\"\n path = frontier.pop()\n node = path.end\n explored.add(node)\n if node == goal:\n return path\n for action in self.ACTIONS(path):\n print(str(action))\n res = action.result(path)\n if res not in explored:\n new_path = path.combine(action)\n frontier.add(new_path)\n nodes_considered+=1","def depthFirstSearch(problem):\r\n \"*** YOUR CODE HERE ***\"\r\n node = problem.getStartState()\r\n if (problem.isGoalState(node)):\r\n return [] # no need to make any moves of the start state is goal\r\n start = (node, 'NoDirection',0)\r\n\r\n frontier_queue = Stack() # queue for frontier\r\n frontier_queue.push(start) # frontier consists of only the start state\r\n\r\n explored_nodes = set()\r\n explored_track = {start:None} # keep a track of parent, parent of root node is None\r\n\r\n while not frontier_queue.isEmpty():\r\n state = frontier_queue.pop() # pop the top element from the queue \r\n explored_nodes.add(state)\r\n\r\n if problem.isGoalState(state[0]):\r\n return get_track(explored_track, state)\r\n\r\n neighbors_state = problem.getSuccessors(state[0])\r\n for neighbor in neighbors_state: # neighbor will be something like this ((34, 15), 'South', 1)\r\n if neighbor not in frontier_queue.list and neighbor not in explored_nodes:\r\n frontier_queue.push(neighbor)\r\n explored_track[neighbor] = state\r\n\r\n\r\n def get_track(explored_track, state):\r\n from game import Directions\r\n track_history = [state]\r\n track_history_direction = []\r\n leaf = state\r\n while (explored_track[leaf]) != start:\r\n track_history.append(explored_track[leaf])\r\n leaf = explored_track[leaf]\r\n\r\n for j in range (len(track_history),-1,-1):\r\n this_step = track_history[j-1]\r\n this_step = this_step[1]\r\n track_history_direction.append(this_step)\r\n return track_history_direction[:-1]","def depthFirstSearch(problem):\n #\"*** YOUR CODE HERE ***\"\n\n \"\"\"\n Pseudocode:\n function G RAPH-S EARCH ( problem) returns a solution, or failure\n initialize the frontier using the initial state of problem\n initialize the explored set to be empty\n loop do\n if the frontier is empty then return failure\n choose a leaf node and remove it from the frontier\n if the node contains a goal state then return the corresponding solution\n add the node to the explored set\n expand the chosen node, adding the resulting nodes to the frontier\n only if not in the frontier or explored set\n\n \"\"\"\n frontier = util.Stack()\n #print 'Create frontier'\n initial_node = node(problem.getStartState(), 0, [], 0)#(state,depth,path_actions,path_cost)\n frontier.push(initial_node)\n #print 'Push ',repr(initial_node.state)\n frontierSet = set([initial_node.state])\n explored = set() #initialize the explored set to be empty\n\n while True:\n if frontier.isEmpty() == True: raise Exception, \"The frontier was emptied\"#if the frontier is empty then return failure\n currNode = frontier.pop()#HERE1\n frontierSet.remove(currNode.state)\n #print 'Remove',repr(currNode.state)\n #print 'State: ' + repr(currNode.state) + '. Depth: ' + repr(currNode.depth) + '. Path Cost: ' + repr(currNode.path_cost) + '. Path Actions: ' + repr(currNode.path_actions) + '.\\n'\n if problem.isGoalState(currNode.state) == True:\n print 'Goal reached!'\n return currNode.path_actions\n explored.add(currNode.state)\n for succ in problem.getSuccessors(currNode.state):\n #print 'Succ: ',repr(succ[0])\n succNode = node(succ[0], currNode.depth + 1, currNode.path_actions + [succ[1],], currNode.path_cost + succ[2])\n if (succNode.state not in explored):\n # Si hacemos estas verificaciones entonces cuando se encuentra que un estado que se quiere expandir ya esta en la frontera\n # eliminamos ese estado de la frontera y lo expandimos ahora. Osea, damos prioridad a los nodos nuevos\n if(succNode.state in frontierSet):\n # Recurso'i:\n for frontierNode in frontier.list:\n if frontierNode.state == succNode.state:\n frontier.list.remove(frontierNode)\n frontierSet.remove(frontierNode.state)\n # if ((succNode.state not in explored) and (succNode.state not in frontierSet)): \n # Alternativa segun el libro. Lo que se hace es que se da prioridad a los nodos viejos.\n\n # Aca no verificaba si ya esta en la frontera porque alteraba el orden en el que se visitan los nodos.\n # Por ejemplo cuando esta pendiente (se genero pero no se expandio) un hijo con un estado,\n # pero en un nivel mas profundo se vuelve a generar el mismo estado y se tiene que expandir.\n # Si seguimos el DFS creo que tendriamos que expandir ese nodo ahi y no en la primera llamada donde quedo pendiente.\n \n frontier.push(succNode)\n #print 'Push ',repr(succNode.state)\n frontierSet.add(succNode.state)\n\n #util.raiseNotDefined()","def depthFirstSearch(problem):\n stack = Stack()\n\n visited = []\n parent_dict = dict()\n start_state = problem.getStartState()\n stack.push(start_state)\n current_path = []\n actions_dict = dict()\n final_actions = []\n flag = False\n\n if problem.isGoalState(problem.getStartState()):\n return []\n\n while not stack.isEmpty():\n current_state = stack.pop()\n current_path.append(current_state)\n visited.append(current_state)\n\n if problem.isGoalState(current_state):\n break\n\n successors = problem.getSuccessors(current_state)\n\n for s in successors:\n flag = False\n if s[0] not in visited:\n stack.push(s[0])\n parent_dict[s[0]] = current_state\n actions_dict[(current_state, s[0])] = s[1]\n flag = True\n\n\n\n if not successors and not stack.isEmpty() or flag is False:\n current_state = stack.pop()\n while current_path[-1] != parent_dict[current_state]:\n current_path.pop()\n stack.push(current_state)\n\n for i in range(len(current_path)-1):\n final_actions.append(actions_dict[current_path[i],current_path[i+1]])\n\n\n return final_actions","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n # current path stack\n path_stack = util.Stack()\n action_stack = util.Stack()\n path_stack.push(problem.getStartState())\n\n # visited (so don't )\n visited = []\n visited.append(problem.getStartState())\n\n i = 0\n while not path_stack.isEmpty():\n\n # check goal state\n if problem.isGoalState(path_stack.list[-1]): # check if goal\n return action_stack.list\n\n # get next possible state (choose first in list)\n successors = problem.getSuccessors(path_stack.list[-1])\n forward=False\n for successor in successors:\n ss,aa,_ = successor\n if ss not in visited:\n\n path_stack.push(ss)\n action_stack.push(aa)\n visited.append(ss) # you don't pop visited\n forward=True\n break\n\n # backtrack\n if forward==False:\n path_stack.pop()\n action_stack.pop()\n\n i+=1\n #if i==25:\n # import pdb; pdb.set_trace()\n #print(path_stack.list)","def depthFirstSearch(problem):\n #Initializing variables\n fringe = util.Stack()\n #Creating visited list\n visited = []\n #Pushing start state to Stack\n fringe.push((problem.getStartState(), []))\n #Adding start state to visited list\n visited.append(problem.getStartState())\n \n #Popping point from the stack\n while fringe.isEmpty() == False:\n state, actions = fringe.pop()\n #Getting successor nodes\n for next in problem.getSuccessors(state):\n newstate = next[0]\n newdirection = next[1]\n #Pushing successor nodes to the stack and appending to visited\n if newstate not in visited:\n if problem.isGoalState(newstate):\n return actions + [newdirection] \n else:\n fringe.push((newstate, actions + [newdirection]))\n visited.append(newstate)\n\n util.raiseNotDefined()","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n \"\"\"\n ALGORITH FOR DFS\n \n function graph-search(problem, fringe) retuen a sloution or failure\n \n closed <-- an empty set\n fringe <-- insert (make-node (initial-state [problem]), fringe)\n \n loop do :\n if fringe is empty then return failure\n node <-- Remove-front (fringe)\n if goal-test (problem, state[node]) then return node\n if state[node] is not in closed then \n add STATE[node] to closed\n for child-node in EXPAND(STATE[node],problem) do\n fringe <-- Insert (child-node, fringe)\n end\n end\n \"\"\"\n\n templist=[]\n explored = set()\n fringe = util.Stack()\n #print \"the stat node is : \", problem.getStartState()\n\n fringe.push((problem.getStartState(),templist))\n while (not fringe.isEmpty()):\n (currentNode,currDir) = fringe.pop()\n # print \"Pacman is currently at : \", currentNode\n if problem.isGoalState(currentNode):\n # print \" Goal State Found : \", currentNode\n pathToGoal = currDir\n break\n if not (currentNode in explored):\n # print \"Adding current node to explored\"\n explored.add(currentNode)\n for childNode in problem.getSuccessors(currentNode):\n # print \"child node : \", childNode , \" is added \"\n fringe.push((childNode[0],currDir+[childNode[1]]))\n\n return pathToGoal","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n class Node:\n def __init__(self, state, parent, action, pathCost):\n self.state = state\n self.parent = parent\n self.action = action\n self.pathCost = pathCost\n\n def solution(self):\n path = list()\n tempNode = self\n while tempNode.state != problem.getStartState():\n path.insert(0, tempNode.action)\n tempNode = tempNode.parent\n return path\n\n def __eq__(self, other):\n if isinstance(other, Node):\n return self.state == other.state\n\n\n def childNode(successor, parent, action, stepCost):\n pathCost = parent.pathCost + stepCost\n child = Node(successor, parent, action, pathCost)\n return child\n\n initialNode = Node(problem.getStartState(), None, None, 0)\n frontier = util.PriorityQueue() #bfs uses a queue\n frontier.push(initialNode, initialNode.pathCost + heuristic(initialNode.state, problem)) #we use f(n) = pathCost + h(n) for the best solution\n explored = set()\n\n while not frontier.isEmpty() :\n nextNode = frontier.pop() #extract from the start of the queue\n if problem.isGoalState(nextNode.state):\n return nextNode.solution()\n explored.add(nextNode.state)\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\n child = childNode(successor, nextNode, action, stepCost)\n if child.state not in explored:\n frontier.update(child, child.pathCost + heuristic(child.state, problem))\n return []\n util.raiseNotDefined()","def graph_search(problem, open_nodes):\n explored = [problem.initial]\n open_nodes.append(Node(problem.initial))\n while len(open_nodes) > 0:\n node = open_nodes.pop()\n if problem.goal_test(node.state):\n #print \"Path cost: %d\" % node.path_cost\n return node.solution()\n for child in node.expand(problem):\n if child.state not in explored:\n open_nodes.append(child)\n explored.append(child.state)\n return None","def graph_search(state, goal_state, height_limit):\n frontier = []\n heapq.heappush(frontier, problem_search_node.SearchNode(state, None, None, 0, 0))\n explored_set = set()\n while frontier:\n current_node = heapq.heappop(frontier)\n if utils.is_goal_state(current_node.state, goal_state):\n return utils.create_path_to_goal(current_node)\n explored_set.add(current_node.state.key())\n actions = current_node.state.possible_actions(explored_set, height_limit)\n for node in [current_node.child_node(action, height_limit, cons_heuristic, goal_state) for action in actions]:\n heapq.heappush(frontier, node)\n return (-1, [])","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n \n from game import Directions\n visited = set() # unique elements\n state = problem.getStartState()\n #returns starting agent's position\n waiting_list = util.Stack()\n # LIFO\n # last in first out\n # parents = collections.defaultdict(collections.UserDict)\n parents = {}\n #dictionary\n sequence = []\n #LIFO\n for action in problem.getSuccessors(state):\n # in order to push full-state values\n waiting_list.push(action)\n # enumarating tuple\n\n while not waiting_list.isEmpty():\n state = waiting_list.pop()\n \n visited.add(state[0])\n # node is visited and we wont visit those nodes\n \n for substate in problem.getSuccessors(state[0]):\n # take a look to successors of current node\n \n if substate[0] not in visited:\n # if not in visited \n # saving parents\n parents[substate[0]]={'parent':state} \n # generate new node\n waiting_list.push(substate)\n # push to stack\n if problem.isGoalState(substate[0]): \n target_state = substate \n #finding wayback\n\n\n while target_state[0] in parents.keys():\n temp=parents[target_state[0]]['parent']\n sequence.append(target_state[1])\n target_state = temp\n sequence.append(target_state[1])\n return sequence[::-1]","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n # util.raiseNotDefined()\n\n # print(\"Start:\", problem.getStartState())\n # print(\"Is the start a goal?\", problem.isGoalState(problem.getStartState()))\n # print(\"Start's successors:\", problem.getSuccessors(problem.getStartState()))\n\n # Initialize a frontier, and push the initial state into the frontier\n frontier = util.Stack()\n frontier.push([(problem.getStartState(), 'move', 0)])\n # Initialize a explored set to store the visited nodes\n exploredSet = set()\n\n # Check the content of frontier\n while not frontier.isEmpty():\n stateList = list()\n stateList = frontier.pop()\n # print (stateList)\n # What we focus on is the next state, not the (previous state + next state), so we should take the last element\n nextState = stateList[len(stateList) - 1]\n # Check the current state is goal or not\n if problem.isGoalState(nextState[0]):\n # Initial a path, which is the way to the goal state\n path = list()\n for eachMove in stateList:\n path.append(eachMove[1])\n # If the initial state is the goal state, there's no need to explore other nodes, so that's called special condition\n if len(path) == 1:\n return path[0]\n # This is the normal condition, we should convey the path except the first one, because we haven't define what's \"move\"\n else:\n return path[1:]\n # If this is a state which we don't visit, add it to the explored set(this is called GSA)\n if not nextState[0] in exploredSet:\n exploredSet.add(nextState[0])\n # Give me your child nodes\n for childState in problem.getSuccessors(nextState[0]):\n nextStateList = stateList[:]\n # we focus on the path, so we have to record the every move from the initial state to the current one\n nextStateList.append(childState)\n frontier.push(nextStateList)\n\n # Or maybe there's no way to the goal state\n else:\n return \"There's no way.\"","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n class Node:\n def __init__(self, state, parent, action, pathCost):\n self.state = state\n self.parent = parent\n self.action = action\n self.pathCost = pathCost\n\n def solution(self):\n path = list()\n tempNode = self\n while tempNode.state != problem.getStartState():\n path.insert(0, tempNode.action)\n tempNode = tempNode.parent\n return path\n\n\n\n\n def childNode(successor, parent, action, stepCost):\n pathCost = parent.pathCost + stepCost\n child = Node(successor, parent, action, pathCost)\n return child\n\n initialNode = Node(problem.getStartState(), None, None, 0)\n if problem.isGoalState(initialNode.state):\n return initialNode.solution()\n\n frontier = util.Queue() #bfs uses a queue\n frontier.push(initialNode)\n explored = set()\n\n while not frontier.isEmpty() :\n nextNode = frontier.pop() #extract from the start of the queue\n explored.add(nextNode.state)\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\n child = childNode(successor, nextNode, action, stepCost)\n if child.state not in explored and child not in frontier.list:\n if problem.isGoalState(child.state):\n return child.solution()\n frontier.push(child)\n return []\n util.raiseNotDefined()","def tree_search(problem, frontier):\n compteur = 0\n stop = False\n frontier.append(Node(problem.initial))\n while frontier and not stop:\n compteur+=1\n node = frontier.pop()\n if problem.goal_test(node.state):\n return node\n if(compteur <= limit):\n frontier.extend(node.expand(problem))\n else:\n stop = True\n \n return None","def graph_search(problem, open_nodes):\n explored = [problem.initial]\n open_nodes.append(Node(problem.initial))\n while len(open_nodes) > 0:\n node = open_nodes.pop()\n if problem.goal_test(node.state):\n #print \"Path cost: %d\" % node.path_cost\n print 'Broj poteza: ' + str(len(node.solution())-1)\n return node.solution()\n for child in node.expand(problem):\n if child.state not in explored:\n open_nodes.append(child)\n explored.append(child.state)\n return None","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n from util import PriorityQueue\n import math\n\n frontier = PriorityQueue()\n explored = []\n actions = []\n\n class node:\n def __init__(self, path, dad, action):\n self.path = path\n self.dad = dad\n self.action = action\n h = heuristic(path,problem.goal)\n if dad == None:\n self.g=0\n else:\n self.g = dad.g + heuristic(dad.path,path)\n self.cost = round(self.g + h,1)\n\n start = node(problem.getStartState(),None,'')\n frontier.push(start,start.cost)\n\n while frontier.isEmpty() == False:\n path = frontier.pop()\n successors = problem.getSuccessors(path.path)\n explored.append(path)\n for vertex in successors:\n achou = False\n for path_ex in explored:\n if vertex[0] == path_ex.path:\n achou = True\n\n if achou == False:\n successor = node(vertex[0],path,vertex[1])\n frontier.push(successor,successor.cost)\n if problem.isGoalState(successor.path):\n while len(explored) > 0:\n ant = explored.pop()\n if ant.path == successor.dad.path:\n actions.append(successor.action)\n successor = ant\n actions.reverse()\n return actions","def search(board:Board, max_depth=3) -> DiGraph:\n\n n = 0 # node label which also serves as a node counter\n depth = 0\n \n G = nx.DiGraph()\n G.add_node(0, winner=None, player=0, board=board.state, board_p = board.display)\n \n # First branch in look ahead\n newleavelist=[]\n parent_node = n\n parent_board = Board(G.nodes[n]['board'][0], G.nodes[n]['board'][1])\n\n for move in ALL_MOVES:\n moves_available = parent_board.moves_available(player=0)\n if move not in moves_available:\n continue\n \n # Do move\n new_board = parent_board.update_board(Move(player=0, move=move))\n \n # Add move node to graph\n n=n+1\n G.add_node(n, winner=new_board.is_winner, player=1, board=new_board.state, board_p = new_board.display)\n G.add_edge(parent_node, n, move=move)\n if new_board.is_winner:\n continue\n newleavelist.append(n)\n \n depth=1\n # subsequent branches\n while depth < max_depth:\n leavelist = newleavelist[:]\n newleavelist = []\n for leave in leavelist: \n # Get parent board\n parent_board = Board(G.nodes[leave]['board'][0], G.nodes[leave]['board'][1])\n for move in ALL_MOVES:\n moves_available = parent_board.moves_available(player=depth%2)\n if move not in moves_available:\n continue\n # Do move\n new_board = parent_board.update_board(Move(player=depth%2, move=move))\n # Add move node to graph\n n=n+1\n G.add_node(n, winner=new_board.is_winner, player=1-depth%2, \n board=new_board.state, board_p=new_board.display)\n G.add_edge(leave, n, move=move)\n if new_board.is_winner:\n continue\n \n newleavelist.append(n)\n depth=depth+1\n return G","def uninformed_search(start, end, graph):\n\n class SearchNode():\n def __init__(self, step_cost, name, predecessor):\n self.path_cost = predecessor.path_cost + step_cost if predecessor is not None else 0\n self.step_cost = step_cost\n self.name = name\n self.predecessor = predecessor\n def __repr__(self):\n return self.predecessor.name + \"->\" + self.name + \"=\" + self.path_cost\n\n class Problem():\n def __init__(self, start, end, graph, goal_predicate):\n self.start = start\n self.end = end\n self.graph = graph\n self.is_goal = goal_predicate\n self.visited_nodes = []\n\n nodes_expanded = 0\n nodes_generated = 0\n max_nodes_in_memory = 0\n\n def tree_search(problem, fringe):\n nonlocal nodes_generated\n nonlocal nodes_expanded\n nonlocal max_nodes_in_memory\n\n # create the initial node\n nodes_generated = 1\n fringe = [SearchNode(0, problem.start, None)]\n\n while len(fringe) > 0:\n # keep track of some metrics\n max_nodes_in_memory = max(max_nodes_in_memory, len(fringe))\n nodes_expanded += 1\n\n node = fringe.pop(0)\n while node.name in problem.visited_nodes:\n # ran out of nodes in the fringe\n if len(fringe) == 0:\n return None\n\n node = fringe.pop(0)\n\n if problem.is_goal(node):\n return node\n \n # make sure we never visit this node again, since we'll be expanding it\n problem.visited_nodes.append(node.name)\n\n # keep the fringe sorted by the path cost\n fringe.extend(expand(node, problem))\n fringe = sorted(\n fringe, \n key=lambda node: node.path_cost\n )\n\n return None\n\n def expand(node, problem):\n nonlocal nodes_generated\n nodes = []\n for edge in problem.graph.edges(node.name):\n nodes.append(SearchNode(edge.weight, edge.destination, node))\n \n nodes_generated += len(nodes)\n return nodes\n\n initial_problem = Problem(start, end, graph, lambda x: x.name == end)\n result = tree_search(initial_problem, [])\n\n # convert the resulting nested structure into an actual path of (start, end, cost)\n def walk(node):\n pred = node.predecessor\n if pred is None:\n return []\n \n path = walk(pred)\n path.append((pred.name, node.name, node.step_cost))\n return path\n\n path = walk(result) if result is not None else None\n return (path, nodes_expanded, nodes_generated, max_nodes_in_memory)","def depth_limited_search(problem, limit):\n\n # in this case, we simply use a list to keep track of nodes we\n # traversed, instead of the data structure, Stack.\n path = list()\n visited = set() # as before, to prevent duplicated nodes\n root = problem.get_initial_state()\n\n def rec_dls(state, action, depth):\n\n visited.add(state)\n\n # if it is a goal\n if problem.goal_test(state):\n path.append((state, action))\n return path\n\n # or if it reaches a certain depth, but not a goal\n elif depth == 0:\n visited.remove(state)\n return None\n\n else:\n path.append([state, action])\n for successor, action, cost in problem.get_successors(state):\n if successor not in visited:\n # recursively expands the deepest node\n res = rec_dls(successor, action, depth-1)\n if res is not None:\n return res\n path.pop()\n visited.remove(state)\n\n # \"Stared From the Bottom\" (root)\n result = rec_dls(root, 'None', limit)\n # return the path if the we DID have achieved something\n if result is not None:\n return path","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\" \n startState = problem.getStartState()\n visitedNodes = []\n fringe = util.Queue()\n cost = 0 \n if (problem.isGoalState(startState) == True ):\n return [] # No Specific Actions\n else :\n fringe.push((startState , [] , cost ))\n while ( fringe.isEmpty() == False ):\n currentState , actions , cost = fringe.pop()\n \"\"\" get the latest node in the Queue \"\"\"\n \n if ( problem.isGoalState(currentState) == True ): \n \"\"\" check if the node is our goal or not \"\"\"\n #print(\"Final Path : \" + str(actions))\n return actions\n else:\n if ( (currentState in visitedNodes) == False ): \n \"\"\" check if this node is alreay visited or needs to be extended ? \"\"\"\n visitedNodes.append(currentState)\n currentNodeSuccessors = problem.getSuccessors(currentState)\n for node in currentNodeSuccessors :\n if(not node in visitedNodes):\n state , action , cost = node \n if ( not state in visitedNodes):\n fringe.push((state , actions + [action] , cost ))\n \n util.raiseNotDefined()","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n e = Directions.EAST\n\n result = []\n st = util.Stack()\n visited = set([])\n\n current = problem.getStartState()\n st.push((current, \"\", 0))\n\n while not st.isEmpty():\n while st.top()[0] in visited:\n st.pop()\n result.pop()\n\n current = st.top()\n visited.add(current[0])\n\n if current[1] != \"\":\n result.append(current[1])\n\n if problem.isGoalState(current[0]):\n break\n\n for each in problem.getSuccessors(current[0]):\n if each[0] not in visited:\n st.push(each)\n\n path = []\n for each in result:\n if each == \"South\":\n path.append(s)\n elif each == \"West\":\n path.append(w)\n elif each == \"North\":\n path.append(n)\n else:\n path.append(e)\n\n return path\n util.raiseNotDefined()","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n # Priority Queue to hold the node along with the path taken from the start node to reach that node\n pqueue = PriorityQueue()\n #Set to hold the node explored.\n explorednode = set()\n # Get the start node.\n startnode = problem.getStartState()\n # Push the starting node on the Queue along with an empty set to know the direction in order to reach the node.\n pqueue.push((startnode, []), 0)\n\n # Loop till the priority queue is empty\n while pqueue.isEmpty() is not True:\n # Pop the currentnode and the direction from the priority queue\n (currentnode, direction) = pqueue.pop()\n # Check if the currentnode is not in the explored node.\n if currentnode not in explorednode:\n # We will now add the node to set of explored node.\n explorednode.add(currentnode)\n # If the node is the goal. We made it!!\n if problem.isGoalState(currentnode):\n # The direction holds the way to reach till the goal from the start node.\n return direction\n # Loop for each successor(child) of the current node.\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\n # Add the successor to the queue along with the path to reach it.\n if successor not in explorednode:\n # Add the successor to the queue along with the path to reach it.\n pqueue.push((successor, direction + [action]), problem.getCostOfActions(direction + [action]) + heuristic(successor, problem))\n util.raiseNotDefined()","def search_for_actions(self, search_depth: int = 1,\n random_seed: int = None) -> list:\n if random_seed is not None:\n random.seed(random_seed)\n for _ in range(self._max_samples):\n execute_round(self._root, max_tree_depth=self._max_tree_depth,\n tree_select_policy=self._tree_select_policy,\n tree_expand_policy=self._tree_expand_policy,\n rollout_policy=self._rollout_policy,\n backpropagate_method=self._back_propagate_policy)\n return self._search(self._root, search_depth)[1]","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n\n templist=[]\n explored = set()\n fringe = util.PriorityQueue()\n # state, list of directions till now and the cost is pushed in the stack\n # so that algorithm can explore the node with lowest cost first\n fringe.push((problem.getStartState(),templist),1)\n\n while (not fringe.isEmpty()):\n (currentNode,currDir) = fringe.pop()\n\n if problem.isGoalState(currentNode):\n pathToGoal = currDir\n break\n if not (currentNode in explored):\n explored.add(currentNode)\n for childNode in problem.getSuccessors(currentNode):\n # total cost is cost till now plus cost to the child node\n totalCost = childNode[2]+problem.getCostOfActions(currDir)\n fringe.push((childNode[0],currDir+[childNode[1]]),totalCost)\n\n\n\n\n return pathToGoal;","def depthFirstSearch(problem):\n\n explored = set()\n frontier = []\n start_state = problem.getStartState()\n frontier.append(start_state)\n parent_hash = {}\n parent_hash[start_state] = (None, None)\n\n def get_path(state):\n path_stack = util.Stack()\n actions = []\n current = state\n while parent_hash[current][0] is not None:\n path_stack.push(parent_hash[current][0])\n current = parent_hash[current][1]\n while not path_stack.isEmpty():\n actions.append(path_stack.pop())\n\n return actions\n\n while len(frontier):\n node = frontier.pop()\n if problem.isGoalState(node):\n return get_path(node)\n explored.add(node)\n for state, action, _ in problem.getSuccessors(node):\n if state not in explored and state not in frontier:\n parent_hash[state] = (action, node)\n frontier.append(state)","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n #Creamos las estructuras de datos necesarias (stack y set)\n openNodes = util.Stack()\n closedNodes = set([])\n\n #Guardamos el nodo inicial\n node = Node(problem.getStartState(), '', 0, None)\n\n #Metemos el nodo en la pila\n openNodes.push(node)\n\n #Iteramos para cada nodo de la pila\n while True:\n if openNodes.isEmpty():\n break #ERROR: throw exception\n else :\n #Sacamos el nodo de arriba de la pila\n node = openNodes.pop()\n if problem.isGoalState(node.name):\n break\n else: #Expandimos los nodos sucesores del nodo n si no estan en closed\n for successor in problem.getSuccessors(node.name):\n n, p, c = successor\n succNode = Node(n, p, c, node)\n if nodeIsClosed(succNode, closedNodes) is False:\n #Metemos al sucesor en la pila\n openNodes.push(succNode)\n #Metemos el nodo n en closed\n closedNodes.add(node)\n\n #Devolvemos el camino al Goal\n return findPath(node)","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n # Initialize data structures\n parent_node = {}\n path_to_node = {}\n priority_queue = util.PriorityQueue()\n\n p_c = 0.5\n h_c = 1 - p_c\n\n # Get the start node\n start_node = problem.getStartState()\n parent_node[start_node] = None\n path_to_node[start_node] = []\n priority_queue.update(start_node, 0)\n\n #goal_found = False\n\n while not priority_queue.isEmpty():\n # Get the next node\n node_to_expand = priority_queue.pop()\n # Check if goal state is reached\n if problem.isGoalState(node_to_expand):\n break\n next_nodes = problem.getSuccessors(node_to_expand)\n path_to_parent = path_to_node[node_to_expand]\n\n for one_node in next_nodes:\n point, move, cost = one_node\n curr_path = path_to_node[node_to_expand] + [move]\n curr_cost = problem.getCostOfActions(curr_path)\n heuristic_cost = heuristic(point, problem)\n # Check if current node already exists in the previously visited nodes\n if point in path_to_node:\n prev_cost = problem.getCostOfActions(path_to_node[point])\n if prev_cost > curr_cost:\n path_to_node[point] = curr_path\n priority_queue.update(point, curr_cost + heuristic_cost)\n \n else:\n path_to_node[point] = curr_path\n priority_queue.update(point, curr_cost + heuristic_cost)\n \n # current_cost = problem.getCostOfActions(point) * p_c + heuristic(point, problem) * h_c\n\n print(node_to_expand) \n return path_to_node[node_to_expand]\n \n# nodes_to_expand = set()\n# # get max value node in the fringe node\n# min_val = float(\"inf\")\n# for one_node in fringe_node:\n# # Compute the cost to reach a node\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\n# if total_cost < min_val:\n# min_val = total_cost\n# \n# for one_node in fringe_node:\n# # Compute the cost to reach a node\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\n# if total_cost == min_val:\n# nodes_to_expand.add(one_node)\n# fringe_node.remove(one_node)\n#\n# # Expand the fringe node \n# for one_node in nodes_to_expand:\n# path_to_parent = path_to_point[one_node]\n# for nxt_node in problem.getSuccessors(one_node):\n# pos = nxt_node[0]\n# mv = nxt_node[1]\n# # check if point already present in path to point\n# prev_cost = float(\"inf\")\n# if pos in cost_to_point:\n# prev_cost = cost_to_point[pos]\n# new_path = path_to_parent + [mv]\n# if prev_cost > problem.getCostOfActions(new_path):\n# path_to_point[pos] = new_path\n# cost_to_point[pos] = problem.getCostOfActions(new_path)\n# fringe_node.append(pos)\n#\n# # Check if destination is reached in the fringe node\n# for one_node in fringe_node:\n# if problem.isGoalState(one_node):\n# final_node = one_node\n# goal_found = True\n# break\n# \n# #print(len(fringe_node))\n# print(final_node)\n# print(path_to_point[final_node])\n# return path_to_point[final_node] \n\n util.raiseNotDefined()","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n #the logic is same as for DFS just that i made use of a Queue data structure\n #Here the queue acts as a FIFO queue\n neighbourNodes = util.Queue()\n moves = []\n neighbourNodes.push((problem.getStartState(),moves))\n seenNodes = set()\n\n while not neighbourNodes.isEmpty():\n poppedNodeState, poppedNodeAction= neighbourNodes.pop()\n if(poppedNodeState in seenNodes):\n continue\n if problem.isGoalState(poppedNodeState):\n return poppedNodeAction\n seenNodes.add(poppedNodeState)\n for state, action, cost in problem.getSuccessors(poppedNodeState):\n if(state in seenNodes):\n continue\n neighbourNodes.push((state, poppedNodeAction+[action]))\n return moves\n #util.raiseNotDefined()","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n fringe = util.Stack()\n return GraphSearch(problem, 'dfs').search(fringe)","def general_search(problem, fringe):\n\n fringe.push(PQItem((problem.get_start_state(), [], 0, None))) # curr_node, action, cost, parent\n closed = set()\n\n while not fringe.isEmpty():\n i = 1\n curr = fringe.pop()\n if problem.is_goal_state(curr.get_node()):\n build_first_plan_dict(curr)\n return curr.get_action()\n elif is_visited_by_plan(curr.get_node()):\n return get_past_path(curr.get_action())\n elif curr.get_node() not in closed:\n successors = problem.get_successors(curr.get_node())\n for i in range(len(successors)):\n next_state, action, cost = successors[i]\n fringe.push(PQItem((next_state, curr.get_action() + [action], cost + curr.get_cost(), None)))\n closed.add(curr.get_node())\n i += 1\n return \"failed\"","def depth_first_search(problem):\r\n \"*** YOUR CODE HERE ***\"\r\n fringe = []\r\n path = set()\r\n final = []\r\n acts = dict()\r\n state = problem.get_start_state()\r\n fringe.append(state)\r\n\r\n while(len(fringe) > 0):\r\n state = fringe.pop()\r\n path.add(state)\r\n states = problem.get_successors(state)\r\n acts[state] = states[:]\r\n if problem.is_goal_state(state):\r\n break\r\n\r\n #states = problem.get_successors(state)\r\n for stat in states:\r\n if stat[0] not in path and stat[0] not in fringe:\r\n fringe.append(stat[0])\r\n\r\n while(True):\r\n if state == problem.get_start_state():\r\n break\r\n for key, val in acts.items():\r\n for va in val: #( x, y, z)\r\n if va[0] == state:\r\n final.append(va[1])\r\n state = key\r\n break\r\n else:\r\n continue\r\n break\r\n\r\n final.reverse()\r\n\r\n return final","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n \n util.raiseNotDefined()","def graph_search(problem, fringe):\n counter = 0\n closed = {}\n fringe.append(Node(problem.initial))\n max_depth=0\n while fringe:\n node = fringe.pop()\n # Print some information about search progress\n if node.depth>max_depth:\n max_depth=node.depth\n if max_depth<50 or max_depth % 1000 == 0:\n pid = os.getpid()\n py = psutil.Process(pid)\n memoryUse = py.memory_info()[0]/1024/1024\n print('Reached depth',max_depth,\n 'Open len', len(fringe),\n 'Node expanse', counter,\n 'Memory used (MBytes)', memoryUse)\n\n if problem.goal_test(node.state):\n return node, counter\n serial = node.state.__str__()\n if serial not in closed:\n counter += 1\n closed[serial] = True\n fringe.extend(node.expand(problem))\n return None","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n fringeList = util.Stack()\n print \"fringeList\",fringeList\n closedList = {str(problem.getStartState()): ([])} #Hash Map to maintain state to path\n print \"closed list:\", closedList\n isGoalStateArrived = False\n\n # Push start state into fringeList\n fringeList.push((problem.getStartState()))\n\n while not isGoalStateArrived and not fringeList.isEmpty():\n currentNode = fringeList.pop()\n print \"currentNode\",currentNode\n currentNodePath = closedList[str(currentNode)]\n print \"currentNodepath:\",currentNodePath\n # Explore children\n childrenOfCurrentNode = problem.getSuccessors(currentNode)\n print \"childrenOfCurrentNode:\",childrenOfCurrentNode\n for childNode in childrenOfCurrentNode:\n if str(childNode[0]) not in closedList:\n path = copy.copy(currentNodePath)\n path.append(childNode[1])\n print \"child [0] %s, child [1] %s\", childNode[0],childNode[1]\n print \"path \", path\n fringeList.push(childNode[0])\n closedList[str(childNode[0])] = path # Put parent node in closed List\n if problem.isGoalState(childNode[0]):\n isGoalStateArrived = True\n goalState = childNode[0]\n break\n\n if isGoalStateArrived:\n #print closedList[str(problem.getStartState())]\n return closedList[str(goalState)]\n \"util.raiseNotDefined()\"","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\"\n # Initialize a stack\n open = util.Stack()\n\n # Retrieve the init state\n initState = (problem.getStartState(), ['Stop'], 0)\n open.push(initState)\n closed = []\n\n while not open.isEmpty():\n currState = open.pop()\n currPos = currState[0]\n currPath = currState[1]\n currCost = currState[2]\n\n if problem.isGoalState(currPos):\n return currPath[1:]\n else:\n closed.append(currPos)\n if currState not in closed:\n successors = problem.getSuccessors(currPos)\n if len(successors) > 0:\n for each in successors:\n if each[0] not in closed:\n temp = (each[0], currPath+[each[1]], currCost+each[2])\n open.push(temp)\n return False","def astar_search(start, goal, heuristic):\r\n open = []\r\n closed = []\r\n\r\n expanded = {} # Dictionary to check if a node has been expanded\r\n explored = {} # Dictionary to check if a node has been explored\r\n\r\n if heuristic == 0:\r\n hval = manhattan_distance(start, goal) # Calculate the heuristic value of the start node\r\n else:\r\n hval = eucledian_distance(start, goal)\r\n\r\n start_node = Node(None, start, 0, hval, hval+0) # Create the new node - root node so no parent\r\n open.append(start_node)\r\n expanded[tuple(start_node.data)] = True # Mark node as being expanded\r\n\r\n while len(open) != 0:\r\n open.sort(key=lambda x: x.f, reverse=False) # Sort f-values of nodes in ascending order\r\n cur_node = open[0] # Select the node with smallest f_value\r\n closed.append(cur_node) # Add the current node to closed as it being explored\r\n explored[tuple(cur_node.data)] = True # Mark node as being explored\r\n open.pop(0) # Remove current node from open list\r\n\r\n if cur_node.h == 0: # Checks if current node is a goal node\r\n trace_path(cur_node)\r\n return len(closed)\r\n\r\n children = children_nodes(cur_node, goal, heuristic) # Get a list of all children nodes\r\n for child in children:\r\n if child.h == 0: # If child node is a goal node then return a trace to root node\r\n trace_path(child)\r\n return len(closed)\r\n\r\n if tuple(child.data) not in expanded and tuple(child.data) not in explored:\r\n open.append(child) # Only expand node if not already expanded and explored\r\n expanded[tuple(child.data)] = True\r\n return False","def graph_search(problem, verbose=False, debug=False):\r\n \r\n # PriorityQueue should be used to maintain the order of the queue.\r\n frontier = PriorityQueue()\r\n \r\n frontier.append(Node(problem, problem.initial))\r\n \r\n current_node = frontier.pop()\r\n \r\n p = True\r\n #depth first search\r\n if current_node.expand(current_node.problem)[0].g < 0:\r\n \r\n frontier = deque()\r\n frontier.append(Node(problem, problem.initial))\r\n #breadth first search\r\n elif current_node.expand(current_node.problem)[0].h < 2:\r\n \r\n p = False\r\n frontier = deque()\r\n frontier.append(Node(problem, problem.initial))\r\n #manhattan\r\n else:\r\n \r\n frontier.append(current_node)\r\n\r\n f_hash = Explored()\r\n f_hash.add(problem.initial.state_tuple())\r\n done = False\r\n n_explored = 0\r\n explored = Explored()\r\n\r\n #graph_search\r\n while not done:\r\n \r\n if p:\r\n current_node = frontier.pop()\r\n else:\r\n current_node = frontier.popleft()\r\n explored.add(current_node.state.state_tuple())\r\n n_explored = n_explored + 1 #inc the number of explored nodes\r\n\r\n if current_node.state.solved():\r\n path = current_node.path()\r\n done = True\r\n return path, n_explored\r\n #if not found in the tree return none and number of nodes explored\r\n else:\r\n \r\n for child in current_node.expand(current_node.problem):\r\n if not explored.exists(child.state.state_tuple()) and not \\\r\n f_hash.exists(child.state.state_tuple()):\r\n frontier.append(child)\r\n f_hash.add(child)\r\n done = len(frontier) == 0\r\n\r\n return None, n_explored","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n stack = util.Stack() # stack for searshing the graph\n visited = [] # Keep track of visited nodes\n start =problem.getStartState() # The start node\n stack.push((start, [])) # the sart state and empty path list is pushed to the stack\n \n while stack:\n (vrtx, path) = stack.pop() # Pop tfrom the stack , vrtx: the poped node for expantion.\n if vrtx not in visited: # if the node is visited alraedy \n if problem.isGoalState(vrtx):\n return [p[1] for p in path]\n visited.append(vrtx)\n for successor in problem.getSuccessors(vrtx):\n stack.push((successor[0], path+[successor]))\n util.raiseNotDefined()","def general_search(fringe, visited, limiting_depth):\n node_to_be_explored = fringe[0]\n node_state = node_to_be_explored['state']\n visited[node_state] = node_to_be_explored\n if goal_test(node_to_be_explored['state']):\n return generate_path(node_to_be_explored, visited)\n current_depth = node_to_be_explored['depth']\n if current_depth == limiting_depth:\n return False\n children = [\n {\n 'state': child_state,\n 'parent': node_state,\n 'depth': current_depth + 1,\n }\n for child_state in operator(node_state)]\n for child in children:\n if child['state'] in visited:\n continue\n fringe_copy = [child] + fringe[1:]\n visited_copy = visited.copy()\n solution = general_search(fringe_copy, visited_copy, limiting_depth)\n if solution:\n return solution\n else:\n continue\n return False","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n #Queue to hold the node along with the path taken from the start node to reach that node\n queue = Queue()\n #Set to hold the node explored.\n explorednode = set()\n # Get the start node.\n startnode = problem.getStartState()\n print startnode\n # Push the starting node on the Queue along with an empty set to know the direction in order to reach the node.\n queue.push((startnode,[]))\n\n # Loop till the queue is empty\n while queue.isEmpty() is not True:\n # Pop the currentnode and the direction from the queue\n currentnode, direction = queue.pop()\n # Check if the currentnode is not in explorednode.\n if currentnode not in explorednode:\n # We will now add the node to set of explored node.\n explorednode.add(currentnode)\n # If the node is the goal. We made it!!\n if problem.isGoalState(currentnode):\n # The direction holds the way to reach till the goal from the start node.\n print currentnode\n return direction\n # Loop for each successor(child) of the current node.\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\n # If the successor(child) is not explored\n if successor not in explorednode:\n # Add the successor to the queue along with the path to reach it.\n queue.push((successor, direction + [action]))\n util.raiseNotDefined()","def search(self):\n open_set = set()\n closed_set = set()\n open_set.add(self.start_node)\n\n # loop through all nodes until open set is empty to build neighbor map\n while open_set:\n current_node = open_set.pop()\n closed_set.add(current_node)\n for removed_cells, score, next_status in current_node.find_next_moves():\n open_status_set = [i.status for i in open_set]\n closed_status_set = [i.status for i in closed_set]\n if next_status in open_status_set:\n index = open_status_set.index(next_status)\n node = list(open_set)[index]\n elif next_status in closed_status_set:\n index = closed_status_set.index(next_status)\n node = list(closed_set)[index]\n else:\n node = PopstarsNode(next_status)\n open_set.add(node)\n node.parents.append(current_node)\n current_node.children[node].append(\n (score, removed_cells, True))\n current_node.update_parents()\n max_score = []\n for i in self.start_node.children:\n max_score += self.start_node.children[i]\n return max(max_score)[0]","def action(self):\n\n # assume the smart opponent can always choose the best step\n # Depth First Search\n steps = 2\n stack = [(self.game_in_head, (), 0)]\n maxmin = None\n good_paths = []\n\n while len(stack) > 0:\n parent_node, path, score = stack.pop(-1)\n if len(path) >= steps*2:\n \n # leaf node in the search tree\n if maxmin is None:\n maxmin = score\n good_paths.append(path)\n elif maxmin == score:\n good_paths.append(path)\n elif maxmin < score:\n maxmin = score\n good_paths.clear()\n good_paths.append(path)\n else:\n # root node, find its leaves\n children_nodes = self.one_step_infe(parent_node, path, score)\n stack += children_nodes\n\n path_dec = random.choice(good_paths) \n if self.colour == 'upper':\n return path_dec[0] \n elif self.colour == 'lower':\n return path_dec[1]","def search(board):\n depth = 0\n while True:\n result = depth_first(board, depth)\n if result:\n return result\n else:\n depth += 1","def depth_first_graph_search(problem):\n\n\tfrontier = [(Node(problem.initial))] # Stack (implemented as a list)\n\n\texplored = set()\n\twhile frontier:\n\t\tnode = frontier.pop()\n\t\tif problem.goal_test(node.state):\n\t\t\treturn node\n\t\texplored.add(node.state)\n\t\tfrontier.extend(child for child in node.expand(problem)\n\t\t\t\t\t\tif child.state not in explored and child not in frontier)\n\treturn None","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n start = problem.getStartState()\n stack = util.Stack() # stack to keep track of frontier nodes where pacman has move\n stack.push(start)\n explored = set() # to keep track of explored areas\n route = []\n\n while not stack.isEmpty():\n current_position = stack.pop()\n explored.add(current_position)\n\n if problem.isGoalState(current_position):\n break\n for each in problem.getSuccessors(current_position):\n if each[0] not in explored: # x,y coordinates of positions we haven't visited are pushed onto stack\n # print(each)\n stack.push(each[0])\n route.append((current_position, each[0], each[1])) # record of movements to rebuild path (from,to,how)\n\n x = len(route)\n while x - 1 != 0: # loop clears out actions that dont come from previous position\n if route[x - 1][0] != route[x - 2][1]: # starts from goal and works backwards\n route.remove(route[x - 2])\n x = len(route)\n else:\n x -= 1\n # print(route)\n return [action[2] for action in route]","def breadth_first_search(initial_state):\n list_of_processed_nodes = []\n num_unprocessed_nodes = 0#\n num_unconsidered_children = 0#\n\n initial_node = Node(state=initial_state)\n node_deque = collections.deque()\n node_deque.append(initial_node)\n goal_state_found = False\n goal_node = None\n\n while len(node_deque) > 0 and not goal_state_found:\n e = node_deque.popleft()\n #pdb.set_trace()\n if e in list_of_processed_nodes:\n num_unprocessed_nodes += 1\n continue\n else:\n list_of_processed_nodes.append(e)\n\n list_of_children_nodes, num_unconsidered_children = generate_children_nodes(\n curr_node=e, list_of_processed_nodes=list_of_processed_nodes,\n running_count_of_children_dups=num_unconsidered_children#\n )\n \n for child_node in list_of_children_nodes:\n #print 'Node {0} with goal status {1}'.format(child_node.index, child_node.state.snake_ate_food)\n if child_node.state.goal_state_reached():\n #print \"Goal state reached with node index {0}\".format(child_node.index)\n goal_state_found = True\n goal_node = child_node\n break\n else:\n #print \"Adding to deque node index {0}\".format(child_node.index)\n node_deque.append(child_node)\n\n if len(node_deque) == 0 and not goal_state_found:\n print '*'*40\n print 'NO SOLUTION PATH FOUND'\n print '*'*40\n sys.exit(0)\n\n #pdb.set_trace()#\n # Summary & results\n #print '{0} nodes processed!'.format(len(list_of_processed_nodes))\n #print '{0} nodes already visited, skipped!'.format(num_unprocessed_nodes)\n #print '{0} node children skipped!'.format(num_unconsidered_children)\n #os.system('say -v \"Victoria\" \"done\"')\n\n return goal_node, list_of_processed_nodes","def search(start):\n\n '''\n Create a class named nodeClass which contains 4 elements: \n state: The puzzle object containing the puzzle board at the node \n misplaced: num of misplaced tiles\n depth: depth of the node in the tree \n prev: parent node\n '''\n nodeClass = namedtuple('nodeClass', 'state, misplaced, depth, prev')\n\n #instantiate object from class creating the root node\n node = nodeClass(start, 0, 0, None)\n\n #stores the nodes that are going to be explored. \n #the node with lower f-score is explored first\n frontier = q.PriorityQueue()\n frontier.put((0,node))\n\n # frontier_set keep track of the nodes in the frontier queue\n frontier_set = {node}\n #contains the board states already explored\n explored_states = set()\n for ite in range(1,max_iterations+2):#while True:\n #Retrieve the node in the frontier with lowest value\n node = frontier.get()[1]\n\n #get the puzzle board obj from the node object\n state = node.state\n\n #Check if the game has ben solved\n if state.solved or ite==max_iterations:\n Result = namedtuple('Result', 'board, depth, nodesExpanded, max_depth, isSolved')\n return Result(state, node.depth, ite, max(no.depth for no in frontier_set), state.solved)\n\n # expanded nodes are added to explored set\n explored_states.add(state)\n\n #EXPANDING\n for mov in state.possible_moves:\n new_state=state.move(mov)\n new_node = nodeClass(new_state, new_state.score,\n node.depth + 1, node)\n\n #compute f-score of the node\n f_score=new_state.score + new_node.depth\n\n if new_state not in explored_states and new_node not in frontier_set:\n frontier.put((f_score,new_node))\n frontier_set.add(new_node)","def search(state, goal_state):\n\n def gn(node):\n return node.gn()\n\n tiles_places = []\n for i in range(len(goal_state)):\n for j in range(len(goal_state)):\n heapq.heappush(tiles_places, (goal_state[i][j], (i, j)))\n\n def hn(node):\n cost = 0\n for i in range(len(node.state)):\n for j in range(len(node.state)):\n tile_i, tile_j = tiles_places[node.state[i][j]][1]\n if i != tile_i or j != tile_j:\n cost += abs(tile_i - i) + abs(tile_j - j)\n return cost\n\n def fn(node):\n return gn(node) + hn(node)\n\n return bfs.search(state, goal_state, fn)","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n class Node:\n def __init__(self, state, parent, action, pathCost):\n self.state = state\n self.parent = parent\n self.action = action\n self.pathCost = pathCost\n\n def solution(self):\n path = list()\n tempNode = self\n while tempNode.state != problem.getStartState():\n path.insert(0, tempNode.action)\n tempNode = tempNode.parent\n return path\n\n def __eq__(self, other):\n if isinstance(other, Node):\n return self.state == other.state\n\n\n def childNode(successor, parent, action, stepCost):\n pathCost = parent.pathCost + stepCost\n child = Node(successor, parent, action, pathCost)\n return child\n\n initialNode = Node(problem.getStartState(), None, None, 0)\n frontier = util.PriorityQueue() #ucs uses a priority queue\n frontier.push(initialNode, initialNode.pathCost)\n explored = set()\n\n while not frontier.isEmpty() :\n nextNode = frontier.pop() #extract from the start of the queue\n if problem.isGoalState(nextNode.state):\n return nextNode.solution()\n explored.add(nextNode.state)\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\n child = childNode(successor, nextNode, action, stepCost)\n if child.state not in explored:\n frontier.update(child, child.pathCost) #we only check if state is in explored because update does the other\n return []\n util.raiseNotDefined()","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n \"\"\"\n same as UCS function, but total cost is sum of cost till now , cost to the child node and \n cost to the goal state (heuristic function)\n \"\"\"\n fringes = util.PriorityQueue()\n explored =set()\n fringes.push((problem.getStartState(),[]),0)\n\n while(not fringes.isEmpty()):\n currentNode,currDir = fringes.pop()\n if problem.isGoalState(currentNode):\n finalPath = currDir\n break\n # print \"HOraaay goal has been found === > \", currentNode\n\n if not (currentNode in explored):\n explored.add(currentNode)\n for childNode in problem.getSuccessors(currentNode):\n totalCost = (childNode[2] + heuristic(childNode[0],problem)+problem.getCostOfActions(currDir))\n fringes.push((childNode[0],currDir+[childNode[1]]),totalCost)\n\n\n return finalPath\n\n\n\n\n\n\n\n util.raiseNotDefined()","def uct_search(root_state,\n tree=None,\n default_policy=default_random_policy,\n player_id=1):\n root_n = Node(root_state)\n if tree is None:\n tree = Tree(root_n)\n edge_node = tree_policy(root_n, tree)\n reward = default_policy(edge_node.state, player_id)\n backup_negamax(edge_node, reward)\n best_root_child = best_child(root_n, 0) # Greedy, so c = 0\n best_root_action_l = [a for p, a in best_root_child.parents if p == root_n]\n return best_root_action_l[0], tree","def recursive_search(i, F, t, s, explored, leaders, order):\n x = len(explored)\n if x % 10 == 0:\n print(\"Length of explored: {}\".format(x))\n explored.append(i)\n if order == 2:\n leaders[i] = s\n arc_list = db.Database.find_one(collection=\"biggraph\", query={\"key\": i})\n if arc_list:\n for node in arc_list['value']:\n if node not in explored:\n F, t, leaders, explored = recursive_search(node, F, t, s, explored, leaders, order)\n if order == 1:\n t += 1\n F[i] = t\n return F, t, leaders, explored","def monteCarloTreeSearch(chessboard):\n init_state = NodeState(chessboard)\n init_state.setCurrentTurn(State.BLACK)\n init_node = TreeNode(init_state)\n\n for _ in range(COMPUTATION_LIMIT):\n expanded_node = treePolicy(init_node)\n reward = defaultPolicy(expanded_node)\n backPropagation(expanded_node, reward)\n \n best_child_node = findBestChild(init_node, False)\n return best_child_node.getState().getBestMovement()","def aStarSearch(problem):\n \"*** YOUR CODE HERE ***\"\n root = problem.getStartState()\n pq = PriorityQueue()\n visited = [] # list of visited nodes to not visit again\n path = {} # to store predecessor and next move of nodes\n gn={} # for total distance\n\n '''intializing for root'''\n pq.push(root,0)\n path[root]=(None,None) # (predecessor, action)\n gn[root]=0\n\n\n while not pq.isEmpty():\n # print(path)\n node = pq.pop()\n successors = problem.getSuccessors(node)\n\n if problem.isGoalState(node):\n p=[root]\n while path[node]!=(None,None): #moving from goal to root\n p.append(node)\n node = path[node][0]\n return p\n\n visited.append(node)\n\n for i in successors:\n i_successor = i[0]\n i_action=i[1]\n i_cost=gn[node]+ i[3] # i_cost is total gn\n if i_successor not in visited:\n if (i_successor not in gn) or (gn[i_successor]>i_cost): #dijkstra property too\n path[i_successor]=(node,i_action) # (predecessor, action)\n gn[i_successor]=i_cost\n fn = i_cost + problem.getHeuristic(i_successor)\n pq.update(i_successor,fn)","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n from game import Directions\n waiting_list = util.Queue()\n # QUEUE\n # FIFO \n visited = set()\n parents = {}\n #collections.defaultdict(collections.UserDict)\n sequence = []\n start_state = problem.getStartState()\n for action in problem.getSuccessors(start_state):\n # in order to push full-state values\n waiting_list.push(action)\n \n while not waiting_list.isEmpty():\n node = waiting_list.pop()\n visited.add(node[0])\n for action in problem.getSuccessors(node[0]):\n \n #if child.STATE is not in explored or frontier then\n if action[0] not in visited:\n parents[action[0]] = {'parent':node} \n waiting_list.push(action)\n if problem.isGoalState(action[0]):\n target_state = action \n \n \n while target_state[0] in parents.keys():\n temp=parents[target_state[0]]['parent']\n sequence.append(target_state[1])\n target_state = temp\n sequence.append(target_state[1])\n return sequence[::-1]","def search(self, depth, state, curr_player):\n \n # enumerate all legal moves from this state\n legal_moves = []\n for i in range(7):\n # if column i is a legal move...\n if self.isLegalMove(i, state):\n # make the move in column i for curr_player\n temp = self.makeMove(state, i, curr_player)\n legal_moves.append(temp)\n \n # if this node (state) is a terminal node or depth == 0...\n if depth == 0 or len(legal_moves) == 0 or self.gameIsOver(state):\n # return the heuristic value of node\n return self.value(state, curr_player)\n \n # determine opponent's color\n if curr_player == self.colors[0]:\n opp_player = self.colors[1]\n else:\n opp_player = self.colors[0]\n\n alpha = -99999999\n for child in legal_moves:\n if child == None:\n print(\"child == None (search)\")\n alpha = max(alpha, -self.search(depth-1, child, opp_player))\n return alpha","def breadthFirstSearch(problem):\r\n \"*** YOUR CODE HERE ***\"\r\n node = problem.getStartState()\r\n if (problem.isGoalState(node)):\r\n return [] # no need to make any moves of the start state is goal\r\n start = (node, 'NoDirection',0)\r\n\r\n frontier_queue = Queue() # queue for frontier\r\n frontier_queue.push(start) # frontier consists of only the start state\r\n\r\n explored_nodes = set()\r\n explored_track = {start:None} # keep a track of parent, parent of root node is None\r\n\r\n while not frontier_queue.isEmpty():\r\n state = frontier_queue.pop() # pop the top element from the queue \r\n explored_nodes.add(state)\r\n\r\n if problem.isGoalState(state[0]):\r\n return get_track(explored_track, state)\r\n\r\n neighbors_state = problem.getSuccessors(state[0])\r\n for neighbor in neighbors_state: # neighbor will be something like this ((34, 15), 'South', 1)\r\n if neighbor not in frontier_queue.list and neighbor not in explored_nodes:\r\n frontier_queue.push(neighbor)\r\n explored_track[neighbor] = state\r\n\r\n\r\n def get_track(explored_track, state):\r\n from game import Directions\r\n track_history = [state]\r\n track_history_direction = []\r\n leaf = state\r\n while (explored_track[leaf]) != start:\r\n track_history.append(explored_track[leaf])\r\n leaf = explored_track[leaf]\r\n\r\n for j in range (len(track_history),-1,-1):\r\n this_step = track_history[j-1]\r\n this_step = this_step[1]\r\n track_history_direction.append(this_step)\r\n return track_history_direction[:-1]","def search_path(self):\n\n nodes = [self.start]\n final_node = None\n \n count = 0\n while True:\n count += 1\n\n if count % self.pick_target == 0:\n pick = self.goal.pos[:2]\n else:\n pick = self.car.random_pos()[:2]\n \n nearest = self.get_nearest_node(nodes, pick)\n\n if count % self.check_dubins == 0:\n solutions = self.dubins.find_tangents(nearest.pos, self.goal.pos)\n dubins_route, cost, valid = self.dubins.best_tangent(solutions)\n \n if valid:\n final_node = nearest\n break\n\n phi = self.get_steering_angle(nearest.pos, pick)\n pos = nearest.pos\n branch = [pos[:2]]\n \n for i in range(self.max_steps):\n pos = self.car.step(pos, phi)\n branch.append(pos[:2])\n \n # check safety of route-----------------------\n if phi == 0:\n safe = self.dubins.is_straight_route_safe(nearest.pos, pos)\n else:\n d, c, r = self.car.get_params(nearest.pos, phi)\n safe = self.dubins.is_turning_route_safe(nearest.pos, pos, d, c, r)\n # --------------------------------------------\n \n if not safe:\n continue\n \n new_node = Node(pos, phi, i+1)\n \n if new_node in nodes:\n continue\n \n new_node.branch = branch\n new_node.parent = nearest\n nodes.append(new_node)\n \n route = self.backtracking(final_node) + dubins_route\n path = self.car.get_path(self.car.start_pos, route)\n print('Total iteration:', count)\n \n return path, nodes","def action(self):\n\n self.start_timer()\n\n minimax_probability = self.norm.cdf(self.root.branching)\n use_minimax = boolean_from_probability(minimax_probability)\n if self.time_consumed > 53:\n # Time is starting to run low, use the faster option\n use_minimax=True\n\n if self.time_consumed < 59:\n if self.root.turn < 4:\n result = book_first_four_moves(self.root)\n elif use_minimax:\n result = minimax_paranoid_reduction(self.root)\n else:\n result = monte_carlo_tree_search(\n self.root,\n playout_amount=3,\n node_cutoff=4,\n outer_cutoff=4,\n num_iterations=1200,\n turn_time=0.75,\n exploration_constant=1.7,\n use_slow_culling=False,\n verbosity=0,\n use_prior=True,\n num_priors=4,\n use_fast_prune_eval=False,\n use_fast_rollout_eval=False,\n )\n else:\n result = greedy_choose(self.root)\n\n self.end_timer()\n\n return result","def aStarSearch(problem, heuristic=nullHeuristic):\n \"*** YOUR CODE HERE ***\"\n\n #Creamos las estructuras de datos necesarias (priority queue y set)\n openNodes = util.PriorityQueue()\n closedNodes = set([])\n\n #Guardamos el nodo inicial\n node = Node(problem.getStartState(), '', 0, None)\n\n #Calculamos funcion heuristica y el coste acumulado para sacar la funcion de evaluacion del nodo inicial\n fn = problem.getCostOfActions(node.path) + heuristic(node.name, problem);\n\n #Lo metemos en la cola con su funcion de evaluacion como prioridad\n openNodes.push(node, fn)\n\n #Iteramos para cada nodo\n while True:\n if openNodes.isEmpty():\n break #ERROR: throw exception\n else :\n #sacamos el nodo de arriba de la cola\n node = openNodes.pop()\n if problem.isGoalState(node.name): #Comprobamos si el nodo es Goal. Si lo es terminamos.\n break\n else: #Expandimos los nodos sucesores del nodo si no estan en closed\n if nodeIsClosed(node, closedNodes) is False:\n for successor in problem.getSuccessors(node.name):\n n, p, c = successor\n succNode = Node(n, p, c, node)\n if nodeIsClosed(succNode, closedNodes) is False:\n fn = problem.getCostOfActions(findPath(succNode)) + heuristic(succNode.name, problem);\n openNodes.push(succNode, fn)\n #Metemos el nodo en closed\n closedNodes.add(node)\n\n #Devolvemos el camino al Goal\n return findPath(node)","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n from util import Stack\n Pilha_Caminho = Stack()\n Pilha_Estados = Stack()\n Caminho = []\n Visitados = []\n\n Pilha_Caminho.push(Caminho) # empilha caminho (vazio, no começo)\n Pilha_Estados.push(problem.getStartState()) # empilha estado inicial\n\n while (Pilha_Caminho.isEmpty() == False and Pilha_Estados.isEmpty() == False):\n Caminho_Andado = Pilha_Caminho.pop() # atualiza caminho\n Estado_Atual = Pilha_Estados.pop() # atualiza estado\n if problem.isGoalState(Estado_Atual): # caso estado atual seja o desejado,\n return Caminho_Andado # retorna o caminho total\n if Estado_Atual not in Visitados: # caso estado atual não tenha sido visitado\n Visitados.append(Estado_Atual) # marca estado como visitado\n for Sucessor in problem.getSuccessors(Estado_Atual): # busca sucessores\n if Sucessor[0] not in Visitados: # caso sucessor não tenha sido visitado\n Pilha_Caminho.push(Caminho_Andado + [Sucessor[1]]) # atualiza caminho total na pilha\n Pilha_Estados.push(Sucessor[0]) # atualiza estado\n return","def depthOrBreadthFirstSearch(problem, container):\n firstNode = (problem.getStartState(), None, 0, None)#state, action to reach, incremental cost, parent node\n container.push(firstNode)\n visitedStates = []\n while (not container.isEmpty()):\n if problem.getNodesExpandedNum() > MAX_NODES_TO_EXPLORE:\n return None\n curNode = container.pop()\n if (problem.isGoalState(curNode[0])):\n return getStatePathFromNode(curNode, problem)\n for successor in problem.getSuccessors(curNode[0]):\n if not successor[0] in visitedStates:\n successorNode = (successor[0], successor[1], successor[2], curNode)\n visitedStates.append(successor[0])\n container.push(successorNode)\n return None","def search(self, board, depth, ply=0):\n self.inc('nodes')\n\n if board.end is not None:\n return self.endscore(board, ply)\n\n if depth <= 0:\n self.inc('leaves')\n return [], self.evaluate(board)\n\n bestmove = []\n bestscore = -INF\n for m in board.moves:\n board.push(m)\n nextmoves, score = self.search(board, depth - 1, ply + 1)\n board.pop()\n score = -score\n # print(board.fen(), score)\n if not bestmove or score >= bestscore:\n bestscore = score\n bestmove = [m] + nextmoves\n\n return bestmove, bestscore","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n # initialize frontier using initial state of problem\n current_state = problem.getStartState()\n frontier = util.Queue()\n frontier.push(current_state)\n\n # initialize explored set to be empty\n explored_set = []\n\n # a dictionary to save how to get to certain states from initial state\n actions_list = {current_state:[]}\n\n # loop while we still have unexplored nodes\n while not frontier.isEmpty():\n\n # choose a leaf node and remove it from frontier\n leaf_node = frontier.pop()\n\n # add the node to explored set\n explored_set.append(leaf_node)\n\n # expand the chosen node\n # and add to the frontier if not in frontier and explored set\n for successor in problem.getSuccessors(leaf_node):\n child, action, _ = successor\n if child not in explored_set and child not in frontier.list:\n # return the solution if it is the goal state\n if problem.isGoalState(child):\n return actions_list[leaf_node] + [action]\n frontier.push(child)\n actions_list[child] = actions_list[leaf_node] + [action]\n else:\n # search through all but still can't find a solution -> failed!\n return 'failure'","def Find_Path(self):\n closed_nodes_map = [] # map of closed (tried-out) nodes\n open_nodes_map = [] # map of open (not-yet-tried) nodes\n dir_map = [] # map of directions\n row = [0] * self.n\n for i in range(self.m): # create 2d arrays\n closed_nodes_map.append(list(row))\n open_nodes_map.append(list(row))\n dir_map.append(list(row))\n \n pq = [[], []] # priority queues of open (not-yet-tried) nodes\n pqi = 0 # priority queue index\n # create the start node and push into list of open nodes\n n0 = node(self.xStart, self.yStart, 0.0, 0.0)\n n0.updatePriority(self.xFinish, self.yFinish)\n heappush(pq[pqi], n0)\n open_nodes_map[self.yStart][self.xStart] = n0.priority # mark it on the open nodes map\n \n # A* search\n while len(pq[pqi]) > 0:\n # get the current node w/ the highest priority\n # from the list of open nodes\n n1 = pq[pqi][0] # top node\n n0 = node(n1.xPos, n1.yPos, n1.distance, n1.priority)\n x = n0.xPos\n y = n0.yPos\n heappop(pq[pqi]) # remove the node from the open list\n open_nodes_map[y][x] = 0\n # mark it on the closed nodes map\n closed_nodes_map[y][x] = 1\n \n # quit searching when the goal state is reached\n if x == self.xFinish and y == self.yFinish:\n # Generate the path from finish to start by following the \n # directions.\n return self.Reconstruct_Path(dir_map)\n \n # generate moves (child nodes) in all possible directions\n for i in range(self.num_directions):\n new_x = x + self.dx[i]\n new_y = y + self.dy[i]\n Flag=True\n if not (new_x < 0 or new_x > self.n-1 or new_y < 0 or new_y > self.m - 1\n or self.MAP[new_y][new_x] == 1 or closed_nodes_map[new_y][new_x] == 1):\n # Check to see if the extended path runs through any obstacles\n if (abs(self.dx[i])>1 or abs(self.dy[i])>1):\n # Need to check that the path does not pass an object\n JumpCells=2*max(abs(self.dx[i]),abs(self.dy[i]))-1\n for K in range(1,JumpCells):\n YPOS=int(round(K*1.0*self.dy[i]/JumpCells))\n XPOS=int(round(K*1.0*self.dx[i]/JumpCells))\n if (self.MAP[y+YPOS][x+XPOS]==1):\n Flag=False\n if Flag: \n # generate a child node\n m0 = node(new_x, new_y, n0.distance, n0.priority)\n m0.calc_cost(self.dx[i], self.dy[i])\n m0.updatePriority(self.xFinish, self.yFinish)\n # if it is not in the open list then add into that\n if open_nodes_map[new_y][new_x] == 0:\n open_nodes_map[new_y][new_x] = m0.priority\n heappush(pq[pqi], m0)\n # mark its parent node direction\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\n elif open_nodes_map[new_y][new_x] > m0.priority:\n # update the priority info\n open_nodes_map[new_y][new_x] = m0.priority\n # update the parent direction info\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\n # replace the node\n # by emptying one pq to the other one\n # except the node to be replaced will be ignored\n # and the new node will be pushed in instead\n while not (pq[pqi][0].xPos == new_x and pq[pqi][0].yPos == new_y):\n heappush(pq[1 - pqi], pq[pqi][0])\n heappop(pq[pqi])\n heappop(pq[pqi]) # remove the wanted node\n # empty the larger size pq to the smaller one\n if len(pq[pqi]) > len(pq[1 - pqi]):\n pqi = 1 - pqi\n while len(pq[pqi]) > 0:\n heappush(pq[1-pqi], pq[pqi][0])\n heappop(pq[pqi]) \n pqi = 1 - pqi\n heappush(pq[pqi], m0) # add the better node instead\n return '','' # no route found","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n # Frontier stored in a Stack\n frontier = util.Stack()\n\n # Visited states stored in a list\n visitedStates = []\n\n # Format of each element: (current coordinates, [path taken to get there]) \n frontier.push((problem.getStartState(), []))\n\n # while there are still states to explore\n while not frontier.isEmpty():\n \n # store the current state and path in separate variables\n currentState, pathTaken = frontier.pop()\n\n # for skipping states that have already been visited\n if currentState in visitedStates:\n continue\n\n # for returning the correct path to the goal state upon discovering it\n if problem.isGoalState(currentState):\n return pathTaken\n\n # count the current state as \"visited\"\n visitedStates.append(currentState)\n\n # for each successor state, check whether they have already been visited. if not, add their coordinates to the frontier, and append their respective direction to the path list\n for coordinates, direction, cost in problem.getSuccessors(currentState):\n\n if coordinates not in visitedStates:\n \n frontier.push((coordinates, pathTaken + [direction]))\n\n\n util.raiseNotDefined()","def depthFirstSearch(problem):\n \n from game import Directions\n North = Directions.NORTH\n South = Directions.SOUTH\n East = Directions.EAST\n West = Directions.WEST \n \n pathDict = {}\n visited = set()\n #visited start\n visited.add(problem.getStartState())\n #initial successors\n successor = problem.getSuccessors(problem.getStartState())\n for initSucc in successor:\n pathDict[initSucc[0]] = [initSucc[1]]\n #loop\n while (1):\n #if fringe = null, return failure\n if (len(successor) == 0):\n print \"Fringe is empty\"\n return util.raiseNotDefined()\n #(v, path) = fringe.pop\n succLocation = successor[0][0]\n succDirection = successor[0][1]\n del successor[0]\n #if isGoal = true, return path\n if problem.isGoalState(succLocation):\n return pathDict[succLocation]\n #if visited = false\n if succLocation not in visited:\n #visited = true\n visited.add(succLocation)\n #L = expand(v,path)\n tempSuccList = problem.getSuccessors(succLocation)\n #Fringe <- L\n for succ in reversed(tempSuccList):\n successor.insert(0,succ)\n pathDict[succ[0]] = []\n pathDict[succ[0]].extend(pathDict[succLocation])\n pathDict[succ[0]].append(succ[1])","def a_star_search(problem, heuristic=null_heuristic):\r\n \"*** YOUR CODE HERE ***\"\r\n fringe = util.PriorityQueue()\r\n path = set()\r\n final = []\r\n acts = dict()\r\n state = problem.get_start_state()\r\n fringe.push(state, 0)\r\n\r\n while (True):\r\n state = fringe.pop()\r\n path.add(state)\r\n states = problem.get_successors(state)\r\n acts[state] = states[:]\r\n if problem.is_goal_state(state):\r\n break\r\n\r\n states = problem.get_successors(state)\r\n # push into fringe\r\n for stat in states:\r\n if stat[0] not in path:\r\n \"\"\"\r\n it does worse in corners problems, to work better needs heavy huristic, not worth in\r\n in corners problem expandend nodes grow expo\r\n all others are better\r\n counter = 0 # in some situation it helps, in some it doesnt\r\n #print(stat[0].pieces)\r\n for x in stat[0].pieces[0]:\r\n if x:\r\n counter += 1\r\n \"\"\"\r\n counter = 0\r\n fringe.push(stat[0], stat[2] + counter + heuristic(stat[0], problem)) # problem.get_cost_of_actions([stat[1]])\r\n\r\n while (True):\r\n\r\n for key, val in acts.items():\r\n for va in val:\r\n if va[0] == state:\r\n final.append(va[1])\r\n state = key\r\n break\r\n else:\r\n continue\r\n break\r\n if state == problem.get_start_state():\r\n break\r\n\r\n final.reverse()\r\n\r\n return final","def breadth_first_search(root_node):\n if root_node.goal_test():\n return root_node\n\n frontier = [root_node]\n explored = []\n\n while frontier:\n node = frontier.pop(0)\n explored.append(node)\n\n for successor in node.generate_successors():\n if not successor:\n continue\n if not (successor.is_in(frontier) and successor.is_in(explored)):\n if successor.goal_test():\n return successor\n frontier.append(successor)\n return None # No Solution","def depthFirstSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n e = Directions.EAST\n \n visitedlist = []\n st = Stack()\n outputlist = []\n st.push(problem.getStartState())\n visitedlist.append(problem.getStartState())\n recurseDFS(st,problem,visitedlist)\n if st.isEmpty():\n print \"No Path exist\"\n else:\n while not st.isEmpty():\n value = st.pop()\n if len(value) == 2:\n continue\n if value[1] == 'South':\n outputlist.append(s)\n elif value[1] == 'North':\n outputlist.append(n)\n elif value[1] == 'East':\n outputlist.append(e)\n elif value[1] == 'West':\n outputlist.append(w)\n \n return outputlist[::-1]","def breadth_first_graph_search(problem):\n node = Node(problem.initial)\n if problem.goal_test(node.state):\n return node\n frontier = collections.deque([node])\n explored = set()\n while frontier:\n node = frontier.popleft()\n explored.add(node.state)\n for child in node.expand(problem):\n if child.state not in explored and child not in frontier:\n if problem.goal_test(child.state):\n return child\n frontier.append(child)\n return None","def search(state, cut_value, game, prune=True):\n print (game.step)\n f = open(\"search_tree_\" + str(game.step) + \".txt\", 'w')\n\n def max_value(state, alpha, beta, depth, node):\n start = time.time()\n if game.cutoff(state, depth):\n return game.evaluate(state), None\n val = -inf\n action = None\n pre_val = game.evaluate(state)\n print (\"pre \" + str(pre_val))\n for a, s in game.successors(state):\n #print (str(a))\n cur_val = game.evaluate(s)\n #print (str(a) + ':' + str(cur_val))\n node_child = Search_node(node, a, cur_val)\n node.add_child(node_child)\n if cur_val > pre_val + cut_value:\n v, _ = min_value(s, alpha, beta, depth + 1, node_child)\n f.write(\"a: \" + str(a) + \"; v: \" + str(v) + \"; depth:\" + \\\n str(depth) + \"; alpha:\" + str(alpha) + \"; beta:\" + str(beta) \\\n + \" \\n\")\n else:\n v = cur_val\n if v > val:\n val = v\n action = a\n if prune:\n if v >= beta:\n return v, a\n alpha = max(alpha, v)\n end = time.time()\n print(\"max t:\" + str(end - start))\n return val, action\n\n def min_value(state, alpha, beta, depth, node):\n if game.cutoff(state, depth):\n return game.evaluate(state), None\n val = inf\n action = None\n pre_val = game.evaluate(state)\n print (\"min pre \" + str(pre_val))\n for a, s in game.successors(state):\n cur_val = game.evaluate(s)\n node_child = Search_node(node, a, cur_val)\n node.add_child(node_child)\n if cur_val < pre_val - cut_value:\n v, _ = max_value(s, alpha, beta, depth + 1, node_child)\n # f.write(\"a: \" + str(a) + \"; v: \" + str(v) + \"; depth:\" + \\\n # str(depth) + \"; alpha:\" + str(alpha) + \"; beta:\" + str(beta) + \" \\n\")\n else:\n v = cur_val\n if v < val:\n val = v\n action = a\n if prune:\n if v <= alpha:\n return v, a\n beta = min(beta, v)\n return val, action\n\n root_node = Search_node(None, None, 0)\n\n _, action = max_value(state, -inf, inf, 0, root_node)\n root_node.print_tree()\n f.close()\n return action","def select(self):\n current = self.root\n actions = []\n while not current.is_leaf:\n # print(\"Selection... considering between:\")\n # print([\"{} ({:.2f})\".format(n, n.ucb) for n in current.visited_children])\n # print(\"Node's stats say that best child is {} ({})\".format(current.best_child, current.best_child.ucb))\n current = current.best_child\n actions.append(current.previous_action)\n # print(\"Selected\", current)\n # print()\n\n for a in actions:\n self.sim.play_action(a)\n # print(\"--------------------------------------\")\n return current","def aStarSearch(problem, heuristic=nullHeuristic):\n\t\"*** YOUR CODE HERE ***\"\n\n\t# Create the priority queue, and visited array to keep track of visited nodes.\n\tdfsStack = util.PriorityQueue()\n\tvisited = []\n\t# Get the first state in the graph, push to the priority queue\n\tfirst = problem.getStartState()\n\tdfsStack.push([first, [], 0], 0)\n\n\t# While the priority queue is not empty, pop the first node from the priority queue, and check if that state\n # is the goal state. If so, return the actions for that node. Otherwise, append that state\n # to the visited array, get its successors, and push them to the priority queue.\n\twhile not dfsStack.isEmpty():\n\t\tNewNode = dfsStack.pop()\n\t\tif((problem.isGoalState(NewNode[0]) == True)):\n\t\t\treturn NewNode[1]\n\t\tif(NewNode[0] not in visited):\n\t\t\tvisited.append(NewNode[0])\n\t\t\tfor NextNode in problem.getSuccessors(NewNode[0]):\n\t\t\t\tif NextNode[0] not in visited:\n\t\t\t\t\tcumulativeCost = NextNode[2] + NewNode[2]\n\t\t\t\t\theuristicCost = cumulativeCost + heuristic(NextNode[0], problem)\n\t\t\t\t\tdfsStack.push((NextNode[0], NewNode[1] + [NextNode[1]], cumulativeCost), heuristicCost)","def solve(start, goal, problem):\r\n explored = set()\r\n frontier = []\r\n node = Node(0, 0, start, None, None)\r\n # push the start node to the beam\r\n heappush(frontier, node)\r\n explorationPath = []\r\n\r\n while (True):\r\n # if all nodes in the beam are explored and path is not found, then\r\n # there exists no path.\r\n if len(frontier) == 0:\r\n return \"Path does not exists.\"\r\n\r\n prevnode = node\r\n node = heappop(frontier)\r\n\r\n if getBestNodeDistance(prevnode.state, node.state) > 1:\r\n explorationPath.extend(backtrackSearch(prevnode, node, problem))\r\n else:\r\n explorationPath.append(node.state)\r\n\r\n explored.add(node.state)\r\n # get the list of all possible actions on the state\r\n Actions = findActions(problem, node.state)\r\n # expand a node and generate children\r\n for action in Actions:\r\n # generate a child node by applying actions to the current state\r\n neighbour = generateChild(problem, goal, node, action)\r\n\r\n if neighbour != None:\r\n # goal test the current node\r\n if goalTest(neighbour, goal):\r\n explorationPath.append(goal)\r\n # get the solution(seq. of actions)\r\n return getExploredPath(explorationPath)\r\n\r\n # check if child is already explored or present in beam\r\n if neighbour not in frontier and neighbour.state not in explored:\r\n #add node to frontier only if it can contain within best k nodes\r\n heappush(frontier, neighbour)\r\n if(len(frontier) > BEAM_SIZE):\r\n del frontier[-1]","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n path_to_point = {}\n cost_to_point = {}\n\n # Get the start node\n start_node = problem.getStartState()\n fringe_node = [start_node]\n path_to_point[start_node] = []\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\n\n goal_found = False\n\n while(not goal_found):\n #for i in range(100): \n nodes_to_expand = set()\n # get max value node in the fringe node\n min_val = float(\"inf\")\n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] < min_val:\n min_val = cost_to_point[one_node]\n \n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] == min_val:\n nodes_to_expand.add(one_node)\n fringe_node.remove(one_node)\n\n # Expand the fringe node \n for one_node in nodes_to_expand:\n path_to_parent = path_to_point[one_node]\n for nxt_node in problem.getSuccessors(one_node):\n pos = nxt_node[0]\n mv = nxt_node[1]\n # check if point already present in path to point\n prev_cost = float(\"inf\")\n if pos in cost_to_point:\n prev_cost = cost_to_point[pos]\n new_path = path_to_parent + [mv]\n if prev_cost > problem.getCostOfActions(new_path):\n path_to_point[pos] = new_path\n cost_to_point[pos] = problem.getCostOfActions(new_path)\n fringe_node.append(pos)\n\n # Check if destination is reached in the fringe node\n for one_node in fringe_node:\n if problem.isGoalState(one_node):\n final_node = one_node\n goal_found = True\n break\n \n #print(len(fringe_node))\n print(final_node)\n print(path_to_point[final_node])\n return path_to_point[final_node] \n\n util.raiseNotDefined()","def AStar_search(problem, heuristic=nullHeuristic):\n root_node = Node(problem.getStartState(), [], 0, None, 0)\n frontier = util.PriorityQueue()\n frontier.push(root_node, 0 + heuristic(root_node.state, problem))\n explored = []\n nodes_list = list(problem.G.nodes)\n # heuristic_value = [heuristic(x,problem) for x in nodes_list]\n # print problem.start_node\n # print problem.end_node\n while not(frontier.isEmpty()):\n\n \tnode_to_explore = frontier.pop()\n \tif problem.isGoalState(node_to_explore.state):\n \t\t# recontruct_path\n \t\t# print \"Some thing\"\n \t\t# print node_to_explore.parent_node.state\n \t\troute_list = [node_to_explore.state]\n \t\tparent = node_to_explore.parent_node\n \t\twhile parent != None:\n \t\t\troute_list.append(parent.state)\n \t\t\tparent = parent.parent_node\n \t\troute_list.reverse()\n \t\t# print route_list\n \t\treturn route_list\n \telse:\n\t\t\tcopy_state = node_to_explore.state\n\t\t\t# successors_state = problem.getSuccessors(copy_state)\n\t\t\tif copy_state not in explored:\n\t\t\t\texplored.append(copy_state)\n\t\t\t\tsuccessors_state = problem.getSuccessors(copy_state)\n\t\t\t\tif len(successors_state) > 0:\n\t\t\t\t\tfor suc_act_cost in successors_state:\n\t\t\t\t\t\tif suc_act_cost[0] in explored:\n\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tcost = node_to_explore.path_cost + suc_act_cost[2]\n\t\t\t\t\t\t\tcost_with_heuristic = cost + heuristic(suc_act_cost[0], problem)\n\t\t\t\t\t\t\tfrontier.update(Node(suc_act_cost[0], suc_act_cost[1], cost , node_to_explore, node_to_explore.depth + 1), cost_with_heuristic)\n\t\t # util.raiseNotDefined()\n # print len(explored)","def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n from util import Stack\n \n st = Stack()\n mapper = {}\n mapper[problem.getStartState()] = None\n\n st.push(problem.getStartState())\n while not(st.isEmpty()):\n vertex = st.pop()\n \n if (problem.isGoalState(vertex)):\n c = vertex\n l = []\n while mapper[c] != None:\n tup = mapper[c]\n l.append(tup[1])\n c = tup[0]\n l.reverse()\n print l\n return l\n\n else:\n neigh = problem.getSuccessors(vertex)\n # neigh.reverse()\n # neigh.sort()\n for child in neigh:\n if child[0] not in mapper:\n st.push(child[0])\n mapper[child[0]] = (vertex, child[1])\n # print mapper\n \n # visited = []\n # p = dfsRecursive(problem, problem.getStartState(), st, visited, [])\n # return p\n \n # pathfind = {}\n # st.push(problem.getStartState())\n # iterative approach:\n # while (not st.isEmpty()):\n # point = st.pop() # (x,y)\n # if problem.isGoalState(point):\n # # print point\n # print pathfind\n # # print visited\n # elif (not (point in visited)):\n # visited.append(point)\n # # print pathfind, '\\n'\n # print visited, '\\n'\n # for child in problem.getSuccessors(point):\n # st.push(child[0])\n # pathfind[child[0]] = point #this preemptively adds!\n # util.raiseNotDefined()","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n # fringe priority queue\n fringe = util.PriorityQueue()\n fringe.push([problem.getStartState()],1) # fringe will have (priority, order, [s0,s1,..])\n\n # closed set\n closed = []\n\n i = 0\n while not fringe.isEmpty():\n\n # get highest priority path for expansion e.g. [s0,s2,s4]\n path_exp = fringe.pop()\n\n # take last node in path e.g. s4\n node_exp = path_exp[-1]\n\n # check goal state\n if problem.isGoalState(node_exp): # check if goal\n actions = actions_for_path(problem,path_exp)\n #import pdb; pdb.set_trace()\n return actions\n\n # add expanded node into closed set e.g. [s0,s1,s2]\n if node_exp not in closed:\n closed.append(node_exp)\n else:\n # if it's in the closed set, don't expand\n continue\n\n # get sucessors to expand fringe\n successors = problem.getSuccessors(node_exp)\n for successor in successors:\n # unpack states, actions\n ss,aa,_ = successor\n if ss not in closed:\n path = path_exp+[ss]\n # expand fringe by adding candidate paths, prioritize by len of path\n fringe.push(path,len(path))\n\n #i+=1\n if i==1000:\n import pdb; pdb.set_trace()\n\n util.raiseNotDefined()","def breadthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n visited=[]\n \n node=dict()\n start=problem.getStartState()\n node['parent']=None\n node['direction']=None\n node['state']=start\n \n \n qu.push(node)\n lis.append(node)\n \n print qu.list\n while qu.isEmpty()!=True:\n node=qu.pop()\n pos=node['state']\n visited.append(pos)\n print visited\n if problem.isGoalState(pos):\n print \"found\"\n return getPath(problem,node)\n #break\n suc=problem.getSuccessors(pos)\n if suc ==None:\n continue \n \n print suc\n for step in suc:\n #if step not in dic :\n if step[0] not in visited:\n childnode={}\n childnode['parent']=pos\n childnode['direction']=step[1]\n childnode['state']=step[0]\n qu.push(childnode)\n lis.append(childnode)\n \n\n #util.raiseNotDefined()","def bfs(board, start_position, start_actions, predicate):\n queue = Queue()\n visited = set()\n start_node = PositionNode(None, start_position, None)\n visited.add(start_position)\n # start actions are actions that have not been pruned\n for action in start_actions:\n next_pos = start_node.next(action)\n visited.add(next_pos)\n node = PositionNode(start_node, next_pos, action)\n queue.put(node)\n\n while not queue.empty():\n node = queue.get()\n if predicate.test(board, node.position):\n return node\n for action in [Action.Up.value, Action.Down.value, Action.Left.value, Action.Right.value]:\n next_pos = node.next(action)\n if valid_agent_position(board, next_pos) and next_pos not in visited:\n queue.put(PositionNode(node, next_pos, action))\n visited.add(next_pos)\n return None # no goal node found"],"string":"[\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n class Node:\\n def __init__(self, state, parent, action, pathCost):\\n self.state = state #state of the game\\n self.parent = parent #parent of the node\\n self.action = action #action that led to that node\\n self.pathCost = pathCost #total cost of tha path until that node\\n\\n def solution(self): #return the path to the goal node\\n path = [] #path is a list of actions\\n tempNode = self #temp node is the goal node\\n while tempNode.state != problem.getStartState(): #until we get to the initial node\\n path.insert(0, tempNode.action) #insert at the start of the list\\n tempNode = tempNode.parent #go to the parent of the node\\n return path #return list of actions\\n\\n def childNode(successor, parent, action, stepCost):\\n pathCost = parent.pathCost + stepCost #total cost is the total cost of the parent + the cost of the last action\\n child = Node(successor, parent, action, pathCost) #create new child node\\n return child\\n\\n initialNode = Node(problem.getStartState(), None, None, 0) #create initial node with start state and no parent\\n if problem.isGoalState(initialNode.state):\\n return initialNode.solution()\\n\\n frontier = util.Stack() #dfs uses a stack\\n frontier.push(initialNode) #insert initial node to the stack\\n explored = set() #explored nodes are added to a set\\n\\n while not frontier.isEmpty(): #while stack is not empty\\n nextNode = frontier.pop() #extract the last node entered\\n explored.add(nextNode.state) #add the state of the node to the explored set\\n for successor, action, stepCost in problem.getSuccessors(nextNode.state): #for every successor create a new child\\n child = childNode(successor, nextNode, action, stepCost)\\n if child.state not in explored and child not in frontier.list: #if child is not already explored or is not in the stack\\n if problem.isGoalState(child.state): # if node is goal node we return the path of actions\\n return child.solution()\\n frontier.push(child) #insert it into the stack\\n\\n return [] #if stack is empty\\n util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n #print \\\"Start:\\\", problem.getStartState()\\n #print \\\"Is the start a goal?\\\", problem.isGoalState(problem.getStartState())\\n #print \\\"Start's successors:\\\", problem.getSuccessors(problem.getStartState())\\n \\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n e = Directions.EAST\\n\\n #created a frontier Stack for DFS\\n #Here the stack acts as a LIFO stack\\n neighbourNodes = util.Stack()\\n #created a list of moves which will be returned in then end\\n moves = []\\n #pushed the start node and empty moves list, onto the frontier stack\\n neighbourNodes.push((problem.getStartState(),moves))\\n #this is a set of nodes which have been seen, to avoid adding nodes already visited \\n seenNodes = set()\\n #condition evaluated based on the existence of elements in the frontier stack\\n while not neighbourNodes.isEmpty():\\n #last node in the stack is popped and its state and action is stored\\n poppedNodeState, poppedNodeAction = neighbourNodes.pop()\\n #condition to check if the node is already been visited\\n if(poppedNodeState in seenNodes):\\n #if yes then it just skips the iteration using the continue statement\\n continue\\n #condition to check if the current node is the goal node\\n if problem.isGoalState(poppedNodeState):\\n #if yes then return the action or moves to be performed list\\n return poppedNodeAction\\n #if not visited before then node is added to the seenNodes set\\n seenNodes.add(poppedNodeState)\\n #loop to parse the successor nodes and check and add them to the frontier stack\\n for state, action, cost in problem.getSuccessors(poppedNodeState):\\n #checking if the successor node has already been visited before\\n if(state in seenNodes):\\n #if yes then it skips that node\\n continue\\n #else it adds that successor along with it action appeneded with the already existing actions\\n neighbourNodes.push((state, poppedNodeAction+[action]))\\n #the list of moves if finally returned\\n return moves\\n #util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from util import Stack\\n\\n frontier = Stack()\\n explored = []\\n actions = []\\n\\n class node:\\n def __init__(self, path, dad, action):\\n self.path = path\\n self.dad = dad\\n self.action = action\\n\\n start = node(problem.getStartState(),'','')\\n frontier.push(start)\\n\\n while frontier.isEmpty() == False:\\n path = frontier.pop()\\n successors = problem.getSuccessors(path.path)\\n explored.append(path)\\n for vertex in successors:\\n achou = False\\n for path_ex in explored:\\n if vertex[0] == path_ex.path:\\n achou = True\\n if achou == False:\\n successor = node(vertex[0],path.path,vertex[1])\\n frontier.push(successor)\\n if problem.isGoalState(successor.path):\\n while len(explored) > 0:\\n ant = explored.pop()\\n if ant.path == successor.dad:\\n actions.append(successor.action)\\n successor = ant\\n actions.reverse()\\n return actions\",\n \"def mcts_search(self, state):\\n assert state.current_player() == self.player\\n root = SearchNode(None, 1)\\n for _ in range(self.max_simulations):\\n visit_path, working_state = self._apply_tree_policy(root, state)\\n if working_state.is_terminal():\\n node_value = working_state.player_return(self.player)\\n else:\\n node_value = self.evaluator.evaluate(\\n working_state, self.player, self._random_state)\\n\\n for node in visit_path:\\n node.total_reward += node_value * node.player_sign\\n node.explore_count += 1\\n\\n most_visited = root.most_visited_child()\\n\\n if self.verbose:\\n print(\\\"Root:\\\", root.to_str())\\n print(\\\"Children:\\\")\\n print(root.children_str(working_state))\\n print(\\\"Children of chosen:\\\")\\n chosen_state = state.clone()\\n chosen_state.apply_action(most_visited.action)\\n print(most_visited.children_str(chosen_state))\\n\\n return most_visited.action\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n visited_nodes = []\\n start_node = problem.getStartState()\\n visited_nodes.append(start_node)\\n curr_node = start_node\\n q = util.Queue()\\n directions = util.Queue()\\n q.push(curr_node)\\n goal_found = problem.isGoalState(curr_node)\\n\\n while not goal_found:\\n nxt_node_list = problem.getSuccessors(curr_node)\\n nxt_node_found = False\\n\\n # Check if a child can be found which has not been visited\\n for node in nxt_node_list:\\n nxt_node = node[0]\\n move = node[1]\\n if nxt_node not in visited_nodes:\\n nxt_node_found = True # mark that a child node has been found\\n q.push(nxt_node) # add the node in the tree\\n directions.push(move) # add the direction\\n visited_nodes.append(nxt_node) # mark the node as visited\\n break\\n\\n # If child not found, go to parent\\n if not nxt_node_found:\\n q.list.pop(0)\\n directions.list.pop(0)\\n\\n if q.isEmpty(): break\\n\\n curr_node = q.list[0]\\n goal_found = problem.isGoalState(curr_node)\\n\\n final_moves = []\\n while not directions.isEmpty():\\n final_moves.append(directions.pop())\\n \\n return final_moves\\n #util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n mystack = util.Stack()\\n startNode = (problem.getStartState(), '', 0, [])\\n mystack.push(startNode)\\n visited = set()\\n while mystack :\\n node = mystack.pop()\\n state, action, cost, path = node\\n if state not in visited :\\n visited.add(state)\\n if problem.isGoalState(state) :\\n path = path + [(state, action)]\\n break;\\n succNodes = problem.expand(state)\\n for succNode in succNodes :\\n succState, succAction, succCost = succNode\\n newNode = (succState, succAction, cost + succCost, path + [(state, action)])\\n mystack.push(newNode)\\n actions = [action[1] for action in path]\\n del actions[0]\\n return actions\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n frontier = util.Stack()\\n start_node = problem.getStartState()\\n\\n if problem.isGoalState(start_node):\\n return ['Stop']\\n frontier.push((start_node,[]))\\n explored = set()\\n while True:\\n if frontier.isEmpty():\\n return []\\n node = frontier.pop()\\n explored.add(node[0])\\n for successor in problem.getSuccessors(node[0]):\\n nextState, action, cost = successor\\n if nextState in explored or nextState in [f[0] for f in frontier.list]:\\n continue\\n actions = node[1][:]\\n actions.append(action)\\n new_node = (nextState, actions)\\n if problem.isGoalState(new_node[0]):\\n return new_node[1]\\n frontier.push(new_node)\\n #print frontier.list\\n return []\",\n \"def search(self):\\r\\n #get the initial state\\r\\n initialState = State()\\r\\n \\r\\n #create root node\\r\\n rootNode = Node(initialState)\\r\\n \\r\\n #show the search tree explored so far\\r\\n treeplot = TreePlot()\\r\\n treeplot.generateDiagram(rootNode, rootNode)\\r\\n \\r\\n #perform search from root node\\r\\n self.performBacktrackSearch(rootNode, rootNode)\\r\\n \\r\\n rootNode.printTree()\",\n \"def solve(problem):\\n\\n # *** YOUR CODE HERE ***\\n\\n # The core of Iterative Deepening Search are iterations of Depth Limited\\n # Search with given increasing depth.\\n\\n # A recursive version of Depth Limited Search\\n def depth_limited_search(problem, limit):\\n \\\"\\\"\\\"\\n Return a list of nodes we traversed (or None).\\n :param problem: the starting set up.\\n :param limit: a given numeric depth limit.\\n :return: a list of nodes.\\n \\\"\\\"\\\"\\n\\n # in this case, we simply use a list to keep track of nodes we\\n # traversed, instead of the data structure, Stack.\\n path = list()\\n visited = set() # as before, to prevent duplicated nodes\\n root = problem.get_initial_state()\\n\\n def rec_dls(state, action, depth):\\n\\n visited.add(state)\\n\\n # if it is a goal\\n if problem.goal_test(state):\\n path.append((state, action))\\n return path\\n\\n # or if it reaches a certain depth, but not a goal\\n elif depth == 0:\\n visited.remove(state)\\n return None\\n\\n else:\\n path.append([state, action])\\n for successor, action, cost in problem.get_successors(state):\\n if successor not in visited:\\n # recursively expands the deepest node\\n res = rec_dls(successor, action, depth-1)\\n if res is not None:\\n return res\\n path.pop()\\n visited.remove(state)\\n\\n # \\\"Stared From the Bottom\\\" (root)\\n result = rec_dls(root, 'None', limit)\\n # return the path if the we DID have achieved something\\n if result is not None:\\n return path\\n\\n import sys\\n for depth in range(sys.maxsize): # depth from 0 to infinity\\n print(\\\"Lower-bound of the optimal cost is {}\\\".format(depth))\\n res2 = depth_limited_search(problem, depth)\\n if res2 is not None:\\n action_list = list()\\n for move in res2:\\n action_list.append(move[1]) # recall index 0 is the parent\\n # do not forget a None returned in iteration 0 (with depth 0)\\n action_list.remove('None')\\n return action_list\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n startState = problem.getStartState()\\n visitedNodes = []\\n actions = []\\n fringe = util.Stack()\\n cost = 0 \\n if (problem.isGoalState(startState) == True):#if startState is the goalState\\n return actions\\n else :\\n # Data Type Format : (currentState,actions,cost) based on errors I got :\\\\\\n fringe.push((startState,actions,cost))\\n while (fringe.isEmpty() == False) :\\n currentState , actions , cost = fringe.pop()\\n if(problem.isGoalState(currentState)):\\n return actions\\n \\n elif ((currentState in visitedNodes) == False ):\\n visitedNodes.append(currentState)\\n currentNodeSuccessors = problem.getSuccessors(currentState)\\n for node in currentNodeSuccessors :\\n state , action , cost = node\\n if ( (state in visitedNodes) == False ):\\n newNode = (state , actions + [action] , cost)\\n fringe.push(newNode)\\n \\n util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n '''\\n print \\\"Start:\\\", problem.getStartState()\\n print \\\"Is the start a goal?\\\", problem.isGoalState((2,2))\\n print \\\"Start's successors:\\\", problem.getSuccessors((1,1))\\n suc=problem.getSuccessors(problem.getStartState())\\n actionList=[]\\n stateList=[]\\n import random\\n randomNum=random.randrange(0,len(suc),1)\\n \\n \\n print len(suc)\\n #for i in range(1000):\\n while not problem.isGoalState(suc[randomNum][0]):\\n\\tprint randomNum\\n\\trandomNum=random.randrange(0,len(suc),1)\\n\\trandomAction=suc[randomNum][1]\\n\\t\\n \\t#print randomNum\\n\\tif suc[randomNum][0] not in stateList:\\n\\t\\tstateList.append(suc[randomNum][0])\\n\\t\\tactionList.append(randomAction)\\n \\t\\tsuc=problem.getSuccessors(suc[randomNum][0]) \\n \\n #actionList.append(suc[randomNum][0])\\n #if kiki==0:\\n print actionList\\n \\n return actionList\\n\\n\\n #util.raiseNotDefined()\\n '''\\n return DFS(problem,problem.getStartState(),[])\",\n \"def depthFirstSearch(problem):\\n\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n st = util.Stack()\\n strt = problem.getStartState()\\n st.push(strt) \\n visited = []\\n came_from ={}\\n came_from [strt] =(None,None)\\n\\n while not st.isEmpty():\\n state = st.pop()\\n if state in visited :\\n continue\\n visited.append(state)\\n if problem.isGoalState(state) :\\n break\\n nodes = problem.getSuccessors(state)\\n for (successor,action,cost) in nodes:\\n if successor not in visited :\\n st.push(successor)\\n came_from[successor] = (state , action) \\n \\n # exit while\\n actions = []\\n while(state != strt) :\\n (parent,action) =came_from[state]\\n state = parent\\n actions.append(action)\\n actions.reverse()\\n return actions\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n #Stack to hold the node that have been visited along with the path taken from the start node to reach that node.\\n stack = Stack()\\n #Set to hold the node explored.\\n explorednode = set()\\n #Get the start node.\\n startnode = problem.getStartState()\\n #Push the starting node on the Stack along with an empty set to know the direction in order to reach the node.\\n stack.push((startnode,[]))\\n #Loop till the stack is empty\\n while stack.isEmpty() is not True:\\n #Pop the currentnode and the direction from the stack\\n currentnode, direction = stack.pop()\\n #We will now add the node to set of explored node.\\n explorednode.add(currentnode)\\n #If the node is the goal. We made it!!\\n if problem.isGoalState(currentnode):\\n #print currentnode, direction\\n #The direction holds the way to reach till the goal from the start node.\\n #print direction\\n return direction\\n #Loop for each successor(child) of the current node.\\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\\n #If the successor(child) is not explored\\n if successor not in explorednode:\\n #Add the successor to the stack along with the path to reach it.\\n stack.push((successor, direction + [action]))\",\n \"def dfs( self ):\\n\\n #print self.state; \\n #print self.visited;\\n SearchProblem.stateVisited= SearchProblem.stateVisited+1 \\n \\n if self.stop: # check class variable and stop searching...\\n return;\\n\\n for action in self.edges(): # consider each edge leading out of this node\\n\\n action.destination.path = self.path + str(action.label); \\n # get the label associated with the\\n # action and append it to the path\\n # string\\n\\n action.destination.visited = self.visited.copy();\\n # make copy of source node's visited set\\n # and use it as destination node's\\n # visited set\\n\\n action.destination.visited.add( repr(action.destination.state) );\\n\\n if action.destination.is_target(): \\n # check if destination of edge is target node\\n action.destination.target_found(); # perform target found action\\n if not self.continue_search(): # stop searching if not required\\n SearchProblem.stop = True; # set class variable to record that we\\n break; # are done\\n\\n if repr(action.destination.state) in self.visited:\\n continue; # skip if we've visited this one before\\n\\n action.destination.dfs(); # resume recursive search \",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n #util.Stack() = LIFO for DFS\\n #travel down path until end of line unlike BFS, backtrack until there is another path\\n\\n visited = []\\n\\n frontier = util.Stack()\\n frontier.push( (problem.getStartState(), []) ) \\n\\n while not frontier.isEmpty():\\n node,actions = frontier.pop()\\n\\n if problem.isGoalState(node):\\n return actions\\n\\n visited.append(node)\\n\\n for coord,direction,cost in problem.getSuccessors(node):\\n if not coord in visited:\\n frontier.push((coord, actions + [direction]))\\n\\n return []\",\n \"def depthFirstSearch(problem):\\n\\t#print(\\\"Start:\\\", problem.getStartState())\\n\\t#print(\\\"Is the start a goal?\\\", problem.isGoalState(problem.getStartState()))\\n\\t#print(\\\"Start's successors:\\\", problem.getSuccessors(problem.getStartState()))\\n\\t\\n\\n\\t\\\"*** YOUR CODE HERE ***\\\"\\n\\n\\t# Create the stack, and visited array to keep track of visited nodes.\\n\\tdfsStack = util.Stack()\\n\\tvisited = []\\n\\t# Get the first state in the graph, push to the stack\\n\\tfirst = problem.getStartState()\\n\\tdfsStack.push([first, [], 0])\\n\\n\\t# While the stack is not empty, pop the first node from the stack, and check if that state\\n # is the goal state. If so, return the actions for that node. Otherwise, append that state\\n # to the visited array, get its successors, and push them to the stack.\\n\\twhile not dfsStack.isEmpty():\\n\\t\\tNewNode = dfsStack.pop()\\n\\t\\tif((problem.isGoalState(NewNode[0]) == True)):\\n\\t\\t\\treturn NewNode[1]\\n\\t\\tif(NewNode[0] not in visited):\\n\\t\\t\\tvisited.append(NewNode[0])\\n\\t\\t\\tfor NextNode in problem.getSuccessors(NewNode[0]):\\n\\t\\t\\t\\tif NextNode[0] not in visited:\\n\\t\\t\\t\\t\\tdfsStack.push((NextNode[0], NewNode[1] + [NextNode[1]], NextNode[2]))\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # initialize frontier using initial state of problem\\n current_state = problem.getStartState()\\n frontier = util.Stack()\\n frontier.push(current_state)\\n\\n # initialize explored set to be empty\\n explored_set = []\\n\\n # a dictionary to save how to get to certain states from initial state\\n actions_list = {current_state:[]}\\n\\n # loop while we still have unexplored nodes\\n while not frontier.isEmpty():\\n\\n # choose a leaf node and remove it from frontier\\n leaf_node = frontier.pop()\\n\\n # return the solution if it is the goal state\\n if problem.isGoalState(leaf_node):\\n return actions_list[leaf_node]\\n\\n # add the node to explored set\\n explored_set.append(leaf_node)\\n\\n # expand the chosen node\\n # and add to the frontier if not in frontier and explored set\\n for successor in problem.getSuccessors(leaf_node):\\n child, action, _ = successor\\n if child not in explored_set and child not in frontier.list:\\n frontier.push(child)\\n actions_list[child] = actions_list[leaf_node] + [action]\\n else:\\n # search through all but still can't find a solution -> failed!\\n return 'failure'\",\n \"def _search(self, node: Node, search_depth: int = 1) -> (float, list):\\n if not node.children or search_depth == 0:\\n return node.tot_reward / node.num_samples, []\\n elif search_depth == 1:\\n max_val = -math.inf\\n max_actions = []\\n for action, child in node.children.items():\\n node_val = child.tot_reward / child.num_samples\\n if node_val > max_val:\\n max_val = node_val\\n max_actions = [action]\\n elif node_val == max_val:\\n max_actions.append(action)\\n max_action = random.choice(max_actions)\\n child = node.children[max_action]\\n return child.tot_reward / child.num_samples, [max_action]\\n best_reward = -math.inf\\n best_act_seq = []\\n for action, child in node.children.items():\\n child_reward, child_act_seq = self._search(child, search_depth - 1)\\n if child_reward > best_reward:\\n best_act_seq = [action] + child_act_seq\\n best_reward = child_reward\\n return best_reward, best_act_seq\",\n \"def graph_search(self, initial_path, goal):\\n nodes_considered = 0\\n frontier = PathPriorityQueue([Path(initial_path, 0)])\\n explored = set()\\n while True:\\n if frontier.is_empty():\\n return \\\"FAIL\\\"\\n path = frontier.pop()\\n node = path.end\\n explored.add(node)\\n if node == goal:\\n return path\\n for action in self.ACTIONS(path):\\n print(str(action))\\n res = action.result(path)\\n if res not in explored:\\n new_path = path.combine(action)\\n frontier.add(new_path)\\n nodes_considered+=1\",\n \"def depthFirstSearch(problem):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n node = problem.getStartState()\\r\\n if (problem.isGoalState(node)):\\r\\n return [] # no need to make any moves of the start state is goal\\r\\n start = (node, 'NoDirection',0)\\r\\n\\r\\n frontier_queue = Stack() # queue for frontier\\r\\n frontier_queue.push(start) # frontier consists of only the start state\\r\\n\\r\\n explored_nodes = set()\\r\\n explored_track = {start:None} # keep a track of parent, parent of root node is None\\r\\n\\r\\n while not frontier_queue.isEmpty():\\r\\n state = frontier_queue.pop() # pop the top element from the queue \\r\\n explored_nodes.add(state)\\r\\n\\r\\n if problem.isGoalState(state[0]):\\r\\n return get_track(explored_track, state)\\r\\n\\r\\n neighbors_state = problem.getSuccessors(state[0])\\r\\n for neighbor in neighbors_state: # neighbor will be something like this ((34, 15), 'South', 1)\\r\\n if neighbor not in frontier_queue.list and neighbor not in explored_nodes:\\r\\n frontier_queue.push(neighbor)\\r\\n explored_track[neighbor] = state\\r\\n\\r\\n\\r\\n def get_track(explored_track, state):\\r\\n from game import Directions\\r\\n track_history = [state]\\r\\n track_history_direction = []\\r\\n leaf = state\\r\\n while (explored_track[leaf]) != start:\\r\\n track_history.append(explored_track[leaf])\\r\\n leaf = explored_track[leaf]\\r\\n\\r\\n for j in range (len(track_history),-1,-1):\\r\\n this_step = track_history[j-1]\\r\\n this_step = this_step[1]\\r\\n track_history_direction.append(this_step)\\r\\n return track_history_direction[:-1]\",\n \"def depthFirstSearch(problem):\\n #\\\"*** YOUR CODE HERE ***\\\"\\n\\n \\\"\\\"\\\"\\n Pseudocode:\\n function G RAPH-S EARCH ( problem) returns a solution, or failure\\n initialize the frontier using the initial state of problem\\n initialize the explored set to be empty\\n loop do\\n if the frontier is empty then return failure\\n choose a leaf node and remove it from the frontier\\n if the node contains a goal state then return the corresponding solution\\n add the node to the explored set\\n expand the chosen node, adding the resulting nodes to the frontier\\n only if not in the frontier or explored set\\n\\n \\\"\\\"\\\"\\n frontier = util.Stack()\\n #print 'Create frontier'\\n initial_node = node(problem.getStartState(), 0, [], 0)#(state,depth,path_actions,path_cost)\\n frontier.push(initial_node)\\n #print 'Push ',repr(initial_node.state)\\n frontierSet = set([initial_node.state])\\n explored = set() #initialize the explored set to be empty\\n\\n while True:\\n if frontier.isEmpty() == True: raise Exception, \\\"The frontier was emptied\\\"#if the frontier is empty then return failure\\n currNode = frontier.pop()#HERE1\\n frontierSet.remove(currNode.state)\\n #print 'Remove',repr(currNode.state)\\n #print 'State: ' + repr(currNode.state) + '. Depth: ' + repr(currNode.depth) + '. Path Cost: ' + repr(currNode.path_cost) + '. Path Actions: ' + repr(currNode.path_actions) + '.\\\\n'\\n if problem.isGoalState(currNode.state) == True:\\n print 'Goal reached!'\\n return currNode.path_actions\\n explored.add(currNode.state)\\n for succ in problem.getSuccessors(currNode.state):\\n #print 'Succ: ',repr(succ[0])\\n succNode = node(succ[0], currNode.depth + 1, currNode.path_actions + [succ[1],], currNode.path_cost + succ[2])\\n if (succNode.state not in explored):\\n # Si hacemos estas verificaciones entonces cuando se encuentra que un estado que se quiere expandir ya esta en la frontera\\n # eliminamos ese estado de la frontera y lo expandimos ahora. Osea, damos prioridad a los nodos nuevos\\n if(succNode.state in frontierSet):\\n # Recurso'i:\\n for frontierNode in frontier.list:\\n if frontierNode.state == succNode.state:\\n frontier.list.remove(frontierNode)\\n frontierSet.remove(frontierNode.state)\\n # if ((succNode.state not in explored) and (succNode.state not in frontierSet)): \\n # Alternativa segun el libro. Lo que se hace es que se da prioridad a los nodos viejos.\\n\\n # Aca no verificaba si ya esta en la frontera porque alteraba el orden en el que se visitan los nodos.\\n # Por ejemplo cuando esta pendiente (se genero pero no se expandio) un hijo con un estado,\\n # pero en un nivel mas profundo se vuelve a generar el mismo estado y se tiene que expandir.\\n # Si seguimos el DFS creo que tendriamos que expandir ese nodo ahi y no en la primera llamada donde quedo pendiente.\\n \\n frontier.push(succNode)\\n #print 'Push ',repr(succNode.state)\\n frontierSet.add(succNode.state)\\n\\n #util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n stack = Stack()\\n\\n visited = []\\n parent_dict = dict()\\n start_state = problem.getStartState()\\n stack.push(start_state)\\n current_path = []\\n actions_dict = dict()\\n final_actions = []\\n flag = False\\n\\n if problem.isGoalState(problem.getStartState()):\\n return []\\n\\n while not stack.isEmpty():\\n current_state = stack.pop()\\n current_path.append(current_state)\\n visited.append(current_state)\\n\\n if problem.isGoalState(current_state):\\n break\\n\\n successors = problem.getSuccessors(current_state)\\n\\n for s in successors:\\n flag = False\\n if s[0] not in visited:\\n stack.push(s[0])\\n parent_dict[s[0]] = current_state\\n actions_dict[(current_state, s[0])] = s[1]\\n flag = True\\n\\n\\n\\n if not successors and not stack.isEmpty() or flag is False:\\n current_state = stack.pop()\\n while current_path[-1] != parent_dict[current_state]:\\n current_path.pop()\\n stack.push(current_state)\\n\\n for i in range(len(current_path)-1):\\n final_actions.append(actions_dict[current_path[i],current_path[i+1]])\\n\\n\\n return final_actions\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n # current path stack\\n path_stack = util.Stack()\\n action_stack = util.Stack()\\n path_stack.push(problem.getStartState())\\n\\n # visited (so don't )\\n visited = []\\n visited.append(problem.getStartState())\\n\\n i = 0\\n while not path_stack.isEmpty():\\n\\n # check goal state\\n if problem.isGoalState(path_stack.list[-1]): # check if goal\\n return action_stack.list\\n\\n # get next possible state (choose first in list)\\n successors = problem.getSuccessors(path_stack.list[-1])\\n forward=False\\n for successor in successors:\\n ss,aa,_ = successor\\n if ss not in visited:\\n\\n path_stack.push(ss)\\n action_stack.push(aa)\\n visited.append(ss) # you don't pop visited\\n forward=True\\n break\\n\\n # backtrack\\n if forward==False:\\n path_stack.pop()\\n action_stack.pop()\\n\\n i+=1\\n #if i==25:\\n # import pdb; pdb.set_trace()\\n #print(path_stack.list)\",\n \"def depthFirstSearch(problem):\\n #Initializing variables\\n fringe = util.Stack()\\n #Creating visited list\\n visited = []\\n #Pushing start state to Stack\\n fringe.push((problem.getStartState(), []))\\n #Adding start state to visited list\\n visited.append(problem.getStartState())\\n \\n #Popping point from the stack\\n while fringe.isEmpty() == False:\\n state, actions = fringe.pop()\\n #Getting successor nodes\\n for next in problem.getSuccessors(state):\\n newstate = next[0]\\n newdirection = next[1]\\n #Pushing successor nodes to the stack and appending to visited\\n if newstate not in visited:\\n if problem.isGoalState(newstate):\\n return actions + [newdirection] \\n else:\\n fringe.push((newstate, actions + [newdirection]))\\n visited.append(newstate)\\n\\n util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n \\\"\\\"\\\"\\n ALGORITH FOR DFS\\n \\n function graph-search(problem, fringe) retuen a sloution or failure\\n \\n closed <-- an empty set\\n fringe <-- insert (make-node (initial-state [problem]), fringe)\\n \\n loop do :\\n if fringe is empty then return failure\\n node <-- Remove-front (fringe)\\n if goal-test (problem, state[node]) then return node\\n if state[node] is not in closed then \\n add STATE[node] to closed\\n for child-node in EXPAND(STATE[node],problem) do\\n fringe <-- Insert (child-node, fringe)\\n end\\n end\\n \\\"\\\"\\\"\\n\\n templist=[]\\n explored = set()\\n fringe = util.Stack()\\n #print \\\"the stat node is : \\\", problem.getStartState()\\n\\n fringe.push((problem.getStartState(),templist))\\n while (not fringe.isEmpty()):\\n (currentNode,currDir) = fringe.pop()\\n # print \\\"Pacman is currently at : \\\", currentNode\\n if problem.isGoalState(currentNode):\\n # print \\\" Goal State Found : \\\", currentNode\\n pathToGoal = currDir\\n break\\n if not (currentNode in explored):\\n # print \\\"Adding current node to explored\\\"\\n explored.add(currentNode)\\n for childNode in problem.getSuccessors(currentNode):\\n # print \\\"child node : \\\", childNode , \\\" is added \\\"\\n fringe.push((childNode[0],currDir+[childNode[1]]))\\n\\n return pathToGoal\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n class Node:\\n def __init__(self, state, parent, action, pathCost):\\n self.state = state\\n self.parent = parent\\n self.action = action\\n self.pathCost = pathCost\\n\\n def solution(self):\\n path = list()\\n tempNode = self\\n while tempNode.state != problem.getStartState():\\n path.insert(0, tempNode.action)\\n tempNode = tempNode.parent\\n return path\\n\\n def __eq__(self, other):\\n if isinstance(other, Node):\\n return self.state == other.state\\n\\n\\n def childNode(successor, parent, action, stepCost):\\n pathCost = parent.pathCost + stepCost\\n child = Node(successor, parent, action, pathCost)\\n return child\\n\\n initialNode = Node(problem.getStartState(), None, None, 0)\\n frontier = util.PriorityQueue() #bfs uses a queue\\n frontier.push(initialNode, initialNode.pathCost + heuristic(initialNode.state, problem)) #we use f(n) = pathCost + h(n) for the best solution\\n explored = set()\\n\\n while not frontier.isEmpty() :\\n nextNode = frontier.pop() #extract from the start of the queue\\n if problem.isGoalState(nextNode.state):\\n return nextNode.solution()\\n explored.add(nextNode.state)\\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\\n child = childNode(successor, nextNode, action, stepCost)\\n if child.state not in explored:\\n frontier.update(child, child.pathCost + heuristic(child.state, problem))\\n return []\\n util.raiseNotDefined()\",\n \"def graph_search(problem, open_nodes):\\n explored = [problem.initial]\\n open_nodes.append(Node(problem.initial))\\n while len(open_nodes) > 0:\\n node = open_nodes.pop()\\n if problem.goal_test(node.state):\\n #print \\\"Path cost: %d\\\" % node.path_cost\\n return node.solution()\\n for child in node.expand(problem):\\n if child.state not in explored:\\n open_nodes.append(child)\\n explored.append(child.state)\\n return None\",\n \"def graph_search(state, goal_state, height_limit):\\n frontier = []\\n heapq.heappush(frontier, problem_search_node.SearchNode(state, None, None, 0, 0))\\n explored_set = set()\\n while frontier:\\n current_node = heapq.heappop(frontier)\\n if utils.is_goal_state(current_node.state, goal_state):\\n return utils.create_path_to_goal(current_node)\\n explored_set.add(current_node.state.key())\\n actions = current_node.state.possible_actions(explored_set, height_limit)\\n for node in [current_node.child_node(action, height_limit, cons_heuristic, goal_state) for action in actions]:\\n heapq.heappush(frontier, node)\\n return (-1, [])\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n from game import Directions\\n visited = set() # unique elements\\n state = problem.getStartState()\\n #returns starting agent's position\\n waiting_list = util.Stack()\\n # LIFO\\n # last in first out\\n # parents = collections.defaultdict(collections.UserDict)\\n parents = {}\\n #dictionary\\n sequence = []\\n #LIFO\\n for action in problem.getSuccessors(state):\\n # in order to push full-state values\\n waiting_list.push(action)\\n # enumarating tuple\\n\\n while not waiting_list.isEmpty():\\n state = waiting_list.pop()\\n \\n visited.add(state[0])\\n # node is visited and we wont visit those nodes\\n \\n for substate in problem.getSuccessors(state[0]):\\n # take a look to successors of current node\\n \\n if substate[0] not in visited:\\n # if not in visited \\n # saving parents\\n parents[substate[0]]={'parent':state} \\n # generate new node\\n waiting_list.push(substate)\\n # push to stack\\n if problem.isGoalState(substate[0]): \\n target_state = substate \\n #finding wayback\\n\\n\\n while target_state[0] in parents.keys():\\n temp=parents[target_state[0]]['parent']\\n sequence.append(target_state[1])\\n target_state = temp\\n sequence.append(target_state[1])\\n return sequence[::-1]\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # util.raiseNotDefined()\\n\\n # print(\\\"Start:\\\", problem.getStartState())\\n # print(\\\"Is the start a goal?\\\", problem.isGoalState(problem.getStartState()))\\n # print(\\\"Start's successors:\\\", problem.getSuccessors(problem.getStartState()))\\n\\n # Initialize a frontier, and push the initial state into the frontier\\n frontier = util.Stack()\\n frontier.push([(problem.getStartState(), 'move', 0)])\\n # Initialize a explored set to store the visited nodes\\n exploredSet = set()\\n\\n # Check the content of frontier\\n while not frontier.isEmpty():\\n stateList = list()\\n stateList = frontier.pop()\\n # print (stateList)\\n # What we focus on is the next state, not the (previous state + next state), so we should take the last element\\n nextState = stateList[len(stateList) - 1]\\n # Check the current state is goal or not\\n if problem.isGoalState(nextState[0]):\\n # Initial a path, which is the way to the goal state\\n path = list()\\n for eachMove in stateList:\\n path.append(eachMove[1])\\n # If the initial state is the goal state, there's no need to explore other nodes, so that's called special condition\\n if len(path) == 1:\\n return path[0]\\n # This is the normal condition, we should convey the path except the first one, because we haven't define what's \\\"move\\\"\\n else:\\n return path[1:]\\n # If this is a state which we don't visit, add it to the explored set(this is called GSA)\\n if not nextState[0] in exploredSet:\\n exploredSet.add(nextState[0])\\n # Give me your child nodes\\n for childState in problem.getSuccessors(nextState[0]):\\n nextStateList = stateList[:]\\n # we focus on the path, so we have to record the every move from the initial state to the current one\\n nextStateList.append(childState)\\n frontier.push(nextStateList)\\n\\n # Or maybe there's no way to the goal state\\n else:\\n return \\\"There's no way.\\\"\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n class Node:\\n def __init__(self, state, parent, action, pathCost):\\n self.state = state\\n self.parent = parent\\n self.action = action\\n self.pathCost = pathCost\\n\\n def solution(self):\\n path = list()\\n tempNode = self\\n while tempNode.state != problem.getStartState():\\n path.insert(0, tempNode.action)\\n tempNode = tempNode.parent\\n return path\\n\\n\\n\\n\\n def childNode(successor, parent, action, stepCost):\\n pathCost = parent.pathCost + stepCost\\n child = Node(successor, parent, action, pathCost)\\n return child\\n\\n initialNode = Node(problem.getStartState(), None, None, 0)\\n if problem.isGoalState(initialNode.state):\\n return initialNode.solution()\\n\\n frontier = util.Queue() #bfs uses a queue\\n frontier.push(initialNode)\\n explored = set()\\n\\n while not frontier.isEmpty() :\\n nextNode = frontier.pop() #extract from the start of the queue\\n explored.add(nextNode.state)\\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\\n child = childNode(successor, nextNode, action, stepCost)\\n if child.state not in explored and child not in frontier.list:\\n if problem.isGoalState(child.state):\\n return child.solution()\\n frontier.push(child)\\n return []\\n util.raiseNotDefined()\",\n \"def tree_search(problem, frontier):\\n compteur = 0\\n stop = False\\n frontier.append(Node(problem.initial))\\n while frontier and not stop:\\n compteur+=1\\n node = frontier.pop()\\n if problem.goal_test(node.state):\\n return node\\n if(compteur <= limit):\\n frontier.extend(node.expand(problem))\\n else:\\n stop = True\\n \\n return None\",\n \"def graph_search(problem, open_nodes):\\n explored = [problem.initial]\\n open_nodes.append(Node(problem.initial))\\n while len(open_nodes) > 0:\\n node = open_nodes.pop()\\n if problem.goal_test(node.state):\\n #print \\\"Path cost: %d\\\" % node.path_cost\\n print 'Broj poteza: ' + str(len(node.solution())-1)\\n return node.solution()\\n for child in node.expand(problem):\\n if child.state not in explored:\\n open_nodes.append(child)\\n explored.append(child.state)\\n return None\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from util import PriorityQueue\\n import math\\n\\n frontier = PriorityQueue()\\n explored = []\\n actions = []\\n\\n class node:\\n def __init__(self, path, dad, action):\\n self.path = path\\n self.dad = dad\\n self.action = action\\n h = heuristic(path,problem.goal)\\n if dad == None:\\n self.g=0\\n else:\\n self.g = dad.g + heuristic(dad.path,path)\\n self.cost = round(self.g + h,1)\\n\\n start = node(problem.getStartState(),None,'')\\n frontier.push(start,start.cost)\\n\\n while frontier.isEmpty() == False:\\n path = frontier.pop()\\n successors = problem.getSuccessors(path.path)\\n explored.append(path)\\n for vertex in successors:\\n achou = False\\n for path_ex in explored:\\n if vertex[0] == path_ex.path:\\n achou = True\\n\\n if achou == False:\\n successor = node(vertex[0],path,vertex[1])\\n frontier.push(successor,successor.cost)\\n if problem.isGoalState(successor.path):\\n while len(explored) > 0:\\n ant = explored.pop()\\n if ant.path == successor.dad.path:\\n actions.append(successor.action)\\n successor = ant\\n actions.reverse()\\n return actions\",\n \"def search(board:Board, max_depth=3) -> DiGraph:\\n\\n n = 0 # node label which also serves as a node counter\\n depth = 0\\n \\n G = nx.DiGraph()\\n G.add_node(0, winner=None, player=0, board=board.state, board_p = board.display)\\n \\n # First branch in look ahead\\n newleavelist=[]\\n parent_node = n\\n parent_board = Board(G.nodes[n]['board'][0], G.nodes[n]['board'][1])\\n\\n for move in ALL_MOVES:\\n moves_available = parent_board.moves_available(player=0)\\n if move not in moves_available:\\n continue\\n \\n # Do move\\n new_board = parent_board.update_board(Move(player=0, move=move))\\n \\n # Add move node to graph\\n n=n+1\\n G.add_node(n, winner=new_board.is_winner, player=1, board=new_board.state, board_p = new_board.display)\\n G.add_edge(parent_node, n, move=move)\\n if new_board.is_winner:\\n continue\\n newleavelist.append(n)\\n \\n depth=1\\n # subsequent branches\\n while depth < max_depth:\\n leavelist = newleavelist[:]\\n newleavelist = []\\n for leave in leavelist: \\n # Get parent board\\n parent_board = Board(G.nodes[leave]['board'][0], G.nodes[leave]['board'][1])\\n for move in ALL_MOVES:\\n moves_available = parent_board.moves_available(player=depth%2)\\n if move not in moves_available:\\n continue\\n # Do move\\n new_board = parent_board.update_board(Move(player=depth%2, move=move))\\n # Add move node to graph\\n n=n+1\\n G.add_node(n, winner=new_board.is_winner, player=1-depth%2, \\n board=new_board.state, board_p=new_board.display)\\n G.add_edge(leave, n, move=move)\\n if new_board.is_winner:\\n continue\\n \\n newleavelist.append(n)\\n depth=depth+1\\n return G\",\n \"def uninformed_search(start, end, graph):\\n\\n class SearchNode():\\n def __init__(self, step_cost, name, predecessor):\\n self.path_cost = predecessor.path_cost + step_cost if predecessor is not None else 0\\n self.step_cost = step_cost\\n self.name = name\\n self.predecessor = predecessor\\n def __repr__(self):\\n return self.predecessor.name + \\\"->\\\" + self.name + \\\"=\\\" + self.path_cost\\n\\n class Problem():\\n def __init__(self, start, end, graph, goal_predicate):\\n self.start = start\\n self.end = end\\n self.graph = graph\\n self.is_goal = goal_predicate\\n self.visited_nodes = []\\n\\n nodes_expanded = 0\\n nodes_generated = 0\\n max_nodes_in_memory = 0\\n\\n def tree_search(problem, fringe):\\n nonlocal nodes_generated\\n nonlocal nodes_expanded\\n nonlocal max_nodes_in_memory\\n\\n # create the initial node\\n nodes_generated = 1\\n fringe = [SearchNode(0, problem.start, None)]\\n\\n while len(fringe) > 0:\\n # keep track of some metrics\\n max_nodes_in_memory = max(max_nodes_in_memory, len(fringe))\\n nodes_expanded += 1\\n\\n node = fringe.pop(0)\\n while node.name in problem.visited_nodes:\\n # ran out of nodes in the fringe\\n if len(fringe) == 0:\\n return None\\n\\n node = fringe.pop(0)\\n\\n if problem.is_goal(node):\\n return node\\n \\n # make sure we never visit this node again, since we'll be expanding it\\n problem.visited_nodes.append(node.name)\\n\\n # keep the fringe sorted by the path cost\\n fringe.extend(expand(node, problem))\\n fringe = sorted(\\n fringe, \\n key=lambda node: node.path_cost\\n )\\n\\n return None\\n\\n def expand(node, problem):\\n nonlocal nodes_generated\\n nodes = []\\n for edge in problem.graph.edges(node.name):\\n nodes.append(SearchNode(edge.weight, edge.destination, node))\\n \\n nodes_generated += len(nodes)\\n return nodes\\n\\n initial_problem = Problem(start, end, graph, lambda x: x.name == end)\\n result = tree_search(initial_problem, [])\\n\\n # convert the resulting nested structure into an actual path of (start, end, cost)\\n def walk(node):\\n pred = node.predecessor\\n if pred is None:\\n return []\\n \\n path = walk(pred)\\n path.append((pred.name, node.name, node.step_cost))\\n return path\\n\\n path = walk(result) if result is not None else None\\n return (path, nodes_expanded, nodes_generated, max_nodes_in_memory)\",\n \"def depth_limited_search(problem, limit):\\n\\n # in this case, we simply use a list to keep track of nodes we\\n # traversed, instead of the data structure, Stack.\\n path = list()\\n visited = set() # as before, to prevent duplicated nodes\\n root = problem.get_initial_state()\\n\\n def rec_dls(state, action, depth):\\n\\n visited.add(state)\\n\\n # if it is a goal\\n if problem.goal_test(state):\\n path.append((state, action))\\n return path\\n\\n # or if it reaches a certain depth, but not a goal\\n elif depth == 0:\\n visited.remove(state)\\n return None\\n\\n else:\\n path.append([state, action])\\n for successor, action, cost in problem.get_successors(state):\\n if successor not in visited:\\n # recursively expands the deepest node\\n res = rec_dls(successor, action, depth-1)\\n if res is not None:\\n return res\\n path.pop()\\n visited.remove(state)\\n\\n # \\\"Stared From the Bottom\\\" (root)\\n result = rec_dls(root, 'None', limit)\\n # return the path if the we DID have achieved something\\n if result is not None:\\n return path\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\" \\n startState = problem.getStartState()\\n visitedNodes = []\\n fringe = util.Queue()\\n cost = 0 \\n if (problem.isGoalState(startState) == True ):\\n return [] # No Specific Actions\\n else :\\n fringe.push((startState , [] , cost ))\\n while ( fringe.isEmpty() == False ):\\n currentState , actions , cost = fringe.pop()\\n \\\"\\\"\\\" get the latest node in the Queue \\\"\\\"\\\"\\n \\n if ( problem.isGoalState(currentState) == True ): \\n \\\"\\\"\\\" check if the node is our goal or not \\\"\\\"\\\"\\n #print(\\\"Final Path : \\\" + str(actions))\\n return actions\\n else:\\n if ( (currentState in visitedNodes) == False ): \\n \\\"\\\"\\\" check if this node is alreay visited or needs to be extended ? \\\"\\\"\\\"\\n visitedNodes.append(currentState)\\n currentNodeSuccessors = problem.getSuccessors(currentState)\\n for node in currentNodeSuccessors :\\n if(not node in visitedNodes):\\n state , action , cost = node \\n if ( not state in visitedNodes):\\n fringe.push((state , actions + [action] , cost ))\\n \\n util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n e = Directions.EAST\\n\\n result = []\\n st = util.Stack()\\n visited = set([])\\n\\n current = problem.getStartState()\\n st.push((current, \\\"\\\", 0))\\n\\n while not st.isEmpty():\\n while st.top()[0] in visited:\\n st.pop()\\n result.pop()\\n\\n current = st.top()\\n visited.add(current[0])\\n\\n if current[1] != \\\"\\\":\\n result.append(current[1])\\n\\n if problem.isGoalState(current[0]):\\n break\\n\\n for each in problem.getSuccessors(current[0]):\\n if each[0] not in visited:\\n st.push(each)\\n\\n path = []\\n for each in result:\\n if each == \\\"South\\\":\\n path.append(s)\\n elif each == \\\"West\\\":\\n path.append(w)\\n elif each == \\\"North\\\":\\n path.append(n)\\n else:\\n path.append(e)\\n\\n return path\\n util.raiseNotDefined()\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Priority Queue to hold the node along with the path taken from the start node to reach that node\\n pqueue = PriorityQueue()\\n #Set to hold the node explored.\\n explorednode = set()\\n # Get the start node.\\n startnode = problem.getStartState()\\n # Push the starting node on the Queue along with an empty set to know the direction in order to reach the node.\\n pqueue.push((startnode, []), 0)\\n\\n # Loop till the priority queue is empty\\n while pqueue.isEmpty() is not True:\\n # Pop the currentnode and the direction from the priority queue\\n (currentnode, direction) = pqueue.pop()\\n # Check if the currentnode is not in the explored node.\\n if currentnode not in explorednode:\\n # We will now add the node to set of explored node.\\n explorednode.add(currentnode)\\n # If the node is the goal. We made it!!\\n if problem.isGoalState(currentnode):\\n # The direction holds the way to reach till the goal from the start node.\\n return direction\\n # Loop for each successor(child) of the current node.\\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\\n # Add the successor to the queue along with the path to reach it.\\n if successor not in explorednode:\\n # Add the successor to the queue along with the path to reach it.\\n pqueue.push((successor, direction + [action]), problem.getCostOfActions(direction + [action]) + heuristic(successor, problem))\\n util.raiseNotDefined()\",\n \"def search_for_actions(self, search_depth: int = 1,\\n random_seed: int = None) -> list:\\n if random_seed is not None:\\n random.seed(random_seed)\\n for _ in range(self._max_samples):\\n execute_round(self._root, max_tree_depth=self._max_tree_depth,\\n tree_select_policy=self._tree_select_policy,\\n tree_expand_policy=self._tree_expand_policy,\\n rollout_policy=self._rollout_policy,\\n backpropagate_method=self._back_propagate_policy)\\n return self._search(self._root, search_depth)[1]\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n\\n templist=[]\\n explored = set()\\n fringe = util.PriorityQueue()\\n # state, list of directions till now and the cost is pushed in the stack\\n # so that algorithm can explore the node with lowest cost first\\n fringe.push((problem.getStartState(),templist),1)\\n\\n while (not fringe.isEmpty()):\\n (currentNode,currDir) = fringe.pop()\\n\\n if problem.isGoalState(currentNode):\\n pathToGoal = currDir\\n break\\n if not (currentNode in explored):\\n explored.add(currentNode)\\n for childNode in problem.getSuccessors(currentNode):\\n # total cost is cost till now plus cost to the child node\\n totalCost = childNode[2]+problem.getCostOfActions(currDir)\\n fringe.push((childNode[0],currDir+[childNode[1]]),totalCost)\\n\\n\\n\\n\\n return pathToGoal;\",\n \"def depthFirstSearch(problem):\\n\\n explored = set()\\n frontier = []\\n start_state = problem.getStartState()\\n frontier.append(start_state)\\n parent_hash = {}\\n parent_hash[start_state] = (None, None)\\n\\n def get_path(state):\\n path_stack = util.Stack()\\n actions = []\\n current = state\\n while parent_hash[current][0] is not None:\\n path_stack.push(parent_hash[current][0])\\n current = parent_hash[current][1]\\n while not path_stack.isEmpty():\\n actions.append(path_stack.pop())\\n\\n return actions\\n\\n while len(frontier):\\n node = frontier.pop()\\n if problem.isGoalState(node):\\n return get_path(node)\\n explored.add(node)\\n for state, action, _ in problem.getSuccessors(node):\\n if state not in explored and state not in frontier:\\n parent_hash[state] = (action, node)\\n frontier.append(state)\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n #Creamos las estructuras de datos necesarias (stack y set)\\n openNodes = util.Stack()\\n closedNodes = set([])\\n\\n #Guardamos el nodo inicial\\n node = Node(problem.getStartState(), '', 0, None)\\n\\n #Metemos el nodo en la pila\\n openNodes.push(node)\\n\\n #Iteramos para cada nodo de la pila\\n while True:\\n if openNodes.isEmpty():\\n break #ERROR: throw exception\\n else :\\n #Sacamos el nodo de arriba de la pila\\n node = openNodes.pop()\\n if problem.isGoalState(node.name):\\n break\\n else: #Expandimos los nodos sucesores del nodo n si no estan en closed\\n for successor in problem.getSuccessors(node.name):\\n n, p, c = successor\\n succNode = Node(n, p, c, node)\\n if nodeIsClosed(succNode, closedNodes) is False:\\n #Metemos al sucesor en la pila\\n openNodes.push(succNode)\\n #Metemos el nodo n en closed\\n closedNodes.add(node)\\n\\n #Devolvemos el camino al Goal\\n return findPath(node)\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Initialize data structures\\n parent_node = {}\\n path_to_node = {}\\n priority_queue = util.PriorityQueue()\\n\\n p_c = 0.5\\n h_c = 1 - p_c\\n\\n # Get the start node\\n start_node = problem.getStartState()\\n parent_node[start_node] = None\\n path_to_node[start_node] = []\\n priority_queue.update(start_node, 0)\\n\\n #goal_found = False\\n\\n while not priority_queue.isEmpty():\\n # Get the next node\\n node_to_expand = priority_queue.pop()\\n # Check if goal state is reached\\n if problem.isGoalState(node_to_expand):\\n break\\n next_nodes = problem.getSuccessors(node_to_expand)\\n path_to_parent = path_to_node[node_to_expand]\\n\\n for one_node in next_nodes:\\n point, move, cost = one_node\\n curr_path = path_to_node[node_to_expand] + [move]\\n curr_cost = problem.getCostOfActions(curr_path)\\n heuristic_cost = heuristic(point, problem)\\n # Check if current node already exists in the previously visited nodes\\n if point in path_to_node:\\n prev_cost = problem.getCostOfActions(path_to_node[point])\\n if prev_cost > curr_cost:\\n path_to_node[point] = curr_path\\n priority_queue.update(point, curr_cost + heuristic_cost)\\n \\n else:\\n path_to_node[point] = curr_path\\n priority_queue.update(point, curr_cost + heuristic_cost)\\n \\n # current_cost = problem.getCostOfActions(point) * p_c + heuristic(point, problem) * h_c\\n\\n print(node_to_expand) \\n return path_to_node[node_to_expand]\\n \\n# nodes_to_expand = set()\\n# # get max value node in the fringe node\\n# min_val = float(\\\"inf\\\")\\n# for one_node in fringe_node:\\n# # Compute the cost to reach a node\\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\\n# if total_cost < min_val:\\n# min_val = total_cost\\n# \\n# for one_node in fringe_node:\\n# # Compute the cost to reach a node\\n# total_cost = cost_to_point[one_node] * p_c + heuristic(one_node,problem) * h_c\\n# if total_cost == min_val:\\n# nodes_to_expand.add(one_node)\\n# fringe_node.remove(one_node)\\n#\\n# # Expand the fringe node \\n# for one_node in nodes_to_expand:\\n# path_to_parent = path_to_point[one_node]\\n# for nxt_node in problem.getSuccessors(one_node):\\n# pos = nxt_node[0]\\n# mv = nxt_node[1]\\n# # check if point already present in path to point\\n# prev_cost = float(\\\"inf\\\")\\n# if pos in cost_to_point:\\n# prev_cost = cost_to_point[pos]\\n# new_path = path_to_parent + [mv]\\n# if prev_cost > problem.getCostOfActions(new_path):\\n# path_to_point[pos] = new_path\\n# cost_to_point[pos] = problem.getCostOfActions(new_path)\\n# fringe_node.append(pos)\\n#\\n# # Check if destination is reached in the fringe node\\n# for one_node in fringe_node:\\n# if problem.isGoalState(one_node):\\n# final_node = one_node\\n# goal_found = True\\n# break\\n# \\n# #print(len(fringe_node))\\n# print(final_node)\\n# print(path_to_point[final_node])\\n# return path_to_point[final_node] \\n\\n util.raiseNotDefined()\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n #the logic is same as for DFS just that i made use of a Queue data structure\\n #Here the queue acts as a FIFO queue\\n neighbourNodes = util.Queue()\\n moves = []\\n neighbourNodes.push((problem.getStartState(),moves))\\n seenNodes = set()\\n\\n while not neighbourNodes.isEmpty():\\n poppedNodeState, poppedNodeAction= neighbourNodes.pop()\\n if(poppedNodeState in seenNodes):\\n continue\\n if problem.isGoalState(poppedNodeState):\\n return poppedNodeAction\\n seenNodes.add(poppedNodeState)\\n for state, action, cost in problem.getSuccessors(poppedNodeState):\\n if(state in seenNodes):\\n continue\\n neighbourNodes.push((state, poppedNodeAction+[action]))\\n return moves\\n #util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n fringe = util.Stack()\\n return GraphSearch(problem, 'dfs').search(fringe)\",\n \"def general_search(problem, fringe):\\n\\n fringe.push(PQItem((problem.get_start_state(), [], 0, None))) # curr_node, action, cost, parent\\n closed = set()\\n\\n while not fringe.isEmpty():\\n i = 1\\n curr = fringe.pop()\\n if problem.is_goal_state(curr.get_node()):\\n build_first_plan_dict(curr)\\n return curr.get_action()\\n elif is_visited_by_plan(curr.get_node()):\\n return get_past_path(curr.get_action())\\n elif curr.get_node() not in closed:\\n successors = problem.get_successors(curr.get_node())\\n for i in range(len(successors)):\\n next_state, action, cost = successors[i]\\n fringe.push(PQItem((next_state, curr.get_action() + [action], cost + curr.get_cost(), None)))\\n closed.add(curr.get_node())\\n i += 1\\n return \\\"failed\\\"\",\n \"def depth_first_search(problem):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n fringe = []\\r\\n path = set()\\r\\n final = []\\r\\n acts = dict()\\r\\n state = problem.get_start_state()\\r\\n fringe.append(state)\\r\\n\\r\\n while(len(fringe) > 0):\\r\\n state = fringe.pop()\\r\\n path.add(state)\\r\\n states = problem.get_successors(state)\\r\\n acts[state] = states[:]\\r\\n if problem.is_goal_state(state):\\r\\n break\\r\\n\\r\\n #states = problem.get_successors(state)\\r\\n for stat in states:\\r\\n if stat[0] not in path and stat[0] not in fringe:\\r\\n fringe.append(stat[0])\\r\\n\\r\\n while(True):\\r\\n if state == problem.get_start_state():\\r\\n break\\r\\n for key, val in acts.items():\\r\\n for va in val: #( x, y, z)\\r\\n if va[0] == state:\\r\\n final.append(va[1])\\r\\n state = key\\r\\n break\\r\\n else:\\r\\n continue\\r\\n break\\r\\n\\r\\n final.reverse()\\r\\n\\r\\n return final\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\n util.raiseNotDefined()\",\n \"def graph_search(problem, fringe):\\n counter = 0\\n closed = {}\\n fringe.append(Node(problem.initial))\\n max_depth=0\\n while fringe:\\n node = fringe.pop()\\n # Print some information about search progress\\n if node.depth>max_depth:\\n max_depth=node.depth\\n if max_depth<50 or max_depth % 1000 == 0:\\n pid = os.getpid()\\n py = psutil.Process(pid)\\n memoryUse = py.memory_info()[0]/1024/1024\\n print('Reached depth',max_depth,\\n 'Open len', len(fringe),\\n 'Node expanse', counter,\\n 'Memory used (MBytes)', memoryUse)\\n\\n if problem.goal_test(node.state):\\n return node, counter\\n serial = node.state.__str__()\\n if serial not in closed:\\n counter += 1\\n closed[serial] = True\\n fringe.extend(node.expand(problem))\\n return None\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n fringeList = util.Stack()\\n print \\\"fringeList\\\",fringeList\\n closedList = {str(problem.getStartState()): ([])} #Hash Map to maintain state to path\\n print \\\"closed list:\\\", closedList\\n isGoalStateArrived = False\\n\\n # Push start state into fringeList\\n fringeList.push((problem.getStartState()))\\n\\n while not isGoalStateArrived and not fringeList.isEmpty():\\n currentNode = fringeList.pop()\\n print \\\"currentNode\\\",currentNode\\n currentNodePath = closedList[str(currentNode)]\\n print \\\"currentNodepath:\\\",currentNodePath\\n # Explore children\\n childrenOfCurrentNode = problem.getSuccessors(currentNode)\\n print \\\"childrenOfCurrentNode:\\\",childrenOfCurrentNode\\n for childNode in childrenOfCurrentNode:\\n if str(childNode[0]) not in closedList:\\n path = copy.copy(currentNodePath)\\n path.append(childNode[1])\\n print \\\"child [0] %s, child [1] %s\\\", childNode[0],childNode[1]\\n print \\\"path \\\", path\\n fringeList.push(childNode[0])\\n closedList[str(childNode[0])] = path # Put parent node in closed List\\n if problem.isGoalState(childNode[0]):\\n isGoalStateArrived = True\\n goalState = childNode[0]\\n break\\n\\n if isGoalStateArrived:\\n #print closedList[str(problem.getStartState())]\\n return closedList[str(goalState)]\\n \\\"util.raiseNotDefined()\\\"\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\\\"\\n # Initialize a stack\\n open = util.Stack()\\n\\n # Retrieve the init state\\n initState = (problem.getStartState(), ['Stop'], 0)\\n open.push(initState)\\n closed = []\\n\\n while not open.isEmpty():\\n currState = open.pop()\\n currPos = currState[0]\\n currPath = currState[1]\\n currCost = currState[2]\\n\\n if problem.isGoalState(currPos):\\n return currPath[1:]\\n else:\\n closed.append(currPos)\\n if currState not in closed:\\n successors = problem.getSuccessors(currPos)\\n if len(successors) > 0:\\n for each in successors:\\n if each[0] not in closed:\\n temp = (each[0], currPath+[each[1]], currCost+each[2])\\n open.push(temp)\\n return False\",\n \"def astar_search(start, goal, heuristic):\\r\\n open = []\\r\\n closed = []\\r\\n\\r\\n expanded = {} # Dictionary to check if a node has been expanded\\r\\n explored = {} # Dictionary to check if a node has been explored\\r\\n\\r\\n if heuristic == 0:\\r\\n hval = manhattan_distance(start, goal) # Calculate the heuristic value of the start node\\r\\n else:\\r\\n hval = eucledian_distance(start, goal)\\r\\n\\r\\n start_node = Node(None, start, 0, hval, hval+0) # Create the new node - root node so no parent\\r\\n open.append(start_node)\\r\\n expanded[tuple(start_node.data)] = True # Mark node as being expanded\\r\\n\\r\\n while len(open) != 0:\\r\\n open.sort(key=lambda x: x.f, reverse=False) # Sort f-values of nodes in ascending order\\r\\n cur_node = open[0] # Select the node with smallest f_value\\r\\n closed.append(cur_node) # Add the current node to closed as it being explored\\r\\n explored[tuple(cur_node.data)] = True # Mark node as being explored\\r\\n open.pop(0) # Remove current node from open list\\r\\n\\r\\n if cur_node.h == 0: # Checks if current node is a goal node\\r\\n trace_path(cur_node)\\r\\n return len(closed)\\r\\n\\r\\n children = children_nodes(cur_node, goal, heuristic) # Get a list of all children nodes\\r\\n for child in children:\\r\\n if child.h == 0: # If child node is a goal node then return a trace to root node\\r\\n trace_path(child)\\r\\n return len(closed)\\r\\n\\r\\n if tuple(child.data) not in expanded and tuple(child.data) not in explored:\\r\\n open.append(child) # Only expand node if not already expanded and explored\\r\\n expanded[tuple(child.data)] = True\\r\\n return False\",\n \"def graph_search(problem, verbose=False, debug=False):\\r\\n \\r\\n # PriorityQueue should be used to maintain the order of the queue.\\r\\n frontier = PriorityQueue()\\r\\n \\r\\n frontier.append(Node(problem, problem.initial))\\r\\n \\r\\n current_node = frontier.pop()\\r\\n \\r\\n p = True\\r\\n #depth first search\\r\\n if current_node.expand(current_node.problem)[0].g < 0:\\r\\n \\r\\n frontier = deque()\\r\\n frontier.append(Node(problem, problem.initial))\\r\\n #breadth first search\\r\\n elif current_node.expand(current_node.problem)[0].h < 2:\\r\\n \\r\\n p = False\\r\\n frontier = deque()\\r\\n frontier.append(Node(problem, problem.initial))\\r\\n #manhattan\\r\\n else:\\r\\n \\r\\n frontier.append(current_node)\\r\\n\\r\\n f_hash = Explored()\\r\\n f_hash.add(problem.initial.state_tuple())\\r\\n done = False\\r\\n n_explored = 0\\r\\n explored = Explored()\\r\\n\\r\\n #graph_search\\r\\n while not done:\\r\\n \\r\\n if p:\\r\\n current_node = frontier.pop()\\r\\n else:\\r\\n current_node = frontier.popleft()\\r\\n explored.add(current_node.state.state_tuple())\\r\\n n_explored = n_explored + 1 #inc the number of explored nodes\\r\\n\\r\\n if current_node.state.solved():\\r\\n path = current_node.path()\\r\\n done = True\\r\\n return path, n_explored\\r\\n #if not found in the tree return none and number of nodes explored\\r\\n else:\\r\\n \\r\\n for child in current_node.expand(current_node.problem):\\r\\n if not explored.exists(child.state.state_tuple()) and not \\\\\\r\\n f_hash.exists(child.state.state_tuple()):\\r\\n frontier.append(child)\\r\\n f_hash.add(child)\\r\\n done = len(frontier) == 0\\r\\n\\r\\n return None, n_explored\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n stack = util.Stack() # stack for searshing the graph\\n visited = [] # Keep track of visited nodes\\n start =problem.getStartState() # The start node\\n stack.push((start, [])) # the sart state and empty path list is pushed to the stack\\n \\n while stack:\\n (vrtx, path) = stack.pop() # Pop tfrom the stack , vrtx: the poped node for expantion.\\n if vrtx not in visited: # if the node is visited alraedy \\n if problem.isGoalState(vrtx):\\n return [p[1] for p in path]\\n visited.append(vrtx)\\n for successor in problem.getSuccessors(vrtx):\\n stack.push((successor[0], path+[successor]))\\n util.raiseNotDefined()\",\n \"def general_search(fringe, visited, limiting_depth):\\n node_to_be_explored = fringe[0]\\n node_state = node_to_be_explored['state']\\n visited[node_state] = node_to_be_explored\\n if goal_test(node_to_be_explored['state']):\\n return generate_path(node_to_be_explored, visited)\\n current_depth = node_to_be_explored['depth']\\n if current_depth == limiting_depth:\\n return False\\n children = [\\n {\\n 'state': child_state,\\n 'parent': node_state,\\n 'depth': current_depth + 1,\\n }\\n for child_state in operator(node_state)]\\n for child in children:\\n if child['state'] in visited:\\n continue\\n fringe_copy = [child] + fringe[1:]\\n visited_copy = visited.copy()\\n solution = general_search(fringe_copy, visited_copy, limiting_depth)\\n if solution:\\n return solution\\n else:\\n continue\\n return False\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n #Queue to hold the node along with the path taken from the start node to reach that node\\n queue = Queue()\\n #Set to hold the node explored.\\n explorednode = set()\\n # Get the start node.\\n startnode = problem.getStartState()\\n print startnode\\n # Push the starting node on the Queue along with an empty set to know the direction in order to reach the node.\\n queue.push((startnode,[]))\\n\\n # Loop till the queue is empty\\n while queue.isEmpty() is not True:\\n # Pop the currentnode and the direction from the queue\\n currentnode, direction = queue.pop()\\n # Check if the currentnode is not in explorednode.\\n if currentnode not in explorednode:\\n # We will now add the node to set of explored node.\\n explorednode.add(currentnode)\\n # If the node is the goal. We made it!!\\n if problem.isGoalState(currentnode):\\n # The direction holds the way to reach till the goal from the start node.\\n print currentnode\\n return direction\\n # Loop for each successor(child) of the current node.\\n for (successor, action, stepCost) in problem.getSuccessors(currentnode):\\n # If the successor(child) is not explored\\n if successor not in explorednode:\\n # Add the successor to the queue along with the path to reach it.\\n queue.push((successor, direction + [action]))\\n util.raiseNotDefined()\",\n \"def search(self):\\n open_set = set()\\n closed_set = set()\\n open_set.add(self.start_node)\\n\\n # loop through all nodes until open set is empty to build neighbor map\\n while open_set:\\n current_node = open_set.pop()\\n closed_set.add(current_node)\\n for removed_cells, score, next_status in current_node.find_next_moves():\\n open_status_set = [i.status for i in open_set]\\n closed_status_set = [i.status for i in closed_set]\\n if next_status in open_status_set:\\n index = open_status_set.index(next_status)\\n node = list(open_set)[index]\\n elif next_status in closed_status_set:\\n index = closed_status_set.index(next_status)\\n node = list(closed_set)[index]\\n else:\\n node = PopstarsNode(next_status)\\n open_set.add(node)\\n node.parents.append(current_node)\\n current_node.children[node].append(\\n (score, removed_cells, True))\\n current_node.update_parents()\\n max_score = []\\n for i in self.start_node.children:\\n max_score += self.start_node.children[i]\\n return max(max_score)[0]\",\n \"def action(self):\\n\\n # assume the smart opponent can always choose the best step\\n # Depth First Search\\n steps = 2\\n stack = [(self.game_in_head, (), 0)]\\n maxmin = None\\n good_paths = []\\n\\n while len(stack) > 0:\\n parent_node, path, score = stack.pop(-1)\\n if len(path) >= steps*2:\\n \\n # leaf node in the search tree\\n if maxmin is None:\\n maxmin = score\\n good_paths.append(path)\\n elif maxmin == score:\\n good_paths.append(path)\\n elif maxmin < score:\\n maxmin = score\\n good_paths.clear()\\n good_paths.append(path)\\n else:\\n # root node, find its leaves\\n children_nodes = self.one_step_infe(parent_node, path, score)\\n stack += children_nodes\\n\\n path_dec = random.choice(good_paths) \\n if self.colour == 'upper':\\n return path_dec[0] \\n elif self.colour == 'lower':\\n return path_dec[1]\",\n \"def search(board):\\n depth = 0\\n while True:\\n result = depth_first(board, depth)\\n if result:\\n return result\\n else:\\n depth += 1\",\n \"def depth_first_graph_search(problem):\\n\\n\\tfrontier = [(Node(problem.initial))] # Stack (implemented as a list)\\n\\n\\texplored = set()\\n\\twhile frontier:\\n\\t\\tnode = frontier.pop()\\n\\t\\tif problem.goal_test(node.state):\\n\\t\\t\\treturn node\\n\\t\\texplored.add(node.state)\\n\\t\\tfrontier.extend(child for child in node.expand(problem)\\n\\t\\t\\t\\t\\t\\tif child.state not in explored and child not in frontier)\\n\\treturn None\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n start = problem.getStartState()\\n stack = util.Stack() # stack to keep track of frontier nodes where pacman has move\\n stack.push(start)\\n explored = set() # to keep track of explored areas\\n route = []\\n\\n while not stack.isEmpty():\\n current_position = stack.pop()\\n explored.add(current_position)\\n\\n if problem.isGoalState(current_position):\\n break\\n for each in problem.getSuccessors(current_position):\\n if each[0] not in explored: # x,y coordinates of positions we haven't visited are pushed onto stack\\n # print(each)\\n stack.push(each[0])\\n route.append((current_position, each[0], each[1])) # record of movements to rebuild path (from,to,how)\\n\\n x = len(route)\\n while x - 1 != 0: # loop clears out actions that dont come from previous position\\n if route[x - 1][0] != route[x - 2][1]: # starts from goal and works backwards\\n route.remove(route[x - 2])\\n x = len(route)\\n else:\\n x -= 1\\n # print(route)\\n return [action[2] for action in route]\",\n \"def breadth_first_search(initial_state):\\n list_of_processed_nodes = []\\n num_unprocessed_nodes = 0#\\n num_unconsidered_children = 0#\\n\\n initial_node = Node(state=initial_state)\\n node_deque = collections.deque()\\n node_deque.append(initial_node)\\n goal_state_found = False\\n goal_node = None\\n\\n while len(node_deque) > 0 and not goal_state_found:\\n e = node_deque.popleft()\\n #pdb.set_trace()\\n if e in list_of_processed_nodes:\\n num_unprocessed_nodes += 1\\n continue\\n else:\\n list_of_processed_nodes.append(e)\\n\\n list_of_children_nodes, num_unconsidered_children = generate_children_nodes(\\n curr_node=e, list_of_processed_nodes=list_of_processed_nodes,\\n running_count_of_children_dups=num_unconsidered_children#\\n )\\n \\n for child_node in list_of_children_nodes:\\n #print 'Node {0} with goal status {1}'.format(child_node.index, child_node.state.snake_ate_food)\\n if child_node.state.goal_state_reached():\\n #print \\\"Goal state reached with node index {0}\\\".format(child_node.index)\\n goal_state_found = True\\n goal_node = child_node\\n break\\n else:\\n #print \\\"Adding to deque node index {0}\\\".format(child_node.index)\\n node_deque.append(child_node)\\n\\n if len(node_deque) == 0 and not goal_state_found:\\n print '*'*40\\n print 'NO SOLUTION PATH FOUND'\\n print '*'*40\\n sys.exit(0)\\n\\n #pdb.set_trace()#\\n # Summary & results\\n #print '{0} nodes processed!'.format(len(list_of_processed_nodes))\\n #print '{0} nodes already visited, skipped!'.format(num_unprocessed_nodes)\\n #print '{0} node children skipped!'.format(num_unconsidered_children)\\n #os.system('say -v \\\"Victoria\\\" \\\"done\\\"')\\n\\n return goal_node, list_of_processed_nodes\",\n \"def search(start):\\n\\n '''\\n Create a class named nodeClass which contains 4 elements: \\n state: The puzzle object containing the puzzle board at the node \\n misplaced: num of misplaced tiles\\n depth: depth of the node in the tree \\n prev: parent node\\n '''\\n nodeClass = namedtuple('nodeClass', 'state, misplaced, depth, prev')\\n\\n #instantiate object from class creating the root node\\n node = nodeClass(start, 0, 0, None)\\n\\n #stores the nodes that are going to be explored. \\n #the node with lower f-score is explored first\\n frontier = q.PriorityQueue()\\n frontier.put((0,node))\\n\\n # frontier_set keep track of the nodes in the frontier queue\\n frontier_set = {node}\\n #contains the board states already explored\\n explored_states = set()\\n for ite in range(1,max_iterations+2):#while True:\\n #Retrieve the node in the frontier with lowest value\\n node = frontier.get()[1]\\n\\n #get the puzzle board obj from the node object\\n state = node.state\\n\\n #Check if the game has ben solved\\n if state.solved or ite==max_iterations:\\n Result = namedtuple('Result', 'board, depth, nodesExpanded, max_depth, isSolved')\\n return Result(state, node.depth, ite, max(no.depth for no in frontier_set), state.solved)\\n\\n # expanded nodes are added to explored set\\n explored_states.add(state)\\n\\n #EXPANDING\\n for mov in state.possible_moves:\\n new_state=state.move(mov)\\n new_node = nodeClass(new_state, new_state.score,\\n node.depth + 1, node)\\n\\n #compute f-score of the node\\n f_score=new_state.score + new_node.depth\\n\\n if new_state not in explored_states and new_node not in frontier_set:\\n frontier.put((f_score,new_node))\\n frontier_set.add(new_node)\",\n \"def search(state, goal_state):\\n\\n def gn(node):\\n return node.gn()\\n\\n tiles_places = []\\n for i in range(len(goal_state)):\\n for j in range(len(goal_state)):\\n heapq.heappush(tiles_places, (goal_state[i][j], (i, j)))\\n\\n def hn(node):\\n cost = 0\\n for i in range(len(node.state)):\\n for j in range(len(node.state)):\\n tile_i, tile_j = tiles_places[node.state[i][j]][1]\\n if i != tile_i or j != tile_j:\\n cost += abs(tile_i - i) + abs(tile_j - j)\\n return cost\\n\\n def fn(node):\\n return gn(node) + hn(node)\\n\\n return bfs.search(state, goal_state, fn)\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n class Node:\\n def __init__(self, state, parent, action, pathCost):\\n self.state = state\\n self.parent = parent\\n self.action = action\\n self.pathCost = pathCost\\n\\n def solution(self):\\n path = list()\\n tempNode = self\\n while tempNode.state != problem.getStartState():\\n path.insert(0, tempNode.action)\\n tempNode = tempNode.parent\\n return path\\n\\n def __eq__(self, other):\\n if isinstance(other, Node):\\n return self.state == other.state\\n\\n\\n def childNode(successor, parent, action, stepCost):\\n pathCost = parent.pathCost + stepCost\\n child = Node(successor, parent, action, pathCost)\\n return child\\n\\n initialNode = Node(problem.getStartState(), None, None, 0)\\n frontier = util.PriorityQueue() #ucs uses a priority queue\\n frontier.push(initialNode, initialNode.pathCost)\\n explored = set()\\n\\n while not frontier.isEmpty() :\\n nextNode = frontier.pop() #extract from the start of the queue\\n if problem.isGoalState(nextNode.state):\\n return nextNode.solution()\\n explored.add(nextNode.state)\\n for successor, action, stepCost in problem.getSuccessors(nextNode.state):\\n child = childNode(successor, nextNode, action, stepCost)\\n if child.state not in explored:\\n frontier.update(child, child.pathCost) #we only check if state is in explored because update does the other\\n return []\\n util.raiseNotDefined()\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n \\\"\\\"\\\"\\n same as UCS function, but total cost is sum of cost till now , cost to the child node and \\n cost to the goal state (heuristic function)\\n \\\"\\\"\\\"\\n fringes = util.PriorityQueue()\\n explored =set()\\n fringes.push((problem.getStartState(),[]),0)\\n\\n while(not fringes.isEmpty()):\\n currentNode,currDir = fringes.pop()\\n if problem.isGoalState(currentNode):\\n finalPath = currDir\\n break\\n # print \\\"HOraaay goal has been found === > \\\", currentNode\\n\\n if not (currentNode in explored):\\n explored.add(currentNode)\\n for childNode in problem.getSuccessors(currentNode):\\n totalCost = (childNode[2] + heuristic(childNode[0],problem)+problem.getCostOfActions(currDir))\\n fringes.push((childNode[0],currDir+[childNode[1]]),totalCost)\\n\\n\\n return finalPath\\n\\n\\n\\n\\n\\n\\n\\n util.raiseNotDefined()\",\n \"def uct_search(root_state,\\n tree=None,\\n default_policy=default_random_policy,\\n player_id=1):\\n root_n = Node(root_state)\\n if tree is None:\\n tree = Tree(root_n)\\n edge_node = tree_policy(root_n, tree)\\n reward = default_policy(edge_node.state, player_id)\\n backup_negamax(edge_node, reward)\\n best_root_child = best_child(root_n, 0) # Greedy, so c = 0\\n best_root_action_l = [a for p, a in best_root_child.parents if p == root_n]\\n return best_root_action_l[0], tree\",\n \"def recursive_search(i, F, t, s, explored, leaders, order):\\n x = len(explored)\\n if x % 10 == 0:\\n print(\\\"Length of explored: {}\\\".format(x))\\n explored.append(i)\\n if order == 2:\\n leaders[i] = s\\n arc_list = db.Database.find_one(collection=\\\"biggraph\\\", query={\\\"key\\\": i})\\n if arc_list:\\n for node in arc_list['value']:\\n if node not in explored:\\n F, t, leaders, explored = recursive_search(node, F, t, s, explored, leaders, order)\\n if order == 1:\\n t += 1\\n F[i] = t\\n return F, t, leaders, explored\",\n \"def monteCarloTreeSearch(chessboard):\\n init_state = NodeState(chessboard)\\n init_state.setCurrentTurn(State.BLACK)\\n init_node = TreeNode(init_state)\\n\\n for _ in range(COMPUTATION_LIMIT):\\n expanded_node = treePolicy(init_node)\\n reward = defaultPolicy(expanded_node)\\n backPropagation(expanded_node, reward)\\n \\n best_child_node = findBestChild(init_node, False)\\n return best_child_node.getState().getBestMovement()\",\n \"def aStarSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n root = problem.getStartState()\\n pq = PriorityQueue()\\n visited = [] # list of visited nodes to not visit again\\n path = {} # to store predecessor and next move of nodes\\n gn={} # for total distance\\n\\n '''intializing for root'''\\n pq.push(root,0)\\n path[root]=(None,None) # (predecessor, action)\\n gn[root]=0\\n\\n\\n while not pq.isEmpty():\\n # print(path)\\n node = pq.pop()\\n successors = problem.getSuccessors(node)\\n\\n if problem.isGoalState(node):\\n p=[root]\\n while path[node]!=(None,None): #moving from goal to root\\n p.append(node)\\n node = path[node][0]\\n return p\\n\\n visited.append(node)\\n\\n for i in successors:\\n i_successor = i[0]\\n i_action=i[1]\\n i_cost=gn[node]+ i[3] # i_cost is total gn\\n if i_successor not in visited:\\n if (i_successor not in gn) or (gn[i_successor]>i_cost): #dijkstra property too\\n path[i_successor]=(node,i_action) # (predecessor, action)\\n gn[i_successor]=i_cost\\n fn = i_cost + problem.getHeuristic(i_successor)\\n pq.update(i_successor,fn)\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from game import Directions\\n waiting_list = util.Queue()\\n # QUEUE\\n # FIFO \\n visited = set()\\n parents = {}\\n #collections.defaultdict(collections.UserDict)\\n sequence = []\\n start_state = problem.getStartState()\\n for action in problem.getSuccessors(start_state):\\n # in order to push full-state values\\n waiting_list.push(action)\\n \\n while not waiting_list.isEmpty():\\n node = waiting_list.pop()\\n visited.add(node[0])\\n for action in problem.getSuccessors(node[0]):\\n \\n #if child.STATE is not in explored or frontier then\\n if action[0] not in visited:\\n parents[action[0]] = {'parent':node} \\n waiting_list.push(action)\\n if problem.isGoalState(action[0]):\\n target_state = action \\n \\n \\n while target_state[0] in parents.keys():\\n temp=parents[target_state[0]]['parent']\\n sequence.append(target_state[1])\\n target_state = temp\\n sequence.append(target_state[1])\\n return sequence[::-1]\",\n \"def search(self, depth, state, curr_player):\\n \\n # enumerate all legal moves from this state\\n legal_moves = []\\n for i in range(7):\\n # if column i is a legal move...\\n if self.isLegalMove(i, state):\\n # make the move in column i for curr_player\\n temp = self.makeMove(state, i, curr_player)\\n legal_moves.append(temp)\\n \\n # if this node (state) is a terminal node or depth == 0...\\n if depth == 0 or len(legal_moves) == 0 or self.gameIsOver(state):\\n # return the heuristic value of node\\n return self.value(state, curr_player)\\n \\n # determine opponent's color\\n if curr_player == self.colors[0]:\\n opp_player = self.colors[1]\\n else:\\n opp_player = self.colors[0]\\n\\n alpha = -99999999\\n for child in legal_moves:\\n if child == None:\\n print(\\\"child == None (search)\\\")\\n alpha = max(alpha, -self.search(depth-1, child, opp_player))\\n return alpha\",\n \"def breadthFirstSearch(problem):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n node = problem.getStartState()\\r\\n if (problem.isGoalState(node)):\\r\\n return [] # no need to make any moves of the start state is goal\\r\\n start = (node, 'NoDirection',0)\\r\\n\\r\\n frontier_queue = Queue() # queue for frontier\\r\\n frontier_queue.push(start) # frontier consists of only the start state\\r\\n\\r\\n explored_nodes = set()\\r\\n explored_track = {start:None} # keep a track of parent, parent of root node is None\\r\\n\\r\\n while not frontier_queue.isEmpty():\\r\\n state = frontier_queue.pop() # pop the top element from the queue \\r\\n explored_nodes.add(state)\\r\\n\\r\\n if problem.isGoalState(state[0]):\\r\\n return get_track(explored_track, state)\\r\\n\\r\\n neighbors_state = problem.getSuccessors(state[0])\\r\\n for neighbor in neighbors_state: # neighbor will be something like this ((34, 15), 'South', 1)\\r\\n if neighbor not in frontier_queue.list and neighbor not in explored_nodes:\\r\\n frontier_queue.push(neighbor)\\r\\n explored_track[neighbor] = state\\r\\n\\r\\n\\r\\n def get_track(explored_track, state):\\r\\n from game import Directions\\r\\n track_history = [state]\\r\\n track_history_direction = []\\r\\n leaf = state\\r\\n while (explored_track[leaf]) != start:\\r\\n track_history.append(explored_track[leaf])\\r\\n leaf = explored_track[leaf]\\r\\n\\r\\n for j in range (len(track_history),-1,-1):\\r\\n this_step = track_history[j-1]\\r\\n this_step = this_step[1]\\r\\n track_history_direction.append(this_step)\\r\\n return track_history_direction[:-1]\",\n \"def search_path(self):\\n\\n nodes = [self.start]\\n final_node = None\\n \\n count = 0\\n while True:\\n count += 1\\n\\n if count % self.pick_target == 0:\\n pick = self.goal.pos[:2]\\n else:\\n pick = self.car.random_pos()[:2]\\n \\n nearest = self.get_nearest_node(nodes, pick)\\n\\n if count % self.check_dubins == 0:\\n solutions = self.dubins.find_tangents(nearest.pos, self.goal.pos)\\n dubins_route, cost, valid = self.dubins.best_tangent(solutions)\\n \\n if valid:\\n final_node = nearest\\n break\\n\\n phi = self.get_steering_angle(nearest.pos, pick)\\n pos = nearest.pos\\n branch = [pos[:2]]\\n \\n for i in range(self.max_steps):\\n pos = self.car.step(pos, phi)\\n branch.append(pos[:2])\\n \\n # check safety of route-----------------------\\n if phi == 0:\\n safe = self.dubins.is_straight_route_safe(nearest.pos, pos)\\n else:\\n d, c, r = self.car.get_params(nearest.pos, phi)\\n safe = self.dubins.is_turning_route_safe(nearest.pos, pos, d, c, r)\\n # --------------------------------------------\\n \\n if not safe:\\n continue\\n \\n new_node = Node(pos, phi, i+1)\\n \\n if new_node in nodes:\\n continue\\n \\n new_node.branch = branch\\n new_node.parent = nearest\\n nodes.append(new_node)\\n \\n route = self.backtracking(final_node) + dubins_route\\n path = self.car.get_path(self.car.start_pos, route)\\n print('Total iteration:', count)\\n \\n return path, nodes\",\n \"def action(self):\\n\\n self.start_timer()\\n\\n minimax_probability = self.norm.cdf(self.root.branching)\\n use_minimax = boolean_from_probability(minimax_probability)\\n if self.time_consumed > 53:\\n # Time is starting to run low, use the faster option\\n use_minimax=True\\n\\n if self.time_consumed < 59:\\n if self.root.turn < 4:\\n result = book_first_four_moves(self.root)\\n elif use_minimax:\\n result = minimax_paranoid_reduction(self.root)\\n else:\\n result = monte_carlo_tree_search(\\n self.root,\\n playout_amount=3,\\n node_cutoff=4,\\n outer_cutoff=4,\\n num_iterations=1200,\\n turn_time=0.75,\\n exploration_constant=1.7,\\n use_slow_culling=False,\\n verbosity=0,\\n use_prior=True,\\n num_priors=4,\\n use_fast_prune_eval=False,\\n use_fast_rollout_eval=False,\\n )\\n else:\\n result = greedy_choose(self.root)\\n\\n self.end_timer()\\n\\n return result\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n #Creamos las estructuras de datos necesarias (priority queue y set)\\n openNodes = util.PriorityQueue()\\n closedNodes = set([])\\n\\n #Guardamos el nodo inicial\\n node = Node(problem.getStartState(), '', 0, None)\\n\\n #Calculamos funcion heuristica y el coste acumulado para sacar la funcion de evaluacion del nodo inicial\\n fn = problem.getCostOfActions(node.path) + heuristic(node.name, problem);\\n\\n #Lo metemos en la cola con su funcion de evaluacion como prioridad\\n openNodes.push(node, fn)\\n\\n #Iteramos para cada nodo\\n while True:\\n if openNodes.isEmpty():\\n break #ERROR: throw exception\\n else :\\n #sacamos el nodo de arriba de la cola\\n node = openNodes.pop()\\n if problem.isGoalState(node.name): #Comprobamos si el nodo es Goal. Si lo es terminamos.\\n break\\n else: #Expandimos los nodos sucesores del nodo si no estan en closed\\n if nodeIsClosed(node, closedNodes) is False:\\n for successor in problem.getSuccessors(node.name):\\n n, p, c = successor\\n succNode = Node(n, p, c, node)\\n if nodeIsClosed(succNode, closedNodes) is False:\\n fn = problem.getCostOfActions(findPath(succNode)) + heuristic(succNode.name, problem);\\n openNodes.push(succNode, fn)\\n #Metemos el nodo en closed\\n closedNodes.add(node)\\n\\n #Devolvemos el camino al Goal\\n return findPath(node)\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from util import Stack\\n Pilha_Caminho = Stack()\\n Pilha_Estados = Stack()\\n Caminho = []\\n Visitados = []\\n\\n Pilha_Caminho.push(Caminho) # empilha caminho (vazio, no começo)\\n Pilha_Estados.push(problem.getStartState()) # empilha estado inicial\\n\\n while (Pilha_Caminho.isEmpty() == False and Pilha_Estados.isEmpty() == False):\\n Caminho_Andado = Pilha_Caminho.pop() # atualiza caminho\\n Estado_Atual = Pilha_Estados.pop() # atualiza estado\\n if problem.isGoalState(Estado_Atual): # caso estado atual seja o desejado,\\n return Caminho_Andado # retorna o caminho total\\n if Estado_Atual not in Visitados: # caso estado atual não tenha sido visitado\\n Visitados.append(Estado_Atual) # marca estado como visitado\\n for Sucessor in problem.getSuccessors(Estado_Atual): # busca sucessores\\n if Sucessor[0] not in Visitados: # caso sucessor não tenha sido visitado\\n Pilha_Caminho.push(Caminho_Andado + [Sucessor[1]]) # atualiza caminho total na pilha\\n Pilha_Estados.push(Sucessor[0]) # atualiza estado\\n return\",\n \"def depthOrBreadthFirstSearch(problem, container):\\n firstNode = (problem.getStartState(), None, 0, None)#state, action to reach, incremental cost, parent node\\n container.push(firstNode)\\n visitedStates = []\\n while (not container.isEmpty()):\\n if problem.getNodesExpandedNum() > MAX_NODES_TO_EXPLORE:\\n return None\\n curNode = container.pop()\\n if (problem.isGoalState(curNode[0])):\\n return getStatePathFromNode(curNode, problem)\\n for successor in problem.getSuccessors(curNode[0]):\\n if not successor[0] in visitedStates:\\n successorNode = (successor[0], successor[1], successor[2], curNode)\\n visitedStates.append(successor[0])\\n container.push(successorNode)\\n return None\",\n \"def search(self, board, depth, ply=0):\\n self.inc('nodes')\\n\\n if board.end is not None:\\n return self.endscore(board, ply)\\n\\n if depth <= 0:\\n self.inc('leaves')\\n return [], self.evaluate(board)\\n\\n bestmove = []\\n bestscore = -INF\\n for m in board.moves:\\n board.push(m)\\n nextmoves, score = self.search(board, depth - 1, ply + 1)\\n board.pop()\\n score = -score\\n # print(board.fen(), score)\\n if not bestmove or score >= bestscore:\\n bestscore = score\\n bestmove = [m] + nextmoves\\n\\n return bestmove, bestscore\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # initialize frontier using initial state of problem\\n current_state = problem.getStartState()\\n frontier = util.Queue()\\n frontier.push(current_state)\\n\\n # initialize explored set to be empty\\n explored_set = []\\n\\n # a dictionary to save how to get to certain states from initial state\\n actions_list = {current_state:[]}\\n\\n # loop while we still have unexplored nodes\\n while not frontier.isEmpty():\\n\\n # choose a leaf node and remove it from frontier\\n leaf_node = frontier.pop()\\n\\n # add the node to explored set\\n explored_set.append(leaf_node)\\n\\n # expand the chosen node\\n # and add to the frontier if not in frontier and explored set\\n for successor in problem.getSuccessors(leaf_node):\\n child, action, _ = successor\\n if child not in explored_set and child not in frontier.list:\\n # return the solution if it is the goal state\\n if problem.isGoalState(child):\\n return actions_list[leaf_node] + [action]\\n frontier.push(child)\\n actions_list[child] = actions_list[leaf_node] + [action]\\n else:\\n # search through all but still can't find a solution -> failed!\\n return 'failure'\",\n \"def Find_Path(self):\\n closed_nodes_map = [] # map of closed (tried-out) nodes\\n open_nodes_map = [] # map of open (not-yet-tried) nodes\\n dir_map = [] # map of directions\\n row = [0] * self.n\\n for i in range(self.m): # create 2d arrays\\n closed_nodes_map.append(list(row))\\n open_nodes_map.append(list(row))\\n dir_map.append(list(row))\\n \\n pq = [[], []] # priority queues of open (not-yet-tried) nodes\\n pqi = 0 # priority queue index\\n # create the start node and push into list of open nodes\\n n0 = node(self.xStart, self.yStart, 0.0, 0.0)\\n n0.updatePriority(self.xFinish, self.yFinish)\\n heappush(pq[pqi], n0)\\n open_nodes_map[self.yStart][self.xStart] = n0.priority # mark it on the open nodes map\\n \\n # A* search\\n while len(pq[pqi]) > 0:\\n # get the current node w/ the highest priority\\n # from the list of open nodes\\n n1 = pq[pqi][0] # top node\\n n0 = node(n1.xPos, n1.yPos, n1.distance, n1.priority)\\n x = n0.xPos\\n y = n0.yPos\\n heappop(pq[pqi]) # remove the node from the open list\\n open_nodes_map[y][x] = 0\\n # mark it on the closed nodes map\\n closed_nodes_map[y][x] = 1\\n \\n # quit searching when the goal state is reached\\n if x == self.xFinish and y == self.yFinish:\\n # Generate the path from finish to start by following the \\n # directions.\\n return self.Reconstruct_Path(dir_map)\\n \\n # generate moves (child nodes) in all possible directions\\n for i in range(self.num_directions):\\n new_x = x + self.dx[i]\\n new_y = y + self.dy[i]\\n Flag=True\\n if not (new_x < 0 or new_x > self.n-1 or new_y < 0 or new_y > self.m - 1\\n or self.MAP[new_y][new_x] == 1 or closed_nodes_map[new_y][new_x] == 1):\\n # Check to see if the extended path runs through any obstacles\\n if (abs(self.dx[i])>1 or abs(self.dy[i])>1):\\n # Need to check that the path does not pass an object\\n JumpCells=2*max(abs(self.dx[i]),abs(self.dy[i]))-1\\n for K in range(1,JumpCells):\\n YPOS=int(round(K*1.0*self.dy[i]/JumpCells))\\n XPOS=int(round(K*1.0*self.dx[i]/JumpCells))\\n if (self.MAP[y+YPOS][x+XPOS]==1):\\n Flag=False\\n if Flag: \\n # generate a child node\\n m0 = node(new_x, new_y, n0.distance, n0.priority)\\n m0.calc_cost(self.dx[i], self.dy[i])\\n m0.updatePriority(self.xFinish, self.yFinish)\\n # if it is not in the open list then add into that\\n if open_nodes_map[new_y][new_x] == 0:\\n open_nodes_map[new_y][new_x] = m0.priority\\n heappush(pq[pqi], m0)\\n # mark its parent node direction\\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\\n elif open_nodes_map[new_y][new_x] > m0.priority:\\n # update the priority info\\n open_nodes_map[new_y][new_x] = m0.priority\\n # update the parent direction info\\n dir_map[new_y][new_x] = (self.num_directions-i-1) % self.num_directions\\n # replace the node\\n # by emptying one pq to the other one\\n # except the node to be replaced will be ignored\\n # and the new node will be pushed in instead\\n while not (pq[pqi][0].xPos == new_x and pq[pqi][0].yPos == new_y):\\n heappush(pq[1 - pqi], pq[pqi][0])\\n heappop(pq[pqi])\\n heappop(pq[pqi]) # remove the wanted node\\n # empty the larger size pq to the smaller one\\n if len(pq[pqi]) > len(pq[1 - pqi]):\\n pqi = 1 - pqi\\n while len(pq[pqi]) > 0:\\n heappush(pq[1-pqi], pq[pqi][0])\\n heappop(pq[pqi]) \\n pqi = 1 - pqi\\n heappush(pq[pqi], m0) # add the better node instead\\n return '','' # no route found\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n # Frontier stored in a Stack\\n frontier = util.Stack()\\n\\n # Visited states stored in a list\\n visitedStates = []\\n\\n # Format of each element: (current coordinates, [path taken to get there]) \\n frontier.push((problem.getStartState(), []))\\n\\n # while there are still states to explore\\n while not frontier.isEmpty():\\n \\n # store the current state and path in separate variables\\n currentState, pathTaken = frontier.pop()\\n\\n # for skipping states that have already been visited\\n if currentState in visitedStates:\\n continue\\n\\n # for returning the correct path to the goal state upon discovering it\\n if problem.isGoalState(currentState):\\n return pathTaken\\n\\n # count the current state as \\\"visited\\\"\\n visitedStates.append(currentState)\\n\\n # for each successor state, check whether they have already been visited. if not, add their coordinates to the frontier, and append their respective direction to the path list\\n for coordinates, direction, cost in problem.getSuccessors(currentState):\\n\\n if coordinates not in visitedStates:\\n \\n frontier.push((coordinates, pathTaken + [direction]))\\n\\n\\n util.raiseNotDefined()\",\n \"def depthFirstSearch(problem):\\n \\n from game import Directions\\n North = Directions.NORTH\\n South = Directions.SOUTH\\n East = Directions.EAST\\n West = Directions.WEST \\n \\n pathDict = {}\\n visited = set()\\n #visited start\\n visited.add(problem.getStartState())\\n #initial successors\\n successor = problem.getSuccessors(problem.getStartState())\\n for initSucc in successor:\\n pathDict[initSucc[0]] = [initSucc[1]]\\n #loop\\n while (1):\\n #if fringe = null, return failure\\n if (len(successor) == 0):\\n print \\\"Fringe is empty\\\"\\n return util.raiseNotDefined()\\n #(v, path) = fringe.pop\\n succLocation = successor[0][0]\\n succDirection = successor[0][1]\\n del successor[0]\\n #if isGoal = true, return path\\n if problem.isGoalState(succLocation):\\n return pathDict[succLocation]\\n #if visited = false\\n if succLocation not in visited:\\n #visited = true\\n visited.add(succLocation)\\n #L = expand(v,path)\\n tempSuccList = problem.getSuccessors(succLocation)\\n #Fringe <- L\\n for succ in reversed(tempSuccList):\\n successor.insert(0,succ)\\n pathDict[succ[0]] = []\\n pathDict[succ[0]].extend(pathDict[succLocation])\\n pathDict[succ[0]].append(succ[1])\",\n \"def a_star_search(problem, heuristic=null_heuristic):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n fringe = util.PriorityQueue()\\r\\n path = set()\\r\\n final = []\\r\\n acts = dict()\\r\\n state = problem.get_start_state()\\r\\n fringe.push(state, 0)\\r\\n\\r\\n while (True):\\r\\n state = fringe.pop()\\r\\n path.add(state)\\r\\n states = problem.get_successors(state)\\r\\n acts[state] = states[:]\\r\\n if problem.is_goal_state(state):\\r\\n break\\r\\n\\r\\n states = problem.get_successors(state)\\r\\n # push into fringe\\r\\n for stat in states:\\r\\n if stat[0] not in path:\\r\\n \\\"\\\"\\\"\\r\\n it does worse in corners problems, to work better needs heavy huristic, not worth in\\r\\n in corners problem expandend nodes grow expo\\r\\n all others are better\\r\\n counter = 0 # in some situation it helps, in some it doesnt\\r\\n #print(stat[0].pieces)\\r\\n for x in stat[0].pieces[0]:\\r\\n if x:\\r\\n counter += 1\\r\\n \\\"\\\"\\\"\\r\\n counter = 0\\r\\n fringe.push(stat[0], stat[2] + counter + heuristic(stat[0], problem)) # problem.get_cost_of_actions([stat[1]])\\r\\n\\r\\n while (True):\\r\\n\\r\\n for key, val in acts.items():\\r\\n for va in val:\\r\\n if va[0] == state:\\r\\n final.append(va[1])\\r\\n state = key\\r\\n break\\r\\n else:\\r\\n continue\\r\\n break\\r\\n if state == problem.get_start_state():\\r\\n break\\r\\n\\r\\n final.reverse()\\r\\n\\r\\n return final\",\n \"def breadth_first_search(root_node):\\n if root_node.goal_test():\\n return root_node\\n\\n frontier = [root_node]\\n explored = []\\n\\n while frontier:\\n node = frontier.pop(0)\\n explored.append(node)\\n\\n for successor in node.generate_successors():\\n if not successor:\\n continue\\n if not (successor.is_in(frontier) and successor.is_in(explored)):\\n if successor.goal_test():\\n return successor\\n frontier.append(successor)\\n return None # No Solution\",\n \"def depthFirstSearch(problem):\\n from game import Directions\\n s = Directions.SOUTH\\n w = Directions.WEST\\n n = Directions.NORTH\\n e = Directions.EAST\\n \\n visitedlist = []\\n st = Stack()\\n outputlist = []\\n st.push(problem.getStartState())\\n visitedlist.append(problem.getStartState())\\n recurseDFS(st,problem,visitedlist)\\n if st.isEmpty():\\n print \\\"No Path exist\\\"\\n else:\\n while not st.isEmpty():\\n value = st.pop()\\n if len(value) == 2:\\n continue\\n if value[1] == 'South':\\n outputlist.append(s)\\n elif value[1] == 'North':\\n outputlist.append(n)\\n elif value[1] == 'East':\\n outputlist.append(e)\\n elif value[1] == 'West':\\n outputlist.append(w)\\n \\n return outputlist[::-1]\",\n \"def breadth_first_graph_search(problem):\\n node = Node(problem.initial)\\n if problem.goal_test(node.state):\\n return node\\n frontier = collections.deque([node])\\n explored = set()\\n while frontier:\\n node = frontier.popleft()\\n explored.add(node.state)\\n for child in node.expand(problem):\\n if child.state not in explored and child not in frontier:\\n if problem.goal_test(child.state):\\n return child\\n frontier.append(child)\\n return None\",\n \"def search(state, cut_value, game, prune=True):\\n print (game.step)\\n f = open(\\\"search_tree_\\\" + str(game.step) + \\\".txt\\\", 'w')\\n\\n def max_value(state, alpha, beta, depth, node):\\n start = time.time()\\n if game.cutoff(state, depth):\\n return game.evaluate(state), None\\n val = -inf\\n action = None\\n pre_val = game.evaluate(state)\\n print (\\\"pre \\\" + str(pre_val))\\n for a, s in game.successors(state):\\n #print (str(a))\\n cur_val = game.evaluate(s)\\n #print (str(a) + ':' + str(cur_val))\\n node_child = Search_node(node, a, cur_val)\\n node.add_child(node_child)\\n if cur_val > pre_val + cut_value:\\n v, _ = min_value(s, alpha, beta, depth + 1, node_child)\\n f.write(\\\"a: \\\" + str(a) + \\\"; v: \\\" + str(v) + \\\"; depth:\\\" + \\\\\\n str(depth) + \\\"; alpha:\\\" + str(alpha) + \\\"; beta:\\\" + str(beta) \\\\\\n + \\\" \\\\n\\\")\\n else:\\n v = cur_val\\n if v > val:\\n val = v\\n action = a\\n if prune:\\n if v >= beta:\\n return v, a\\n alpha = max(alpha, v)\\n end = time.time()\\n print(\\\"max t:\\\" + str(end - start))\\n return val, action\\n\\n def min_value(state, alpha, beta, depth, node):\\n if game.cutoff(state, depth):\\n return game.evaluate(state), None\\n val = inf\\n action = None\\n pre_val = game.evaluate(state)\\n print (\\\"min pre \\\" + str(pre_val))\\n for a, s in game.successors(state):\\n cur_val = game.evaluate(s)\\n node_child = Search_node(node, a, cur_val)\\n node.add_child(node_child)\\n if cur_val < pre_val - cut_value:\\n v, _ = max_value(s, alpha, beta, depth + 1, node_child)\\n # f.write(\\\"a: \\\" + str(a) + \\\"; v: \\\" + str(v) + \\\"; depth:\\\" + \\\\\\n # str(depth) + \\\"; alpha:\\\" + str(alpha) + \\\"; beta:\\\" + str(beta) + \\\" \\\\n\\\")\\n else:\\n v = cur_val\\n if v < val:\\n val = v\\n action = a\\n if prune:\\n if v <= alpha:\\n return v, a\\n beta = min(beta, v)\\n return val, action\\n\\n root_node = Search_node(None, None, 0)\\n\\n _, action = max_value(state, -inf, inf, 0, root_node)\\n root_node.print_tree()\\n f.close()\\n return action\",\n \"def select(self):\\n current = self.root\\n actions = []\\n while not current.is_leaf:\\n # print(\\\"Selection... considering between:\\\")\\n # print([\\\"{} ({:.2f})\\\".format(n, n.ucb) for n in current.visited_children])\\n # print(\\\"Node's stats say that best child is {} ({})\\\".format(current.best_child, current.best_child.ucb))\\n current = current.best_child\\n actions.append(current.previous_action)\\n # print(\\\"Selected\\\", current)\\n # print()\\n\\n for a in actions:\\n self.sim.play_action(a)\\n # print(\\\"--------------------------------------\\\")\\n return current\",\n \"def aStarSearch(problem, heuristic=nullHeuristic):\\n\\t\\\"*** YOUR CODE HERE ***\\\"\\n\\n\\t# Create the priority queue, and visited array to keep track of visited nodes.\\n\\tdfsStack = util.PriorityQueue()\\n\\tvisited = []\\n\\t# Get the first state in the graph, push to the priority queue\\n\\tfirst = problem.getStartState()\\n\\tdfsStack.push([first, [], 0], 0)\\n\\n\\t# While the priority queue is not empty, pop the first node from the priority queue, and check if that state\\n # is the goal state. If so, return the actions for that node. Otherwise, append that state\\n # to the visited array, get its successors, and push them to the priority queue.\\n\\twhile not dfsStack.isEmpty():\\n\\t\\tNewNode = dfsStack.pop()\\n\\t\\tif((problem.isGoalState(NewNode[0]) == True)):\\n\\t\\t\\treturn NewNode[1]\\n\\t\\tif(NewNode[0] not in visited):\\n\\t\\t\\tvisited.append(NewNode[0])\\n\\t\\t\\tfor NextNode in problem.getSuccessors(NewNode[0]):\\n\\t\\t\\t\\tif NextNode[0] not in visited:\\n\\t\\t\\t\\t\\tcumulativeCost = NextNode[2] + NewNode[2]\\n\\t\\t\\t\\t\\theuristicCost = cumulativeCost + heuristic(NextNode[0], problem)\\n\\t\\t\\t\\t\\tdfsStack.push((NextNode[0], NewNode[1] + [NextNode[1]], cumulativeCost), heuristicCost)\",\n \"def solve(start, goal, problem):\\r\\n explored = set()\\r\\n frontier = []\\r\\n node = Node(0, 0, start, None, None)\\r\\n # push the start node to the beam\\r\\n heappush(frontier, node)\\r\\n explorationPath = []\\r\\n\\r\\n while (True):\\r\\n # if all nodes in the beam are explored and path is not found, then\\r\\n # there exists no path.\\r\\n if len(frontier) == 0:\\r\\n return \\\"Path does not exists.\\\"\\r\\n\\r\\n prevnode = node\\r\\n node = heappop(frontier)\\r\\n\\r\\n if getBestNodeDistance(prevnode.state, node.state) > 1:\\r\\n explorationPath.extend(backtrackSearch(prevnode, node, problem))\\r\\n else:\\r\\n explorationPath.append(node.state)\\r\\n\\r\\n explored.add(node.state)\\r\\n # get the list of all possible actions on the state\\r\\n Actions = findActions(problem, node.state)\\r\\n # expand a node and generate children\\r\\n for action in Actions:\\r\\n # generate a child node by applying actions to the current state\\r\\n neighbour = generateChild(problem, goal, node, action)\\r\\n\\r\\n if neighbour != None:\\r\\n # goal test the current node\\r\\n if goalTest(neighbour, goal):\\r\\n explorationPath.append(goal)\\r\\n # get the solution(seq. of actions)\\r\\n return getExploredPath(explorationPath)\\r\\n\\r\\n # check if child is already explored or present in beam\\r\\n if neighbour not in frontier and neighbour.state not in explored:\\r\\n #add node to frontier only if it can contain within best k nodes\\r\\n heappush(frontier, neighbour)\\r\\n if(len(frontier) > BEAM_SIZE):\\r\\n del frontier[-1]\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n path_to_point = {}\\n cost_to_point = {}\\n\\n # Get the start node\\n start_node = problem.getStartState()\\n fringe_node = [start_node]\\n path_to_point[start_node] = []\\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\\n\\n goal_found = False\\n\\n while(not goal_found):\\n #for i in range(100): \\n nodes_to_expand = set()\\n # get max value node in the fringe node\\n min_val = float(\\\"inf\\\")\\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] < min_val:\\n min_val = cost_to_point[one_node]\\n \\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] == min_val:\\n nodes_to_expand.add(one_node)\\n fringe_node.remove(one_node)\\n\\n # Expand the fringe node \\n for one_node in nodes_to_expand:\\n path_to_parent = path_to_point[one_node]\\n for nxt_node in problem.getSuccessors(one_node):\\n pos = nxt_node[0]\\n mv = nxt_node[1]\\n # check if point already present in path to point\\n prev_cost = float(\\\"inf\\\")\\n if pos in cost_to_point:\\n prev_cost = cost_to_point[pos]\\n new_path = path_to_parent + [mv]\\n if prev_cost > problem.getCostOfActions(new_path):\\n path_to_point[pos] = new_path\\n cost_to_point[pos] = problem.getCostOfActions(new_path)\\n fringe_node.append(pos)\\n\\n # Check if destination is reached in the fringe node\\n for one_node in fringe_node:\\n if problem.isGoalState(one_node):\\n final_node = one_node\\n goal_found = True\\n break\\n \\n #print(len(fringe_node))\\n print(final_node)\\n print(path_to_point[final_node])\\n return path_to_point[final_node] \\n\\n util.raiseNotDefined()\",\n \"def AStar_search(problem, heuristic=nullHeuristic):\\n root_node = Node(problem.getStartState(), [], 0, None, 0)\\n frontier = util.PriorityQueue()\\n frontier.push(root_node, 0 + heuristic(root_node.state, problem))\\n explored = []\\n nodes_list = list(problem.G.nodes)\\n # heuristic_value = [heuristic(x,problem) for x in nodes_list]\\n # print problem.start_node\\n # print problem.end_node\\n while not(frontier.isEmpty()):\\n\\n \\tnode_to_explore = frontier.pop()\\n \\tif problem.isGoalState(node_to_explore.state):\\n \\t\\t# recontruct_path\\n \\t\\t# print \\\"Some thing\\\"\\n \\t\\t# print node_to_explore.parent_node.state\\n \\t\\troute_list = [node_to_explore.state]\\n \\t\\tparent = node_to_explore.parent_node\\n \\t\\twhile parent != None:\\n \\t\\t\\troute_list.append(parent.state)\\n \\t\\t\\tparent = parent.parent_node\\n \\t\\troute_list.reverse()\\n \\t\\t# print route_list\\n \\t\\treturn route_list\\n \\telse:\\n\\t\\t\\tcopy_state = node_to_explore.state\\n\\t\\t\\t# successors_state = problem.getSuccessors(copy_state)\\n\\t\\t\\tif copy_state not in explored:\\n\\t\\t\\t\\texplored.append(copy_state)\\n\\t\\t\\t\\tsuccessors_state = problem.getSuccessors(copy_state)\\n\\t\\t\\t\\tif len(successors_state) > 0:\\n\\t\\t\\t\\t\\tfor suc_act_cost in successors_state:\\n\\t\\t\\t\\t\\t\\tif suc_act_cost[0] in explored:\\n\\t\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tcost = node_to_explore.path_cost + suc_act_cost[2]\\n\\t\\t\\t\\t\\t\\t\\tcost_with_heuristic = cost + heuristic(suc_act_cost[0], problem)\\n\\t\\t\\t\\t\\t\\t\\tfrontier.update(Node(suc_act_cost[0], suc_act_cost[1], cost , node_to_explore, node_to_explore.depth + 1), cost_with_heuristic)\\n\\t\\t # util.raiseNotDefined()\\n # print len(explored)\",\n \"def depthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n from util import Stack\\n \\n st = Stack()\\n mapper = {}\\n mapper[problem.getStartState()] = None\\n\\n st.push(problem.getStartState())\\n while not(st.isEmpty()):\\n vertex = st.pop()\\n \\n if (problem.isGoalState(vertex)):\\n c = vertex\\n l = []\\n while mapper[c] != None:\\n tup = mapper[c]\\n l.append(tup[1])\\n c = tup[0]\\n l.reverse()\\n print l\\n return l\\n\\n else:\\n neigh = problem.getSuccessors(vertex)\\n # neigh.reverse()\\n # neigh.sort()\\n for child in neigh:\\n if child[0] not in mapper:\\n st.push(child[0])\\n mapper[child[0]] = (vertex, child[1])\\n # print mapper\\n \\n # visited = []\\n # p = dfsRecursive(problem, problem.getStartState(), st, visited, [])\\n # return p\\n \\n # pathfind = {}\\n # st.push(problem.getStartState())\\n # iterative approach:\\n # while (not st.isEmpty()):\\n # point = st.pop() # (x,y)\\n # if problem.isGoalState(point):\\n # # print point\\n # print pathfind\\n # # print visited\\n # elif (not (point in visited)):\\n # visited.append(point)\\n # # print pathfind, '\\\\n'\\n # print visited, '\\\\n'\\n # for child in problem.getSuccessors(point):\\n # st.push(child[0])\\n # pathfind[child[0]] = point #this preemptively adds!\\n # util.raiseNotDefined()\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n # fringe priority queue\\n fringe = util.PriorityQueue()\\n fringe.push([problem.getStartState()],1) # fringe will have (priority, order, [s0,s1,..])\\n\\n # closed set\\n closed = []\\n\\n i = 0\\n while not fringe.isEmpty():\\n\\n # get highest priority path for expansion e.g. [s0,s2,s4]\\n path_exp = fringe.pop()\\n\\n # take last node in path e.g. s4\\n node_exp = path_exp[-1]\\n\\n # check goal state\\n if problem.isGoalState(node_exp): # check if goal\\n actions = actions_for_path(problem,path_exp)\\n #import pdb; pdb.set_trace()\\n return actions\\n\\n # add expanded node into closed set e.g. [s0,s1,s2]\\n if node_exp not in closed:\\n closed.append(node_exp)\\n else:\\n # if it's in the closed set, don't expand\\n continue\\n\\n # get sucessors to expand fringe\\n successors = problem.getSuccessors(node_exp)\\n for successor in successors:\\n # unpack states, actions\\n ss,aa,_ = successor\\n if ss not in closed:\\n path = path_exp+[ss]\\n # expand fringe by adding candidate paths, prioritize by len of path\\n fringe.push(path,len(path))\\n\\n #i+=1\\n if i==1000:\\n import pdb; pdb.set_trace()\\n\\n util.raiseNotDefined()\",\n \"def breadthFirstSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n visited=[]\\n \\n node=dict()\\n start=problem.getStartState()\\n node['parent']=None\\n node['direction']=None\\n node['state']=start\\n \\n \\n qu.push(node)\\n lis.append(node)\\n \\n print qu.list\\n while qu.isEmpty()!=True:\\n node=qu.pop()\\n pos=node['state']\\n visited.append(pos)\\n print visited\\n if problem.isGoalState(pos):\\n print \\\"found\\\"\\n return getPath(problem,node)\\n #break\\n suc=problem.getSuccessors(pos)\\n if suc ==None:\\n continue \\n \\n print suc\\n for step in suc:\\n #if step not in dic :\\n if step[0] not in visited:\\n childnode={}\\n childnode['parent']=pos\\n childnode['direction']=step[1]\\n childnode['state']=step[0]\\n qu.push(childnode)\\n lis.append(childnode)\\n \\n\\n #util.raiseNotDefined()\",\n \"def bfs(board, start_position, start_actions, predicate):\\n queue = Queue()\\n visited = set()\\n start_node = PositionNode(None, start_position, None)\\n visited.add(start_position)\\n # start actions are actions that have not been pruned\\n for action in start_actions:\\n next_pos = start_node.next(action)\\n visited.add(next_pos)\\n node = PositionNode(start_node, next_pos, action)\\n queue.put(node)\\n\\n while not queue.empty():\\n node = queue.get()\\n if predicate.test(board, node.position):\\n return node\\n for action in [Action.Up.value, Action.Down.value, Action.Left.value, Action.Right.value]:\\n next_pos = node.next(action)\\n if valid_agent_position(board, next_pos) and next_pos not in visited:\\n queue.put(PositionNode(node, next_pos, action))\\n visited.add(next_pos)\\n return None # no goal node found\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7513152","0.7225696","0.7204362","0.7134987","0.71109664","0.7070234","0.70049804","0.69962883","0.6984793","0.6974376","0.6913317","0.69028807","0.6886942","0.6876935","0.68767977","0.6869486","0.682488","0.67664015","0.67569697","0.675022","0.6741336","0.6737866","0.6714954","0.66934043","0.6689023","0.66847706","0.66661","0.6659621","0.66533226","0.66294825","0.66226184","0.65980095","0.6596372","0.65492517","0.65408874","0.65381247","0.653215","0.6521927","0.6502367","0.64879924","0.6484481","0.6478028","0.6472891","0.64682406","0.64432067","0.6439029","0.6420552","0.64182293","0.6417508","0.64170635","0.6410576","0.64056027","0.6384933","0.63841337","0.6379074","0.6363776","0.6358799","0.6358086","0.63428706","0.6342157","0.6335386","0.6335212","0.6323314","0.63201284","0.6307738","0.6276376","0.6272515","0.62643844","0.6263922","0.6262193","0.62613004","0.62584645","0.62520427","0.6244341","0.6240211","0.62378883","0.6226281","0.62235636","0.6195441","0.61952204","0.6189542","0.6188558","0.61763936","0.6154804","0.615266","0.6132127","0.612974","0.61238754","0.6121147","0.6112448","0.61088526","0.6105976","0.6105303","0.6100337","0.60999846","0.6099666","0.6092223","0.60920227","0.6090946","0.60845363"],"string":"[\n \"0.7513152\",\n \"0.7225696\",\n \"0.7204362\",\n \"0.7134987\",\n \"0.71109664\",\n \"0.7070234\",\n \"0.70049804\",\n \"0.69962883\",\n \"0.6984793\",\n \"0.6974376\",\n \"0.6913317\",\n \"0.69028807\",\n \"0.6886942\",\n \"0.6876935\",\n \"0.68767977\",\n \"0.6869486\",\n \"0.682488\",\n \"0.67664015\",\n \"0.67569697\",\n \"0.675022\",\n \"0.6741336\",\n \"0.6737866\",\n \"0.6714954\",\n \"0.66934043\",\n \"0.6689023\",\n \"0.66847706\",\n \"0.66661\",\n \"0.6659621\",\n \"0.66533226\",\n \"0.66294825\",\n \"0.66226184\",\n \"0.65980095\",\n \"0.6596372\",\n \"0.65492517\",\n \"0.65408874\",\n \"0.65381247\",\n \"0.653215\",\n \"0.6521927\",\n \"0.6502367\",\n \"0.64879924\",\n \"0.6484481\",\n \"0.6478028\",\n \"0.6472891\",\n \"0.64682406\",\n \"0.64432067\",\n \"0.6439029\",\n \"0.6420552\",\n \"0.64182293\",\n \"0.6417508\",\n \"0.64170635\",\n \"0.6410576\",\n \"0.64056027\",\n \"0.6384933\",\n \"0.63841337\",\n \"0.6379074\",\n \"0.6363776\",\n \"0.6358799\",\n \"0.6358086\",\n \"0.63428706\",\n \"0.6342157\",\n \"0.6335386\",\n \"0.6335212\",\n \"0.6323314\",\n \"0.63201284\",\n \"0.6307738\",\n \"0.6276376\",\n \"0.6272515\",\n \"0.62643844\",\n \"0.6263922\",\n \"0.6262193\",\n \"0.62613004\",\n \"0.62584645\",\n \"0.62520427\",\n \"0.6244341\",\n \"0.6240211\",\n \"0.62378883\",\n \"0.6226281\",\n \"0.62235636\",\n \"0.6195441\",\n \"0.61952204\",\n \"0.6189542\",\n \"0.6188558\",\n \"0.61763936\",\n \"0.6154804\",\n \"0.615266\",\n \"0.6132127\",\n \"0.612974\",\n \"0.61238754\",\n \"0.6121147\",\n \"0.6112448\",\n \"0.61088526\",\n \"0.6105976\",\n \"0.6105303\",\n \"0.6100337\",\n \"0.60999846\",\n \"0.6099666\",\n \"0.6092223\",\n \"0.60920227\",\n \"0.6090946\",\n \"0.60845363\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.655119"},"document_rank":{"kind":"string","value":"33"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":765,"numItemsPerPage":100,"numTotalItems":95772,"offset":76500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjUyMjY4NSwianRpIjoiOTdkNWEzN2UtZjYwNi00NGQwLThlYmQtMDEzMTVhZTY1OTFlIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY1MjYyODUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.BlEeiKULqGUjv_lICmawJ8tIirRNlguMHQaOm6ti2UZVXAlCXCkC_BV9EiNHCwxePEdDQvHh3-s1hYSdNDsWCw","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 |
|---|---|---|---|---|---|---|
The function makes currying. | def carry(function):
def dec_1(first_arg):
def dec_2(second_arg):
def dec_3(third_arg):
def dec_4(fourth_arg):
print(first_arg + second_arg +
third_arg + fourth_arg)
return function
return dec_4
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def curry(func):\n def curried(*args, **kwargs):\n return func(args, **kwargs)\n return curried",
"def _(func, *args, **kwargs):\r\n return CurryingWrapper(func, *args, **kwargs)",
"def _compat_curry(fun, *args, **kwargs):\n\n def _curried(*addargs, **addkwargs):\n return fun(*(args+a... | [
"0.8128945",
"0.75029737",
"0.7459536",
"0.7189017",
"0.70955986",
"0.7085532",
"0.70025253",
"0.6770132",
"0.6730792",
"0.6678913",
"0.6391263",
"0.6336106",
"0.6202939",
"0.6059338",
"0.5997176",
"0.59315217",
"0.5907922",
"0.58864945",
"0.58152425",
"0.5729332",
"0.5727609... | 0.5496153 | 41 |
The function to curry. | def given_func(arg_1, arg_2, arg_3, arg_4):
return arg_1 + arg_2 + arg_3 + arg_4 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def curry(func):\n def curried(*args, **kwargs):\n return func(args, **kwargs)\n return curried",
"def curry2(f):\n return lambda x: lambda y: f(x, y)",
"def curry(f: Callable) -> Callable:\n @functools.wraps(f)\n def decorator(*args: object, **kwargs: object) -> Any:\n return Curr... | [
"0.7753282",
"0.7037408",
"0.7028376",
"0.7009016",
"0.6910099",
"0.68881893",
"0.680502",
"0.6618646",
"0.6539153",
"0.6523903",
"0.649776",
"0.62962383",
"0.62244517",
"0.6130228",
"0.59942424",
"0.5978484",
"0.5952794",
"0.5945213",
"0.59353554",
"0.586335",
"0.5792939",
... | 0.0 | -1 |
Main loop of the game | def gameloop(self):
# What you see above (""" some text """) is called a docstring.
# It explains the purpose of the method/function.
# There should generally be one for every function.
# Below is the main loop
while True:
# One cycle in the loop is equiv... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Gameloop():",
"def main():\n g = Game(800, 600)\n g.start()",
"def main():\r\n gameclass = data.game.GameClass()\r\n gameclass.main_loop()",
"def GAME_LOOP():\n pass",
"def main():\n g = DemoGame(800, 600)\n g.start()",
"def game_loop(self):\n self.interface.game_loop(... | [
"0.8618443",
"0.8491576",
"0.8377245",
"0.8225048",
"0.8171834",
"0.8108598",
"0.80508864",
"0.80445045",
"0.80276704",
"0.79887885",
"0.79750353",
"0.79735273",
"0.7931562",
"0.78987134",
"0.7891214",
"0.7877787",
"0.78247064",
"0.7808233",
"0.77779156",
"0.7738986",
"0.7738... | 0.7991744 | 9 |
Refreshes the screen, and keeps the framerate stable | def update_display(self):
# The display.update() Updates the screen, making the new frame replace the old one.
pg.display.update()
# clock.tick sets a framerate for the game.
# This is to make the game run at a stable fps
self.clock.tick(cng.FRAMERATE) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self) -> None:\n self.screen.refresh()",
"def refresh_screen(self):",
"def _update_screen(self):\n self.screen.fill((250,250,250))\n self.rocket.blitme()\n pygame.display.flip()",
"def update(self):\r\n pygame.display.update()\r\n return",
"def _refresh... | [
"0.83246535",
"0.7862803",
"0.76323617",
"0.752276",
"0.7522323",
"0.74499613",
"0.73839813",
"0.7364671",
"0.7351016",
"0.72493345",
"0.7239161",
"0.70169955",
"0.70018166",
"0.6962198",
"0.69360656",
"0.6918648",
"0.6893443",
"0.68931735",
"0.687911",
"0.6869362",
"0.684624... | 0.75532764 | 3 |
Widget to reclassify raster/feature_class into local classes | def __init__(self, *args, **kwargs):
self.dense = True
# Create table
super().__init__(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reclassify(self):\n if not self.checkConditions():\n return\n \n somethingMade = False\n reclassifiedFeatures = 0\n \n #button that sent the signal\n self.buttonName = self.sender().text()\n (reclassificationLayer, self.category, self.edgvClass... | [
"0.6807139",
"0.56661713",
"0.558603",
"0.5570115",
"0.5464505",
"0.52979136",
"0.5291363",
"0.52849865",
"0.5284896",
"0.52798796",
"0.5200945",
"0.51445824",
"0.5142979",
"0.51421237",
"0.51225793",
"0.51190907",
"0.51189446",
"0.5117211",
"0.51104474",
"0.5097539",
"0.5094... | 0.0 | -1 |
Init table reading local classes file and code/categories fields | def _get_matrix(self, code_fields, classes_file=''):
self.matrix = {}
# Set empty items if there is not a file selected
self.items = []
if classes_file: self.items = self.read_classes_from_file(classes_file)
headers = ['From: user code... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwargs):\n TableLoader.__init__(self, **kwargs)\n \n self._top_level_categories_ = ['Mathematics',\n 'People',\n 'Science',\n 'Law',\n 'History',\n 'Culture',\n 'Politics',\n 'Technology',\n 'Education',\n ... | [
"0.68784857",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.67007977",
"0.6250758",
"0.6238833",
"0.6183437",
"0.61654633",
"0.61508626",
"0.6150765",
"0.6121898",
"0.6098673",
"0... | 0.0 | -1 |
Read classes from .csv file | def read_classes_from_file(self, class_file):
items = []
with open(class_file) as f:
for cl in f.readlines():
# c:code, d:description
item = [{'value': c, 'text': f'{c}: ' + d.replace('\n','')} for c, d in [cl.split(',')]]
items+=item
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv():",
"def load_class_list():\r\n try:\r\n firstLine = True #keeping track of the first line in the csv file (the header)\r\n index = 0\r\n if os.access(\"mySchedule.csv\", os.F_OK): #If the file exists\r\n f = open(\"mySchedule.csv\")\r\n for row in csv.... | [
"0.73640335",
"0.7316954",
"0.7263384",
"0.7037231",
"0.7030433",
"0.69492215",
"0.6938637",
"0.68829817",
"0.6876325",
"0.67768806",
"0.677276",
"0.670412",
"0.6661229",
"0.6641916",
"0.6617991",
"0.65395534",
"0.64838445",
"0.64634323",
"0.64495176",
"0.6403338",
"0.6369451... | 0.57443583 | 73 |
Store user row code and new select value (file class) | def store(self, code, change):
self.matrix[code] = change['new'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_row_to_insert(self, data_row, option_file):\n data_dict = {}\n\n if(option_file == 'distelec'):\n data_dict = {\n \"codigo_electoral\": data_row[0],\n \"provincia\": data_row[1].strip(),\n \"canton\": data_row[2].strip(),\n ... | [
"0.593672",
"0.5832076",
"0.5602219",
"0.55295897",
"0.5498477",
"0.5468663",
"0.53920156",
"0.53917986",
"0.5379102",
"0.535196",
"0.53162205",
"0.5312261",
"0.5241234",
"0.5227456",
"0.51944655",
"0.5179577",
"0.51707476",
"0.5152179",
"0.5152179",
"0.5084932",
"0.5078263",... | 0.0 | -1 |
Get class selector on the fly and store code to matrix | def get_classes(self, code):
select = v.Combobox(
_metadata={'name':code},
items=self.items,
v_model=None,
dense=True,
hide_details=True
)
select.observe(partial(self.store, code), 'v_model')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_class(numlist,classlist=string.ascii_lowercase):\n\n return np.vectorize(lambda t: classlist[t])(numlist)",
"def to_class(numlist,classlist=string.ascii_lowercase):\n\n return np.vectorize(lambda t: classlist[t])(numlist)",
"def identify_class(self, cls):",
"def _classifier(self, classes):\n ... | [
"0.5367522",
"0.5367522",
"0.5352208",
"0.5264769",
"0.52475744",
"0.52023804",
"0.5068794",
"0.5063609",
"0.50205195",
"0.5015453",
"0.50087535",
"0.49962926",
"0.49717507",
"0.49532643",
"0.49110916",
"0.49093753",
"0.48867622",
"0.48821568",
"0.4837388",
"0.48327234",
"0.4... | 0.0 | -1 |
Clone or pull repo using Git depending on if it exists or not. | def update_git_repo(webhook):
# TODO: Fail fast if a repo doesn't exist
project_path = os.path.join(Global.PROJECTS_PATH, Global.repo_full_name(webhook))
if os.path.exists(project_path):
output = Git.pull_repo(project_path, webhook)
else:
output = Git.clone_repo(p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _clone_gitrepo():\n # Puts git repo in ~/.ssh/config to avoid interaction due to missing known_hosts\n git_server = urllib.splituser(urllib.splittype(env.project['git_repo'])[0])[1]\n if not files.exists('~/.ssh/config') or not files.contains('~/.ssh/config', git_server):\n files.append('~/.ssh... | [
"0.73447335",
"0.73035216",
"0.72421116",
"0.7090096",
"0.6912739",
"0.6888623",
"0.6865049",
"0.68422073",
"0.6772946",
"0.67509604",
"0.6737348",
"0.6725153",
"0.66586995",
"0.66022795",
"0.6589142",
"0.6562682",
"0.64966714",
"0.6482546",
"0.64669746",
"0.6456992",
"0.6408... | 0.5928002 | 64 |
Pull updates for a repo in the Harvey projects folder. | def pull_repo(project_path, webhook):
try:
final_output = subprocess.check_output(
# TODO: Rebase without the need to specify the branch
f'git -C {project_path} pull --rebase origin main',
stdin=None,
stderr=None,
shell=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_from_repo():\n\treturn",
"def pull(args):\n do_all_projects(args + [\"pull\"])",
"def update():\n call('git -C ~/norminette+ pull', shell=True)",
"def run(self):\n self.update_repos()",
"def git_pull(where=None):\n config = get_config(where)\n with settings(host_string=config['h... | [
"0.73854375",
"0.72276235",
"0.7226156",
"0.69447446",
"0.6878521",
"0.68385345",
"0.66932493",
"0.6640741",
"0.66180634",
"0.6557121",
"0.64469326",
"0.63802475",
"0.63315153",
"0.6311704",
"0.62625736",
"0.62582576",
"0.62278783",
"0.6208341",
"0.61823314",
"0.6167809",
"0.... | 0.67034894 | 6 |
Clone a repo into the Harvey projects folder. | def clone_repo(project_path, webhook):
try:
final_output = subprocess.check_output(
f'git clone --depth=10 {Global.repo_url(webhook)} {project_path}',
stdin=None,
stderr=None,
shell=True,
timeout=Global.GIT_TIMEOUT,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clone():\n with cd(os.path.dirname(env.proj_root.rstrip('/'))):\n run('git clone --recursive %s' % (git_repo,))",
"def clone_repo():\n with settings(warn_only=True):\n run('git clone %(repository_url)s %(repo_path)s' % env)",
"def clone(self):\n out, err, code = self.command( [\"... | [
"0.77692336",
"0.7594056",
"0.73292404",
"0.73037136",
"0.7276886",
"0.72755396",
"0.72170615",
"0.7151643",
"0.6946478",
"0.69039273",
"0.68761927",
"0.683624",
"0.6801833",
"0.67621565",
"0.66591036",
"0.66388273",
"0.659276",
"0.65672845",
"0.6550663",
"0.65505",
"0.653900... | 0.70394915 | 8 |
Generate a file that represents locations in Calliope. | def construct_locations(path_to_shapes, path_to_land_eligibility_km2, path_to_hydro_capacities_mw,
path_to_biofuel_potential_mwh, flat_roof_share, maximum_installable_power_density,
scaling_factors, biofuel_efficiency, path_to_output_yaml, path_to_output_csv):
locatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeLocationPtShapefile(config,locationData):\n\n\n # set up the shapefile driver\n driver = ogr.GetDriverByName(\"ESRI Shapefile\")\n\n num_years = config.EndYear\n \n for iteration in range(config.MinimumIteration, config.MaximumIteration + 1):\n for year in range(1, num_years + 1):\n\n... | [
"0.63554776",
"0.62833744",
"0.62250984",
"0.6023786",
"0.5978605",
"0.5890049",
"0.58753896",
"0.5832321",
"0.5797035",
"0.5796448",
"0.5791602",
"0.57861376",
"0.5766778",
"0.57144153",
"0.5708117",
"0.57072043",
"0.56742126",
"0.5648806",
"0.5602178",
"0.55888146",
"0.5572... | 0.5993339 | 4 |
Compute weighted UniFrac with or without branch length normalization | def weighted_unifrac(u_counts, v_counts, otu_ids, tree, normalized=False,
validate=True, **kwargs):
if validate:
_validate(u_counts=u_counts, v_counts=v_counts,
otu_ids=otu_ids, tree=tree)
u_obs_otu_counts = _observed_otu_counts(u_counts, otu_ids)
u_total_count... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_weights(self, w):\n n = w.astype(np.float64, copy=True)\n c = float(np.sum(w))\n n /= c\n return n",
"def compute_norm_fac_per_weight(fan_in):\n ksi = 1. / math.sqrt(fan_in)\n return (1 / 3) * ksi ** 2",
"def u(self, k, m, z):\n result = (1. - self.fb) * sel... | [
"0.62866193",
"0.6168332",
"0.60630053",
"0.60494703",
"0.5957002",
"0.59218806",
"0.5918151",
"0.58993274",
"0.58558947",
"0.5850155",
"0.5842917",
"0.5827281",
"0.5779808",
"0.5770108",
"0.5739889",
"0.56738794",
"0.56464136",
"0.56451756",
"0.56447554",
"0.56447554",
"0.56... | 0.61756164 | 1 |
to be call with .csv to return csv see views landcover/get_landcover_csv.csv | def get_landcover():
wdpaid = request.args[0]
landcover = db(db.landcover.wdpaid==wdpaid).select(db.landcover.lc_2000, db.landcover.lc_2010, db.landcover.areakm2)
return dict(landcover=landcover) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv():",
"def main(csv_name):\n BASE_URL = \"https://www.thrashermagazine.com/{}\"\n COVER_URL = BASE_URL.format(\"covers/\")\n\n page = requests.get(COVER_URL)\n\n soup = BeautifulSoup(page.content, 'html.parser')\n image_spans = soup.find_all(\"span\", class_=\"icons\")\n date_spans ... | [
"0.66249716",
"0.6470151",
"0.6278387",
"0.62153035",
"0.6078332",
"0.60775775",
"0.6066134",
"0.60183424",
"0.5897358",
"0.58904845",
"0.58735585",
"0.5837709",
"0.58255124",
"0.5822193",
"0.57970434",
"0.57764256",
"0.5771422",
"0.57561743",
"0.57504046",
"0.57358587",
"0.5... | 0.0 | -1 |
Assert that two Expressions are equal | def assert_equal(left, right):
msg = "{} != {}".format(left, right)
assert left == right, msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assertExpressionEqual(self, left, right):\n\n stmt = sa.select([left.label(\"value\")], from_obj=self.table)\n result = self.engine.execute(stmt)\n left_result = [row[\"value\"] for row in result]\n\n\n stmt = sa.select([right.label(\"value\")], from_obj=self.table)\n result ... | [
"0.7290886",
"0.72509766",
"0.71756524",
"0.699899",
"0.68636274",
"0.6852251",
"0.6833598",
"0.6825536",
"0.6778559",
"0.671169",
"0.66600335",
"0.66432226",
"0.6625708",
"0.6545947",
"0.6511113",
"0.64782494",
"0.6468275",
"0.6468275",
"0.6436739",
"0.6402951",
"0.63754636"... | 0.63558614 | 25 |
Generate test cases from an iterable of ordered pairs | def generate_from_data(self, data):
for left, right in data:
yield self.assert_equal, left, right | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_what_to_run_concepts(pairs_to_test):\n\n pairs_for_sstesting = []\n # prepare pairs for concpet vs random.\n for pair in pairs_to_test:\n for concept in pair[1]:\n pairs_for_sstesting.append([pair[0], [concept]])\n return pairs_for_sstesting",
"def _test_pairs(self, idx0... | [
"0.6630613",
"0.6215423",
"0.6009414",
"0.60061336",
"0.5980631",
"0.5979496",
"0.5959456",
"0.5958225",
"0.580495",
"0.5800429",
"0.57898694",
"0.57013935",
"0.5682468",
"0.56762177",
"0.56751466",
"0.56724614",
"0.564519",
"0.56307524",
"0.563066",
"0.562664",
"0.56140083",... | 0.59740925 | 6 |
test composing variables with all operators | def test_first_level_composition(self):
oe = expression.OperationalExpression
v1, v2 = map(expression.Variable, ["v1", "v2"])
data = [
[(v1 + v2), oe('+', v1, v2)],
[(v1 - v2), oe('-', v1, v2)],
[(v1 / v2), oe('/', v1, v2)],
[(v1 * v2), oe('*', v1,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_operator_sanity(self):\r\n var1 = 5.0\r\n var2 = 2.0\r\n operators = [('+', 7), ('-', 3), ('*', 10), ('/', 2.5), ('^', 25)]\r\n\r\n for (operator, answer) in operators:\r\n input_str = \"{0} {1} {2}\".format(var1, operator, var2)\r\n result = calc.evaluato... | [
"0.70314986",
"0.6903428",
"0.66045415",
"0.65166736",
"0.6297173",
"0.62969416",
"0.62389696",
"0.6236109",
"0.62030494",
"0.61995924",
"0.6189159",
"0.6182945",
"0.6145458",
"0.6145458",
"0.6132459",
"0.6131872",
"0.6077709",
"0.6050098",
"0.60376734",
"0.60126805",
"0.6009... | 0.0 | -1 |
test medium level composition of expressions | def test_primitive_composition(self):
oe = expression.OperationalExpression
v1 = expression.Variable("v1")
f = Fraction(3 / 5)
data = [
[(v1 + 1), oe('+', v1, 1)],
[(v1 - 2.0), oe('-', v1, 2.0)],
[(v1 / f), oe('/', v1, f)],
[(1 * v1), oe('*... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_expr(self):\n self.common_test_expr(True)",
"def test_expression(x, y, z):\n return x * y + y / z",
"def test_second_level_composition(self):\n oe = expression.OperationalExpression\n v1, v2 = map(expression.Variable, [\"v1\", \"v2\"])\n exp = (v1 + v2) / (v1 - v2)\n ... | [
"0.77058685",
"0.71593964",
"0.67252547",
"0.655287",
"0.63776237",
"0.6375139",
"0.6357889",
"0.6337127",
"0.63133055",
"0.6308272",
"0.6283322",
"0.6200537",
"0.6189136",
"0.61859864",
"0.6176959",
"0.61450034",
"0.61379457",
"0.6122228",
"0.6110731",
"0.61077434",
"0.60823... | 0.60047615 | 27 |
test slightly harder composition of expressions | def test_second_level_composition(self):
oe = expression.OperationalExpression
v1, v2 = map(expression.Variable, ["v1", "v2"])
exp = (v1 + v2) / (v1 - v2)
expected_exp = oe('/', oe('+', v1, v2), oe('-', v1, v2))
self.assert_equal(exp, expected_exp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_expr(self):\n self.common_test_expr(True)",
"def test_composition(self):\n\n i = Code()\n j = Code()\n k = Code()\n l = Code()\n\n c = j + i ** i // 5 / l < j - k\n self.assertEqual(str(c), 'j + i ** i // 5 / l < j - k')",
"def test_bin_op_support():\n ... | [
"0.7180387",
"0.67720294",
"0.6408602",
"0.64034086",
"0.6381854",
"0.62376976",
"0.6234587",
"0.6092578",
"0.6032658",
"0.6000569",
"0.5960447",
"0.59546",
"0.5917527",
"0.59171945",
"0.5895119",
"0.5881925",
"0.5850813",
"0.58494717",
"0.5838811",
"0.5827639",
"0.5826372",
... | 0.67275876 | 2 |
Test a composing expression that has vectors with variable attributes | def test_compose_vectors_with_attrs(self):
oe = expression.OperationalExpression
v1, v2 = map(expression.Variable, ["v1", "v2"])
exp = 1 + V(v1.x, v2.y)
expected_exp = oe('+', 1, V(v1.x, v2.y))
self.assert_equal(exp, expected_exp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_complex_extraction_of_values(self):\n\t\ta = bf.Var(\"a\")\n\t\tb = bf.Var(\"b\")\n\t\tc = bf.Var(\"c\")\n\t\tformula = bf.And([bf.Or([b, a, c]), bf.Or([bf.Not(a), bf.Not(c)]), bf.Not(b)])\n\t\tself.assertEqual([\"a\", \"b\", \"c\"], au.extract_variables(formula), \"Invalid variables extracted, expected [... | [
"0.6213941",
"0.60124946",
"0.58145964",
"0.57848656",
"0.57236844",
"0.57096756",
"0.567647",
"0.56665623",
"0.5648646",
"0.56261915",
"0.5604976",
"0.55950737",
"0.55904126",
"0.55702084",
"0.5555966",
"0.5552883",
"0.5525541",
"0.55212194",
"0.54941386",
"0.5478895",
"0.54... | 0.78425336 | 0 |
Function to start the process of saving the commands to xml. | def Write_XML(gui):
# lock buttons
gui.action_lock('Lock', gui.save_button)
# clear output
gui.output_clear()
# get the desired delay from the gui.
delay_time = gui.get_delay()
# get the desired ascii delay from the gui.
ascii_time = gui.get_ascii_delay()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _send_xml_cli(self, commands, no_end=False):\n if isinstance(commands, str):\n commands = [commands]\n if not no_end:\n commands.append(\"end\")\n self.logger.debug(\"Sending commands {} to {}\".format(str(commands), self.host))\n try:\n self._ncc.nx... | [
"0.6063771",
"0.5795947",
"0.5710056",
"0.5695167",
"0.5617394",
"0.5534581",
"0.5529304",
"0.551602",
"0.5449832",
"0.54495037",
"0.5444347",
"0.5399038",
"0.53412414",
"0.53403497",
"0.530564",
"0.5292865",
"0.529165",
"0.52267593",
"0.52267593",
"0.52267593",
"0.52267593",... | 0.5952237 | 1 |
Function to load a command set, delays and address from a saved xml file | def Load_XML(gui):
# lock the buttons
gui.action_lock('Lock', gui.xml_button)
# prepare to open a window to load a file through
file_opt = options = {}
options['defaultextension'] = '.xml'
options['filetypes'] = [('xml files', '.xml')]
options['initialdir'] = os.getcwd() + '/xml... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadData(self,filepath):\r\n self.removeCheckbuttons()\r\n self.tree = ET.parse(filepath)# Parse xml Tree\r\n self.data = self.tree.getroot().find(\"data\")# Find Data\r\n self.sensors = [i.text for i in self.tree.getroot().find('columns')]# Get Sensor Names\r\n for s in self... | [
"0.6020558",
"0.55900437",
"0.547431",
"0.5467832",
"0.54143196",
"0.54053646",
"0.5335379",
"0.5326394",
"0.5290998",
"0.5274877",
"0.5269875",
"0.526416",
"0.52612525",
"0.52557683",
"0.5247965",
"0.52428174",
"0.52398396",
"0.52201504",
"0.52079225",
"0.52027446",
"0.51986... | 0.6403766 | 0 |
Function to read in the default values for GUI parameters from XML | def update_gui_defaults(GUI_defaults):
# failure flag
config_import_error = False
# xml source directory
src_dir = os.getcwd() + '\\src'
# attempt to parse the xml file and get it's root
try:
tree = ET.parse(src_dir + '\\pySCPI_config.xml')
root = tree.getroot()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initDefaults(self):\n return _libsbml.Parameter_initDefaults(self)",
"def _read_custom_pars(self):\n if self.use_defaults:\n param_set = \"default_values\"\n else:\n param_set = \"parameters\"\n self.outpars = self.input_cfg_json_data[param_set][self.step_tit... | [
"0.60259306",
"0.5917316",
"0.5879052",
"0.58556134",
"0.5806529",
"0.5773313",
"0.57520735",
"0.5735366",
"0.5723001",
"0.5692128",
"0.5658283",
"0.56419754",
"0.5638085",
"0.5636669",
"0.5633002",
"0.5620782",
"0.55702066",
"0.55439883",
"0.55336916",
"0.5531336",
"0.552916... | 0.6818052 | 0 |
Function to import updated SCPI library information from XML. | def update_commands(SCPI_library):
# failure flag
config_import_error = False
# xml source directory
src_dir = os.getcwd() + '\\src'
# try to parse the xml file and get it's root
try:
tree = ET.parse(src_dir + '\\SCPI_Commands.xml')
root = tree.getroot()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _populate_from_xml_file(self, xml):\n '''\n example from API: http://www.ga.gov.au/www/argus.argus_api.survey?pSurveyNo=921\n\n <?xml version=\"1.0\" ?>\n <ROWSET>\n <ROW>\n <SURVEYID>921</SURVEYID>\n <SURVEYNAME>Goomalling, WA, 1996</SURVEYN... | [
"0.58593714",
"0.56911325",
"0.5407649",
"0.53319305",
"0.53311896",
"0.53112024",
"0.52964",
"0.5261561",
"0.5247046",
"0.5242455",
"0.52102464",
"0.51831394",
"0.51444477",
"0.51391345",
"0.51136756",
"0.5014432",
"0.49752128",
"0.49142268",
"0.49138352",
"0.49101362",
"0.4... | 0.53175026 | 5 |
Write an Aardvark compatible .xml file that can be used with the Total phase system or loaded back into pySCPI | def create_XML(directives, gui):
# unpack the directives
commands = directives.command_list
Delay = directives.delay_time
Ascii_delay = directives.ascii_time
addr = directives.addr
# Start XML
aardvark = ET.Element('aardvark')
# starup comment for historical reasons
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saving_file(xml):\r\n\r\n xml_string = etree.tostring(xml)\r\n parsed = minidom.parseString(xml_string)\r\n with open(self.app_path + \"\\\\temp_\\\\\" + file_name + \".xml\", \"w\") as file:\r\n file.write(parsed.toprettyxml(indent=\" \"))",
"def export... | [
"0.6515338",
"0.63872993",
"0.6364386",
"0.6297682",
"0.62434924",
"0.6230958",
"0.621191",
"0.60897154",
"0.60321975",
"0.6010241",
"0.5969192",
"0.5957748",
"0.59319156",
"0.59156126",
"0.58857924",
"0.5852645",
"0.58315367",
"0.57871634",
"0.5785052",
"0.5784642",
"0.57793... | 0.644834 | 1 |
Function to improve the readability of the xml file produced. | def beautify_xml(XML):
# convert XML file to modifiable string to beautify it
text_string = ET.tostring(XML, encoding='UTF-8', method='xml')
# insert line breaks before end of file tag
file_string = text_string.replace('</aardvark>', '\n\n</aardvark>')
# insert double new line before comme... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')",
"def writeXml(self):\n text = u' type=\"%s\"' % self.typeName\n if self.format:\n text += u' format=\"%s\"' % escape(self.format, treedoc.escDict)\n if self.prefix:\n text += u'... | [
"0.65539247",
"0.63723135",
"0.63601106",
"0.633199",
"0.63063323",
"0.63027126",
"0.6289212",
"0.6213498",
"0.62073106",
"0.6194992",
"0.6152282",
"0.6151681",
"0.6146073",
"0.6137961",
"0.61245584",
"0.609112",
"0.6061833",
"0.606017",
"0.60590106",
"0.6041505",
"0.6037666"... | 0.676322 | 0 |
Save the configuration requested by a config command to XML | def update_XML(command, address, XML):
# return value
new_address = address
# split command into list
command_list = command.split(' ')
command_arg = command_list[1][0:-1]
# determine the appropriate action to take
if (command_list[0] == '<DELAY') and command_arg.isdigit():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_config():\n\n e = Element(\"Configuration\")\n r = SubElement(e, \"RepositoryList\")\n r = SubElement(r, \"Repository\", name = \"default\")\n SubElement(r, \"Module\").text = args.driver\n SubElement(r, \"TokenLabel\").text = args.token_label\n SubElement(r, \"PIN\").text = args.pin\n ElementTree... | [
"0.76294816",
"0.7332591",
"0.72645265",
"0.7191158",
"0.7133609",
"0.71090084",
"0.70826906",
"0.6991815",
"0.69753504",
"0.69223756",
"0.6897391",
"0.6830783",
"0.6830552",
"0.6826689",
"0.68222356",
"0.68165976",
"0.67617404",
"0.67575526",
"0.6747976",
"0.6741561",
"0.674... | 0.0 | -1 |
Fill in container instructions | def __instructions(self):
self += comment('Arm Allinea Studio version {}'.format(self.__version))
if self.__ospackages:
self += packages(ospackages=self.__ospackages)
if self.__tarball:
self += copy(src=self.__tarball, dest=self.__wd)
self += shell(commands=se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_instructions(self):\n #de, aux, vers = self.rods\n de, aux, vers = 0, 1, 2\n n = self.num_rings\n\n self.recur(n, de, aux, vers)\n\n ### Add dummy tuple at end so I can look one move ahead on states\n self.instructions.append((0, 0, 0))",
"def instructions(self)... | [
"0.61357474",
"0.5750941",
"0.5637806",
"0.5637374",
"0.55108917",
"0.54922396",
"0.5417737",
"0.5323309",
"0.5283579",
"0.5279315",
"0.52423096",
"0.51637995",
"0.5158927",
"0.5156974",
"0.51351786",
"0.50859696",
"0.5071212",
"0.50173676",
"0.49817103",
"0.49499556",
"0.494... | 0.4697476 | 59 |
Based on the Linux distribution, set values accordingly. A user specified value overrides any defaults. | def __distro(self):
if hpccm.config.g_linux_distro == linux_distro.UBUNTU:
self.__directory_string = 'Ubuntu-16.04'
# By specifying an install prefix, the installer bypasses
# the deb package manager (debs are not relocatable like
# rpms). Therefore, remove the ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __distro(self):\n\n if hpccm.config.g_linux_distro == linux_distro.UBUNTU:\n if not self.__ospackages:\n self.__ospackages = ['build-essential', 'cpio']\n self.__bashrc = '/etc/bash.bashrc'\n elif hpccm.config.g_linux_distro == linux_distro.CENTOS:\n ... | [
"0.593223",
"0.58652776",
"0.585403",
"0.576295",
"0.576295",
"0.5558115",
"0.55375224",
"0.5533098",
"0.5482613",
"0.54246676",
"0.54144907",
"0.5398145",
"0.53678435",
"0.5332948",
"0.52729666",
"0.5230247",
"0.5221588",
"0.5180811",
"0.51568455",
"0.515432",
"0.5151007",
... | 0.53032106 | 14 |
Construct the series of shell commands, i.e., fill in self.__commands | def __setup(self):
if self.__tarball:
tarball = posixpath.basename(self.__tarball)
# Figure out the version from the tarbal name
match = re.match(r'Arm-Compiler-for-HPC_(?P<year>\d\d)\.0?(?P<month>[1-9][0-9]?)',
tarball)
if match and... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commands():",
"def process_commands(self, commands: List[str]):",
"def command_create(self):\n command = []\n for macro in self.my_xml.tool_data[self.shell_dict['short_name']]['pre_tmpls']:\n command.append(self.my_xml.chth_tmpl.substitute(macro=macro))\n command.extend(self... | [
"0.6871228",
"0.679808",
"0.67225176",
"0.6588337",
"0.6577435",
"0.65688705",
"0.65423495",
"0.6525996",
"0.6524536",
"0.6510382",
"0.650695",
"0.650695",
"0.650695",
"0.650695",
"0.6501545",
"0.6494713",
"0.6449746",
"0.6449303",
"0.6420589",
"0.6417928",
"0.64127463",
"0... | 0.0 | -1 |
Generate the set of instructions to install the runtime specific components from a build in a previous stage. Examples ```python a = arm_allinea_compiler(...) Stage0 += a Stage1 += a.runtime() ``` | def runtime(self, _from='0'):
instructions = []
instructions.append(comment('Arm Allinea Studio'))
gcc_path = posixpath.join(
self.__prefix,
'gcc-{0}_Generic-AArch64_{1}_aarch64-linux'.format(
self.__gcc_version, self.__directory_string))
llvm_pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_runtime(self):\n s0 = Stage()\n s0 += gnu()\n s0 += shell(commands=['gcc -o hello hello.c'])\n s1 = Stage()\n s1 += s0.runtime()\n self.assertEqual(str(s1),\nr'''# GNU compiler runtime\nRUN yum install -y \\\n libgfortran \\\n libgomp && \\\n rm -... | [
"0.6434725",
"0.620022",
"0.61711156",
"0.5887484",
"0.5721989",
"0.5680253",
"0.5664536",
"0.550372",
"0.5462016",
"0.53730744",
"0.5336362",
"0.5336342",
"0.53230923",
"0.5300937",
"0.52958727",
"0.5276965",
"0.52585906",
"0.52580607",
"0.5237822",
"0.51931524",
"0.51877236... | 0.68220097 | 0 |
load stock time and price data for two stocks The return values (d1,p1,d2,p2) are the trade time (in days) and prices for stocks 1 and 2 (intc and aapl) | def get_two_stock_data():
ticker1, ticker2 = 'INTC', 'AAPL'
file1 = cbook.get_sample_data('INTC.dat.gz')
file2 = cbook.get_sample_data('AAPL.dat.gz')
M1 = fromstring(file1.read(), '<d')
M1 = resize(M1, (M1.shape[0]//2, 2))
M2 = fromstring(file2.read(), '<d')
M2 = resize(M2, (M2.shape[0]//... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(pair, other):\n days_ago = 7\n endtime = int(time())\n starttime = endtime - 60 * 60 * 24 * days_ago\n\n geckourl = '%s/markets?vs_currency=%s&ids=%s' % (API, pair[\"currency\"],\n pair[\"coin\"])\n liveprice = requests.get(geckourl).j... | [
"0.6660464",
"0.6615989",
"0.64531744",
"0.6355358",
"0.6307623",
"0.6276847",
"0.6220814",
"0.61832434",
"0.60175335",
"0.60079485",
"0.5918773",
"0.585842",
"0.5851734",
"0.5843024",
"0.5840139",
"0.5792696",
"0.5774242",
"0.57644534",
"0.574364",
"0.57333547",
"0.57249",
... | 0.78072286 | 0 |
return stock1 and stock2 instances, each of which have attributes open, high, low, close, volume as numeric arrays | def get_daily_data():
class C:
pass
def get_ticker(ticker):
vals = []
datafile = cbook.get_sample_data('%s.csv' % ticker, asfileobj=False)
lines = open(datafile).readlines()
for line in lines[1:]:
vals.append([float(val) for val in line.split(',')[1:]])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_two_stock_data():\n ticker1, ticker2 = 'INTC', 'AAPL'\n\n file1 = cbook.get_sample_data('INTC.dat.gz')\n file2 = cbook.get_sample_data('AAPL.dat.gz')\n M1 = fromstring(file1.read(), '<d')\n\n M1 = resize(M1, (M1.shape[0]//2, 2))\n\n M2 = fromstring(file2.read(), '<d')\n M2 = resize(M2,... | [
"0.690658",
"0.579665",
"0.5742262",
"0.56939626",
"0.56424576",
"0.55489075",
"0.5467829",
"0.5454544",
"0.5423713",
"0.5407581",
"0.5386085",
"0.5376399",
"0.5357336",
"0.53431493",
"0.53205866",
"0.53127074",
"0.53015745",
"0.5291757",
"0.52858096",
"0.52858096",
"0.528171... | 0.4965072 | 46 |
Q is a tensor with its last two dimensions as (..., seq_len_q, dk) containing the query matrix K is a tensor with its last two dimensions as (..., seq_len_v, dk) containing the key matrix V is a tensor with its last two dimensions as (..., seq_len_v, dv) containing the value matrix mask is a tensor that can be broadcas... | def sdp_attention(Q, K, V, mask=None):
matmul_qk = tf.matmul(Q, K, transpose_b=True)
# scale matmul_qk
dk = tf.cast(tf.shape(K)[-1], tf.float32)
scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)
# add the mask to the scaled tensor.
if mask is not None:
scaled_attention_logits += (... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sdp_attention(Q, K, V, mask=None):\n matmul_qk = tf.matmul(Q, K, transpose_b=True)\n # scale matmul_qk\n dk = tf.cast(tf.shape(K)[-1], tf.float32)\n scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)\n # add mask to scaled tensor\n if mask is not None:\n scaled_attention_logits += ... | [
"0.66350186",
"0.66066206",
"0.65810335",
"0.64763",
"0.64397424",
"0.6408181",
"0.63542753",
"0.63542455",
"0.63436663",
"0.6335895",
"0.6335895",
"0.63351864",
"0.6310624",
"0.6304251",
"0.6237615",
"0.6224539",
"0.61700386",
"0.6101289",
"0.60288817",
"0.6009258",
"0.58814... | 0.6586491 | 2 |
dm is an integer representing the dimensionality of the model h is an integer representing the number of heads dm is divisible by h | def __init__(self, dm, h):
super().__init__()
self.h = h
self.dm = dm
self.depth = dm // h
self.Wq = tf.keras.layers.Dense(dm)
self.Wk = tf.keras.layers.Dense(dm)
self.Wv = tf.keras.layers.Dense(dm)
self.linear = tf.keras.layers.Dense(dm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dim_per_head(self):\n p = self.params\n return p.dim_per_head or p.hidden_dim // p.num_heads",
"def __init__(self, d_model, n_heads, use_cos, kernel, dropout,\n ffn_ratio, ln_eps, denom_eps, bias):\n super(MHA_block, self).__init__()\n self.ln1 = nn.LayerNorm(d_model, eps=... | [
"0.60416514",
"0.59796304",
"0.58199686",
"0.56614614",
"0.5604034",
"0.55746675",
"0.55614406",
"0.55234414",
"0.54783124",
"0.5457982",
"0.545518",
"0.5452053",
"0.5443593",
"0.5433428",
"0.54292744",
"0.5412994",
"0.5382375",
"0.53673047",
"0.5362075",
"0.5312807",
"0.5306... | 0.5838266 | 2 |
Split the last dimension into (num_heads, depth). Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth) | def split_heads(self, x, batch_size):
x = tf.reshape(x, (batch_size, -1, self.h, self.depth))
return tf.transpose(x, perm=[0, 2, 1, 3]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_heads(x, batch_size, num_heads, depth):\n x = tf.reshape(x, (batch_size, -1, num_heads, depth))\n return tf.transpose(x, perm=[0, 2, 1, 3])",
"def _split_heads(x, num_heads):\n\tshape_lst = bert_utils.get_shape_list(x)\n\tdepth = shape_lst[-1]\n\tbatch = shape_lst[0]\n\tseq = shap... | [
"0.7916115",
"0.7600231",
"0.7481175",
"0.7254155",
"0.72504663",
"0.72504663",
"0.72504663",
"0.72504663",
"0.72504663",
"0.72504663",
"0.72504663",
"0.7161194",
"0.7055214",
"0.659434",
"0.6588306",
"0.6588306",
"0.6527259",
"0.63739264",
"0.62708795",
"0.60758406",
"0.6002... | 0.7328985 | 3 |
Q is a tensor of shape (batch, seq_len_q, dk) containing the input to generate the query matrix K is a tensor of shape (batch, seq_len_v, dk) containing the input to generate the key matrix V is a tensor of shape (batch, seq_len_v, dv) containing the input to generate the value matrix mask is always None | def call(self, Q, K, V, mask):
batch_size = tf.shape(Q)[0]
q = self.Wq(Q)
k = self.Wk(K)
v = self.Wv(V)
q = self.split_heads(q, batch_size)
k = self.split_heads(k, batch_size)
v = self.split_heads(v, batch_size)
scaled_attention, attention_weights = sd... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def call(self, querys, keys, values, mask = None, training = False):\n\n sequence_len = shape_list(keys)[1]\n\n # q_i = Q * W^Q_i\n #print('query.shape=', querys.shape)\n querys = self.w_q(querys)\n querys = tf.reshape(querys, shape = (-1, sequence_len, self.num_attention_heads, ... | [
"0.6493404",
"0.6427816",
"0.64240754",
"0.6418321",
"0.6301944",
"0.6113004",
"0.6097452",
"0.6081869",
"0.6049511",
"0.60341233",
"0.60284936",
"0.5986255",
"0.5980415",
"0.5970355",
"0.59539115",
"0.59345806",
"0.59323347",
"0.59292626",
"0.5913883",
"0.5895534",
"0.582593... | 0.6124515 | 5 |
dm the dimensionality of the model h the number of heads hidden the number of hidden units in the fully connected layer drop_rate the dropout rate | def __init__(self, dm, h, hidden, drop_rate=0.1):
super().__init__()
self.mha = MultiHeadAttention(dm, h)
self.ffn = point_wise_feed_forward_network(dm, hidden)
self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
self.layernorm2 = tf.keras.layers.LayerNormalizatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, dm, h, hidden, drop_rate=0.1):\n super().__init__()\n\n self.mha1 = MultiHeadAttention(dm, h)\n self.mha2 = MultiHeadAttention(dm, h)\n\n self.ffn = point_wise_feed_forward_network(dm, hidden)\n\n self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-... | [
"0.6785643",
"0.67229116",
"0.6380261",
"0.6364374",
"0.6323939",
"0.63031614",
"0.625298",
"0.6168952",
"0.61116683",
"0.603366",
"0.60317063",
"0.59837466",
"0.5970474",
"0.5934955",
"0.5934622",
"0.590435",
"0.5896029",
"0.5895661",
"0.5886991",
"0.5885217",
"0.58829165",
... | 0.69252604 | 0 |
dm the dimensionality of the model h the number of heads hidden the number of hidden units in the fully connected layer drop_rate the dropout rate | def __init__(self, dm, h, hidden, drop_rate=0.1):
super().__init__()
self.mha1 = MultiHeadAttention(dm, h)
self.mha2 = MultiHeadAttention(dm, h)
self.ffn = point_wise_feed_forward_network(dm, hidden)
self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, dm, h, hidden, drop_rate=0.1):\n super().__init__()\n self.mha = MultiHeadAttention(dm, h)\n self.ffn = point_wise_feed_forward_network(dm, hidden)\n\n self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n self.layernorm2 = tf.keras.layers.LayerN... | [
"0.6926322",
"0.67232263",
"0.6377668",
"0.63622075",
"0.63210016",
"0.6301156",
"0.62541866",
"0.6165916",
"0.61140305",
"0.6033471",
"0.60285664",
"0.5983597",
"0.59702533",
"0.5933133",
"0.5933072",
"0.5901348",
"0.5895014",
"0.58933127",
"0.588453",
"0.5882685",
"0.588206... | 0.6786822 | 1 |
x a tensor of shape (batch, input_seq_len, dm)containing the input to the encoder training a boolean to determine if the model is training mask the mask to be applied for multi head attention | def call(self, x, training, mask):
seq_len = tf.shape(x)[1]
# adding embedding and position encoding.
embedding = self.embedding(x) # (batch_size, input_seq_len, d_model)
embedding *= tf.math.sqrt(tf.cast(self.dm, tf.float32))
embedding += self.positional_encoding[:, :seq_len, :... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x, mask):\n x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))\n #print('encoder')\n #print(x.shape)\n return self.sublayer[1](x, self.feed_forward)",
"def forward(self, x: Tensor) -> Tensor:\n x1 = x[:, 0]\n x2 = x[:, 1]\n features... | [
"0.68944144",
"0.6433218",
"0.6370818",
"0.6343878",
"0.6306005",
"0.6193689",
"0.6187625",
"0.61835486",
"0.6144924",
"0.6137682",
"0.61019653",
"0.60944766",
"0.603872",
"0.60364276",
"0.6025595",
"0.59151536",
"0.5872006",
"0.5864127",
"0.5857473",
"0.5822816",
"0.5774186"... | 0.629951 | 5 |
x a tensor of shape (batch, target_seq_len, dm)containing the input to the decoder encoder_output a tensor of shape (batch, input_seq_len, dm) containing the output of the encoder training a boolean to determine if the model is training look_ahead_mask the mask to be applied to the first multi head attention layer padd... | def call(self, x, encoder_output, training,
look_ahead_mask, padding_mask):
seq_len = tf.shape(x)[1]
attention_weights = {}
x = self.embedding(x)
x *= tf.math.sqrt(tf.cast(self.dm, tf.float32))
x += self.positional_encoding[:, :seq_len, :]
x = self.dropout(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, state, encoder_padding_mask):\n residual = state.clone()\n\n '''\n ___QUESTION-6-DESCRIBE-D-START___\n What is the purpose of encoder_padding_mask? What will the output shape of `state' Tensor \n be after multi-head attention? HINT: formulate your answer in ter... | [
"0.68980443",
"0.6785151",
"0.672374",
"0.666072",
"0.6574727",
"0.649962",
"0.64837235",
"0.6482765",
"0.6397254",
"0.63569766",
"0.634568",
"0.6323986",
"0.63232094",
"0.62556964",
"0.62244546",
"0.6217759",
"0.6191466",
"0.6188659",
"0.61652607",
"0.6162906",
"0.6146513",
... | 0.72239923 | 0 |
N the number of blocks in the encoder and decoder dm the dimensionality of the model h the number of heads hidden the number of hidden units in the fully connected layers input_vocab the size of the input vocabulary target_vocab the size of the target vocabulary max_seq_input the maximum sequence length possible for th... | def __init__(self, N, dm, h, hidden, input_vocab, target_vocab,
max_seq_input, max_seq_target, drop_rate=0.1):
super().__init__()
self.encoder = Encoder(N, dm, h, hidden, input_vocab,
max_seq_input, drop_rate)
self.decoder = Decoder(N, dm, h, hidde... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n super(Decoder_1m, self).__init__()\n self.lconvtwos = nn.ModuleList(\n [\n nn.Sequential(\n nn.Dropout(p=0.1),\n nn.Conv2d(128, 32, kernel_size=(3, 3), padding=1),\n nn.BatchNorm2d(32),\n ... | [
"0.6649107",
"0.6574562",
"0.6515605",
"0.64855504",
"0.6468661",
"0.64408153",
"0.64387065",
"0.64374036",
"0.6415218",
"0.63973427",
"0.6371662",
"0.6340037",
"0.62952334",
"0.6289063",
"0.62647885",
"0.62570995",
"0.6251119",
"0.6237663",
"0.6213453",
"0.61888",
"0.6172886... | 0.7143646 | 0 |
inputs a tensor of shape (batch, input_seq_len, dm) containing the inputs target a tensor of shape (batch, target_seq_len, dm) containing the target training a boolean to determine if the model is training encoder_mask the padding mask to be applied to the encoder look_ahead_mask the look ahead mask to be applied to th... | def call(self, inputs, target, training, encoder_mask,
look_ahead_mask, decoder_mask):
enc_output = self.encoder(inputs, training, encoder_mask)
dec_output, attention = self.decoder(target, enc_output, training,
look_ahead_mask, decoder_mask)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, inputs: tf.Tensor, outputs: tf.Tensor,\n out_mask: tf.Tensor,in_pad_mask: tf.Tensor=None,\n training: bool=False):\n encoder_outputs, enc_attention = self.encoder(\n inputs, in_pad_mask, training\n )\n # shape=(batch_size, inputs_seq_le... | [
"0.6993221",
"0.6545811",
"0.65400386",
"0.65084684",
"0.64289606",
"0.6405675",
"0.6401761",
"0.6400004",
"0.6378901",
"0.6355544",
"0.6320946",
"0.6316737",
"0.6313478",
"0.6303749",
"0.6302028",
"0.6298374",
"0.62815",
"0.6278293",
"0.6256351",
"0.6249569",
"0.6234648",
... | 0.6196893 | 28 |
Aggregate metric value across towers. | def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):
def fn(distribution, *a):
"""Call `metric_value_fn` in the correct control flow context."""
if hasattr(distribution, '_outer_control_flow_context'):
# If there was an outer context captured before this method was ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\n def fn(distribution, *a):\n \"\"\"Call `metric_value_fn` in the correct control flow context.\"\"\"\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was c... | [
"0.6474678",
"0.61006385",
"0.60297525",
"0.59245074",
"0.584058",
"0.5800489",
"0.56997293",
"0.56921005",
"0.56350535",
"0.5630873",
"0.56030244",
"0.5590685",
"0.5583606",
"0.55782723",
"0.5570165",
"0.5558878",
"0.55482966",
"0.5541951",
"0.5541951",
"0.55373263",
"0.5535... | 0.6526208 | 0 |
Call `metric_value_fn` in the correct control flow context. | def fn(distribution, *a):
if hasattr(distribution, '_outer_control_flow_context'):
# If there was an outer context captured before this method was called,
# then we enter that context to create the metric value op. If the
# caputred context is `None`, ops.control_dependencies... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(distribution, *a):\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives ... | [
"0.6464017",
"0.58839256",
"0.5767293",
"0.574908",
"0.55788815",
"0.5566902",
"0.548517",
"0.5422161",
"0.537603",
"0.5365945",
"0.52946395",
"0.52842236",
"0.51841676",
"0.5158378",
"0.515165",
"0.51359975",
"0.51274526",
"0.5114945",
"0.5100913",
"0.50856",
"0.5031937",
... | 0.6583132 | 0 |
for use in an mcmc sampler; e.g. > x ~ S(x|x) > computing S(x|x) may not be just a parameter replacement. | def apply_param_transformations(self,params_edict,**kwargs):
if self.params_transforms == None:
return params_edict
for key,transform_function in self.params_transforms.items():
params_edict[key] = transform_function(params_edict,**kwargs)
return params_edict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reparametrize(self, mu, sigma):\n return mu + sigma # TODO Your code goes here.",
"def doParametersOfInterest(self):\n ''' ref : physicsmodel -> rvf\n self.modelBuilder.out.var(\"MH\").setRange(float(self.mHRange[0]),float(self.mHRange[1]))\n self.modelBuilder.out.var(\"MH... | [
"0.5839029",
"0.5783593",
"0.57772535",
"0.57220954",
"0.5710603",
"0.5695862",
"0.5565797",
"0.5561556",
"0.55528784",
"0.5543692",
"0.5518341",
"0.5416179",
"0.5407878",
"0.54026794",
"0.54021186",
"0.5393204",
"0.5393108",
"0.53861153",
"0.53641415",
"0.53463084",
"0.53016... | 0.0 | -1 |
l = self.rateself.shape / gamma_fx(self.rate) \ x(self.shape 1) np.exp(self.rate x) | def likelihood(self,x,params = None,**kwargs):
return np.exp(self.log_likelihood(x,params=params,**kwargs)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def f(x):\n res = np.real(np.exp(-1j*x[1])*\\\n sum(y_obs[k+sample_size]*np.exp(1j*k*x[0]) \\\n for k in range(-sample_size,sample_size+1))) \n res = -res/np.sqrt(2*sample_size+1) \n return res",
"def f(x):\n res = np.real(np.exp(... | [
"0.6485697",
"0.6419354",
"0.64037347",
"0.6296128",
"0.62531024",
"0.6230634",
"0.62213445",
"0.61988693",
"0.6122977",
"0.606668",
"0.6050784",
"0.60382915",
"0.6036193",
"0.6016605",
"0.6011339",
"0.60109717",
"0.59830993",
"0.59787333",
"0.5977478",
"0.596798",
"0.5966289... | 0.0 | -1 |
Set up the Compensation sensor. | async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
if discovery_info is None:
return
compensation: str = discovery_info[CONF_COMPENSATION]
conf: dict[str, Any] ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _setup_sensor ( self ):\n self.spectral = Spectral ( np.array([500, 610, 780, 1580.] ),\n np.array([590, 680, 890, 1750.] ) )",
"def _setup_sensor ( self ):\n self.spectral = Spectral ( np.array([450, 520, 630, 770., 1550, 2090.] ),\n ... | [
"0.6478045",
"0.6474628",
"0.63748217",
"0.63305384",
"0.5945454",
"0.5933097",
"0.5911297",
"0.5906468",
"0.5860258",
"0.58439195",
"0.5830285",
"0.58104193",
"0.58040017",
"0.57652694",
"0.5751883",
"0.57220465",
"0.5698215",
"0.5668131",
"0.56662774",
"0.565487",
"0.564631... | 0.5624291 | 21 |
Initialize the Compensation sensor. | def __init__(
self,
unique_id: str | None,
name: str,
source: str,
attribute: str | None,
precision: int,
polynomial: np.poly1d,
unit_of_measurement: str | None,
minimum: tuple[float, float] | None,
maximum: tuple[float, float] | None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._read_calibration_data()\n self.configure_sensor(\n TemperatureOversamplings.x08,\n PressureOversamplings.x16,\n HumidityOversamplings.x08,\n IIRFilterCoefficients.FC_003,\n 250,\n 250)",
"def _initialize(s... | [
"0.67914665",
"0.6568444",
"0.64031917",
"0.64006346",
"0.6294963",
"0.6220404",
"0.6154173",
"0.6138862",
"0.6089179",
"0.60084",
"0.5986519",
"0.58660346",
"0.5860093",
"0.58214515",
"0.5811828",
"0.580052",
"0.5731715",
"0.57221127",
"0.56790245",
"0.56587887",
"0.5650349"... | 0.0 | -1 |
Handle added to Hass. | async def async_added_to_hass(self) -> None:
self.async_on_remove(
async_track_state_change_event(
self.hass,
[self._source_entity_id],
self._async_compensation_sensor_state_listener,
)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_handle(self, handle):\n\n self.pool.append(handle)",
"def add_handler(self, handler):\n pass",
"def handle(self) -> None:",
"def add(self, handler, on_error=None):\n self.handlers.append(handler)",
"def new_handle(self):\n\n raise NotImplementedError('new_handle')",
"d... | [
"0.725439",
"0.657552",
"0.6394768",
"0.6374983",
"0.6372746",
"0.6322899",
"0.62675667",
"0.6254536",
"0.6239498",
"0.6233317",
"0.6200009",
"0.6163698",
"0.61499554",
"0.6108559",
"0.6108103",
"0.6089797",
"0.5973883",
"0.59327257",
"0.59327257",
"0.592064",
"0.5815749",
... | 0.0 | -1 |
Return the state attributes of the sensor. | def extra_state_attributes(self) -> dict[str, Any]:
ret = {
ATTR_SOURCE: self._source_entity_id,
ATTR_COEFFICIENTS: self._coefficients,
}
if self._source_attribute:
ret[ATTR_SOURCE_ATTRIBUTE] = self._source_attribute
return ret | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def device_state_attributes(self):\r\n return self.attributes",
"def device_state_attributes(self):\r\n return self._attributes",
"def device_state_attributes(self):\n return self.attr",
"def device_state_attributes(self):\n return self.attr",
"def device_state_attributes(self) ... | [
"0.8418945",
"0.82497084",
"0.8243777",
"0.8243777",
"0.8200083",
"0.8169021",
"0.8169021",
"0.8159991",
"0.8159991",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
"0.8145903",
... | 0.0 | -1 |
Handle sensor state changes. | def _async_compensation_sensor_state_listener(
self, event: EventType[EventStateChangedData]
) -> None:
new_state: State | None
if (new_state := event.data["new_state"]) is None:
return
if self.native_unit_of_measurement is None and self._source_attribute is None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n print(\"sensorState Update\")",
"def async_compensation_sensor_state_listener(event):\n new_state = event.data.get(\"new_state\")\n self.calc_state(new_state)\n self.async_write_ha_state()",
"def update(self):\n self.data.update()\n for ... | [
"0.7827983",
"0.7324876",
"0.72655034",
"0.7017487",
"0.69500244",
"0.6899691",
"0.68305683",
"0.674897",
"0.6707175",
"0.6699208",
"0.6617866",
"0.66092294",
"0.6587371",
"0.6576934",
"0.64607686",
"0.64607686",
"0.64336",
"0.64127284",
"0.63538086",
"0.6352331",
"0.63261676... | 0.64938736 | 14 |
return True if the ip address exists in the subnet address otherwise return False | def address_exists_in_network(ip_address, net_n_bits):
ip_address = struct.unpack('<L', socket.inet_aton(ip_address))[0]
net, bits = net_n_bits.split('/')
net_address = struct.unpack('<L', socket.inet_aton(net))[0]
net_mask = ((1L << int(bits)) - 1)
return ip_address & net_mask == net_address & net_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ipcalc(self, ipaddr, subnet):\n if IPNetwork(ipaddr) in IPNetwork(subnet):\n return True\n else:\n return False",
"def __contains__(self, address):\n return any([\n ipaddress.ip_address(address) in network\n for network in self.networks... | [
"0.81065077",
"0.73484886",
"0.7259473",
"0.6860128",
"0.66347903",
"0.66137534",
"0.65785533",
"0.6569621",
"0.6553362",
"0.65437984",
"0.6522481",
"0.6495472",
"0.64427274",
"0.6418303",
"0.6388048",
"0.63813025",
"0.6377752",
"0.6375657",
"0.6367962",
"0.6317943",
"0.62854... | 0.74176997 | 1 |
get the client IP Address | def get_client_ip_address(request):
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
ip_address = x_forwarded_for.split(',')[-1].strip()
else:
ip_address = request.META.get('REMOTE_ADDR')
return ip_address | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getClientIP(self):\n if isinstance(self.client, IPv4Address):\n return self.client.host\n return None",
"def client_ip(self):\n return self._client_ip",
"def get_client_ip(request):\n ip_chain = request.META.get(\"HTTP_X_FORWARDED_FOR\") # forward ip\n if ip_chain:\n ... | [
"0.8652703",
"0.8567096",
"0.81901723",
"0.814352",
"0.81124896",
"0.80822957",
"0.80822957",
"0.80810416",
"0.80326486",
"0.7998328",
"0.7963591",
"0.79506534",
"0.79266024",
"0.78766394",
"0.78621244",
"0.7749208",
"0.7641865",
"0.7623153",
"0.75724876",
"0.7569217",
"0.753... | 0.8159527 | 3 |
convert string to bool | def str2bool(value):
if value:
return value.lower() in ("true",)
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str_to_bool(self, s):\n if s == 'True':\n return True\n elif s == 'False':\n return False\n else:\n raise ValueError",
"def toBool( string ):\r\n return string == 'true'",
"def str_to_bool(a):\n if a == 'True':\n return True\n else:\n ... | [
"0.8893736",
"0.8891024",
"0.86924744",
"0.864158",
"0.8400088",
"0.8397288",
"0.83907926",
"0.83267844",
"0.8312677",
"0.83008534",
"0.83008534",
"0.8291738",
"0.82773185",
"0.8274537",
"0.8269423",
"0.8265565",
"0.8246185",
"0.8227842",
"0.8224764",
"0.8224154",
"0.8224154"... | 0.828739 | 13 |
checks if a string value can be interpreted as integer | def is_int(value):
try:
int(value)
return True
except ValueError:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __is_int(self,string):\r\n try: \r\n int(string)\r\n return True\r\n except ValueError:\r\n return False",
"def is_integer(self, string):\n try:\n return int(string)\n except:\n return False",
"def is_int(string:str) -> bool... | [
"0.85836047",
"0.84053147",
"0.8392874",
"0.82936084",
"0.8283946",
"0.82359105",
"0.82089317",
"0.81410223",
"0.81367934",
"0.81324106",
"0.8119482",
"0.7988272",
"0.7985464",
"0.7954548",
"0.79346615",
"0.78169835",
"0.7803405",
"0.77925634",
"0.7789233",
"0.77684367",
"0.7... | 0.7849056 | 16 |
examine a `obj` for given `items`. if all `items` are found in `obj` return True otherwise false. where `obj` is a dictionary and `items` is list of dictionaries | def dict_has_items(obj, items):
has_items = False
if isinstance(obj, basestring):
obj = json.loads(obj)
for item in items:
for lookup_key, lookup_val in item.iteritems():
if lookup_key in obj and obj[lookup_key] == lookup_val:
has_items = True
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __contains__(self, items):\n if type(items) != list:\n raise PJFInvalidType(items, list)\n ret = 0\n for item in items:\n for key in self.__dict__:\n if isinstance(self.__dict__[key], JsonFactory):\n ret += item in self.__dict__[key]\... | [
"0.7628567",
"0.7596022",
"0.7045878",
"0.7019639",
"0.6952219",
"0.6796098",
"0.6757188",
"0.66694134",
"0.65806514",
"0.65183485",
"0.64792097",
"0.6399194",
"0.63207513",
"0.62711006",
"0.62627935",
"0.6229428",
"0.6218",
"0.61813146",
"0.61776984",
"0.6154515",
"0.6083926... | 0.831852 | 0 |
extracts all query params which starts with data__ | def extract_data_params(request):
data_params = []
for key, val in request.QUERY_PARAMS.iteritems():
if key.startswith('data__'):
data_params.append({key[6:]: val})
return data_params | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_query_from_data(data):\n query_params = {}\n for key, value in data.items():\n if key == 'title':\n Product._set_query_params(query_params, key, value)\n elif isinstance(value, str):\n param_key = f'params.{str(key)}'\n Produc... | [
"0.67417115",
"0.6304133",
"0.6147768",
"0.611534",
"0.61150604",
"0.60223615",
"0.59562993",
"0.59472",
"0.5920123",
"0.5918791",
"0.5805078",
"0.5745934",
"0.5745177",
"0.5745177",
"0.57365286",
"0.57353395",
"0.5715842",
"0.5676375",
"0.56709933",
"0.5644437",
"0.56289977"... | 0.8259755 | 0 |
Get a list of filehandle numbers from logger to be handed to DaemonContext.files_preserve | def getLogFileHandles(logger):
handles = []
for handler in logger.handlers:
handles.append(handler.stream.fileno())
if logger.parent:
handles += getLogFileHandles(logger.parent)
return handles | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fileHandlers(self):\n fileHandlers = list()\n handlers = self.logger.handlers\n for handler in handlers:\n try:\n if handler._name.startswith(\"LogFile-\"):\n fileHandlers.append(handler)\n except:\n pass\n retur... | [
"0.5972954",
"0.5800055",
"0.57424676",
"0.57307327",
"0.56020564",
"0.5504199",
"0.5497882",
"0.5497588",
"0.5413338",
"0.53834784",
"0.5348",
"0.5341512",
"0.5340336",
"0.5339177",
"0.5326712",
"0.5315424",
"0.5308099",
"0.52998996",
"0.52989507",
"0.5291758",
"0.52897704",... | 0.6881586 | 0 |
Contextmanager for using a fasteners ipc lock in a nonblocking way. | def ipc_lock_nonblock(lock):
acquired = lock.acquire(blocking=False)
if acquired:
yield lock
lock.release()
else:
raise AgentLockException("Could not acquire lock.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def i_am_locking(self):\r\n pass",
"def acquire(self, blocking=True, shared=False):",
"def lock(*args):",
"def __enter__(self):\r\n self.acquire()\r\n return self",
"async def __aenter__(self):\n self.acquired = True\n return self",
"def __enter__(self):\n return... | [
"0.6242284",
"0.621957",
"0.61042243",
"0.573302",
"0.5642721",
"0.5634328",
"0.5580956",
"0.556809",
"0.55674386",
"0.5557476",
"0.5536869",
"0.5532729",
"0.5532729",
"0.55189383",
"0.55090845",
"0.5496174",
"0.54606235",
"0.54491425",
"0.54491425",
"0.5433907",
"0.54096675"... | 0.5499122 | 15 |
Create socket to listen on. | def make_server_socket(path):
# Remove old socket.
if os.path.exists(path):
os.remove(path)
# Set umask to create the socket with minimal permissions.
old_umask = os.umask(0077)
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.bind(path)
os.umask(old_umask)
sock.lis... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_socket():\n sock = socket.socket()\n return sock",
"def CreateListenSocket(self):\r\n self.listenSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\r\n self.listenSocket.bind(('localhost', 0))\r\n self.listenSocket.listen(BACKLOG)\r\n self.listenSocket.setblo... | [
"0.76166683",
"0.7588409",
"0.7583967",
"0.74945956",
"0.7447012",
"0.7447012",
"0.7425985",
"0.7217528",
"0.7190284",
"0.7139241",
"0.7102865",
"0.7098133",
"0.7091456",
"0.69858724",
"0.69730246",
"0.6971519",
"0.69640803",
"0.69456434",
"0.69436437",
"0.6940075",
"0.693128... | 0.68377393 | 23 |
Process a json message. This does user interaction and could block for a long time. | def process_message(self, message):
if not isinstance(message, dict):
return None
mtype = message.get("type", None)
self.maybe_expire_credentials()
if mtype == None:
return None
if mtype == "ping":
return {"pong": "pong"}
if mtype ==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _process_message(self, json_object):\n\n message = json.loads(json_object)\n if message['type'] == \"relay\":\n self._process_relay(message)\n elif message['type'] == \"control\":\n self._process_control(message)\n else:\n print(\"ERROR Received m... | [
"0.7290384",
"0.70513016",
"0.70031065",
"0.69798326",
"0.69033194",
"0.6897784",
"0.6757918",
"0.67505205",
"0.66754055",
"0.666377",
"0.666377",
"0.65524524",
"0.64504385",
"0.6433004",
"0.6414654",
"0.6400912",
"0.63942283",
"0.6390054",
"0.6371682",
"0.6353576",
"0.633220... | 0.5550369 | 100 |
Expire credentials if it has been too long. | def maybe_expire_credentials(self):
time_since_last_auth = time.time() - self.last_auth
logging.debug("Time since last auth {}.".format(time_since_last_auth))
if time_since_last_auth > CREDENTIALS_LIFETIME:
logging.info("Expiring credentials.")
hashpasslib.forget_master() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_password_expire(self):\n user_dn = \"cn=skip,ou=nerdherd,dc=bonsai,dc=test\"\n cli = LDAPClient(\"ldap://%s\" % self.ipaddr)\n cli.set_password_policy(True)\n cli.set_credentials(\"SIMPLE\", (user_dn, \"p@ssword\"))\n conn, ctrl = cli.connect()\n entry = conn.sear... | [
"0.65905154",
"0.65896976",
"0.63954246",
"0.6326304",
"0.63095117",
"0.62831146",
"0.62369967",
"0.62012815",
"0.6155768",
"0.61305135",
"0.60969484",
"0.6067817",
"0.60407585",
"0.6034622",
"0.60302615",
"0.6014281",
"0.6014172",
"0.59970254",
"0.59674865",
"0.5948415",
"0.... | 0.84588826 | 0 |
Gets the password via pinentry. Calls use_master if it works, otherwise does nothing. | def get_master_gui(use_bcrypt):
try:
pw = pinentry.get_pin(description="Enter hashpass master password:",
prompt="Password:")
while pw is None or not hashpasslib.is_correct_master(pw):
if pw == None:
logging.warn("User canceled password entry... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_password(self):\r\n return self._password",
"def get_password(self):\n mpw = master_pass.MPW(self.user, self.master_password)\n return mpw.password(self.ucs_server)",
"def _get_password(self):\n return self._password",
"def masterPassword(self):\r\n return self... | [
"0.6644678",
"0.66201836",
"0.66150063",
"0.65591604",
"0.65305823",
"0.64333534",
"0.6419651",
"0.63834316",
"0.63571024",
"0.63272214",
"0.63112754",
"0.63109064",
"0.62714154",
"0.6229617",
"0.62100583",
"0.61854845",
"0.617317",
"0.61616355",
"0.6161462",
"0.6152583",
"0.... | 0.7349455 | 0 |
Remove html tags from a string | def remove_html_tags(text):
print('VOU REMOVER AS TAGS DA STRING')
clean = re.compile('<.*?>')
print('',re.sub(clean, '', text))
return re.sub(clean, '', text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_html_tags(self,text):\n #https://medium.com/@jorlugaqui/how-to-strip-html-tags-from-a-string-in-python-7cb81a2bbf44\n clean = re.compile('<.*?>')\n return re.sub(clean, '', text)",
"def remove_html_tags(text):\r\n clean = re.compile('<.*?>')\r\n return re.sub(clean, '', text... | [
"0.8504336",
"0.8412507",
"0.84054434",
"0.83764374",
"0.83524",
"0.83524",
"0.83290035",
"0.8306803",
"0.8299078",
"0.82290506",
"0.82162106",
"0.81617314",
"0.8151329",
"0.8143021",
"0.812958",
"0.80990636",
"0.8071161",
"0.80520815",
"0.80184025",
"0.8011543",
"0.79809445"... | 0.8636281 | 0 |
picks and sets onebyone until all the regions are covered | def trivial_cover(regions_count, clinics_count, clinics):
clinics_built = [0]*range(0, clinics_count)
coverted = set()
for clinic in clinics:
clinics_built[clinic.index] = 1
coverted |= set(clinic.regions)
if len(coverted) >= regions_count:
break # We are done, we cover ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_assign_to_regions(self):\n \n tool = pybedtools.BedTool(clipper.test_file(\"FOX2Brain-05.15.09.polyATrim.adapterTrim.rmRep.sorted.rmDup.peaks.bed\"))\n \n assign_to_regions(tool=tool, \n clusters=\"test\", \n speciesFA= clipper.... | [
"0.5690144",
"0.56761265",
"0.56038886",
"0.5585656",
"0.5530814",
"0.5513189",
"0.54393256",
"0.5427754",
"0.5368495",
"0.5355389",
"0.53465384",
"0.53144586",
"0.5309058",
"0.5297361",
"0.5285404",
"0.5273793",
"0.5240959",
"0.52374387",
"0.5226939",
"0.52219576",
"0.521646... | 0.0 | -1 |
Plot the grid generated by a flow. The displacement can be too small, so we add a scale factor | def plot_grid(ax, flow, factor=10):
grid = factor * flow[:, ::8, ::8]
lin_range = np.linspace(0, 512, 64)
x, y = np.meshgrid(lin_range, lin_range)
x = x + grid[0, ...]
y = y + grid[1, ...]
y = y
segs1 = np.stack((x, y), axis=2)
segs2 = segs1.transpose(1, 0, 2)
ax.add_collection(Line... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_grid(frame, episode_nr):\n plt.grid('on')\n ax = plt.gca()\n ax.set_xticks(np.arange(0.5, 10, 1))\n ax.set_yticks(np.arange(0.5, 10, 1))\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n ax.imshow(frame, cmap='binary')\n ax.set_title(\"Episode {}\".format(episode_nr))\n plt.pa... | [
"0.64805615",
"0.6395517",
"0.63600767",
"0.6321238",
"0.6193627",
"0.61895263",
"0.6010808",
"0.59778",
"0.5938082",
"0.5934734",
"0.59344804",
"0.592055",
"0.58944136",
"0.5893408",
"0.5877107",
"0.58597356",
"0.58251846",
"0.5823605",
"0.58234686",
"0.58124083",
"0.5784960... | 0.7789411 | 0 |
Save some images and plots during training | def generate_plots(fixed, moving, warped, flows, train_loss, val_loss, reg_loss, epoch):
moving = moving.detach().cpu().numpy()
fixed = fixed.detach().cpu().numpy()
warped = [w.detach().cpu().numpy() for w in warped]
flows = [f.detach().cpu().numpy() for f in flows]
fig = plt.figure(constrained_lay... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_images(PATH, show_img, datasets, from_dataset):\n dataset = datasets[from_dataset]\n imgModels = dataset['models']\n for modelname, model in imgModels.items():\n print('save', modelname)\n plt.imshow(model[70])\n plt.set_cmap(\"gray\")\n plt.axis('off')\n plt.sa... | [
"0.78799677",
"0.7536049",
"0.7308674",
"0.7303662",
"0.7167811",
"0.7157019",
"0.7031298",
"0.69756454",
"0.6960181",
"0.6957856",
"0.6898664",
"0.6836575",
"0.68074214",
"0.6796281",
"0.67932737",
"0.6753751",
"0.6747309",
"0.6742162",
"0.67349654",
"0.6719155",
"0.6683331"... | 0.0 | -1 |
GIFOutput a model defined in Swagger | def __init__(self, gif_fps=None, color_depth=None, gif_loop=None, height=None, start=None, duration=None,
suffix=None, overlay=None, overlay_alignment=None, overlay_scale='fit', label=None):
self._gif_fps = None
self._color_depth = None
self._gif_loop = None
self._heigh... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_random_gif():\n\n random_gif_url = giphy_random_generator()\n return jsonify(random_gif_url)",
"def run(self):\n generated_gif = self.generate()\n with open(self.out_filename, 'wb') as out_fd:\n out_fd.write(generated_gif)",
"def generate_im(self, model):\n ka... | [
"0.5817749",
"0.5611348",
"0.55694085",
"0.5549498",
"0.54999256",
"0.5440405",
"0.5431132",
"0.540683",
"0.53500056",
"0.53045505",
"0.529118",
"0.526501",
"0.5244855",
"0.52252036",
"0.52224654",
"0.521024",
"0.5190709",
"0.5121285",
"0.50855976",
"0.50822467",
"0.50727075"... | 0.0 | -1 |
Gets the gif_fps of this GIFOutput. The frame rate of the GIF. Default is the Video frame rate | def gif_fps(self):
return self._gif_fps | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fps(self):\n return self._num_frames / (datetime.now() - self._start).total_seconds()",
"def get_fps(self):\n # Take difference.\n interframe_intervals = np.diff(self.data[\"t\"])\n\n # Inter-frame interval in milliseconds.\n mean_interval = np.mean(interframe_intervals... | [
"0.7494257",
"0.7355209",
"0.7317423",
"0.71695226",
"0.70986986",
"0.7062496",
"0.70086706",
"0.69287163",
"0.69171",
"0.68915033",
"0.68721455",
"0.6822134",
"0.6741372",
"0.6735853",
"0.67118305",
"0.6672671",
"0.662301",
"0.662301",
"0.6597375",
"0.6547688",
"0.64681935",... | 0.8816731 | 0 |
Sets the gif_fps of this GIFOutput. The frame rate of the GIF. Default is the Video frame rate | def gif_fps(self, gif_fps):
if gif_fps is not None and gif_fps > 30:
raise ValueError("Invalid value for `gif_fps`, must be a value less than or equal to `30`")
self._gif_fps = gif_fps | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gif_fps(self):\n return self._gif_fps",
"def set_fps(self, fps=25):\n raise NotImplementedError(\"set_fps is not implemented\")",
"def set_framerate(self, framerate):\n self._framerate = int(framerate)",
"def set_fps(self, fps=25):\n # self._root.knob('fps').setValue(fp... | [
"0.74496573",
"0.69945496",
"0.6775548",
"0.6714409",
"0.62625706",
"0.6213025",
"0.59868544",
"0.5918831",
"0.5851581",
"0.5825714",
"0.5825714",
"0.5749928",
"0.5744896",
"0.5659933",
"0.5629519",
"0.56099874",
"0.5604374",
"0.5597134",
"0.55247176",
"0.550153",
"0.54935694... | 0.85410434 | 0 |
Gets the color_depth of this GIFOutput. Amount of colors in palette | def color_depth(self):
return self._color_depth | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_explored(self):\n return self.__num_explored",
"def queryNumberOfColors(self):\n self._numColorsInUse = \\\n self._readInt('How many colors are available', 2, len(self._palette))\n return self._numColorsInUse",
"def num_depth(self):\n return len(self._sizes) + len(self._ra... | [
"0.68169844",
"0.65945107",
"0.65047747",
"0.64739394",
"0.6416106",
"0.6415538",
"0.6361293",
"0.63216704",
"0.6281688",
"0.62379676",
"0.622544",
"0.61876786",
"0.6183844",
"0.6128096",
"0.60531795",
"0.60531795",
"0.60180753",
"0.592283",
"0.5902543",
"0.5848112",
"0.58416... | 0.8169639 | 0 |
Sets the color_depth of this GIFOutput. Amount of colors in palette | def color_depth(self, color_depth):
self._color_depth = color_depth | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SetDepth(*args, **kwargs):\n return _gdi_.Bitmap_SetDepth(*args, **kwargs)",
"def set_depth(self, depth):\n self._depth = depth\n if self._scaled_image_coordinates is None:\n self._initialise()\n else:\n self._update_depth()",
"def color_depth(self):\n ... | [
"0.6401659",
"0.6380821",
"0.6300926",
"0.62612724",
"0.5997467",
"0.5974511",
"0.5967667",
"0.5931414",
"0.5931148",
"0.59209645",
"0.58476746",
"0.58119255",
"0.57820714",
"0.57815474",
"0.5667481",
"0.5611237",
"0.5600413",
"0.5562935",
"0.5406338",
"0.53640157",
"0.535976... | 0.756508 | 0 |
Gets the gif_loop of this GIFOutput. If to loop the GIF. 1 is no loop, 0 is infinite loops, and other numbers are number of loops. | def gif_loop(self):
return self._gif_loop | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gif_loop(self, gif_loop):\n if gif_loop is not None and gif_loop < -1:\n raise ValueError(\"Invalid value for `gif_loop`, must be a value greater than or equal to `-1`\")\n\n self._gif_loop = gif_loop",
"def get_loop(self):\n\n log(\"Getting loop for {} at {}\".format(self._lo... | [
"0.6869839",
"0.6846498",
"0.622958",
"0.6160181",
"0.5945182",
"0.57386464",
"0.55551046",
"0.554464",
"0.53494954",
"0.5158095",
"0.5133926",
"0.5090462",
"0.50807434",
"0.5023866",
"0.5007544",
"0.4975262",
"0.49709076",
"0.49350947",
"0.4925683",
"0.4912694",
"0.48901445"... | 0.8365495 | 0 |
Sets the gif_loop of this GIFOutput. If to loop the GIF. 1 is no loop, 0 is infinite loops, and other numbers are number of loops. | def gif_loop(self, gif_loop):
if gif_loop is not None and gif_loop < -1:
raise ValueError("Invalid value for `gif_loop`, must be a value greater than or equal to `-1`")
self._gif_loop = gif_loop | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gif_loop(self):\n return self._gif_loop",
"def __loop(self):\n if self.loops is \"inf\":\n self.play()\n else:\n if self.loops > self.current_loop:\n self.current_loop += 1\n self.play()\n else:\n self.stop()",... | [
"0.7291405",
"0.6020012",
"0.59639007",
"0.57001525",
"0.54498154",
"0.54039925",
"0.53877467",
"0.532594",
"0.5293056",
"0.523517",
"0.52066076",
"0.51812136",
"0.51310414",
"0.50876",
"0.50081354",
"0.49736694",
"0.49516755",
"0.4897915",
"0.48965508",
"0.4870012",
"0.48547... | 0.81786376 | 0 |
Gets the height of this GIFOutput. Height of the media to be rendered, in pixels. Should be the height of your scenes unless a smaller resolution is needed. Resolution higher than the scene resolution reduces quality. The width is automatically calculated to keep the aspect ratio. | def height(self):
return self._height | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_height(self) -> int:\n return self.rsimulator.get_frame_height()",
"def get_height(self):\n if self.height:\n return self.height\n \n if not self._oembed:\n return ''\n \n return self._oembed.get('height', None)",
"def height(self):\n return self... | [
"0.7565148",
"0.73991317",
"0.7380456",
"0.736369",
"0.7310083",
"0.7279103",
"0.72679317",
"0.7228617",
"0.72236824",
"0.71272886",
"0.71267223",
"0.70312136",
"0.70312136",
"0.7028361",
"0.70189685",
"0.7004611",
"0.6970833",
"0.6970833",
"0.6967758",
"0.69549733",
"0.69441... | 0.66156316 | 56 |
Sets the height of this GIFOutput. Height of the media to be rendered, in pixels. Should be the height of your scenes unless a smaller resolution is needed. Resolution higher than the scene resolution reduces quality. The width is automatically calculated to keep the aspect ratio. | def height(self, height):
if height is None:
raise ValueError("Invalid value for `height`, must not be `None`")
self._height = height | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setHeight(self, *args):\n return _libsbml.Dimensions_setHeight(self, *args)",
"def SetHeight(*args, **kwargs):\n return _gdi_.Bitmap_SetHeight(*args, **kwargs)",
"def set_height(height):\n resize.transforms[1].size = height",
"def SetHeight(self, h):\r\n\r\n self._height = h",
"... | [
"0.6735364",
"0.6383196",
"0.63685995",
"0.630886",
"0.62710375",
"0.62426734",
"0.6142797",
"0.60943526",
"0.60887784",
"0.60887784",
"0.60887784",
"0.60887784",
"0.60887784",
"0.6074497",
"0.60136455",
"0.60128236",
"0.5981412",
"0.5960381",
"0.5942689",
"0.59383595",
"0.58... | 0.5538502 | 57 |
Gets the start of this GIFOutput. What second of the storyboard timeline to start the GIF. | def start(self):
return self._start | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getStartTime(self):\n return _osgAnimation.Animation_getStartTime(self)",
"def getStartTime(self):\n return _osgAnimation.Channel_getStartTime(self)",
"def get_start(self):\n return self._start",
"def getStart(self):\n return self._start",
"def _get_start(self):\n ret... | [
"0.7076997",
"0.6851174",
"0.66245645",
"0.6571833",
"0.65565145",
"0.6531953",
"0.65159637",
"0.65159637",
"0.63531405",
"0.63480484",
"0.6346194",
"0.63422894",
"0.6338405",
"0.6206076",
"0.6201802",
"0.61647004",
"0.6138878",
"0.6114829",
"0.6110501",
"0.607757",
"0.606464... | 0.61608136 | 20 |
Sets the start of this GIFOutput. What second of the storyboard timeline to start the GIF. | def start(self, start):
if start is None:
raise ValueError("Invalid value for `start`, must not be `None`")
self._start = start | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self, start):\n\n self._start = start",
"def start(self, start):\n\n self._start = start",
"def start(self, start):\n\n self._start = start",
"def start(self, start):\n\n self._start = start",
"def start(self):\n\t\tif self._start is not None:\n\t\t\traise RuntimeError... | [
"0.6723576",
"0.6723576",
"0.6723576",
"0.6723576",
"0.6678015",
"0.665719",
"0.6505287",
"0.6384998",
"0.6332083",
"0.62387615",
"0.62376267",
"0.62024736",
"0.6184223",
"0.6178705",
"0.60933346",
"0.60816824",
"0.60661453",
"0.5995193",
"0.5995193",
"0.59945655",
"0.5989577... | 0.60994416 | 14 |
Gets the duration of this GIFOutput. Seconds for the duration of the GIF. Can't be longer than the video. | def duration(self):
return self._duration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def duration():\r\n elapsed_time, duration = video_time()\r\n return duration",
"def video_duration(self):\n # type: () -> int\n return self._video_duration",
"def get_duration(self):\n frame_dur = self.get_frame_duration()\n num_frames = self.get_num_frames()\n motion_dur = frame_... | [
"0.7762158",
"0.7709614",
"0.75428295",
"0.7538186",
"0.74586827",
"0.74504477",
"0.74190795",
"0.7403893",
"0.7340937",
"0.733311",
"0.7328377",
"0.7324417",
"0.72875273",
"0.7262277",
"0.7247565",
"0.72455525",
"0.72377896",
"0.7232972",
"0.721482",
"0.7209425",
"0.7201544"... | 0.7359599 | 12 |
Sets the duration of this GIFOutput. Seconds for the duration of the GIF. Can't be longer than the video. | def duration(self, duration):
self._duration = duration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setDuration(self, *args):\n return _osgAnimation.Animation_setDuration(self, *args)",
"def duration(self, duration):\n self._duration = duration",
"def duration(self, duration):\n self._duration = duration",
"async def async_set_duration(self, duration):\n self._duration = dur... | [
"0.7234786",
"0.72298867",
"0.72298867",
"0.7033115",
"0.6978191",
"0.6903736",
"0.6718069",
"0.6541939",
"0.65389705",
"0.64146113",
"0.623737",
"0.6063905",
"0.6063905",
"0.5945565",
"0.5841082",
"0.58208543",
"0.5790863",
"0.57763195",
"0.5763773",
"0.5758399",
"0.56954765... | 0.7048977 | 8 |
Gets the suffix of this GIFOutput. Unique ending of the file name so several outputs can be created then identified. Required if there is more then 1 video output. | def suffix(self):
return self._suffix | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def suffix(self):\n return self[\"suffix\"]",
"def suffix(self):\n return self[\"suffix\"]",
"def file_suffix(self):\n return f'{self.image_count:05}' if self.sequential_naming else \\\n datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")",
"def suffix ( self ) :\n ... | [
"0.7610536",
"0.7610536",
"0.75316405",
"0.7521287",
"0.7521287",
"0.7347243",
"0.7304037",
"0.70785016",
"0.70785016",
"0.70710915",
"0.7039384",
"0.69881004",
"0.6693291",
"0.6596418",
"0.65870094",
"0.651454",
"0.64653707",
"0.6425669",
"0.63848877",
"0.63419944",
"0.63229... | 0.7638083 | 2 |
Sets the suffix of this GIFOutput. Unique ending of the file name so several outputs can be created then identified. Required if there is more then 1 video output. | def suffix(self, suffix):
self._suffix = suffix | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setSuffix(self, value):\n return self._set(suffix=value)",
"def file_suffix(self):\n return f'{self.image_count:05}' if self.sequential_naming else \\\n datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\")",
"def suffix(self):\n return self._suffix",
"def suffix(self):\... | [
"0.7028223",
"0.69330084",
"0.67990613",
"0.67990613",
"0.67990613",
"0.67454875",
"0.67454875",
"0.67304456",
"0.66012996",
"0.66012996",
"0.6601247",
"0.6541266",
"0.63328516",
"0.6209011",
"0.6205128",
"0.61271995",
"0.6105634",
"0.6063221",
"0.60500926",
"0.60498923",
"0.... | 0.73530364 | 3 |
Gets the overlay of this GIFOutput. | def overlay(self):
return self._overlay | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gif_loop(self):\n return self._gif_loop",
"def layer(self):\n return self.GetLayer()",
"def draw_overlay(self):\n pass",
"def gif(self):\n\n if self._gif is None:\n\n url = self.url.replace('f=fits', 'f=gif')\n\n try:\n url_data = urllib.re... | [
"0.58112276",
"0.5789104",
"0.5632958",
"0.5590468",
"0.55475557",
"0.5475671",
"0.54720825",
"0.54714066",
"0.54669756",
"0.54507834",
"0.54363924",
"0.5428256",
"0.5422926",
"0.54158616",
"0.5394534",
"0.5377252",
"0.5376429",
"0.53099346",
"0.53099346",
"0.53099346",
"0.52... | 0.77030104 | 0 |
Sets the overlay of this GIFOutput. | def overlay(self, overlay):
self._overlay = overlay | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_overlay(self, image_path):\n if not osp.isfile(image_path):\n raise ValueError(\"Invalid background image '{}'\".format(image_path))\n self._overlay_image = image_path\n self._final = None # Force rebuild",
"def draw_overlay(self):\n pass",
"def set_image_overlay... | [
"0.6185808",
"0.6119764",
"0.5662509",
"0.56069213",
"0.54998136",
"0.5440037",
"0.54383683",
"0.53346497",
"0.5262761",
"0.5242616",
"0.5206041",
"0.5164456",
"0.51297665",
"0.5111875",
"0.50731605",
"0.50062686",
"0.4991521",
"0.4922425",
"0.4873345",
"0.48438504",
"0.48411... | 0.71629286 | 0 |
Gets the overlay_alignment of this GIFOutput. Alignment for overlay image in case the image doesn't fit the video perfectly. The first item in the array is X. The second is Y. | def overlay_alignment(self):
return self._overlay_alignment | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overlay_alignment(self, overlay_alignment):\n allowed_values = [\"left\", \"center\", \"right\", \"top\", \"middle\", \"bottom\"]\n if not set(overlay_alignment).issubset(set(allowed_values)):\n raise ValueError(\n \"Invalid values for `overlay_alignment` [{0}], must be ... | [
"0.6082157",
"0.5811847",
"0.57966024",
"0.5563203",
"0.5563203",
"0.5563203",
"0.5542505",
"0.54789925",
"0.5473381",
"0.5473381",
"0.5473381",
"0.54557025",
"0.5414728",
"0.5391308",
"0.53716415",
"0.53711426",
"0.53711426",
"0.5358381",
"0.5308002",
"0.5301803",
"0.5293957... | 0.78458405 | 0 |
Sets the overlay_alignment of this GIFOutput. Alignment for overlay image in case the image doesn't fit the video perfectly. The first item in the array is X. The second is Y. | def overlay_alignment(self, overlay_alignment):
allowed_values = ["left", "center", "right", "top", "middle", "bottom"]
if not set(overlay_alignment).issubset(set(allowed_values)):
raise ValueError(
"Invalid values for `overlay_alignment` [{0}], must be a subset of [{1}]"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overlay_alignment(self):\n return self._overlay_alignment",
"def overlay(self, overlay):\n\n self._overlay = overlay",
"def gonio_axis_align():\n \n # Invert camera image, so dark pin on light image becomes a peak\n cam_7.proc1.scale.put(-1)\n cam_8.proc1.scale.put(-1)\n \n ... | [
"0.6678817",
"0.5036174",
"0.49780422",
"0.49720982",
"0.49529678",
"0.4905251",
"0.48996106",
"0.48916376",
"0.48693442",
"0.4828346",
"0.48276195",
"0.4773495",
"0.46798646",
"0.46748582",
"0.46645558",
"0.46387076",
"0.4636476",
"0.46264026",
"0.46152508",
"0.45992303",
"0... | 0.7055731 | 0 |
Gets the overlay_scale of this GIFOutput. | def overlay_scale(self):
return self._overlay_scale | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_scale(self):\n\n if not hasattr(self, \"scale\"):\n raise NotImplementedError(\"\"\"All end-use subclasses of Color should define\n a get_scale method.\"\"\")\n\n return self.scale",
"def scale(self):\n return self._scale",
"def scaling(self):\n return self... | [
"0.6790271",
"0.6653809",
"0.66482663",
"0.66482663",
"0.65947706",
"0.6566475",
"0.6556108",
"0.6550792",
"0.6483977",
"0.646856",
"0.64394736",
"0.64268297",
"0.6364694",
"0.6363281",
"0.635813",
"0.63503003",
"0.6337674",
"0.63340884",
"0.62737983",
"0.62683964",
"0.626098... | 0.8657468 | 0 |
Sets the overlay_scale of this GIFOutput. | def overlay_scale(self, overlay_scale):
allowed_values = ["fit", "fill", "none"]
if overlay_scale not in allowed_values:
raise ValueError(
"Invalid value for `overlay_scale` ({0}), must be one of {1}"
.format(overlay_scale, allowed_values)
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overlay_scale(self):\n return self._overlay_scale",
"def scale(self, scale):\n\n self._scale = scale",
"def scale(self, scale):\n\n self._scale = scale",
"def overlay(self, overlay):\n\n self._overlay = overlay",
"def with_scale_op(self, scale):\n\t\tself.variables['scale'] ... | [
"0.63258976",
"0.6225319",
"0.6225319",
"0.60859454",
"0.6069903",
"0.599363",
"0.5942604",
"0.59057343",
"0.5672578",
"0.55856156",
"0.55695605",
"0.5541849",
"0.54761684",
"0.54468507",
"0.5435712",
"0.543293",
"0.54186404",
"0.53943425",
"0.5391189",
"0.5248213",
"0.518084... | 0.7558165 | 0 |
Gets the label of this GIFOutput. This label is another way to identify this specific output. The label is returned in the response, but does not appear in the file name. | def label(self):
return self._label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")",
"def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")",
"def label(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"label\")",
"def GetLabel(self) -> str:\n return self._la... | [
"0.7676132",
"0.7676132",
"0.7676132",
"0.72346693",
"0.72052455",
"0.7165676",
"0.7153336",
"0.7116317",
"0.709397",
"0.709397",
"0.709397",
"0.709397",
"0.7070629",
"0.70703095",
"0.69807523",
"0.6979013",
"0.69762206",
"0.69762206",
"0.69762206",
"0.69762206",
"0.69762206"... | 0.69314796 | 36 |
Sets the label of this GIFOutput. This label is another way to identify this specific output. The label is returned in the response, but does not appear in the file name. | def label(self, label):
self._label = label | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SetLabel(self, label):\r\n\r\n self.label = label",
"def set_label(self, value: str = \"nowhere\"):\r\n self._logger.info(log_message_formatter(\r\n \"set\", f\"{self}\", \"label\"))\r\n self._name = value",
"def label(self, label: str):\n\n self._label = label",
"d... | [
"0.7037132",
"0.7015011",
"0.6995444",
"0.69905746",
"0.6945674",
"0.69194204",
"0.69194204",
"0.69194204",
"0.6830198",
"0.6777393",
"0.6766795",
"0.67664",
"0.6736288",
"0.6702227",
"0.6684909",
"0.6660016",
"0.66550493",
"0.66285706",
"0.6598174",
"0.6524958",
"0.65165377"... | 0.6942709 | 14 |
Returns the model properties as a dict | def to_dict(self):
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return self.properties",
"def to_dict(self):\n return self.properties",
"def get_properties(self):\n return self.properties",
"def asdict(self):\n return self._prop_dict",
"def json(self):\n rv = {\n prop: getattr(self, prop)\n f... | [
"0.7751993",
"0.7751993",
"0.73391134",
"0.7334895",
"0.7297356",
"0.727818",
"0.7159078",
"0.71578115",
"0.71494967",
"0.71494967",
"0.71283495",
"0.71275014",
"0.7122587",
"0.71079814",
"0.7060394",
"0.7043251",
"0.7034103",
"0.70233124",
"0.69635814",
"0.69586295",
"0.6900... | 0.0 | -1 |
Returns the string representation of the model | def to_str(self):
return pprint.pformat(self.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.85856134",
"0.7814518",
"0.77898884",
"0.7751367",
"0.7751367",
"0.7712228",
"0.76981676",
"0.76700574",
"0.7651133",
"0.7597206",
"0.75800353",
"0.7568254",
"0.7538184",
"0.75228703",
"0.7515832",
"0.7498764",
"0.74850684",
"0.74850684",
"0.7467648",
"0.74488163",
"0.7442... | 0.0 | -1 |
For `print` and `pprint` | def __repr__(self):
return self.to_str() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pprint(*args, **kwargs):\n if PRINTING:\n print(*args, **kwargs)",
"def print_out():\n pass",
"def custom_print(*objects):\n print(*objects, sep=OFS, end=ORS)",
"def _print(self, *args):\n return _ida_hexrays.vd_printer_t__print(self, *args)",
"def _printable(self):\n ... | [
"0.7557754",
"0.7338058",
"0.6987503",
"0.69850004",
"0.69455147",
"0.6924971",
"0.6898882",
"0.6898829",
"0.6815187",
"0.68062454",
"0.6751603",
"0.6749909",
"0.67452943",
"0.67000484",
"0.66911054",
"0.66751033",
"0.6657706",
"0.6609648",
"0.6608622",
"0.66017973",
"0.65629... | 0.0 | -1 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, GIFOutput):
return False
return self.__dict__ == other.__dict__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.8088132",
"0.8088132",
"0.8054589",
"0.7982687",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
return not self == other | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.845611",
"0.8391477",
"0.8144138",
"0.81410587",
"0.8132492",
"0.8093973",
"0.80920255",
"0.80920255",
"0.80920255",
"0.8085325",
"0.8085325",
"0.8076365",
"0.8076365",
"0.8065748"
] | 0.0 | -1 |
Returns the start state for the search problem. | def getStartState(self):
util.raiseNotDefined() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getStartState(self):\n return self._start_loc",
"def getStartState(self):\n\t\tutil.raiseNotDefined()",
"def getStartState(self):\n\t\tutil.raiseNotDefined()",
"def getStartState(self):\r\n\t\tutil.raiseNotDefined()",
"def get_start_state(self):\n util.raiseNotDefined()",
"def get_start... | [
"0.75840217",
"0.7533028",
"0.7533028",
"0.7457706",
"0.7429071",
"0.7384781",
"0.7342245",
"0.7342245",
"0.7342245",
"0.7342245",
"0.7342245",
"0.7342245",
"0.7342245",
"0.7342245",
"0.7342245",
"0.7339077",
"0.69931024",
"0.6990535",
"0.6884872",
"0.6682311",
"0.6666652",
... | 0.74203616 | 37 |
Returns a sequence of moves that solves tinyMaze. For any other maze, the sequence of moves will be incorrect, so only use this for tinyMaze. | def tinyMazeSearch(problem):
from game import Directions
s = Directions.SOUTH
w = Directions.WEST
return [s, s, w, s, w, w, s, w] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tinyMazeSearch(problem):\n from game import Directions\n s = Directions.SOUTH\n w = Directions.WEST\n n = Directions.NORTH\n\n return [s, s, n, s, w, s, w, w, s, w]",
"def tinyMazeSearch(problem):\n from game import Directions\n\n s = Directions.SOUTH\n w = Directions.WEST\n retur... | [
"0.7175067",
"0.71658105",
"0.7148162",
"0.7116588",
"0.7116588",
"0.7116588",
"0.7103733",
"0.7103733",
"0.7103733",
"0.7103733",
"0.7103733",
"0.7103733",
"0.7103733",
"0.7101113",
"0.7101113",
"0.7101113",
"0.7101113",
"0.7101113",
"0.7101113",
"0.7101113",
"0.7101113",
... | 0.7095842 | 44 |
Search the deepest nodes in the search tree first. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm. To get started, you might want to try some of these simple commands to | def depthFirstSearch(problem):
# Initialization
startState = problem.getStartState()
# print "Start:", startState
if problem.isGoalState(startState):
return [] # No action needed
route = util.Stack()
closed = set([startState])
stack = util.Stack() # DFS use stack
# print prob... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def depthFirstSearch(problem):\n \"*** YOUR CODE HERE ***\"\n class Node:\n def __init__(self, state, parent, action, pathCost):\n self.state = state #state of the game\n self.parent = parent #parent of the node\n self.action = action #action that led to that node\n ... | [
"0.7513152",
"0.7225696",
"0.7204362",
"0.7134987",
"0.71109664",
"0.7070234",
"0.70049804",
"0.69962883",
"0.6984793",
"0.6974376",
"0.6913317",
"0.69028807",
"0.6886942",
"0.6876935",
"0.68767977",
"0.6869486",
"0.682488",
"0.67664015",
"0.67569697",
"0.675022",
"0.6741336"... | 0.655119 | 33 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.