None:","def setup(self,chip,line,mode):\n if len(self.chips[chip]) < line:\n raise ValueError(\"invalid line offset\")\n chip_line = gpio_chips[chip][line]\n if mode == OUT:\n chip_line['direction'] = OUT\n else:\n chip_line['direction'] = IN","def create_line(self):\n if self.hosts and self.line:\n self.msg(\"There is a line here already.\")\n self.display_line()\n return\n self.line = []\n other_hosts = [self.caller.search(arg) for arg in self.lhslist]\n other_hosts = [ob for ob in other_hosts if ob and ob.player]\n other_hosts.append(self.caller)\n self.hosts = other_hosts\n if \"loop\" in self.switches:\n self.toggle_loop()\n self.display_line()","def groupLines(self, parts):\n\t\tline = []\n\t\thasDifference = False\n\t\treplaceline = lambda line: list((p[0], self.color_linedifferent if hasDifference and p[1] == self.color_normal else p[1]) for p in line)\n\t\tfor part in parts:\n\t\t\tif part[1] != self.color_normal:\n\t\t\t\thasDifference = True\n\t\t\tif not len(part[0]): continue\n\t\t\tline += [part]\n\t\t\tif part[0][-1] == \"\\n\":\n\t\t\t\tyield replaceline(line)\n\t\t\t\tline = []\n\t\t\t\thasDifference = False\n\t\tyield replaceline(line)","def __setslice__(self, *args):\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___setslice__(self, *args)","def add_line_element(self, obj, typ_sofi, layer):\n\n bm = LineElement(obj, typ_sofi)\n bm.n1 = self.nodes.add(Node(None, rs.CurveStartPoint(obj)))\n bm.n2 = self.nodes.add(Node(None, rs.CurveEndPoint(obj)))\n\n bm.mark_start_point()\n bm.layer = layer\n\n self.line_elements.add(bm)","def grid_line(object):\n def __init__(self, casenum):\n self.casenum = casenum\n \n def getList(self):\n \"\"\"\n to get the whole list of grid line data\n \"\"\"\n lineList = get_array(self.casenum, 'branch')\n self.lineList = lineList\n return lineList\n \n def getLineNum(self):\n \"\"\"\n :return: number of lines\n \"\"\"\n self.lineNum = len(self.getList())\n return self.lineNum\n \n def getFBus(self):\n \"\"\"\n :return:list of \"from\" bus numbers\n \"\"\"\n FBus = []\n for e in self.getList():\n FBus.append(e[0])\n self.FBus = FBus\n return self.Bus\n \n def getTBus(self):\n \"\"\"\n :return: list of \"to\" bus numbers\n \"\"\"\n TBus = []\n for e in self.getList():\n TBus.append(e[1])\n self.TBus = TBus\n return self.TBus","def line_graph(self, backtracking=True, shared=False):\n raise Exception(\"Graph store doesn't support creating an line matrix.\")","def line(self, arg, fill):\n pass","def test_line():\n model = pb.Model(examples.chain_lattice(a=1), pb.line(0, 4.5))\n assert model.system.num_sites == 4\n\n model = pb.Model(examples.chain_lattice(a=1), pb.line([0, -0.5], [5, 0.5]))\n assert model.system.num_sites == 6","def add_line(self, src_state: int, dst_state: int, color: str):\n src_y = src_state // self.width\n src_x = src_state % self.width\n dst_y = dst_state // self.width\n dst_x = dst_state % self.width\n\n self.lines[(src_x, src_y, dst_x, dst_y, color)] += 1","def put(self, line):\n self.rpc.call(MsfRpcMethod.SessionRingPut, [self.sid, line])","def SetLineAlpha(self, alpha):\n self._attalpha[\"line\"] = alpha\n self.SetLineColorAlpha(self.GetLineColor(), alpha)","def __init__(self, model, line, line_ht, segments = None, influence = None, \r\n connectivity = 1, connectivity_normdist = None,\r\n variables = [], priors=[]):\r\n\r\n import numpy as np\r\n from scipy.interpolate import interp1d\r\n import copy\r\n \r\n # Connect this element to the solver\r\n self.model = model\r\n model.elementlist.append(self)\r\n model.linear_solver = True\r\n \r\n # Prepare the stochastic variables\r\n self.variables = variables\r\n self.priors = priors\r\n \r\n # Initialize the head target and connectivity variables\r\n self.line_ht = line_ht\r\n self.connectivity = connectivity\r\n if np.isscalar(self.connectivity): # Connectivity provided is uniform\r\n \r\n self.connectivity_uniform = True\r\n \r\n else: # Connectivity provided \r\n \r\n self.connectivity_uniform = False\r\n \r\n # Check if normalized distances were provided\r\n if connectivity_normdist is None:\r\n raise Exception('If connectivity is not uniform, a vector of equal length containing normalized distances (e.g., [0., 0.25, 0.6, 1.]) must be specified.')\r\n \r\n # Check if connectivity_normdist is valid\r\n if np.min(connectivity_normdist) < 0 or np.max(connectivity_normdist) > 1:\r\n raise Exception('connectivity_normdist values must be between 0 and 1. Current values: '+str(connectivity_normdist))\r\n \r\n # Check if connectivity_normdist is sorted\r\n if not (connectivity_normdist == np.sort(connectivity_normdist)).all():\r\n raise Exception('connectivity_normdist values must be provided in ascending order. Current values: '+str(connectivity_normdist))\r\n \r\n self.connectivity_normdist = connectivity_normdist\r\n \r\n # ---------------------------------------------------------------------\r\n # Subdivide the provided no flow boundary into #segments pieces\r\n \r\n # Complexify the line, if it wasn't already complex\r\n line = self.complexify(line)\r\n \r\n # The subdivision algorith requires the line coordinates as a real N-by-2 matrix\r\n line = np.column_stack((\r\n np.real(line)[:,np.newaxis],\r\n np.imag(line)[:,np.newaxis]))\r\n \r\n # Make a copy of the line\r\n self.line_raw = copy.copy(line)\r\n \r\n # Check if a subdivision has been specified\r\n if segments is None: # No subdivision required\r\n self.segments = line.shape[0]-1\r\n else: # Otherwise, set target\r\n self.segments = segments\r\n \r\n # A number of consistency checks\r\n if self.segments < self.line_raw.shape[0]-1:\r\n raise Exception('Number of segments '+str(self.segments)+\" mustn't be smaller than number of line points \"+str(line.shape[0])+'.')\r\n if len(line_ht) != line.shape[0]:\r\n raise Exception('Number of head prescriptions must equal number of vertices: '+str(len(line_ht))+' =/= '+str(line.shape[0]))\r\n \r\n \r\n if self.segments > self.line_raw.shape[0]:\r\n \r\n # Subdivide the line\r\n self.line = self.subdivide_line(np.column_stack((line,self.line_ht)),self.segments)\r\n self.line_c = copy.copy(self.line[:,0] + 1j*self.line[:,1])\r\n self.line_ht = copy.copy(self.line[:,2])\r\n \r\n else:\r\n \r\n # Otherwise, reconstruct the line format\r\n self.line = self.line_raw.copy()\r\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\r\n self.line_ht = line_ht\r\n \r\n # --------------------------------------------------------------------- \r\n \r\n # Assign the initial strength variables for each segment\r\n self.strength = np.ones(self.segments)\r\n \r\n # Prepare the influence range for this line sink\r\n if influence is None:\r\n # If no influence range is specified, set it to twice the domain radius\r\n # to ensure that no point in the model domain will lie outside this range\r\n self.influence = self.model.domain_radius*2\r\n else:\r\n self.influence = influence\r\n \r\n # Prepare a few variables for this element\r\n self.L = [] # Length of each line segment\r\n self.zc = [] # Center of each line segment\r\n self.head_target = [] # Head target at each line segment\r\n \r\n for seg in range(self.segments):\r\n \r\n self.L += [np.abs(self.line_c[seg+1] - self.line_c[seg])]\r\n self.zc += [(self.line_c[seg]+self.line_c[seg+1])/2]\r\n self.head_target += [(self.line_ht[seg]+self.line_ht[seg+1])/2]\r\n \r\n # Convert list of segment centers to array\r\n self.zc = np.asarray(self.zc)\r\n self.head_target = np.asarray(self.head_target)\r\n \r\n # Now form a vector of cumulative distances\r\n self.cumdist = []\r\n for seg in range(self.segments):\r\n if seg == 0:\r\n self.cumdist.append(np.abs(self.zc[0]-self.line_c[0]))\r\n else:\r\n self.cumdist.append(np.abs(self.zc[seg]-self.zc[seg-1]))\r\n self.cumdist = np.cumsum(np.asarray(self.cumdist))\r\n self.cumdist /= (self.cumdist[-1] + np.abs(self.zc[-1]-self.line_c[-1]))\r\n \r\n if not self.connectivity_uniform:\r\n \r\n # Interpolate the connectivity\r\n from scipy.interpolate import interp1d\r\n itp = interp1d(self.connectivity_normdist,self.connectivity)\r\n self.connectivity_interpolated = itp(self.cumdist)\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n # Convert the head targets to potential targets\r\n self.set_potential_target()\r\n \r\n # Check if the prior matches the number of parameters\r\n if len(self.priors) != len(self.variables):\r\n raise Exception('Number of priors must match number of unknown variables. Number of priors: '+str(self.priors)+' / Number of unknown variables: '+str(len(self.variables)))\r\n \r\n # Go through all elements\r\n if len(self.variables) > 0:\r\n # There are some model variables specified\r\n for idx,var in enumerate(self.variables):\r\n self.model.num_params += 1\r\n exec(\"self.model.params += [self.%s]\" % var)\r\n self.model.priors += [self.priors[idx]]\r\n self.model.variables += [var]\r\n if 'name' in list(self.priors[idx].keys()):\r\n self.model.param_names += [self.priors[idx]['name']] \r\n else: \r\n self.model.param_names += ['unknown']","def parse_line(self, line):\n raise NotImplementedError","def startLineDrawing(self, startPos):\n self.line = LineNodePath(render2d, thickness=2, colorVec=(0.8,0.8,0.8,1))\n self.line.moveTo(startPos)\n t = taskMgr.add(self.drawLineTask, \"drawLineTask\")\n t.startPos = startPos","def updateLine(self, column: str, value: [str,int], lineId: int):\n value = f\"'{value}'\" if type(value) == str else value\n query = f\"\"\"\n UPDATE lines\n SET {column} = {value}\n WHERE id = {lineId};\n \"\"\"\n sql.executeQuery(self.connection, query)","def EuclidI31(self, line: Line, point: Point, interesting=True) -> Line:\n if point in line:\n # If the point is already on the line, the parallel of the line is the line itself\n return line\n # rename point as A, points B,C on line\n a = point\n b, c = line.point1, line.point2\n circle_center_b_radius_ba = self.add_circle(b, a, interesting=interesting)\n intersections = self.find_intersections_line_circle(line, circle_center_b_radius_ba)\n d = list(intersections)[0] # It doesn't matter which one we pick.\n circle_center_d_radius_da = self.add_circle(d, a, interesting=interesting)\n intersections = list(self.find_intersections_circle_circle(circle_center_b_radius_ba,\n circle_center_d_radius_da))\n e = intersections[0] if intersections[0] != a else intersections[1] # Pick the intersection not A\n de = self.add_line(d, e, interesting=interesting)\n intersections = list(self.find_intersections_line_circle(de, circle_center_d_radius_da))\n f = intersections[0] if intersections[0] != e else intersections[1]\n return self.add_line(a, f, interesting=interesting)"],"string":"[\n \"def update(self, line):\",\n \"def _write_line(\\n self,\\n shape: LineString,\\n emission: float,\\n info: EmissionInfo,\\n source_group: int,\\n ):\\n # split the line string in single lines\\n previous_coord = shape.coords[0]\\n\\n lines = [LineString([previous_coord, coord]) for coord in shape.coords[1:]]\\n\\n # split the emission between the lines based on the length\\n line_lengths = np.array([line.length for line in lines])\\n line_emission_ratios = line_lengths / line_lengths.sum()\\n line_emissions = line_emission_ratios * emission\\n\\n for i, (line, line_emission) in enumerate(zip(lines, line_emissions)):\\n self._write_staight_line(\\n Point(line.coords[0]),\\n Point(line.coords[1]),\\n line_emission,\\n info,\\n source_group,\\n section=i,\\n )\",\n \"def IntersectWithLine(self, , , p_float_6, p_float_7, p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def add(self, line):\\n self.cull()\\n self.lines.append(line)\",\n \"def repair_lines(self) -> None:\\n if len(self.lines) == 0:\\n self.create_lines()\\n else:\\n for line in self.lines:\\n connection = line.connection\\n start_component = self.components[connection.start_entity]\\n end_component = self.components[connection.end_entity]\\n start_pin_location = (\\n start_component.location\\n + start_component.pin_locations[connection.start_pin]\\n )\\n end_pin_location = (\\n end_component.location\\n + end_component.pin_locations[connection.end_pin]\\n )\\n\\n # If the line can be straight we do that\\n if (\\n start_pin_location.x == end_pin_location.x\\n or start_pin_location.y == end_pin_location.y\\n ):\\n line.locations = [start_pin_location, end_pin_location]\\n\\n if not (\\n start_pin_location == line.locations[0]\\n and end_pin_location == line.locations[-1]\\n ):\\n # Change locations of lines when components move\\n if len(line.locations) < 4:\\n # Add a bend if the line was previously straight\\n x_midpoint = (start_pin_location.x + end_pin_location.x) / 2\\n bend_start = Point(x_midpoint, start_pin_location.y)\\n bend_end = Point(x_midpoint, end_pin_location.y)\\n bends = [bend_start, bend_end]\\n line.locations = [start_pin_location, *bends, end_pin_location]\\n else:\\n # Otherwise, just change the y of the existing points to match\\n line.locations[0] = start_pin_location\\n line.locations[1].y = start_pin_location.y\\n line.locations[-2].y = end_pin_location.y\\n line.locations[-1] = end_pin_location\",\n \"def setReference(self, line):\\n #updates experimental lines\\n original = self.cellLines.copy()\\n updatedIndices = list(range(len(self.cellLines)))\\n ind = self.cellLines.index(line)\\n self.cellLines.append(self.cellLines.pop(ind))\\n self.colors.append(self.colors.pop(ind))\\n updatedIndices.append(updatedIndices.pop(ind))\\n\\n #updates replicates lines and redoes reference intersections\\n for each in self.experimentalReplicates:\\n each.setReference(updatedIndices)\\n each.referenceIntersections()\\n #redoes combining replicates to recalculate intersections on an experimental level\\n if self.combinedReplicates:\\n self.combineReplicates(n_cutoff = self.n_cutoff, std_cutoff = self.std_cutoff)\\n #resets phenotypicMeasurements too\\n for each in self.phenotypicMeasurements.values():\\n each.setReference(line, updatedIndices)\\n\\n print(\\\"New REFERENCE set to {}\\\".format(line))\",\n \"def setReference(self, line, updatedIndices = None):\\n #called from a higher class\\n if updatedIndices:\\n updated = [self.phenotypicData.index.values[i] for i in updatedIndices]\\n self.phenotypicData = self.phenotypicData.reindex(updated)\\n # self.colors[:] = [self.colors[i] for i in updatedIndices]\\n #called by user directly\\n else:\\n original = self.cellLines.copy()\\n updated = list(self.phenotypicData.index.values)\\n ind = updated.index(line)\\n updated.append(updated.pop(ind))\\n self.phenotypicData = self.phenotypicData.reindex(updated)\\n # self.colors.append(self.colors.pop(ind))\",\n \"def __init__(self, model, line, segments = None,head_target = 0,\\r\\n variables = [], priors=[]):\\r\\n\\r\\n import numpy as np\\r\\n from scipy.interpolate import interp1d\\r\\n import copy\\r\\n \\r\\n # Append this element to the specified model\\r\\n self.model = model\\r\\n model.elementlist.append(self)\\r\\n model.linear_solver = True\\r\\n\\r\\n # ---------------------------------------------------------------------\\r\\n # Subdivide the provided no flow boundary into segments pieces\\r\\n \\r\\n # Complexify the line, if it wasn't already complex\\r\\n line = self.complexify(line)\\r\\n \\r\\n # The subdivision algorith requires the line coordinates as a real N-by-2 matrix\\r\\n line = np.column_stack((\\r\\n np.real(line)[:,np.newaxis],\\r\\n np.imag(line)[:,np.newaxis]))\\r\\n \\r\\n self.line_raw = copy.copy(line)\\r\\n if segments is None:\\r\\n self.segments = line.shape[0]-1\\r\\n else:\\r\\n self.segments = segments\\r\\n \\r\\n if self.segments < self.line_raw.shape[0]-1:\\r\\n raise Exception('Prescribed number of line segments '+str(self.segments)+\\\" mustn't be smaller than base number of segments \\\"+str(line.shape[0]-1)+'.')\\r\\n \\r\\n if self.segments > self.line_raw.shape[0]-1:\\r\\n \\r\\n # Subdivide the line\\r\\n self.line = self.subdivide_line(line,self.segments)\\r\\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\\r\\n \\r\\n else:\\r\\n \\r\\n self.line = self.line_raw.copy()\\r\\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\\r\\n \\r\\n # Also get the normal vector components to each segment\\r\\n self.line_nvec = self.line[:,1] - 1j*self.line[:,0]\\r\\n self.line_nvec = self.line_nvec/np.abs(self.line_nvec)\\r\\n\\r\\n # ---------------------------------------------------------------------\\r\\n \\r\\n # Get strength parameters for each vertex\\r\\n self.strength = np.ones(self.segments)\\r\\n \\r\\n \\r\\n self.zc = []\\r\\n self.segment_nvec = []\\r\\n self.L = []\\r\\n \\r\\n for seg in range(self.segments):\\r\\n \\r\\n self.zc += [(self.line_c[seg]+self.line_c[seg+1])/2]\\r\\n \\r\\n # Calculate the normal vector to this segment\\r\\n self.segment_nvec += [(self.line_c[seg]-self.line_c[seg+1])]\\r\\n self.segment_nvec[-1]= [np.imag(self.segment_nvec[-1])-1j*np.real(self.segment_nvec[-1])]\\r\\n \\r\\n self.L += [np.abs(self.line_c[seg+1] - self.line_c[seg])]\\r\\n \\r\\n self.zc = np.asarray(self.zc)\\r\\n \\r\\n # Extract target variables\\r\\n self.variables = variables\\r\\n self.priors = priors\\r\\n \\r\\n self.L = np.asarray(self.L)\\r\\n \\r\\n \\r\\n # Check if the prior matches the number of parameters\\r\\n if len(self.priors) != len(self.variables):\\r\\n raise Exception('Number of priors must match number of unknown variables. Number of priors: '+str(self.priors)+' / Number of unknown variables: '+str(len(self.variables)))\\r\\n \\r\\n # Go through all elements\\r\\n if len(self.variables) > 0:\\r\\n # There are some model variables specified\\r\\n for idx,var in enumerate(self.variables):\\r\\n self.model.num_params += 1\\r\\n exec(\\\"self.model.params += [self.%s]\\\" % var)\\r\\n self.model.priors += [self.priors[idx]]\\r\\n self.model.variables += [var]\\r\\n if 'name' in list(self.priors[idx].keys()):\\r\\n self.model.param_names += [self.priors[idx]['name']] \\r\\n else: \\r\\n self.model.param_names += ['unknown']\",\n \"def update_lines(self):\\n self._checkfigure()\\n for ld in self.lines:\\n line = ld['line']\\n\\n color = ld['color']\\n line.set_color(color)\\n\\n lw = ld['linewidth']\\n hlf = ld['highlight factor']\\n highlight = hlf if ld['highlighted'] else 1.0\\n lw = lw*highlight\\n line.set_linewidth(lw)\\n\\n for vline in ld['vlines']:\\n vline.set_color(color)\\n vline.set_linestyle('--')\\n vline.set_linewidth(lw)\\n\\n for hline in ld['vlines']:\\n hline.set_color(color)\\n hline.set_linestyle('--')\\n hline.set_linewidth(lw)\",\n \"def set_line(self, line, membership):\\n self._lines[line] = membership\",\n \"def _write_staight_line(\\n self,\\n start: Point,\\n end: Point,\\n emission: float,\\n info: EmissionInfo,\\n source_group: int,\\n section: int, # Section number of the line\\n ):\\n z_start = info.height\\n z_end = info.height\\n if info.height_over_buildings:\\n z_start += self.grid.building_heights[self.grid.get_index(start.x, start.y)]\\n z_end += self.grid.building_heights[self.grid.get_index(end.x, end.y)]\\n\\n with open(self.file_lines, \\\"a\\\") as f:\\n # Write the line\\n f.write(\\n f\\\"unnamed,{section},{source_group},{start.x},{start.y},{z_start},\\\"\\n f\\\"{end.x},{end.y},{z_end},{info.width},-{info.vertical_extension},0,0,\\\"\\n f\\\"{emission},0,0,0,0\\\\n\\\"\\n )\",\n \"def buildLine(self):\\n self.clearLineshape()\\n if len(self.components)==0:\\n y = np.zeros(len(self.x))\\n self.lineshape = y\\n else:\\n '''for component in self.components:\\n y = np.array([component.function(x) for x in self.x])\\n self.lineshape = np.add(self.lineshape,y)'''\\n self.buffer._sum()\",\n \"def edit_line(self, line):\\r\\n for code, code_obj in self.code_objs.items():\\r\\n line = self.__edit_line(line, code, code_obj)\\r\\n return line\",\n \"def set_mask_line(self, _=None):\\n self.set_mask_type(\\\"line\\\")\",\n \"def addLine(self, verts, color=[220,0,0], thickness=1.0, alpha=255,\\n linestyle='=', selectable=True, movable=True, isCosmetic=False):\\n\\n # addLine is just a simplified interface to addPolygon\\n return QViewerBase.addPolygon(self, verts, color=color, thickness=thickness, alpha=alpha,\\n linestyle=linestyle, selectable=selectable, movable=movable,\\n closed=False, isCosmetic=isCosmetic)\",\n \"def calc_line(tik_instance, grads, y, grads_h,\\n loc_h, loc_w, n_index, start_c1, end_c1):\\n in_w = grads.shape[3]\\n out_w = y.shape[3]\\n grads_ub = tik_instance.Tensor(\\n \\\"float32\\\", [in_w, 16], name=\\\"grads_ub\\\", scope=tik.scope_ubuf)\\n y_ub = tik_instance.Tensor(\\n \\\"float32\\\", [out_w, 16], name=\\\"y_ub\\\", scope=tik.scope_ubuf)\\n loc_reg = tik_instance.Scalar(dtype=\\\"int32\\\")\\n c1_reg = tik_instance.Scalar(dtype=\\\"int32\\\")\\n\\n calc_c1_num = end_c1 - start_c1\\n with tik_instance.for_range(0, calc_c1_num) as c1_index:\\n # read one line grads\\n c1_reg.set_as(start_c1 + c1_index)\\n tik_instance.tensor_mov(grads_ub,\\n grads[n_index, c1_reg, grads_h, 0, 0],\\n '', 1, (in_w * 16 * 4 + 31) // 32, 0, 0)\\n # clear out ub\\n clear_ub(tik_instance, y_ub)\\n\\n with tik_instance.for_range(0, in_w) as i:\\n loc_reg.set_as(loc_w[i])\\n tik_instance.vadd(16, y_ub[loc_reg, 0], y_ub[loc_reg, 0],\\n grads_ub[i, 0], 1, 1, 1, 1, 0, 0, 0)\\n\\n # move data out\\n tik_instance.set_atomic_add(1)\\n tik_instance.tensor_mov(y[n_index, start_c1 + c1_index, loc_h, 0, 0],\\n y_ub, '', 1,\\n (out_w * 16 * 4 + 31) // 32, 0, 0)\\n tik_instance.set_atomic_add(0)\",\n \"def SectionVertex(self, *args):\\n return _BRepAlgo.BRepAlgo_DSAccess_SectionVertex(self, *args)\",\n \"def _prepare_order_line_invoice_line(self, cr, uid, line, account_id=False, context=None):\\n res = super(sale_order_line, self)._prepare_order_line_invoice_line(cr, uid, line, account_id=account_id, context=context)\\n \\n res.update({'part_number': line.part_number, 'internal_part_number' : line.internal_part_number})\\n return res\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n self.model_give_dim = model.give_dim()\\n #if grps and model: \\n # lines = WC.Lines()\\n # cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n # lines.add(cmd + \\\"reuse=MAIL,\\\")\\n # lines.init_idt = \\\" \\\" * len(cmd)\\n # lines.add(\\\"MAILLAGE=MAIL,\\\")\\n # opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\\n # lines.add(\\\");\\\")\\n # bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n self.model_give_dim = model.give_dim()\\n #if grps and model: \\n # lines = WC.Lines()\\n # cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n # lines.add(cmd + \\\"reuse=MAIL,\\\")\\n # lines.init_idt = \\\" \\\" * len(cmd)\\n # lines.add(\\\"MAILLAGE=MAIL,\\\")\\n # opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\\n # lines.add(\\\");\\\")\\n # bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n self.model_give_dim = model.give_dim()\\n #if grps and model: \\n # lines = WC.Lines()\\n # cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n # lines.add(cmd + \\\"reuse=MAIL,\\\")\\n # lines.init_idt = \\\" \\\" * len(cmd)\\n # lines.add(\\\"MAILLAGE=MAIL,\\\")\\n # opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n # #lines.add(opt % (model.give_dim(), tuple(grps)))\\n # lines.add(opt % (self.model_give_dim, tuple(grps)))\\n # lines.add(\\\");\\\")\\n # bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def addToGroup(self, frontorback, drawing, svggroup, **extra): \\r\\n super(byA_FB_SideLine, self).addToGroup(drawing, svggroup, **extra)\",\n \"def add_line_piece(self, start, end):\\r\\n self.pieces.append(LineSegment(start, end))\\r\\n self.total_length += self.pieces[-1].get_length()\",\n \"def updateLine(self, ikey, vecx=None, vecy=None, linestyle=None, linecolor=None, marker=None, markercolor=None):\\n # check\\n assert isinstance(ikey, int), 'Line key must be an integer.'\\n assert ikey in self._my1DPlotDict, 'Line with ID %d is not on canvas. ' % ikey\\n\\n return self._myCanvas.updateLine(ikey, vecx, vecy, linestyle, linecolor, marker, markercolor)\",\n \"def _g_line_changed(self):\\n self.gSpin.setValue(self.gLine.value())\\n self._update_image()\",\n \"def refresh_mpl_line(self, line=None):\\n if line:\\n self.set_label(self.label,line=line)\\n self.set_color(self.color,line=line)\\n self.set_style(self.style,line=line)\\n self.set_marker(self.marker,line=line)\\n self.set_markersize(self.markersize,line=line)\\n self.set_linewidth(self.linewidth,line=line)\",\n \"def set_line_segments(self, line):\\n line_row_col = []\\n # transform x, y coordinates to columns and rows\\n line_converted = []\\n for i, point in enumerate(line):\\n point_converted = xy_to_colrow(\\n point[0],\\n point[1],\\n self.grid.xmin,\\n self.grid.ymin,\\n self.grid.dx,\\n self.grid.dy\\n )\\n line_converted.append(point_converted)\\n # get cells intersected by line segments\\n for i in range(len(line_converted) - 1):\\n line_row_col.append(get_line_grid(line_converted[i], line_converted[i+1]))\\n # delete last cell of each segment\\n for i in line_row_col:\\n del i[-1]\\n # generate number of segments for each boundary\\n self.nums_of_segments = self.rand_seg_nums(\\n len(line_row_col),\\n len(self.data_source.linear_boundaries)\\n )\\n # assign cells to each boundary type\\n for idx, key in enumerate(self.data_source.linear_boundaries):\\n for i in range(self.nums_of_segments[idx]):\\n self.line_segments[key].extend(\\n line_row_col[i]\\n )\\n del line_row_col[:self.nums_of_segments[idx]]\\n\\n return self.line_segments\",\n \"def fromRevLineSeg(x1, y1, x2, y2, mesh):\\n patch = Patch(mesh)\\n patch.addRevLineSeg(x1, y1, x2, y2)\\n return patch\",\n \"def line(self, x, y):\\n self.call('line', x, y)\",\n \"def _b_line_changed(self):\\n self.bSpin.setValue(self.bLine.value())\\n self._update_image()\",\n \"def _r_line_changed(self):\\n self.rSpin.setValue(self.rLine.value())\\n self._update_image()\",\n \"def _write_mesh_change(self, writer):\\n bloc = \\\"\\\"\\n grps = self._grp_names_for_mesh\\n model = writer.get(Modelisation)\\n if grps and model: \\n lines = WC.Lines()\\n cmd = \\\"MAIL=MODI_MAILLAGE(\\\"\\n lines.add(cmd + \\\"reuse=MAIL,\\\")\\n lines.init_idt = \\\" \\\" * len(cmd)\\n lines.add(\\\"MAILLAGE=MAIL,\\\")\\n opt = \\\"ORIE_PEAU_%sD=_F(GROUP_MA=%s,),\\\"\\n lines.add(opt % (model.give_dim(), tuple(grps)))\\n lines.add(\\\");\\\")\\n bloc = lines.build_part()\\n writer.subs(\\\"mesh_change_key\\\", bloc)\",\n \"def append_subcircuit(self, lines: Tuple[int, int], circuit: Circuit, content: str) -> None:\",\n \"def FilterLine(self, a_line):\\n return a_line\",\n \"def update_anim(i,dt, mol,line):\\n time_step(dt, mol)\\n line.set_data([(mol.p1.pos[0], mol.p2.pos[0]),\\n (mol.p1.pos[1], mol.p2.pos[1])])\\n return line,\",\n \"def draw_line(self, start_p, end_p, color, thickness: float):\\n line_seg = LineSegs(\\\"interface\\\")\\n line_seg.setColor(*color)\\n line_seg.moveTo(start_p[0] * self.w_scale, 0, start_p[1] * self.h_scale)\\n line_seg.drawTo(end_p[0] * self.w_scale, 0, end_p[1] * self.h_scale)\\n line_seg.setThickness(thickness)\\n line_np = self.aspect2d.attachNewNode(line_seg.create(False))\\n return line_np\",\n \"def _parseLine(self, line, delimiter = \\\":\\\"):\\r\\n\\t\\tsplt = line.split(delimiter)\\r\\n\\t\\tinVec = self._parseVec(splt[0])\\r\\n\\t\\toutVec = self._parseVec(splt[1])\\r\\n\\t\\tif (len(splt) == 2):\\r\\n\\t\\t\\tlabel = \\\"\\\"\\r\\n\\t\\telse:\\r\\n\\t\\t\\tlabel = splt[2]\\r\\n\\t\\tself.data.append({'in':inVec, 'out':outVec, 'label':label})\",\n \"def line_put(self, line):\\n resp = None\\n url = '{}line/'.format(self.epoint)\\n body_json = json.dumps(self.fillter_dct(self.line_attrs_allowed, line))\\n try:\\n resp = requests.put(url, timeout=self.to, headers=self.headers,\\n data=body_json)\\n resp.raise_for_status()\\n except Exception as e:\\n panic(e=e, resp=resp)\\n\\n return resp.json(), resp.headers.get('location')\",\n \"def update_blocks(self, ln, block, occ):\\n\\n if ln == Line.LINE_GREEN:\\n if (block < 1) or (block > 150):\\n raise Exception('TrainSystem : update_blocks received blocks out of\\\\\\n range for Green Line')\\n else:\\n self.blocks_green_arr[block - 1].occupied = occ\\n else:\\n if (block < 1) or (block > 76):\\n raise Exception('TrainSystem : update_blocks received blocks out of\\\\\\n range for Red Line')\\n else:\\n self.blocks_red_arr[block - 1].occupied = occ\\n\\n # Update the location of the train with every block moved\\n self.update_train_loc()\",\n \"def do_draw_network(self, line):\\n self.fibbing.root.lsdb.graph.draw(line)\",\n \"def render_lines(self, line_cells):\\n for cell in line_cells:\\n self.surface.set_at(cell.tuple('2D'), YELLOW)\",\n \"def subdivide(self, subdivision, new_point):\\n\\n\\t\\tassert(subdivision.ndim == 3)\\n\\n\\t\\t# Find the attached faces.\\n\\t\\tface1, face2, face3, face4 = self.attached_faces\\n\\n\\t\\t# Find the attached lines, and be able to associate them with the\\n\\t\\t# faces.\\n\\t\\tline12, = face1.attached_lines & face2.attached_lines\\n\\t\\tline13, = face1.attached_lines & face3.attached_lines\\n\\t\\tline14, = face1.attached_lines & face4.attached_lines\\n\\t\\tline23, = face2.attached_lines & face3.attached_lines\\n\\t\\tline24, = face2.attached_lines & face4.attached_lines\\n\\t\\tline34, = face3.attached_lines & face4.attached_lines\\n\\n\\t\\t# Find the attached points, and be able to associate them with the \\n\\t\\t# faces.\\n\\t\\tpoint123, = line12.attached_points & line13.attached_points\\n\\t\\tpoint124, = line12.attached_points & line14.attached_points\\n\\t\\tpoint134, = line13.attached_points & line14.attached_points\\n\\t\\tpoint234, = line23.attached_points & line24.attached_points\\n\\n\\t\\t# Create the new lines.\\n\\t\\tnew_line123 = matplot3dext.objects.line.Line(point123, new_point)\\n\\t\\tnew_line124 = matplot3dext.objects.line.Line(point124, new_point)\\n\\t\\tnew_line134 = matplot3dext.objects.line.Line(point134, new_point)\\n\\t\\tnew_line234 = matplot3dext.objects.line.Line(point234, new_point)\\n\\n\\t\\t# Create the new faces.\\n\\t\\tnew_face12 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline12, new_line123, new_line124)\\n\\t\\tnew_face13 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline13, new_line123, new_line134)\\n\\t\\tnew_face14 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline14, new_line124, new_line134)\\n\\t\\tnew_face23 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline23, new_line123, new_line234)\\n\\t\\tnew_face24 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline24, new_line124, new_line234)\\n\\t\\tnew_face34 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline34, new_line134, new_line234)\\n\\n\\t\\t# Create the new tetrahedra.\\n\\t\\t#\\n\\t\\t# Make a sketch to understand what's going on now.\\n\\t\\tnew_tetrahedron1 = Tetrahedron(\\n\\t\\t\\t\\tface1, new_face12, new_face13, new_face14)\\n\\t\\tnew_tetrahedron2 = Tetrahedron(\\n\\t\\t\\t\\tface2, new_face12, new_face23, new_face24)\\n\\t\\tnew_tetrahedron3 = Tetrahedron(\\n\\t\\t\\t\\tface3, new_face13, new_face23, new_face34)\\n\\t\\tnew_tetrahedron4 = TetrahedroN(\\n\\t\\t\\t\\tface4, new_face14, new_face24, new_face34)\\n\\n\\t\\tself.replace_by([new_tetrahdron1, new_tetrahedron2, \\n\\t\\t\\t\\tnew_tetrahedron3, new_tetrahedron4], subdivision.world)\\n\\n\\t\\treturn new_point\",\n \"def __setslice__(self, *args):\\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint2___setslice__(self, *args)\",\n \"def splitLineAtPoint_backup(lineGraph, pointGraph, decimals=6):\\n lineGraphCopy = lineGraph.copy()\\n attrs = set(list(lineGraphCopy.edges(data=True)[0][2].keys()))\\n remains = set(['Ind', 'coordinates'] + list(attrs))\\n delAttrs = attrs.difference(remains)\\n \\n for edge in lineGraphCopy.edges(data=True):\\n for delAttr in delAttrs:\\n del edge[2][delAttr]\\n \\n pointList = []\\n for point in pointGraph.nodes(data=True):\\n pointList.append([point[0][0], point[0][1]])\\n \\n tempId = len(pointGraph.nodes(data=True))\\n \\n # for every center point (splitFeatures)\\n for pointInd, point in enumerate(pointList):\\n print('{}/{}'.format(pointInd, len(pointList)))\\n # find the edge that the center point located\\n done = False\\n for edge in lineGraphCopy.edges(data=True):\\n # among the segments in the edge\\n prevVertex = None\\n for ind, vertex in enumerate(edge[2]['coordinates']):\\n if ind == 0:\\n prevVertex = vertex\\n else:\\n currVertex = vertex\\n onLine = geometry.isPointOnLine(prevVertex, currVertex, point)\\n \\n # if the center point is on the segment\\n if onLine == True:\\n coord1 = edge[2]['coordinates'][:ind]\\n coord1.append(point) # add 'point' in the end of the list\\n coord2 = edge[2]['coordinates'][ind:]\\n coord2.insert(0, point) # add 'point' at the front of the list\\n \\n \\n# startNode1 = tuple(coord1[0])\\n startNode1 = tuple([round(coord, decimals) for coord in coord1[0]])\\n# endNode1 = tuple(coord1[-1])\\n endNode1 = tuple([round(coord, decimals) for coord in coord1[-1]])\\n# startNode2 = tuple(coord2[0])\\n startNode2 = tuple([round(coord, decimals) for coord in coord2[0]])\\n# endNode2 = tuple(coord2[-1])\\n endNode2 = tuple([round(coord, decimals) for coord in coord2[-1]])\\n \\n attrsDict = {}\\n attrsDict['Ind'] = tempId\\n attrsDict['coordinates'] = coord1\\n attrs = attrs.difference(set(['Ind', 'coordinates']))\\n for attr in attrs:\\n attrsDict[attr] = edge[2][attr]\\n \\n lineGraphCopy.add_edge(startNode1, endNode1, attrsDict)\\n tempId+=1\\n \\n attrsDict['Ind'] = tempId\\n attrsDict['coordinates'] = coord2\\n lineGraphCopy.add_edge(startNode2, endNode2, attrsDict)\\n tempId+=1\\n \\n # remove the original edge\\n e = (edge[0], edge[1], {'Ind':edge[2]['Ind']})\\n lineGraphCopy.remove_edge(*e[:2])\\n \\n prevVertex = currVertex\\n \\n done = True\\n break\\n \\n prevVertex = currVertex\\n if done == True:\\n break\\n \\n graphCalculate.addDistance(lineGraphCopy)\\n return lineGraphCopy\",\n \"def render_line(self, line_num, is_reset=False):\\n\\n # Find all elements to be rendered in current line\\n elems_inline = [elem for elem in self.elems if elem.pos.row == line_num]\\n\\n visible_parts = []\\n\\n def visible_check((A_left, A_right, _), (B_left, B_right, B_id)):\\n\\n # compare the left/right bound of new element with each\\n # existing bound.\\n\\n A_left_shaded = A_left <= B_left\\n A_right_shaded = A_right >= B_right\\n A_left_dodged = A_right < B_left\\n A_right_dodged = A_left > B_right\\n\\n # Four cases of shading:\\n # 1. dodged: the fore and back element doesn't overlap\\n # 2. shaded: fore element shaded at left or right bound of back\\n # element.\\n # 3. split: fore element splits back element into two visible\\n # parts.\\n\\n if A_left_dodged or A_right_dodged: # dodged\\n return ((B_left, B_right, B_id),)\\n elif not (A_left_shaded or A_right_shaded): # splitted\\n return ((B_left, A_left, B_id),(A_right, B_right, B_id))\\n elif (A_left_shaded and A_right_shaded): # fully shaded\\n return []\\n else: # partially shaded\\n if A_left_shaded:\\n return ((A_right, B_right, B_id),)\\n if A_right_shaded:\\n return ((B_left, A_left, B_id),)\\n\\n for elem_i, elem in enumerate(elems_inline):\\n\\n elem_bound = (elem.pos.col, elem.pos.col + len(elem.text), elem_i)\\n\\n for i, part in enumerate(visible_parts):\\n visible_parts[i] = visible_check(elem_bound, part)\\n visible_parts.append((elem_bound,))\\n\\n # list flatten operation by itertools.chain flatten both list and\\n # tuple (and all iterables), thus we have to coat it with one more\\n # tuple in order to maintain the form.\\n visible_parts = list(itertools.chain.from_iterable(visible_parts))\\n\\n visible_parts = sorted(visible_parts, key=lambda x:x[0])\\n\\n # handles if no elements in this line\\n strokes = \\\"\\\" if visible_parts == [] else \\\" \\\" * visible_parts[0][0]\\n\\n COLOR_RESET = '\\\\x01\\\\x1b[0m\\\\x02'\\n\\n for part in visible_parts:\\n elem = elems_inline[part[2]]\\n color = elem.color\\n text = elem.text[part[0] - elem.pos.col : part[1] - elem.pos.col]\\n strokes += self.stroke(text, color)\\n strokes += COLOR_RESET if is_reset else \\\"\\\"\\n\\n sys.stdout.write(strokes + COLOR_RESET)\\n sys.stdout.write(\\\"\\\\n\\\")\",\n \"def __init__(self, model, line, segments = None, influence = None, \\r\\n strength = 1, variables = [], priors=[]):\\r\\n\\r\\n import numpy as np\\r\\n from scipy.interpolate import interp1d\\r\\n import copy\\r\\n \\r\\n self.model = model\\r\\n model.elementlist.append(self)\\r\\n \\r\\n self.variables = variables\\r\\n self.priors = priors\\r\\n \\r\\n # ---------------------------------------------------------------------\\r\\n # Subdivide the provided no flow boundary into #segments pieces\\r\\n \\r\\n self.line_raw = copy.copy(line)\\r\\n \\r\\n if segments is None:\\r\\n \\r\\n self.segments = line.shape[0]-1\\r\\n \\r\\n else:\\r\\n self.segments = segments\\r\\n \\r\\n if self.segments < self.line_raw.shape[0]-1:\\r\\n \\r\\n raise Exception('Number of segments '+str(self.segments)+\\\" mustn't be smaller than number of line points \\\"+str(line.shape[0])+'.')\\r\\n \\r\\n if self.segments > self.line_raw.shape[0]:\\r\\n \\r\\n # Subdivide the line\\r\\n self.line = self.subdivide_line(line,self.segments)\\r\\n self.line_c = copy.copy(self.line[:,0] + 1j*self.line[:,1])\\r\\n else:\\r\\n \\r\\n self.line = self.line_raw.copy()\\r\\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\\r\\n \\r\\n # Also get the normal vector components to each segment\\r\\n self.line_nvec = self.line[:,1] - 1j*self.line[:,0]\\r\\n self.line_nvec = self.line_nvec/np.abs(self.line_nvec)\\r\\n\\r\\n # --------------------------------------------------------------------- \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n self.strength = np.ones(self.segments)*strength\\r\\n \\r\\n if influence is None:\\r\\n self.influence = self.model.domain_radius*2\\r\\n else:\\r\\n self.influence = influence\\r\\n \\r\\n \\r\\n self.Zi = []\\r\\n self.offset_outside = []\\r\\n self.L = []\\r\\n self.zc = []\\r\\n self.segment_nvec = []\\r\\n self.head_target = []\\r\\n \\r\\n for seg in range(self.segments):\\r\\n \\r\\n self.L += [np.abs(self.line_c[seg+1] - self.line_c[seg])]\\r\\n \\r\\n influence_pt = (self.line_c[seg+1]-self.line_c[seg])*self.influence/self.L[seg] + self.line_c[seg]\\r\\n Z = (2*influence_pt-(self.line_c[seg]+self.line_c[seg+1]))/(self.line_c[seg+1]-self.line_c[seg])\\r\\n self.Zi += [copy.copy(Z)]\\r\\n \\r\\n self.zc += [(self.line_c[seg]+self.line_c[seg+1])/2]\\r\\n \\r\\n # Calculate the normal vector to this segment\\r\\n self.segment_nvec += [(self.line_c[seg]-self.line_c[seg+1])]\\r\\n self.segment_nvec[-1]= [np.imag(self.segment_nvec[-1])-1j*np.real(self.segment_nvec[-1])]\\r\\n \\r\\n part1 = np.nan_to_num((Z+1)*np.log(Z+1))\\r\\n part2 = np.nan_to_num((Z-1)*np.log(Z-1))\\r\\n self.offset_outside += [self.L[seg] / (4*np.pi) * (part1 - part2)]\\r\\n \\r\\n # Convert list of segment centers to array\\r\\n self.zc = np.asarray(self.zc)\\r\\n \\r\\n \\r\\n # Check if the prior matches the number of parameters\\r\\n if len(self.priors) != len(self.variables):\\r\\n raise Exception('Number of priors must match number of unknown variables. Number of priors: '+str(self.priors)+' / Number of unknown variables: '+str(len(self.variables)))\\r\\n \\r\\n # Go through all elements\\r\\n if len(self.variables) > 0:\\r\\n # There are some model variables specified\\r\\n for idx,var in enumerate(self.variables):\\r\\n self.model.num_params += 1\\r\\n exec(\\\"self.model.params += [self.%s]\\\" % var)\\r\\n self.model.priors += [self.priors[idx]]\\r\\n self.model.variables += [var]\\r\\n if 'name' in list(self.priors[idx].keys()):\\r\\n self.model.param_names += [self.priors[idx]['name']] \\r\\n else: \\r\\n self.model.param_names += ['unknown']\",\n \"def next_line():\\r\\n set_point(point().next_line())\",\n \"def update_line(self):\\n self._draw_line_text()\\n self._draw_status()\\n self._line_listbox.set_focus(self.model.l_index)\",\n \"def mouseMoveEvent(self, event):\\n if self.line:\\n self.line.setLine(QLineF(self.line.line().p1(), event.scenePos()))\\n\\n QGraphicsScene.mouseMoveEvent(self, event)\\n self.update()\",\n \"def dispatch_train(self, block_to, line):\\n\\n # Create the train which will dispatch\\n temp_train = Train(self.next_train_num, block_to, line)\\n\\n # Give Train Speed and Authority (blocks, km/hr)\\n temp_train.authority = 3\\n temp_train.command_speed = 70\\n\\n # Add blocks to train object\\n if line == Line.LINE_GREEN:\\n if block_to in self.green_blocks_inter:\\n temp_train.route_switches_arr = copy.deepcopy(self.green_route_switches)\\n temp_train.route_blocks_arr = copy.deepcopy(self.green_route_blocks)\\n\\n temp_train.route_blocks_arr.pop()\\n temp_train.route_blocks_arr.extend(self.green_blocks_inter)\\n temp_train.route_blocks_arr.extend(self.green_route_blocks_multiple)\\n temp_train.route_blocks_arr.append(-1)\\n\\n temp_train.route_switches_arr.pop()\\n temp_train.route_switches_arr.append(1)\\n temp_train.route_switches_arr.extend(self.green_route_switches_inter)\\n temp_train.route_switches_arr.pop()\\n temp_train.route_switches_arr.append(0)\\n else:\\n temp_train.route_switches_arr = self.green_route_switches\\n temp_train.route_blocks_arr = self.green_route_blocks\\n\\n else:\\n if block_to in self.red_blocks_inter:\\n temp_train.route_switches_arr = copy.deepcopy(self.red_route_switches)\\n temp_train.route_blocks_arr = copy.deepcopy(self.red_route_blocks)\\n\\n temp_train.route_blocks_arr.pop()\\n temp_train.route_blocks_arr.extend(self.red_blocks_inter)\\n temp_train.route_blocks_arr.extend(self.red_route_blocks_multiple)\\n temp_train.route_blocks_arr.append(-1)\\n\\n temp_train.route_switches_arr.pop()\\n temp_train.route_switches_arr.extend(self.red_route_switches_inter)\\n temp_train.route_switches_arr.pop()\\n temp_train.route_switches_arr.append(0)\\n else:\\n temp_train.route_switches_arr = self.red_route_switches\\n temp_train.route_blocks_arr = self.red_route_blocks\\n\\n #print(list(map(bool, temp_train.route_switches_arr)))\\n #print(temp_train.route_blocks_arr)\\n\\n # Add train to this array\\n self.trains_arr.append(temp_train)\\n self.train_numbers.append(self.next_train_num)\\n\\n # Send signal to Track Controller\\n signals.swtrack_dispatch_train.emit(temp_train.train_id,\\n temp_train.destination_block,\\n temp_train.command_speed,\\n temp_train.authority,\\n temp_train.line_on,\\n list(map(bool, temp_train.route_switches_arr)))\\n\\n # Increment the next train number counter\\n self.next_train_num += 1\",\n \"def multi_line(self, multi_line):\\n\\n self._multi_line = multi_line\",\n \"def sliceMesh(polyline,IKLE,MESHX,MESHY,tree=None):\\n from matplotlib.tri import Triangulation\\n xys = []\\n douplets = []\\n # ~~> Calculate the minimum mesh resolution\\n dxy = math.sqrt(min(np.square(np.sum(np.fabs(MESHX[IKLE]-MESHX[np.roll(IKLE,1)]),axis=1)/3.0) + \\\\\\n np.square(np.sum(np.fabs(MESHY[IKLE]-MESHY[np.roll(IKLE,1)]),axis=1)/3.0)))\\n accuracy = np.power(10.0, -8+np.floor(np.log10(dxy)))\\n\\n xyo = np.array(polyline[0])\\n for i in range(len(polyline)-1):\\n xyi = np.array(polyline[i+1])\\n dio = math.sqrt(sum(np.square(xyo-xyi)))\\n\\n # ~~> Resample the line to that minimum mesh resolution\\n rsmpline = np.dstack((np.linspace(xyo[0],xyi[0],num=int(dio/dxy)),np.linspace(xyo[1],xyi[1],num=int(dio/dxy))))[0]\\n nbpoints = len(rsmpline)\\n nbneighs = min( 8,len(IKLE) )\\n # ~~> Filter closest 8 elements (please create a good mesh) as a halo around the polyline\\n halo = np.zeros((nbpoints,nbneighs),dtype=np.int)\\n for i in range(nbpoints):\\n d,e = tree.query(rsmpline[i],nbneighs)\\n halo[i] = e\\n halo = np.unique(halo)\\n\\n # ~~> Get the intersecting halo (on a smaller mesh connectivity)\\n edges = Triangulation(MESHX,MESHY,IKLE[halo]).get_cpp_triangulation().get_edges()\\n\\n # ~~> Last filter, all nodes that are on the polyline\\n olah = []\\n nodes = np.unique(edges)\\n for node in nodes: # TODO(jcp): replace by numpy calcs\\n if getDistancePointToLine((MESHX[node],MESHY[node]),xyo,xyi) < accuracy: olah.append(node)\\n ijsect = zip(olah,olah)\\n xysect = [(MESHX[i],MESHY[i]) for i in olah]\\n lmsect = [ (1.0,0.0) for i in range(len(ijsect)) ]\\n mask = np.zeros((len(edges),2),dtype=bool)\\n for i in olah:\\n mask = np.logical_or( edges == i , mask )\\n edges = np.compress(np.logical_not(np.any(mask,axis=1)),edges,axis=0)\\n\\n # ~~> Intersection with remaining edges\\n for edge in edges:\\n xyj = getSegmentIntersection( (MESHX[edge[0]],MESHY[edge[0]]),(MESHX[edge[1]],MESHY[edge[1]]),xyo,xyi )\\n if xyj != []:\\n ijsect.append(edge) # nodes from the mesh\\n xysect.append(tuple(xyj[0])) # intersection (xo,yo)\\n lmsect.append((xyj[1],1.0-xyj[1])) # weight along each each\\n\\n # ~~> Final sorting along keys x and y\\n xysect = np.array(xysect, dtype=[('x', '<f4'), ('y', '<f4')])\\n xysort = np.argsort(xysect, order=('x','y'))\\n\\n # ~~> Move on to next point\\n for i in xysort:\\n xys.append( xysect[i] )\\n douplets.append( (ijsect[i],lmsect[i]) )\\n xyo = xyi\\n\\n return xys,douplets\",\n \"def expand_line(x0,y0,x1,y1,nx,ny,edge=6):\\n def d2(x0,y0,x1,y1):\\n \\\"\\\"\\\"squared distance between two points\\\"\\\"\\\"\\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)\\n def inside(x,e,n):\\n \\\"\\\"\\\"return if x is within e and n-e-1\\n \\\"\\\"\\\"\\n if x < e: return False\\n if x > n-e-1: return False\\n return True\\n # bypass everything\\n if False:\\n return [x0,y0,x1,y1]\\n # pathetic cases\\n if x0==x1: return [x0, edge, x1, ny-1-edge]\\n if y0==y1: return [edge, y0, nx-1-edge, y1]\\n # slope and center point of line\\n a = (y1-y0)/(x1-x0)\\n xc = (x0+x1)/2.0\\n yc = (y0+y1)/2.0\\n # intersections with the box vertices\\n x_e = xc + (edge-yc)/a\\n y_e = yc + a*(edge-xc)\\n x_n = xc + (ny-edge-1-yc)/a\\n y_n = yc + a*(nx-edge-1-xc)\\n print \\\"x,y(0) x,y(1):\\\",x0,y0,x1,y1\\n print \\\"x,y(e) x,y(n):\\\",x_e,y_e,x_n,y_n\\n e = []\\n if inside(x_e,edge,nx): \\n e.append(x_e)\\n e.append(edge)\\n if inside(y_e,edge,ny):\\n e.append(edge)\\n e.append(y_e)\\n if inside(x_n,edge,nx):\\n e.append(x_n)\\n e.append(ny-edge-1)\\n if inside(y_n,edge,ny):\\n e.append(nx-edge-1)\\n e.append(y_n)\\n if len(e) != 4:\\n # can happen for small maps?\\n msg = \\\"Math Error in expand_line: \\\",e\\n raise Exception,msg\\n return e\",\n \"def update_line(s, bold=False, underline=False, blinking=False, color=None, bgcolor=None):\\n s = get_line(s, bold=bold, underline=underline, blinking=blinking,\\n color=color, bgcolor=bgcolor, update_line=True)\\n print(s, end='')\",\n \"def line_to(self, x, y):\\n self._impl.line_to(x, y)\",\n \"def __init__(self, vertices, **kwargs):\\n super(Line, self).__init__(vertices, **kwargs)\\n self._geotype = \\\"Line\\\"\\n return\",\n \"def line_layer(self):\\n screen_origin = self.ids.mapview.get_window_xy_from(lat1, lon1, self.ids.mapview.zoom)\\n screen_destination = self.ids.mapview.get_window_xy_from(lat2, lon2, self.ids.mapview.zoom)\\n point_list = [screen_origin[0], screen_origin[1], screen_destination[0], screen_destination[1]]\\n\\n with self.ids.line.canvas:\\n self.ids.line.canvas.clear()\\n\\n Color(0, 0, 0, .6)\\n Line(points=point_list, width=3, joint=\\\"bevel\\\")\",\n \"def lineTo(self, pt: Tuple[float, float]) -> None:\\n raise NotImplementedError\",\n \"def SetLineMode(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_ConvertCurve3dToBezier_SetLineMode(self, *args)\",\n \"def event_drag_multipoint_line(self, event):\\n\\n if self.variables.current_shape_id:\\n self.show_shape(self.variables.current_shape_id)\\n event_x_pos = self.canvasx(event.x)\\n event_y_pos = self.canvasy(event.y)\\n coords = self.coords(self.variables.current_shape_id)\\n new_coords = list(coords[0:-2]) + [event_x_pos, event_y_pos]\\n vector_object = self.get_vector_object(self.variables.current_shape_id)\\n if vector_object.type == SHAPE_TYPES.ARROW or vector_object.type == SHAPE_TYPES.LINE:\\n self.modify_existing_shape_using_canvas_coords(self.variables.current_shape_id, new_coords)\\n else:\\n pass\",\n \"def update(self, new_line):\\n if new_line == self._line:\\n return\\n\\n self._backup_line()\\n self._line = new_line\",\n \"def _add_line(self, key, info):\\n info = copy.deepcopy(info)\\n anticipated_bus = self._get_df_with_new_elements(\\\"bus\\\")\\n new_lines = []\\n required = {\\\"from_bus_id\\\", \\\"to_bus_id\\\"}\\n xor_sets = {(\\\"capacity\\\", \\\"Pmax\\\"), (\\\"capacity\\\", \\\"Pmin\\\")}\\n optional = {\\\"Pmin\\\"}\\n for i, line in enumerate(info):\\n self._check_entry_keys(line, i, key, required, xor_sets, optional)\\n start = line[\\\"from_bus_id\\\"]\\n end = line[\\\"to_bus_id\\\"]\\n if start not in anticipated_bus.index:\\n raise ValueError(\\n \\\"No bus with the following id for line #%d: %d\\\" % (i + 1, start)\\n )\\n if end not in anticipated_bus.index:\\n raise ValueError(\\n \\\"No bus with the following id for line #%d: %d\\\" % (i + 1, end)\\n )\\n if start == end:\\n raise ValueError(f\\\"to/from buses of line #{i + 1} must be different\\\")\\n if \\\"capacity\\\" in line:\\n if not isinstance(line[\\\"capacity\\\"], (int, float)):\\n raise ValueError(\\\"'capacity' must be a number (int/float)\\\")\\n if line[\\\"capacity\\\"] < 0:\\n raise ValueError(\\\"capacity of line #%d must be positive\\\" % (i + 1))\\n # Everything looks good, let's translate this to Pmin/Pmax\\n line[\\\"Pmax\\\"] = line[\\\"capacity\\\"]\\n line[\\\"Pmin\\\"] = -1 * line[\\\"capacity\\\"]\\n del line[\\\"capacity\\\"]\\n elif {\\\"Pmin\\\", \\\"Pmax\\\"} < set(line.keys()):\\n if key == \\\"new_branch\\\":\\n err_msg = \\\"Can't independently set Pmin & Pmax for AC branches\\\"\\n raise ValueError(err_msg)\\n for p in {\\\"Pmin\\\", \\\"Pmax\\\"}:\\n if not isinstance(line[p], (int, float)):\\n raise ValueError(f\\\"'{p}' must be a number (int/float)\\\")\\n if line[\\\"Pmin\\\"] > line[\\\"Pmax\\\"]:\\n raise ValueError(\\\"Pmin cannot be greater than Pmax\\\")\\n else:\\n raise ValueError(\\\"Must specify either 'capacity' or Pmin and Pmax\\\")\\n if (\\n key == \\\"new_branch\\\"\\n and anticipated_bus.interconnect[start]\\n != anticipated_bus.interconnect[end]\\n ):\\n raise ValueError(\\n \\\"Buses of line #%d must be in same interconnect\\\" % (i + 1)\\n )\\n elif (\\n anticipated_bus.lat[start] == anticipated_bus.lat[end]\\n and anticipated_bus.lon[start] == anticipated_bus.lon[end]\\n ):\\n raise ValueError(\\\"Distance between buses of line #%d is 0\\\" % (i + 1))\\n new_lines.append(line)\\n\\n if key not in self.ct:\\n self.ct[key] = []\\n self.ct[key] += new_lines\",\n \"def send_line(self, line, update_buses: bool = False, update_passengers: bool = False, free_text: str = \\\"\\\",\\n kick_reason: str = \\\"\\\"):\\n\\n while self.__lock_data: # makes sure to not change the data while it's being proccessed and sent.\\n sleep(0.01)\\n if line in self.__line_messages.keys():\\n self.__line_messages[line][\\\"passengers\\\"] = self.__line_messages[line][\\\"passengers\\\"] or update_passengers\\n self.__line_messages[line][\\\"buses\\\"] = self.__line_messages[line][\\\"buses\\\"] or update_buses\\n if free_text != \\\"\\\":\\n self.__line_messages[line][\\\"free text\\\"] += free_text + \\\"\\\\n\\\"\\n if kick_reason != \\\"\\\":\\n buses_copy = deepcopy(self.__bus_dict[line])\\n for bus in buses_copy:\\n if bus not in self.__buses_to_kick:\\n self.__buses_to_kick.append(bus)\\n self.__line_messages[line][\\\"kick reason\\\"] += kick_reason + \\\"\\\\n\\\"\\n\\n\\n else:\\n self.__line_messages[line] = dict()\\n self.__line_messages[line][\\\"passengers\\\"] = update_passengers\\n self.__line_messages[line][\\\"buses\\\"] = update_buses\\n self.__line_messages[line][\\\"free text\\\"] = \\\"\\\"\\n self.__line_messages[line][\\\"kick reason\\\"] = \\\"\\\"\\n if free_text != \\\"\\\":\\n self.__line_messages[line][\\\"free text\\\"] = free_text + \\\"\\\\n\\\"\\n if kick_reason != \\\"\\\":\\n self.__line_messages[line][\\\"kick reason\\\"] = free_text + \\\"\\\\n\\\"\",\n \"def _line(x,m,c):\\n return m*x+c\",\n \"def _line(x,m,c):\\n return m*x+c\",\n \"def lines(\\n self,\\n lines: LineReturn,\\n line_type: LineType,\\n ax: figure | int = 0,\\n color: str = \\\"C0\\\",\\n alpha: float = 1.0,\\n linewidth: float = 1,\\n ) -> None:\\n fig = self._get_figure(ax)\\n color = self._convert_color(color)\\n xs, ys = lines_to_bokeh(lines, line_type)\\n if len(xs) > 0:\\n fig.multi_line(xs, ys, line_color=color, line_alpha=alpha, line_width=linewidth)\",\n \"def set_mode_line():\\n global DRAW_MODE, CURRENT_LABEL, SHAPE_SIZE\\n global mouse_pos, line_start_pos\\n\\n if DRAW_MODE==\\\"line\\\":\\n # draw the line on the mask\\n cv.line(source_msk, line_start_pos, mouse_pos, CURRENT_LABEL, thickness=SHAPE_SIZE)\\n\\n line_start_pos = mouse_pos\\n DRAW_MODE=\\\"line\\\"\",\n \"def calc_line_slice(tik_instance, grads, y, grads_h, loc_h,\\n loc_w, n_index, start_c1, end_c1, scale_w):\\n in_w = grads.shape[3]\\n in_slice_w, out_slice_w = calc_slice_size(scale_w)\\n\\n grads_ub = tik_instance.Tensor(\\n \\\"float32\\\", [in_slice_w, 16], name=\\\"grads_ub\\\", scope=tik.scope_ubuf)\\n y_ub = tik_instance.Tensor(\\n \\\"float32\\\", [out_slice_w, 16], name=\\\"y_ub\\\", scope=tik.scope_ubuf)\\n loc_reg = tik_instance.Scalar(dtype=\\\"int32\\\")\\n index_reg = tik_instance.Scalar(dtype=\\\"int32\\\")\\n start_out_w = tik_instance.Scalar(dtype=\\\"int32\\\")\\n mov_out_w = tik_instance.Scalar(dtype=\\\"int32\\\")\\n\\n calc_c1_num = end_c1 - start_c1\\n repeat_times = (in_w + in_slice_w - 1) // in_slice_w\\n with tik_instance.for_range(0, calc_c1_num) as c1_index:\\n\\n with tik_instance.for_range(0, repeat_times) as w_index:\\n start_out_w.set_as(loc_w[w_index * in_slice_w])\\n cp_len = calc_segment(tik_instance, in_w, w_index, in_slice_w)\\n # read one line grads\\n tik_instance.tensor_mov(grads_ub,\\n grads[n_index, start_c1 + c1_index,\\n grads_h,\\n w_index * in_slice_w, 0],\\n '', 1, (cp_len * 16 * 4 + 31) // 32, 0, 0)\\n # clear out ub\\n clear_ub(tik_instance, y_ub)\\n\\n with tik_instance.for_range(0, cp_len) as i:\\n index_reg.set_as((w_index * in_slice_w) + i)\\n index_reg.set_as(loc_w[index_reg])\\n loc_reg.set_as(index_reg - start_out_w)\\n tik_instance.vadd(16, y_ub[loc_reg, 0], y_ub[loc_reg, 0],\\n grads_ub[i, 0], 1, 1, 1, 1, 0, 0, 0)\\n\\n # move data out\\n mov_out_w.set_as(loc_w[(w_index * in_slice_w) + cp_len - 1])\\n mov_out_w.set_as(mov_out_w - start_out_w + 1)\\n tik_instance.set_atomic_add(1)\\n tik_instance.tensor_mov(y[n_index, start_c1 + c1_index,\\n loc_h, start_out_w, 0],\\n y_ub[0, 0], '', 1,\\n (mov_out_w * 16 * 4 + 31) // 32, 0, 0)\\n tik_instance.set_atomic_add(0)\",\n \"def splitLineAtPoint(lineGraph, pointGraph, nodeAttrs=[], decimals=6):\\n lineGraphCopy = lineGraph.copy()\\n initConvert = {'str': '', 'int': -1, 'float': -1, 'bool':False}\\n for node in nodeAttrs:\\n nx.set_edge_attributes(lineGraphCopy, 'node1_{}'.format(node[0]), initConvert[node[1]])\\n nx.set_edge_attributes(lineGraphCopy, 'node2_{}'.format(node[0]), initConvert[node[1]])\\n attrs = set(list(lineGraphCopy.edges(data=True)[0][2].keys()))\\n attrs = attrs.difference(set(['Ind', 'coordinates']))\\n# remains = set(['Ind', 'coordinates'] + list(attrs))\\n# delAttrs = attrs.difference(remains)\\n# \\n# for edge in lineGraphCopy.edges(data=True):\\n# for delAttr in delAttrs:\\n# del edge[2][delAttr]\\n \\n pointList = []\\n for point in pointGraph.nodes(data=True):\\n pointList.append([point[0][0], point[0][1]])\\n \\n tempId = len(pointGraph.nodes(data=True))\\n \\n # for every center point (splitFeatures)\\n for pointInd, point in enumerate(pointList):\\n# print('{}/{}'.format(pointInd, len(pointList)))\\n # find the edge that the center point located\\n done = False\\n for edge in lineGraphCopy.edges(data=True):\\n # among the segments in the edge\\n prevVertex = None\\n for ind, vertex in enumerate(edge[2]['coordinates']):\\n if ind == 0:\\n prevVertex = vertex\\n else:\\n currVertex = vertex\\n onLine = geometry.isPointOnLine(prevVertex, currVertex, point)\\n \\n near_x,near_y = geometry.findNearPointOnLine(prevVertex, currVertex, point)\\n near_dist = geometry.lineLength((near_x, near_y), point)\\n # if the center point is on the segment\\n if onLine == True and near_dist < 0.0001:\\n coord1 = edge[2]['coordinates'][:ind]\\n coord1.append((near_x, near_y)) # add 'point' in the end of the list\\n coord2 = edge[2]['coordinates'][ind:]\\n coord2.insert(0, (near_x, near_y)) # add 'point' at the front of the list\\n \\n# startNode1 = tuple(coord1[0])\\n startNode1 = tuple([round(coord, decimals) for coord in coord1[0]])\\n# endNode1 = tuple(coord1[-1])\\n endNode1 = tuple([round(coord, decimals) for coord in coord1[-1]])\\n# startNode2 = tuple(coord2[0])\\n startNode2 = tuple([round(coord, decimals) for coord in coord2[0]])\\n# endNode2 = tuple(coord2[-1])\\n endNode2 = tuple([round(coord, decimals) for coord in coord2[-1]])\\n \\n attrsDict = {}\\n attrsDict['Ind'] = tempId\\n attrsDict['coordinates'] = coord1\\n \\n for attr in attrs:\\n attrsDict[attr] = edge[2][attr]\\n \\n for nodeAttr in nodeAttrs:\\n key1 = tuple(coord1[0])\\n# key1 = (round(coord1[0][0], decimals), round(coord1[0][1], decimals))\\n if key1 in pointGraph.nodes():\\n attrsDict['node1_{}'.format(nodeAttr[0])] = pointGraph.node[key1][nodeAttr[0]]\\n \\n key2 = tuple(coord1[-1])\\n# key2 = (round(coord1[-1][0], decimals), round(coord1[-1][1], decimals))\\n if key2 in pointGraph.nodes():\\n attrsDict['node2_{}'.format(nodeAttr[0])] = pointGraph.node[key2][nodeAttr[0]]\\n \\n if startNode1 != endNode1:\\n lineGraphCopy.add_edge(startNode1, endNode1, attrsDict)\\n tempId+=1\\n \\n attrsDict['Ind'] = tempId\\n attrsDict['coordinates'] = coord2\\n \\n for nodeAttr in nodeAttrs:\\n key1 = tuple(coord2[0])\\n# key1 = (round(coord2[0][0], decimals), round(coord2[0][1], decimals))\\n if key1 in pointGraph.nodes():\\n attrsDict['node1_{}'.format(nodeAttr[0])] = pointGraph.node[key1][nodeAttr[0]]\\n \\n key2 = tuple(coord2[-1])\\n# key2 = (round(coord2[-1][0], decimals), round(coord2[-1][1], decimals))\\n if key2 in pointGraph.nodes():\\n attrsDict['node2_{}'.format(nodeAttr[0])] = pointGraph.node[key2][nodeAttr[0]]\\n \\n if startNode2 != endNode2:\\n lineGraphCopy.add_edge(startNode2, endNode2, attrsDict)\\n tempId+=1\\n \\n # remove the original edge\\n e = (edge[0], edge[1], {'Ind':edge[2]['Ind']})\\n lineGraphCopy.remove_edge(*e[:2])\\n \\n prevVertex = currVertex\\n \\n done = True\\n break\\n \\n prevVertex = currVertex\\n if done == True:\\n break\\n \\n graphCalculate.addDistance(lineGraphCopy)\\n return lineGraphCopy\",\n \"def line_moved(self):\\n\\n # The line is supposed to be moved by hand to the beginning of first wrinkle.\\n # The optimal spot is local maximum (not always visible)\\n ext_index = self.index_of_drop + int(self.line.value() * 10000)\\n ext_value = self.data[ext_index]\\n\\n p_i, p_f = toolbox_2.get_pressure_change(self.measurement)\\n smallest_growing_particle = toolbox_2.minimum_particle_diameter(p_i, p_f, self.saturation_percentage / 100)\\n\\n n = toolbox_2.particle_count_2(ext_value)\\n\\n # measurement series 1\\n if self.selected_data == 3 and 7 <= self.meas_selected_number <= 17 and self.meas_selected_series == 1:\\n index = self.meas_selected_number - 7 # Assumes that first measurement is number 7\\n self.smallest_particles[index] = smallest_growing_particle\\n self.number_counts[index] = n\\n\\n self.update_distribution()\\n # Update plot\\n self.curve_distribution.setData(self.particle_distribution_x, self.particle_distribution_y*1e-10)\\n self.curve_distribution_cumulative.setData(self.smallest_particles, self.number_counts*1e-10)\\n\\n # measurement series 2\\n elif self.selected_data == 3 and self.meas_selected_series == 2:\\n index = self.meas_selected_number - 1 # begins from 1, 0th measurement is just copy of 8th\\n self.number_counts_2[index] = n\\n\\n self.curve_rotatometer.setData(np.array([4, 6, 8, 10, 12, 14, 16, 18]), self.number_counts_2*1e-10)\\n x = np.linspace(3.5, 20, 100)\\n self.curve_rotatometer_fit.setData(x, self.number_counts_2[0] * 4 * (1 / x) *1e-10)\\n\\n #print(\\\"N\\\", \\\"%.2e\\\"%n, \\\"dpres\\\", round(p_i - p_f))\",\n \"def __init__(self, polyhedron, data):\\n super(Line, self).__init__(polyhedron, data)\",\n \"def create_line(uniform = True, *args):\\n axis = cmds.radioButtonGrp(widgets[\\\"lineAxisRBG\\\"], q=True, sl=True)\\n length = cmds.floatFieldGrp(widgets[\\\"lineLenFFG\\\"], q=True, v1=True)\\n density = cmds.floatFieldGrp(widgets[\\\"lineDenFFG\\\"], q=True, v1=True)\\n\\n numCvs = length * density\\n if numCvs < 3.0: # curve needs 3 cvs (for 3 dg curve)\\n numCvs = 3.0\\n\\n cvDist = length/numCvs\\n\\n # make a list of pt dist along some axis\\n axisList = []\\n for x in range(0,int(numCvs)+1):\\n axisList.append(x)\\n\\n pts = []\\n\\n if axis == 1:\\n for y in range(0, int(numCvs)+1):\\n pt = [axisList[y]*cvDist, 0, 0]\\n pts.append(pt)\\n\\n if axis == 2:\\n for y in range(0, int(numCvs)+1):\\n pt = [0, axisList[y]*cvDist, 0]\\n pts.append(pt)\\n\\n if axis == 3:\\n for y in range(0, int(numCvs)+1):\\n pt = [0, 0, axisList[y]*cvDist]\\n pts.append(pt)\\t\\t\\t\\n \\n line = cmds.curve(name = \\\"line_01\\\", d=3, p=pts)\\n shp = cmds.listRelatives(line, s=True)[0]\\n cmds.rename(shp, \\\"{0}Shape\\\".format(line))\\n if uniform:\\n line = cmds.rebuildCurve(line, rebuildType = 0, spans = 0, keepRange = 0, replaceOriginal=True, end=1, keepControlPoints=0)[0]\\n\\n cmds.select(line, r=True)\",\n \"def test_RegionDimensionsCylinder_createLineOldVersion(self):\\r\\n\\r\\n lineRef = \\\"-500.000000 -500.000000 300.000000 0.000000 1.000000 0.350000 1000.000000 300.000000\\\"\\r\\n\\r\\n regionDimensions = RegionDimensions.RegionDimensionsCylinder()\\r\\n regionDimensions.positionX = -500.0\\r\\n regionDimensions.positionY = -500.0\\r\\n regionDimensions.positionZ = 300.0\\r\\n regionDimensions.directionX = 0.0\\r\\n regionDimensions.directionY = 1.0\\r\\n regionDimensions.directionZ = 0.35\\r\\n regionDimensions.length = 1000.0\\r\\n regionDimensions.radius = 300.0\\r\\n\\r\\n line = regionDimensions.createLineOldVersion()\\r\\n self.assertEquals(lineRef, line)\\r\\n\\r\\n #self.fail(\\\"Test if the testcase is working.\\\")\\r\",\n \"def update_lines(num, ax, fargs):\\n \\n dataLines, lines = fargs\\n for line, data in zip(lines, dataLines):\\n # NOTE: there is no .set_data() for 3 dim data...\\n line.set_data(data[0:2, :num])\\n line.set_3d_properties(data[2, :num])\\n return lines\",\n \"def update_line(self, player: str, letter: str) -> None:\\n if self.player == '@':\\n i = 0\\n while i < len(self.cells):\\n self.cells[i] = self.cells[i].update_cell(player, letter)\\n i += 1\\n self.check_score()\\n if self.player_1 >= self.total / 2:\\n self.player = 1\\n elif self.player_2 >= self.total / 2:\\n self.player = 2\",\n \"def update_rect(self):\\n if self.vertex_list:\\n # Shrink the rectangle by half-a-pixel so there's no ambiguity \\n # about where the line should be drawn. (The problem is that the \\n # widget rect is always rounded to the nearest pixel, but OpenGL \\n # doesn't seem deterministic about which side of the pixel it draws \\n # the line on.)\\n rect = self._rect.get_shrunk(0.5)\\n self.vertex_list.vertices = (\\n rect.bottom_left.tuple +\\n # Don't know why this offset is necessary, but without it \\n # the bottom-right pixel doesn't get filled in...\\n (rect.bottom_right + (1,0)).tuple +\\n rect.bottom_right.tuple +\\n rect.top_right.tuple +\\n rect.top_right.tuple +\\n rect.top_left.tuple +\\n rect.top_left.tuple +\\n rect.bottom_left.tuple\\n )\",\n \"def addPolyLineToScene(self, controlPoint, colorVar, needleType='Detection',script=False, endMarker=False, name=\\\"^\\\", trans=0, manualName=\\\"\\\",radius=1,bPause=False):\\r\\n #research\\r\\n #profprint()\\r\\n \\\"\\\"\\\"\\r\\n Create a model of the linear needle segments\\r\\n \\\"\\\"\\\"\\r\\n widget = slicer.modules.NeedleFinderWidget\\r\\n\\r\\n realNeedleLength = widget.realNeedleLength.value\\r\\n extendNeedle = widget.extendNeedle.isChecked()\\r\\n\\r\\n # sort the points in a decreasing order (from tip to bottom)\\r\\n controlPointListSorted = controlPoint #self.sortTableReverse(controlPoint, (2, 1, 0))\\r\\n\\r\\n # calculate the length of the list of ctr points\\r\\n lenghtTotal = 0\\r\\n for i in range(len(controlPoint) - 1):\\r\\n lenghtTotal += self.distanceTwoPoints(controlPointListSorted[i + 1], controlPointListSorted[i])\\r\\n #print \\\"Polygon added to scene, length of tube: \\\", lenghtTotal\\r\\n\\r\\n # in case we want to extend the needle to the wanted length\\r\\n \\\"\\\"\\\"\\r\\n The extension is currently done by adding a point to the control point list.\\r\\n \\\"\\\"\\\"\\r\\n if lenghtTotal < realNeedleLength and extendNeedle:\\r\\n lastPoint = [controlPointListSorted[-1][0], controlPointListSorted[-1][1], controlPointListSorted[-1][2] - (realNeedleLength - lenghtTotal)]\\r\\n controlPointListSorted.append(lastPoint)\\r\\n\\r\\n scene = slicer.mrmlScene\\r\\n points = vtk.vtkPoints()\\r\\n polyData = vtk.vtkPolyData()\\r\\n polyData.SetPoints(points)\\r\\n lines = vtk.vtkCellArray()\\r\\n polyData.SetLines(lines)\\r\\n linesIDArray = lines.GetData()\\r\\n linesIDArray.Reset()\\r\\n linesIDArray.InsertNextTuple1(0)\\r\\n polygons = vtk.vtkCellArray()\\r\\n polyData.SetPolys(polygons)\\r\\n idArray = polygons.GetData()\\r\\n idArray.Reset()\\r\\n idArray.InsertNextTuple1(0)\\r\\n n = len(controlPointListSorted)\\r\\n # start read out\\r\\n for i in range(n):\\r\\n pointIndex = points.InsertNextPoint(*(controlPointListSorted[i]))\\r\\n linesIDArray.InsertNextTuple1(pointIndex)\\r\\n linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1)\\r\\n lines.SetNumberOfCells(1)\\r\\n # ## Create model node\\r\\n model = slicer.vtkMRMLModelNode()\\r\\n model.SetScene(scene)\\r\\n model.SetAndObservePolyData(polyData)\\r\\n # ## Create display node\\r\\n modelDisplay = slicer.vtkMRMLModelDisplayNode()\\r\\n\\r\\n modelDisplay.SetScene(scene)\\r\\n scene.AddNode(modelDisplay)\\r\\n model.SetAndObserveDisplayNodeID(modelDisplay.GetID())\\r\\n # ## Add to scene\\r\\n modelDisplay.SetInputPolyDataConnection(model.GetPolyDataConnection())\\r\\n scene.AddNode(model)\\r\\n # ##Create Tube around the line\\r\\n tube = vtk.vtkTubeFilter()\\r\\n polyData = model.GetPolyData()\\r\\n tube.SetInputData(polyData)\\r\\n tube.SetRadius(radius)\\r\\n tube.SetNumberOfSides(50)\\r\\n tube.Update()\\r\\n\\r\\n model.SetAndObservePolyData(tube.GetOutput())\\r\\n model.GetDisplayNode().SliceIntersectionVisibilityOn()\\r\\n model.GetDisplayNode().SetOpacity(1-trans)\\r\\n if needleType == 'Validation':\\r\\n model.SetName('.manual-seg_' + str(colorVar))\\r\\n elif needleType == 'Obturator':\\r\\n model.SetName('.obturator-seg_' + str(colorVar))\\r\\n else:\\r\\n model.SetName('.auto-seg_' + str(self.round) + '-ID-' + str(model.GetID())+'-'+manualName)\\r\\n model.SetAttribute('type', needleType)\\r\\n\\r\\n if needleType == 'Validation' or needleType =='Debug':\\r\\n nth = int(colorVar) % MAXCOL\\r\\n modelDisplay.SetColor(self.color[int(nth)][0], self.color[int(nth)][1], self.color[int(nth)][2])\\r\\n model.SetAttribute(\\\"nth\\\", str(nth))\\r\\n\\r\\n else:\\r\\n nth = int(model.GetID().strip('vtkMRMLModelNode')) % MAXCOL\\r\\n modelDisplay.SetColor(self.color[int(nth)][0], self.color[int(nth)][1], self.color[int(nth)][2])\\r\\n model.SetAttribute(\\\"nth\\\", str(nth))\\r\\n\\r\\n if endMarker:\\r\\n fiducial = slicer.mrmlScene.CreateNodeByClass('vtkMRMLAnnotationFiducialNode')\\r\\n fiducial.SetName('.'+name+'_'+str(colorVar))\\r\\n fiducial.Initialize(slicer.mrmlScene)\\r\\n fiducial.SetFiducialCoordinates(controlPointListSorted[-1])\\r\\n fiducial.SetAttribute('TemporaryFiducial', '1')\\r\\n fiducial.SetLocked(True)\\r\\n displayNode = fiducial.GetDisplayNode()\\r\\n displayNode.SetGlyphScale(.5) # \\\"arrow head\\\"\\r\\n displayNode.SetColor(0, 0, 0)\\r\\n textNode = fiducial.GetAnnotationTextDisplayNode()\\r\\n textNode.SetTextScale(1)\\r\\n textNode.SetColor(0, 0, 0)\\r\\n if bPause: breakbox('Inspect this situation in the viewer!')\",\n \"def delTcline(self, line):\\n self._checkfigure()\\n ld = self._get_linedict(line)\\n for vline in ld['vlines']:\\n vline.remove()\\n ld['vlines'] = []\",\n \"def send_line(self, line):\\n self.ser.write(line + \\\"\\\\r\\\")\",\n \"def draw_shape_line(self, line, xform, colour):\\n pts = [xform.chain(p) for p in (line.p1, line.p2)]\\n self.canvas.line([(p.x, p.y) for p in pts], fill=colour)\",\n \"def update_cds(self, line, cds):\\n args = self.extract_cds_args(line)\\n cds.add_indices(args['indices'])\\n cds.add_phase(args['phase'])\\n cds.add_identifier(args['identifier'])\\n if 'score' in args:\\n cds.add_score(args['score'])\",\n \"def bimedianOnLine(self, line=..., idx:int=...):\\n from Drawables.Point import Point\\n from Drawables.Line import Line\\n if isinstance(idx, (int, float)):\\n idx = round(idx)\\n elif isinstance(line, Line):\\n a = (self.lineInQuad(line))\\n if a == None:\\n raise ValueError(\\n \\\"ValueError:\\\\tLine not in quad.\\\"\\n )\\n else:\\n idx = round(a)\\n else:\\n raise TypeError(\\n \\\"TypeError:\\\\tExpected Line or float, received \\\"+\\n f\\\"{type(line).__name__} and {type(idx).__name__}.\\\"\\n )\\n p1 = Point.middlePoint(\\n self.vertices[idx], self.vertices[idx-1]\\n )\\n idx = (idx + 2) % 4\\n p2 = Point.middlePoint(\\n self.vertices[idx], self.vertices[idx-1]\\n )\\n return Line.fromPoints(p1, p2)\",\n \"def _plot_group_ROW_edges(ax, xss, **kw):\\n\\n #if the CrossSections all have the same ROW edges, plot a single pair\\n l, r = [xs.lROW for xs in xss], [xs.rROW for xs in xss]\\n if(all([i == l[0] for i in l[1:]]) and all([i == r[0] for i in r[1:]])):\\n _plot_ROW_edges(ax, l[0], r[0], **kw)\\n\\n #if there are only two CrossSections and they have different ROW edges,\\n #handle ROW edges independently\\n elif(len(xss) == 2):\\n yl = ax.get_ylim()\\n ax.plot([xss[0].lROW]*2, yl, '--', color=_colormap[0],\\n linewidth=_ROW_linewidth, zorder=-1)\\n ax.plot([xss[1].lROW]*2, yl, '--', color=_colormap[1],\\n linewidth=_ROW_linewidth, zorder=-1)\\n #check if the left ROW edges are in the same place for both sections\\n ax.plot([xss[0].rROW]*2, yl, '--', color=_colormap[0],\\n linewidth=_ROW_linewidth, zorder=-1)\\n ax.plot([xss[1].rROW]*2, yl, '--', color=_colormap[1],\\n linewidth=_ROW_linewidth, zorder=-1)\\n #create a line handle and label for each color of the dashed line\\n kw['H'] += [\\n mpl.lines.Line2D([], [], linestyle='--',color=_colormap[0]),\\n mpl.lines.Line2D([], [], linestyle='--', color=_colormap[1])\\n ]\\n kw['L'] += ['ROW Edges - ' + xss[0].sheet, 'ROW Edges - ' + xss[1].sheet]\",\n \"def append_circuit(self, lines: Tuple[int, int], circuit: ACircuit, content: str) -> None:\",\n \"def setup(self,chip,line,mode):\\n if len(self.chips[chip]) < line:\\n raise ValueError(\\\"invalid line offset\\\")\\n chip_line = gpio_chips[chip][line]\\n if mode == OUT:\\n chip_line['direction'] = OUT\\n else:\\n chip_line['direction'] = IN\",\n \"def create_line(self):\\n if self.hosts and self.line:\\n self.msg(\\\"There is a line here already.\\\")\\n self.display_line()\\n return\\n self.line = []\\n other_hosts = [self.caller.search(arg) for arg in self.lhslist]\\n other_hosts = [ob for ob in other_hosts if ob and ob.player]\\n other_hosts.append(self.caller)\\n self.hosts = other_hosts\\n if \\\"loop\\\" in self.switches:\\n self.toggle_loop()\\n self.display_line()\",\n \"def groupLines(self, parts):\\n\\t\\tline = []\\n\\t\\thasDifference = False\\n\\t\\treplaceline = lambda line: list((p[0], self.color_linedifferent if hasDifference and p[1] == self.color_normal else p[1]) for p in line)\\n\\t\\tfor part in parts:\\n\\t\\t\\tif part[1] != self.color_normal:\\n\\t\\t\\t\\thasDifference = True\\n\\t\\t\\tif not len(part[0]): continue\\n\\t\\t\\tline += [part]\\n\\t\\t\\tif part[0][-1] == \\\"\\\\n\\\":\\n\\t\\t\\t\\tyield replaceline(line)\\n\\t\\t\\t\\tline = []\\n\\t\\t\\t\\thasDifference = False\\n\\t\\tyield replaceline(line)\",\n \"def __setslice__(self, *args):\\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___setslice__(self, *args)\",\n \"def add_line_element(self, obj, typ_sofi, layer):\\n\\n bm = LineElement(obj, typ_sofi)\\n bm.n1 = self.nodes.add(Node(None, rs.CurveStartPoint(obj)))\\n bm.n2 = self.nodes.add(Node(None, rs.CurveEndPoint(obj)))\\n\\n bm.mark_start_point()\\n bm.layer = layer\\n\\n self.line_elements.add(bm)\",\n \"def grid_line(object):\\n def __init__(self, casenum):\\n self.casenum = casenum\\n \\n def getList(self):\\n \\\"\\\"\\\"\\n to get the whole list of grid line data\\n \\\"\\\"\\\"\\n lineList = get_array(self.casenum, 'branch')\\n self.lineList = lineList\\n return lineList\\n \\n def getLineNum(self):\\n \\\"\\\"\\\"\\n :return: number of lines\\n \\\"\\\"\\\"\\n self.lineNum = len(self.getList())\\n return self.lineNum\\n \\n def getFBus(self):\\n \\\"\\\"\\\"\\n :return:list of \\\"from\\\" bus numbers\\n \\\"\\\"\\\"\\n FBus = []\\n for e in self.getList():\\n FBus.append(e[0])\\n self.FBus = FBus\\n return self.Bus\\n \\n def getTBus(self):\\n \\\"\\\"\\\"\\n :return: list of \\\"to\\\" bus numbers\\n \\\"\\\"\\\"\\n TBus = []\\n for e in self.getList():\\n TBus.append(e[1])\\n self.TBus = TBus\\n return self.TBus\",\n \"def line_graph(self, backtracking=True, shared=False):\\n raise Exception(\\\"Graph store doesn't support creating an line matrix.\\\")\",\n \"def line(self, arg, fill):\\n pass\",\n \"def test_line():\\n model = pb.Model(examples.chain_lattice(a=1), pb.line(0, 4.5))\\n assert model.system.num_sites == 4\\n\\n model = pb.Model(examples.chain_lattice(a=1), pb.line([0, -0.5], [5, 0.5]))\\n assert model.system.num_sites == 6\",\n \"def add_line(self, src_state: int, dst_state: int, color: str):\\n src_y = src_state // self.width\\n src_x = src_state % self.width\\n dst_y = dst_state // self.width\\n dst_x = dst_state % self.width\\n\\n self.lines[(src_x, src_y, dst_x, dst_y, color)] += 1\",\n \"def put(self, line):\\n self.rpc.call(MsfRpcMethod.SessionRingPut, [self.sid, line])\",\n \"def SetLineAlpha(self, alpha):\\n self._attalpha[\\\"line\\\"] = alpha\\n self.SetLineColorAlpha(self.GetLineColor(), alpha)\",\n \"def __init__(self, model, line, line_ht, segments = None, influence = None, \\r\\n connectivity = 1, connectivity_normdist = None,\\r\\n variables = [], priors=[]):\\r\\n\\r\\n import numpy as np\\r\\n from scipy.interpolate import interp1d\\r\\n import copy\\r\\n \\r\\n # Connect this element to the solver\\r\\n self.model = model\\r\\n model.elementlist.append(self)\\r\\n model.linear_solver = True\\r\\n \\r\\n # Prepare the stochastic variables\\r\\n self.variables = variables\\r\\n self.priors = priors\\r\\n \\r\\n # Initialize the head target and connectivity variables\\r\\n self.line_ht = line_ht\\r\\n self.connectivity = connectivity\\r\\n if np.isscalar(self.connectivity): # Connectivity provided is uniform\\r\\n \\r\\n self.connectivity_uniform = True\\r\\n \\r\\n else: # Connectivity provided \\r\\n \\r\\n self.connectivity_uniform = False\\r\\n \\r\\n # Check if normalized distances were provided\\r\\n if connectivity_normdist is None:\\r\\n raise Exception('If connectivity is not uniform, a vector of equal length containing normalized distances (e.g., [0., 0.25, 0.6, 1.]) must be specified.')\\r\\n \\r\\n # Check if connectivity_normdist is valid\\r\\n if np.min(connectivity_normdist) < 0 or np.max(connectivity_normdist) > 1:\\r\\n raise Exception('connectivity_normdist values must be between 0 and 1. Current values: '+str(connectivity_normdist))\\r\\n \\r\\n # Check if connectivity_normdist is sorted\\r\\n if not (connectivity_normdist == np.sort(connectivity_normdist)).all():\\r\\n raise Exception('connectivity_normdist values must be provided in ascending order. Current values: '+str(connectivity_normdist))\\r\\n \\r\\n self.connectivity_normdist = connectivity_normdist\\r\\n \\r\\n # ---------------------------------------------------------------------\\r\\n # Subdivide the provided no flow boundary into #segments pieces\\r\\n \\r\\n # Complexify the line, if it wasn't already complex\\r\\n line = self.complexify(line)\\r\\n \\r\\n # The subdivision algorith requires the line coordinates as a real N-by-2 matrix\\r\\n line = np.column_stack((\\r\\n np.real(line)[:,np.newaxis],\\r\\n np.imag(line)[:,np.newaxis]))\\r\\n \\r\\n # Make a copy of the line\\r\\n self.line_raw = copy.copy(line)\\r\\n \\r\\n # Check if a subdivision has been specified\\r\\n if segments is None: # No subdivision required\\r\\n self.segments = line.shape[0]-1\\r\\n else: # Otherwise, set target\\r\\n self.segments = segments\\r\\n \\r\\n # A number of consistency checks\\r\\n if self.segments < self.line_raw.shape[0]-1:\\r\\n raise Exception('Number of segments '+str(self.segments)+\\\" mustn't be smaller than number of line points \\\"+str(line.shape[0])+'.')\\r\\n if len(line_ht) != line.shape[0]:\\r\\n raise Exception('Number of head prescriptions must equal number of vertices: '+str(len(line_ht))+' =/= '+str(line.shape[0]))\\r\\n \\r\\n \\r\\n if self.segments > self.line_raw.shape[0]:\\r\\n \\r\\n # Subdivide the line\\r\\n self.line = self.subdivide_line(np.column_stack((line,self.line_ht)),self.segments)\\r\\n self.line_c = copy.copy(self.line[:,0] + 1j*self.line[:,1])\\r\\n self.line_ht = copy.copy(self.line[:,2])\\r\\n \\r\\n else:\\r\\n \\r\\n # Otherwise, reconstruct the line format\\r\\n self.line = self.line_raw.copy()\\r\\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\\r\\n self.line_ht = line_ht\\r\\n \\r\\n # --------------------------------------------------------------------- \\r\\n \\r\\n # Assign the initial strength variables for each segment\\r\\n self.strength = np.ones(self.segments)\\r\\n \\r\\n # Prepare the influence range for this line sink\\r\\n if influence is None:\\r\\n # If no influence range is specified, set it to twice the domain radius\\r\\n # to ensure that no point in the model domain will lie outside this range\\r\\n self.influence = self.model.domain_radius*2\\r\\n else:\\r\\n self.influence = influence\\r\\n \\r\\n # Prepare a few variables for this element\\r\\n self.L = [] # Length of each line segment\\r\\n self.zc = [] # Center of each line segment\\r\\n self.head_target = [] # Head target at each line segment\\r\\n \\r\\n for seg in range(self.segments):\\r\\n \\r\\n self.L += [np.abs(self.line_c[seg+1] - self.line_c[seg])]\\r\\n self.zc += [(self.line_c[seg]+self.line_c[seg+1])/2]\\r\\n self.head_target += [(self.line_ht[seg]+self.line_ht[seg+1])/2]\\r\\n \\r\\n # Convert list of segment centers to array\\r\\n self.zc = np.asarray(self.zc)\\r\\n self.head_target = np.asarray(self.head_target)\\r\\n \\r\\n # Now form a vector of cumulative distances\\r\\n self.cumdist = []\\r\\n for seg in range(self.segments):\\r\\n if seg == 0:\\r\\n self.cumdist.append(np.abs(self.zc[0]-self.line_c[0]))\\r\\n else:\\r\\n self.cumdist.append(np.abs(self.zc[seg]-self.zc[seg-1]))\\r\\n self.cumdist = np.cumsum(np.asarray(self.cumdist))\\r\\n self.cumdist /= (self.cumdist[-1] + np.abs(self.zc[-1]-self.line_c[-1]))\\r\\n \\r\\n if not self.connectivity_uniform:\\r\\n \\r\\n # Interpolate the connectivity\\r\\n from scipy.interpolate import interp1d\\r\\n itp = interp1d(self.connectivity_normdist,self.connectivity)\\r\\n self.connectivity_interpolated = itp(self.cumdist)\\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n \\r\\n # Convert the head targets to potential targets\\r\\n self.set_potential_target()\\r\\n \\r\\n # Check if the prior matches the number of parameters\\r\\n if len(self.priors) != len(self.variables):\\r\\n raise Exception('Number of priors must match number of unknown variables. Number of priors: '+str(self.priors)+' / Number of unknown variables: '+str(len(self.variables)))\\r\\n \\r\\n # Go through all elements\\r\\n if len(self.variables) > 0:\\r\\n # There are some model variables specified\\r\\n for idx,var in enumerate(self.variables):\\r\\n self.model.num_params += 1\\r\\n exec(\\\"self.model.params += [self.%s]\\\" % var)\\r\\n self.model.priors += [self.priors[idx]]\\r\\n self.model.variables += [var]\\r\\n if 'name' in list(self.priors[idx].keys()):\\r\\n self.model.param_names += [self.priors[idx]['name']] \\r\\n else: \\r\\n self.model.param_names += ['unknown']\",\n \"def parse_line(self, line):\\n raise NotImplementedError\",\n \"def startLineDrawing(self, startPos):\\n self.line = LineNodePath(render2d, thickness=2, colorVec=(0.8,0.8,0.8,1))\\n self.line.moveTo(startPos)\\n t = taskMgr.add(self.drawLineTask, \\\"drawLineTask\\\")\\n t.startPos = startPos\",\n \"def updateLine(self, column: str, value: [str,int], lineId: int):\\n value = f\\\"'{value}'\\\" if type(value) == str else value\\n query = f\\\"\\\"\\\"\\n UPDATE lines\\n SET {column} = {value}\\n WHERE id = {lineId};\\n \\\"\\\"\\\"\\n sql.executeQuery(self.connection, query)\",\n \"def EuclidI31(self, line: Line, point: Point, interesting=True) -> Line:\\n if point in line:\\n # If the point is already on the line, the parallel of the line is the line itself\\n return line\\n # rename point as A, points B,C on line\\n a = point\\n b, c = line.point1, line.point2\\n circle_center_b_radius_ba = self.add_circle(b, a, interesting=interesting)\\n intersections = self.find_intersections_line_circle(line, circle_center_b_radius_ba)\\n d = list(intersections)[0] # It doesn't matter which one we pick.\\n circle_center_d_radius_da = self.add_circle(d, a, interesting=interesting)\\n intersections = list(self.find_intersections_circle_circle(circle_center_b_radius_ba,\\n circle_center_d_radius_da))\\n e = intersections[0] if intersections[0] != a else intersections[1] # Pick the intersection not A\\n de = self.add_line(d, e, interesting=interesting)\\n intersections = list(self.find_intersections_line_circle(de, circle_center_d_radius_da))\\n f = intersections[0] if intersections[0] != e else intersections[1]\\n return self.add_line(a, f, interesting=interesting)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6074737","0.5583487","0.55022883","0.5488069","0.54185945","0.5411359","0.5380621","0.5375459","0.5367733","0.5354074","0.5351168","0.5344226","0.53420377","0.5332318","0.5319096","0.52651125","0.5257836","0.5232933","0.521354","0.521354","0.521354","0.521259","0.5210061","0.5192015","0.5183167","0.5181195","0.5168285","0.5136085","0.51357013","0.51279134","0.5101699","0.50900817","0.50717986","0.50666606","0.504807","0.50409615","0.50251865","0.5024047","0.50238955","0.5017104","0.50019044","0.4995393","0.498768","0.4976644","0.4974204","0.49733415","0.4967366","0.49585852","0.49584737","0.49584267","0.4954201","0.49530527","0.4950798","0.49496004","0.49350598","0.49287075","0.4928702","0.4926275","0.49228442","0.4918205","0.49158713","0.491535","0.4909802","0.49050573","0.49050573","0.4901781","0.48900348","0.48843592","0.48804194","0.48799938","0.48736414","0.48694003","0.4860796","0.48565993","0.484043","0.48334235","0.48194823","0.4814443","0.4811899","0.48085365","0.4803873","0.48004895","0.47987184","0.47955924","0.47934362","0.4786975","0.4785151","0.47848845","0.47789836","0.47756454","0.47709167","0.4767097","0.4766536","0.47616166","0.4756768","0.47497737","0.47418448","0.47399536","0.47370696","0.47365996","0.47272322"],"string":"[\n \"0.6074737\",\n \"0.5583487\",\n \"0.55022883\",\n \"0.5488069\",\n \"0.54185945\",\n \"0.5411359\",\n \"0.5380621\",\n \"0.5375459\",\n \"0.5367733\",\n \"0.5354074\",\n \"0.5351168\",\n \"0.5344226\",\n \"0.53420377\",\n \"0.5332318\",\n \"0.5319096\",\n \"0.52651125\",\n \"0.5257836\",\n \"0.5232933\",\n \"0.521354\",\n \"0.521354\",\n \"0.521354\",\n \"0.521259\",\n \"0.5210061\",\n \"0.5192015\",\n \"0.5183167\",\n \"0.5181195\",\n \"0.5168285\",\n \"0.5136085\",\n \"0.51357013\",\n \"0.51279134\",\n \"0.5101699\",\n \"0.50900817\",\n \"0.50717986\",\n \"0.50666606\",\n \"0.504807\",\n \"0.50409615\",\n \"0.50251865\",\n \"0.5024047\",\n \"0.50238955\",\n \"0.5017104\",\n \"0.50019044\",\n \"0.4995393\",\n \"0.498768\",\n \"0.4976644\",\n \"0.4974204\",\n \"0.49733415\",\n \"0.4967366\",\n \"0.49585852\",\n \"0.49584737\",\n \"0.49584267\",\n \"0.4954201\",\n \"0.49530527\",\n \"0.4950798\",\n \"0.49496004\",\n \"0.49350598\",\n \"0.49287075\",\n \"0.4928702\",\n \"0.4926275\",\n \"0.49228442\",\n \"0.4918205\",\n \"0.49158713\",\n \"0.491535\",\n \"0.4909802\",\n \"0.49050573\",\n \"0.49050573\",\n \"0.4901781\",\n \"0.48900348\",\n \"0.48843592\",\n \"0.48804194\",\n \"0.48799938\",\n \"0.48736414\",\n \"0.48694003\",\n \"0.4860796\",\n \"0.48565993\",\n \"0.484043\",\n \"0.48334235\",\n \"0.48194823\",\n \"0.4814443\",\n \"0.4811899\",\n \"0.48085365\",\n \"0.4803873\",\n \"0.48004895\",\n \"0.47987184\",\n \"0.47955924\",\n \"0.47934362\",\n \"0.4786975\",\n \"0.4785151\",\n \"0.47848845\",\n \"0.47789836\",\n \"0.47756454\",\n \"0.47709167\",\n \"0.4767097\",\n \"0.4766536\",\n \"0.47616166\",\n \"0.4756768\",\n \"0.47497737\",\n \"0.47418448\",\n \"0.47399536\",\n \"0.47370696\",\n \"0.47365996\",\n \"0.47272322\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78785,"cells":{"query":{"kind":"string","value":"NYI Make invalid a Vertex of section. The Vertex shoud be reconstructed from a point."},"document":{"kind":"string","value":"def SuppressSectionVertex(self, *args):\n return _BRepAlgo.BRepAlgo_DSAccess_SuppressSectionVertex(self, *args)"},"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 is_vertex(self): \n return False","def _validateVertex(self, v):\n if v < 0 or v >= self._V:\n raise Exception(\"vertex {} is not between 0 and {}\".format(v, (self._V-1)))","def agregar_vertice(self, v):\n if not v in self.vertices.keys():\n self.vertices[v] = {}","def test_init_edge_cases(self):\n\n # use K = 1\n s = space(curvature=1)\n\n # 0-dimensional point is always [1]\n p = s.make_point((), 1)\n self.assertTrue(p[0] == 1)\n\n # 1-dimensional negative direction\n p = s.make_point((-1,), 1)\n self.assertTrue(p[1] < 0)\n\n # 1-dimensional negative magnitude\n p = s.make_point((1,), -1)\n self.assertTrue(p[1] < 0)\n\n # 1-dimensional looping\n p = s.make_point((1,), 2)\n self.assertTrue(p[1] < 0)\n\n # 1-dimensional zero point\n p = s.make_point((0,), 1)\n self.assertTrue(p[1] == 0)\n\n # 1-dimensional zero point again but with normalize flag\n p = s.make_point((0,), 1, normalize=True)\n self.assertTrue(p[1] == 0)","def is_vertex(self):\n return False","def add_vertex(self, vertex):\n if vertex.id not in self.vertices.keys():\n self.vertices[vertex.id] = vertex","def add_vertex_fig(cls, quad, obj_temp):\n\n\t\tx = cls.get_address_value(quad.left_operand)\n\t\ty = cls.get_address_value(quad.right_operand)\n\t\tobj_temp.setNextVertex(x, y)\n\n\t\t#Verify reset figure figure\n\t\t#commented before\n\t\t# if not obj_temp.setNextVertex(x, y):\n\t\t# \ttype = abs(quad.result) // 1000\n\t\t# \tError.wrong_vertex_number(type)","def __init__(self, polyhedron, data):\n super(Vertex, self).__init__(polyhedron, data)","def __init__(self) -> None:\n self._vertices = {}","def parse_vertex(lines):\n print \" * Parsing vertex\"\n return _parse_vn(lines, \"v %.6f %.6f %.6f\")","def newVertex(self, inter):\n try:\n if inter.nV is None:\n raise AttributeError\n return inter.nV\n except AttributeError:\n vert = inter.v if type(inter) is intersector else inter\n inter.nV = self.result.addVertex(vert.x, vert.y, vert.z)\n assert inter.nV is not None\n return inter.nV","def addVertex(self, v, n, startIndex, apex=False):\n for vv in self._sharedVertices[-1::-1]:\n if self.verticesEqual(v, vv):\n break\n else:\n self._sharedVertices.append(v)\n if not apex:\n # blend with the previous patch?\n startIndex = min(startIndex, self._prevPatchStartIndex)\n i = self._nVertices - 1\n while i >= startIndex:\n if self.verticesEqual(self._vertices[i], v):\n # vertex found\n # sum its normal with the duplicate vertex's normal\n nn = QVector3D(*self._normals[i])\n nn += QVector3D(*n)\n nn.normalize()\n self._normals[i] = [nn.x(), nn.y(), nn.z()]\n return i\n i -= 1\n # vertex not found or it's an apex vertex\n self._vertices.append(v)\n self._normals.append(n)\n self._nVertices += 1\n return self._nVertices - 1","def is_vertex(self):\n return True","def is_vertex(self):\n return True","def verify_vertex_values(self):\n for (line, row) in [(ln, rw) for ln in range(9) for rw in range(9)]:\n if self.grid[line][row] not in range(1, 10) and self.grid[line][row] is not None:\n raise VertexValueError()","def __init__(self, vertices):\n if len(vertices) < 3:\n raise LocationsTooLittle(\"Requires three or more vertices to form \"\n \"a polygon\")\n self.vertices = vertices","def getStartVertex(self):","def _create_vertex_skel(self, path):\n self.vertices_path = os.path.join(path, \"vertices\")\n os.makedirs(self.vertices_path)\n\n self.vertices_constraints_path = os.path.join(\n self.vertices_path, \"constraints.json\"\n )\n with open(self.vertices_constraints_path, \"w\") as constraint_fh:\n constraint_fh.write(\"[]\")","def create_partition(mesh,polygons,enforce_exact=False):","def remove_vertex(self, index):\n\n if len(self._coordinates) <= 6:\n raise GeometryError(\"There must be at least three vertices\")\n if not isinstance(index, int):\n raise TypeError(\"Vertex index must be int\")\n self._coordinates.pop(index * 2)\n self._coordinates.pop(index * 2)","def __init__(self):\n self.vertices = {}","def insert(self, vertex, start, end):\n if vertex.xy == start.xy:\n copy = vertex.copy()\n self.replace(start, copy)\n return # dont process further\n\n elif vertex.xy == end.xy:\n copy = vertex.copy()\n self.replace(end, copy)\n return # dont process further\n\n # position based on alpha\n curr = start\n while curr != end and curr.alpha < vertex.alpha:\n curr = curr.__next__\n\n if vertex.xy == curr.prev.xy:\n## if vertex.xy == curr.xy: self.replace(curr, vertex)\n## elif vertex.xy == curr.prev.xy: self.replace(curr, vertex.prev)\n vertex.neighbour.neighbour = curr.prev\n return # dont do it if same as a previously inserted intersection\n\n if vertex.xy == curr.xy:\n## if vertex.xy == curr.xy: self.replace(curr, vertex)\n## elif vertex.xy == curr.prev.xy: self.replace(curr, vertex.prev)\n vertex.neighbour.neighbour = curr\n return # dont do it if same as a previously inserted intersection\n \n vertex.next = curr\n vertex.prev = curr.prev\n vertex.next.prev = vertex\n vertex.prev.next = vertex\n #print \"inserted\",vertex","def test_pointnum3():\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(1000, -500), radius=5000, thickness=50)\n assert len(shape.points) == 12\n assert len(shape.processed_points) == 13","def canonical_vertex(self):\n return self.L.zero(), self.K.one()","def test_pointnum2():\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(100, -100), radius=400, thickness=25)\n assert len(shape.points) == 12\n assert len(shape.processed_points) == 13","def SectionVertex(self, *args):\n return _BRepAlgo.BRepAlgo_DSAccess_SectionVertex(self, *args)","def __init__(self, nVertex, pVertex=None, pFace=None, nFace=None):\n if type(nVertex) is vector:\n self.pvt = vertex(nVertex)\n self.nvt = vertex(0, 0, 0)\n else:\n self.pvt = pVertex # positive vertex\n self.nvt = nVertex # negative vertex\n self.pFace = pFace # positive face\n self.nFace = nFace # negative face","def test_pointnum1():\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(0, 0), radius=300, thickness=10)\n assert len(shape.points) == 12\n assert len(shape.processed_points) == 13","def redefinir_vertices(self):\n self.nueva_posicion_posible_parte_inferior = [0,0]\n self.nueva_posicion_posible_parte_superior = [0,0]\n self.vertice_1 = self.posicion\n self.vertice_2 = [self.posicion[0] + self.medidas, self.posicion[1]]\n self.vertice_3 = [self.posicion[0], self.posicion[1] + self.medidas]\n self.vertice_4 = [self.posicion[0] + self.medidas, self.posicion[1] + self.medidas]","def add_vertex(self, v):\n v = {'x': v[0], 'y': v[1]}\n if v not in self:\n self.append(v)\n return len(self)-1\n return self.index(v)","def remove_vertex(self, index):\n\n if len(self._coordinates) <= 4:\n raise GeometryError(\"There must be at least two vertices\")\n if not isinstance(index, int):\n raise TypeError(\"Vertex index must be int\")\n self._coordinates.pop(index * 2)\n self._coordinates.pop(index * 2)","def get_vertex(self, p, v, x, y, z):\n x.value, y.value, z.value = self._get_vertex(p, v, x.value, y.value, z.value)","def copy(self):\n return vertex(self.x, self.y, self.z)","def add_vertex(self, event: matplotlib.backend_bases.LocationEvent) \\\n -> None:\n\n transform_func = event.inaxes.transData.inverted().transform\n new_coords = transform_func((event.x, event.y))\n log.info(f'Adding Vertex @ {event.x} - {event.y}, axis: '\n f'{new_coords}')\n graph = self._get_connected_graph(event.inaxes)\n vertex = Vertex()\n vertex.attr['x'] = float(new_coords[0])\n vertex.attr['y'] = float(new_coords[1])\n graph.add(vertex)\n self._redraw_graph()","def __init__(self, mesh, V):\n super().__init__(mesh, V)\n self.source = Constant(0)","def clearVertex(self, index):\n Parameter.checkIndex(index, 0, len(self.V))\n self.V[index] = None","def add_vertex(self, vertex):\n raise NotImplementedError","def registerVertices(self,vl):\n self.set('patchmesh.vertices',FuzzList(vl))","def add_vertex(self, vertex):\n if vertex not in self.graph_dict:\n self.graph_dict[vertex] = []\n return vertex","def move_vertex(region, vertex, new_vertex, vert_dict):\n # Skip useless moves\n if vertex == new_vertex:\n return\n # Update the original region\n new_vertex_list = [new_vertex if v == vertex else v for v in region.vertices]\n region.set_vertices(new_vertex_list)\n # Check the neighbours\n for r in region.get_neighbors():\n new_vertex_list = [new_vertex if v == vertex else v for v in r.vertices]\n r.set_vertices(new_vertex_list)\n # Update the point position in the graph\n vert_dict[vertex] = new_vertex","def makeSparse(self):\n center = self.center\n l = []\n for point in self.points:\n angle = Vector.createFromTwoPoints(point, center).angle\n l.append((angle, copy.deepcopy(point)))\n l = sorted(l, key=lambda x: x[0])\n for i in range(len(l)):\n self.points[i].set(l[i][1])","def add_vertex(self, vertex_id):\n # creates a vertex with an empty list as their neighboring vertices\n self.vertices[vertex_id] = set()","def relax_vertex(vertex, neighbor):\n if vertex.distance + 1 < neighbor.distance:\n neighbor.distance = vertex.distance + 1\n neighbor.parent = vertex","def __init__(self, g, v):\n super().__init__(g, v, 'The node does not belong to the graph.')","def addVertex(self, vertex):\n if vertex not in self.adjList:\n self.adjList[vertex] = []","def _vertex_constraint_violated(self, vertex, **kwargs):\n key_index = self._vconstraints.get(vertex.label, {})\n\n # first check the entity properties for constraint violations\n # Then check any additional properties for constraint violations.\n # Additional properties are for cases like `.set_property`\n for props in [vertex.properties, kwargs]:\n for key, value in props.items():\n if key not in key_index:\n continue\n\n for indexed_entity in key_index[key]:\n if indexed_entity != vertex:\n if indexed_entity.properties[key] == value:\n raise interfaces.ConstraintViolation(\n \"{!r} violated constraint {!r}\".format(\n vertex, key\n )\n )","def __init__(self, vertex):\n self.id = vertex\n self.neighbors = {}","def add_vertex(self, vertex):\n if vertex not in self.graph_dict:\n self.graph_dict[vertex] = []","def addPoint(self, p):\n p = np.asarray(p)\n idx = len(self.coords)\n # print(\"coords[\", idx,\"] ->\",p)\n self.coords.append(p)\n\n # Search the triangle(s) whose circumcircle contains p\n bad_triangles = []\n for T in self.triangles:\n # Choose one method: inCircleRobust(T, p) or inCircleFast(T, p)\n if self.inCircleFast(T, p):\n bad_triangles.append(T)\n\n # Find the CCW boundary (star shape) of the bad triangles,\n # expressed as a list of edges (point pairs) and the opposite\n # triangle to each edge.\n boundary = []\n # Choose a \"random\" triangle and edge\n T = bad_triangles[0]\n edge = 0\n # get the opposite triangle of this edge\n while True:\n # Check if edge of triangle T is on the boundary...\n # if opposite triangle of this edge is external to the list\n tri_op = self.triangles[T][edge]\n if tri_op not in bad_triangles:\n # Insert edge and external triangle into boundary list\n boundary.append((T[(edge+1) % 3], T[(edge-1) % 3], tri_op))\n\n # Move to next CCW edge in this triangle\n edge = (edge + 1) % 3\n\n # Check if boundary is a closed loop\n if boundary[0][0] == boundary[-1][1]:\n break\n else:\n # Move to next CCW edge in opposite triangle\n edge = (self.triangles[tri_op].index(T) + 1) % 3\n T = tri_op\n\n # Remove triangles too near of point p of our solution\n for T in bad_triangles:\n del self.triangles[T]\n del self.circles[T]\n\n # Retriangle the hole left by bad_triangles\n new_triangles = []\n for (e0, e1, tri_op) in boundary:\n # Create a new triangle using point p and edge extremes\n T = (idx, e0, e1)\n\n # Store circumcenter and circumradius of the triangle\n self.circles[T] = self.circumcenter(T)\n\n # Set opposite triangle of the edge as neighbour of T\n self.triangles[T] = [tri_op, None, None]\n\n # Try to set T as neighbour of the opposite triangle\n if tri_op:\n # search the neighbour of tri_op that use edge (e1, e0)\n for i, neigh in enumerate(self.triangles[tri_op]):\n if neigh:\n if e1 in neigh and e0 in neigh:\n # change link to use our new triangle\n self.triangles[tri_op][i] = T\n\n # Add triangle to a temporal list\n new_triangles.append(T)\n\n # Link the new triangles each another\n N = len(new_triangles)\n for i, T in enumerate(new_triangles):\n self.triangles[T][1] = new_triangles[(i+1) % N] # next\n self.triangles[T][2] = new_triangles[(i-1) % N] # previous","def __init__(self):\n self.vert_dict = {}\n # self.vert_dict = []\n self.num_vertices = 0","def __init__(self, start, end, oldLine = None):\n self.__start = start\n self.__end = end\n if(self.__start == self.__end):\n \"\"\"\n If a zero length line is created that most likely means there is a\n logic problem somewhere in the program. This does not throw and error\n so that the output can still be examined to help diagnose the problem.\n \"\"\"\n# raise Exception('Zero length line')\n logger.warning('A line was created with no length at: ' + \n str(self.start))\n \"\"\" The Point which is the upper left corner of the line's bounding box \"\"\"\n self.__upperLeft = None\n \"\"\" The Point of the lower right corner of the bounding box. \"\"\"\n self.__lowerRight = None\n self.__extrusionRate = 0\n self.freezeExRate = False\n if not(oldLine is None):\n self.__extrusionRate = oldLine.extrusionRate\n self.freezeExRate = oldLine.freezeExRate\n self.vector = np.array([self.end.x-self.start.x,\n self.end.y-self.start.y])","def add_vertex(self, room):\r\n if room['room_id'] not in self.rooms:\r\n self.rooms[room['room_id']] = room\r\n # self.rooms[room['room_id']]['exits'] = {\r\n # d: '?' for d in room['exits']}\r","def test_polygon_with_duplicate_nodes_is_valid():\n geom = query_row(db_conf, 'osm_landusages', 30005)['geometry']\n assert geom.is_valid\n assert len(geom.exterior.coords) == 4","def add_vertex(self,vertex):\n if vertex not in self.__graph_dict:\n self.__graph_dict[vertex] = []\n # logging.debug(\"vertex being initialized ..\", vertex)\n else:\n # logging.debug(\"vertex not added ..\", vertex)\n pass","def _create_vertex_list(self):\n raise NotImplementedError('_create_vertex_list must be defined in '\n 'order to use group or batch properties')","def __validatePoint(self, point):\n # print point\n if point[0] > self.scn_width:\n raise ValueError('X coordinate: %d out of range.' % point[0])\n if point[1] > self.scn_height:\n raise ValueError('Y coordinate: %d out of range.' % point[1])\n return point","def add_vertex(self, vertex_id): # O(1) time complexity\n self.vertices[vertex_id] = set() \n\n # additional options (class)\n '''\n if vertex_id not in self.vertices:\n self.vertices[vertex_id] = {}\n\n else:\n return \"Vertex is already in Graph\"\n '''","def _remove_vertex(self, i):\n if (len(self._xys) > 2 and\n self._selection_completed and\n i in (0, len(self._xys) - 1)):\n # If selecting the first or final vertex, remove both first and\n # last vertex as they are the same for a closed polygon\n self._xys.pop(0)\n self._xys.pop(-1)\n # Close the polygon again by appending the new first vertex to the\n # end\n self._xys.append(self._xys[0])\n else:\n self._xys.pop(i)\n if len(self._xys) <= 2:\n # If only one point left, return to incomplete state to let user\n # start drawing again\n self._selection_completed = False\n self._remove_box()","def __init__(self):\n self.vert_list = {}\n self.num_vertices = 0","def validate_mesh(self):\n pass","def is_legal(vtx, color):\n for neighbor in vtx[\"adjacent\"]:\n if VERTICES[neighbor][\"color\"] is color:\n return False\n return True","def test_vertex_constructor(self):\r\n metros = {\"code\": \"SCL\", \"name\": \"Santiago\"}\r\n self.assertRaises(Exception, Vertex, metros)\r\n metros = {\"code\": \"SCL\", \"name\": \"Santiago\", \"country\": \"CL\", \"continent\": \"South America\", \"timezone\": -4,\r\n \"coordinates\": {\"S\": 33, \"W\": 71}, \"population\": 6000000, \"region\": 1}\r\n vertex = Vertex(metros)\r\n self.assertIsInstance(vertex, Vertex)\r\n self.assertIs(vertex.code, \"SCL\")\r\n self.assertIs(vertex.name, \"Santiago\")\r\n self.assertIs(vertex.country, \"CL\")\r\n self.assertIs(vertex.continent, \"South America\")\r\n self.assertIs(vertex.coordinates[\"S\"], 33)\r\n self.assertIs(vertex.coordinates[\"W\"], 71)\r\n self.assertIs(vertex.population, 6000000)\r\n self.assertIs(vertex.region, 1)","def __init__(self, points, verbose=False):\n assert(type(points) == np.ndarray)\n assert(points.dtype==int)\n assert(points.shape[1] == 3)\n assert(points.shape[0]>1)\n\n # Make points unique to avoid duplicate vertices:\n self.points = np.unique(points, axis=0)\n self.verbose = verbose\n self.g = self.__generate()","def add_vertex(self, v):\n self[v] = {}","def add_vertex(self, v):\n self[v] = {}","def addVertices(self, n):\n oldN = len(self.V)\n for i in range(oldN, oldN+n):\n self.V[i] = None","def add_vertex(self, vertex):\n if vertex not in self.__graph_dict:\n self.__graph_dict[vertex] = []","def add_vertex(self, vertex):\n if vertex not in self.__graph_dict:\n self.__graph_dict[vertex] = []","def makeEdgeVertex(self, f, v):\n newV = self.addVertex(0, 0, 0)\n newE = self.addEdge(v, newV)\n newE.pFace = f\n return (newE, newV)","def adicionaVertice(self, vertice):\r\n self.vertices.append(vertice)","def __init__(self, v, w, weight):\n if v < 0:\n raise IllegalArgumentException(\"vertex index must be a nonnegative integer\")\n if w < 0:\n raise IllegalArgumentException(\"vertex index must be a nonnegative integer\")\n if math.isnan(weight):\n raise IllegalArgumentException(\"Weight is NaN\")\n self._v = v\n self._w = w\n self._weight = weight","def move_vertex(self, p, v, x, y, z):\n self._move_vertex(p, v, x, y, z)","def contract(self):\n self.vertices[-1, :] = self.contracted","def addVertex(self,x):\n self.dictOut[x]=[]","def add_vertex(self, vertex):\n self[vertex] = {}","def _init_V(self, V):\n if V < 0: raise Exception(\"Number of vertices must be nonnegative\")\n self._V = V\n self._E = 0\n self._adj = [set() for v in range(V)]","def add_vertex(self, vertex_id):\n pass # TODO","def render(self, vertex_highlighting=False):\n pass","def _generate_vertexes(self):\n # generate list of sets for each vms\n self._graph = [set() for _ in range(self._vm_count)]","def test_no_start_vertex_in_graph(self):\n self.assertEquals(\n Dijkstras().dijkstras(self.g13, 'a', 'b'),\n '\\'a\\' as a start node not found')","def __init__(self, vertices):\n self.vertices = vertices","def _ensure_mesh(self):\n if self._knots_to_mesh is None:\n self._mesh, self._knots_to_mesh = np.unique(self.kv, return_inverse=True)","def prepare_point(infos: PointInfos):\n point = GraphVisualizerPoint()\n point.connected = infos.connected\n point.set_text(infos.text)\n return point","def mutate_point_poly(mutated_genome):\n seed = random.randint(0,7)\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if len(mutated_genome[index][2]) < 3: seed = 0\n if seed == 0:\n insert_point(mutated_genome,index)\n elif seed == 1:\n remove_point(mutated_genome,index)\n elif seed == 2:\n switch_points(mutated_genome,index)\n elif seed == 3:\n shuffle_points(mutated_genome,index)\n elif seed == 4:\n move_point(mutated_genome,index)\n elif seed == 5:\n shift_point(mutated_genome,index)\n elif seed == 6:\n increment_point(mutated_genome,index)\n else: #seed == 7:\n decrement_point(mutated_genome,index)","def CreateDummyLowerDimensionalMesh(self):\n\n\n sys.stdout = open(os.devnull, \"w\")\n p = self.InferPolynomialDegree()\n mesh = Mesh()\n if self.element_type == \"tet\":\n mesh.Rectangle(nx=1,ny=1, element_type=\"tri\")\n mesh.GetHighOrderMesh(p=p)\n elif self.element_type == \"hex\":\n mesh.Rectangle(nx=1,ny=1, element_type=\"quad\")\n mesh.GetHighOrderMesh(p=p)\n elif self.element_type == \"tri\" or self.element_type == \"quad\":\n mesh.Line(n=1, p=p)\n elif self.element_type == \"line\":\n mesh.element_type = \"point\"\n mesh.nelem = 1\n mesh.nnode = 1\n mesh.degree = p\n mesh.elements = np.array([[0]])\n mesh.points = np.array([[0.,0.,0.]])\n sys.stdout = sys.__stdout__\n\n return mesh","def get_regular_points(self, npoints=None, device=\"gpu0\"):\n if not self.npoints == npoints:\n self.mesh = pymesh.generate_icosphere(1, [0, 0, 0], 4) # 2562 vertices\n self.vertex = torch.from_numpy(self.mesh.vertices).to(device).float()\n self.num_vertex = self.vertex.size(0)\n self.vertex = self.vertex.transpose(0,1).contiguous().unsqueeze(0)\n self.npoints = npoints\n\n return Variable(self.vertex.to(device))","def clean_edges(self):","def generaCubo(self):\r\n #Use Panda predefined format for vertex coordinate only\r\n format = GeomVertexFormat.getV3()\r\n \r\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \r\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\r\n \r\n #I will have to write vertex data so I create a writer for these data\r\n vertex = GeomVertexWriter(vdata, 'vertex')\r\n \r\n #I now use the writer to add vertex data\r\n vertex.addData3f(0, 0, 0)\r\n vertex.addData3f(1, 1, 1)\r\n vertex.addData3f(0, 1, 1)\r\n vertex.addData3f(0, 1, 0)\r\n vertex.addData3f(0, 0, 1)\r\n vertex.addData3f(1, 0, 0)\r\n vertex.addData3f(1, 0, 1)\r\n vertex.addData3f(1, 1, 0)\r\n \r\n #I now create 12 triangles\r\n prim = GeomTriangles(Geom.UHStatic)\r\n\r\n #and then I add vertex to them\r\n #Next time use addVertices(0,1,2) !!!\r\n prim.addVertex(7)\r\n prim.addVertex(0)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(3)\r\n prim.addVertex(0)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n \r\n prim.addVertex(2)\r\n prim.addVertex(6)\r\n prim.addVertex(4)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(6)\r\n prim.addVertex(2)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(7)\r\n prim.addVertex(2)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(1)\r\n prim.addVertex(2)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(3)\r\n prim.addVertex(4)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(2)\r\n prim.addVertex(4)\r\n prim.addVertex(3)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(0)\r\n prim.addVertex(6)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(4)\r\n prim.addVertex(6)\r\n prim.addVertex(0)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(5)\r\n prim.addVertex(1)\r\n prim.addVertex(7)\r\n prim.closePrimitive()\r\n\r\n prim.addVertex(6)\r\n prim.addVertex(1)\r\n prim.addVertex(5)\r\n prim.closePrimitive()\r\n\r\n #Create a Geom to bing vertex data to primitives\r\n geom = Geom(vdata)\r\n geom.addPrimitive(prim)\r\n\r\n #Create a node for the Geom in order to be able to render it\r\n node = GeomNode('gnode')\r\n node.addGeom(geom)\r\n\r\n #Adde the node to the scene graph == render it!\r\n nodePath = render.attachNewNode(node)\r\n \r\n #is this needed?\r\n nodePath.setPos( 0, 5, 0)\r\n \r\n self.camera.lookAt(nodePath)\r\n \r\n base.setBackgroundColor( .0, .0, .0 )\r\n \r\n taskMgr.add(self.SpinCameraTask, \"SpinCameraTask\")","def MeshVtxAdjacentVtxs (strMesh, index, blnAbsolutConnections=False, blnCreate=False):\n \"\"\"custom function\"\"\"\n #-----------------------------------------------------------------------------------------------------------------------------------------\n def CullDuplicates(seq, idfun=None): \n # order preserving \n if idfun is None: \n def idfun(x): return x \n seen = {} \n result = [] \n for item in seq: \n marker = idfun(item) \n if marker in seen: continue \n seen[marker] = 1 \n result.append(item) \n return result\n #-----------------------------------------------------------------------------------------------------------------------------------------\n MeshVtxAdjacentVtxs = []\n if rs.IsMesh(strMesh)==False : \n print \"strMesh is not an mesh\"\n return None\n if type(index)==type(\"string\"):\n print \"index is not an integer\"\n return None\n if type(index)==type(0.1): index = int(index)\n\n arrVertices = rs.MeshVertices (strMesh)\n arrFaceVertices = rs.MeshFaceVertices(strMesh)\n\n intCount = 0\n arrAdjacentVtxs = []\n for arrFace in arrFaceVertices:\n blnIsAdjacent = False\n for arrVtxIndex in arrFace:\n if arrVtxIndex == index :\n blnIsAdjacent = True\n if blnIsAdjacent :\n if blnAbsolutConnections :\n if arrFace[2]==arrFace[3] :\n for arrVtxIndex in arrFace :\n if arrVtxIndex != index :\n arrAdjacentVtxs.append( arrVtxIndex)\n else :\n if index == arrFace[0] :\n arrAdjacentVtxs.append( arrFace[3] )\n arrAdjacentVtxs.append( arrFace[1] )\n elif index == arrFace[1] :\n arrAdjacentVtxs.append( arrFace[0] )\n arrAdjacentVtxs.append( arrFace[2] )\n elif index == arrFace[2] :\n arrAdjacentVtxs.append( arrFace[1] )\n arrAdjacentVtxs.append( arrFace[3] )\n elif index == arrFace(3) :\n arrAdjacentVtxs.append( arrFace[2] )\n arrAdjacentVtxs.append( arrFace[0] )\n else :\n for arrVtxIndex in arrFace :\n if arrVtxIndex != index :\n arrAdjacentVtxs.append( arrVtxIndex )\n if type(arrAdjacentVtxs) != type([]) : return None\n arrOrderAdjacentVtxs = CullDuplicates(arrAdjacentVtxs)\n if blnCreate :\n arrStrPts = []\n for arrVtxIndex in arrOrderAdjacentVtxs:\n rs.AddPoint ( arrVertices[arrVtxIndex] )\n arrStrPts.append( arrVertices[arrVtxIndex] )\n return arrStrPts\n else :\n return arrOrderAdjacentVtxs","def _remove_unreferenced_vertices(self):\n # convert vertices to an array\n vertex_array = np.array(self.mesh_.vertices())\n num_v = vertex_array.shape[0]\n\n # fill in a 1 for each referenced vertex\n reffed_array = np.zeros([num_v, 1])\n for f in self.mesh_.triangles():\n if f[0] < num_v and f[1] < num_v and f[2] < num_v:\n reffed_array[f[0]] = 1\n reffed_array[f[1]] = 1\n reffed_array[f[2]] = 1\n\n # trim out vertices that are not referenced\n reffed_v_old_ind = np.where(reffed_array == 1)\n reffed_v_old_ind = reffed_v_old_ind[0]\n reffed_v_new_ind = np.cumsum(reffed_array).astype(np.int) - 1 # counts number of reffed v before each ind\n\n try:\n self.mesh_.set_vertices(vertex_array[reffed_v_old_ind, :].tolist())\n if self.mesh_.normals() is not None:\n normals_array = np.array(self.mesh_.normals())\n self.mesh_.set_normals(normals_array[reffed_v_old_ind, :].tolist())\n except IndexError:\n return False\n\n # create new face indices\n new_triangles = []\n for f in self.mesh_.triangles():\n new_triangles.append([reffed_v_new_ind[f[0]], reffed_v_new_ind[f[1]], reffed_v_new_ind[f[2]]] )\n self.mesh_.set_triangles(new_triangles)\n return True","def add_vertex(self, vertex_id):\n if vertex_id not in self.vertices:\n self.vertices[vertex_id] = set()","def test_no_vertex_in_graph(self):\n self.assertEquals(\n Dijkstras().dijkstras(self.g11, 'a', 'b'),\n 'No vertex found in graph')","def validate(self):\r\n if self.eid is None:\r\n if self._inV is None:\r\n raise ValidationError('in vertex must be set before saving new edges')\r\n if self._outV is None:\r\n raise ValidationError('out vertex must be set before saving new edges')\r\n super(Edge, self).validate()","def EuclidI12(self, line: Line, point: Point, interesting=True) -> Line:\n if point in line:\n raise ValueError(f'Cannot drop a perpendicular. Point {point} is on line {line}.')\n # rename point as C\n c = point\n # Pick a point on the opposite side of line from c\n d = self.pick_point_not_on_line_on_side(line, c, same_side=False)\n circle_center_c_radius_cd = self.add_circle(c, d, interesting=interesting)\n a, b = self.find_intersections_line_circle(line, circle_center_c_radius_cd)\n side = d\n f = self.ErectEquilateralTriangle(Line(a, b), side=side, interesting=interesting)\n return self.add_line(c, f)","def add_vertex(self, v, i=None):\n if len(self) < 2:\n return LineString.add_vertex(self, v, i)","def add_vertex(self, item: Any, kind: str) -> None:\n if item not in self._vertices:\n self._vertices[item] = _Vertex(item, kind)","def add_vertex(self, vertex):\r\n if vertex not in self.__graph_dict:\r\n self.__graph_dict[vertex] = {}","def __init__(self, model, line, segments = None,head_target = 0,\r\n variables = [], priors=[]):\r\n\r\n import numpy as np\r\n from scipy.interpolate import interp1d\r\n import copy\r\n \r\n # Append this element to the specified model\r\n self.model = model\r\n model.elementlist.append(self)\r\n model.linear_solver = True\r\n\r\n # ---------------------------------------------------------------------\r\n # Subdivide the provided no flow boundary into segments pieces\r\n \r\n # Complexify the line, if it wasn't already complex\r\n line = self.complexify(line)\r\n \r\n # The subdivision algorith requires the line coordinates as a real N-by-2 matrix\r\n line = np.column_stack((\r\n np.real(line)[:,np.newaxis],\r\n np.imag(line)[:,np.newaxis]))\r\n \r\n self.line_raw = copy.copy(line)\r\n if segments is None:\r\n self.segments = line.shape[0]-1\r\n else:\r\n self.segments = segments\r\n \r\n if self.segments < self.line_raw.shape[0]-1:\r\n raise Exception('Prescribed number of line segments '+str(self.segments)+\" mustn't be smaller than base number of segments \"+str(line.shape[0]-1)+'.')\r\n \r\n if self.segments > self.line_raw.shape[0]-1:\r\n \r\n # Subdivide the line\r\n self.line = self.subdivide_line(line,self.segments)\r\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\r\n \r\n else:\r\n \r\n self.line = self.line_raw.copy()\r\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\r\n \r\n # Also get the normal vector components to each segment\r\n self.line_nvec = self.line[:,1] - 1j*self.line[:,0]\r\n self.line_nvec = self.line_nvec/np.abs(self.line_nvec)\r\n\r\n # ---------------------------------------------------------------------\r\n \r\n # Get strength parameters for each vertex\r\n self.strength = np.ones(self.segments)\r\n \r\n \r\n self.zc = []\r\n self.segment_nvec = []\r\n self.L = []\r\n \r\n for seg in range(self.segments):\r\n \r\n self.zc += [(self.line_c[seg]+self.line_c[seg+1])/2]\r\n \r\n # Calculate the normal vector to this segment\r\n self.segment_nvec += [(self.line_c[seg]-self.line_c[seg+1])]\r\n self.segment_nvec[-1]= [np.imag(self.segment_nvec[-1])-1j*np.real(self.segment_nvec[-1])]\r\n \r\n self.L += [np.abs(self.line_c[seg+1] - self.line_c[seg])]\r\n \r\n self.zc = np.asarray(self.zc)\r\n \r\n # Extract target variables\r\n self.variables = variables\r\n self.priors = priors\r\n \r\n self.L = np.asarray(self.L)\r\n \r\n \r\n # Check if the prior matches the number of parameters\r\n if len(self.priors) != len(self.variables):\r\n raise Exception('Number of priors must match number of unknown variables. Number of priors: '+str(self.priors)+' / Number of unknown variables: '+str(len(self.variables)))\r\n \r\n # Go through all elements\r\n if len(self.variables) > 0:\r\n # There are some model variables specified\r\n for idx,var in enumerate(self.variables):\r\n self.model.num_params += 1\r\n exec(\"self.model.params += [self.%s]\" % var)\r\n self.model.priors += [self.priors[idx]]\r\n self.model.variables += [var]\r\n if 'name' in list(self.priors[idx].keys()):\r\n self.model.param_names += [self.priors[idx]['name']] \r\n else: \r\n self.model.param_names += ['unknown']","def __init__(self, polyhedron, data):\n super(Inequality, self).__init__(polyhedron, data)","def add_vertex(self, vertex):\n try:\n vertex_idx = self.vertices.index(vertex)\n # print \"{} already in {}\".format(vertex, self.vertices)\n return self.vertices[vertex_idx]\n except Exception:\n self.vertices.append(vertex)\n # print \"adding {} to {}\".format(vertex, self.vertices)\n return vertex"],"string":"[\n \"def is_vertex(self): \\n return False\",\n \"def _validateVertex(self, v):\\n if v < 0 or v >= self._V:\\n raise Exception(\\\"vertex {} is not between 0 and {}\\\".format(v, (self._V-1)))\",\n \"def agregar_vertice(self, v):\\n if not v in self.vertices.keys():\\n self.vertices[v] = {}\",\n \"def test_init_edge_cases(self):\\n\\n # use K = 1\\n s = space(curvature=1)\\n\\n # 0-dimensional point is always [1]\\n p = s.make_point((), 1)\\n self.assertTrue(p[0] == 1)\\n\\n # 1-dimensional negative direction\\n p = s.make_point((-1,), 1)\\n self.assertTrue(p[1] < 0)\\n\\n # 1-dimensional negative magnitude\\n p = s.make_point((1,), -1)\\n self.assertTrue(p[1] < 0)\\n\\n # 1-dimensional looping\\n p = s.make_point((1,), 2)\\n self.assertTrue(p[1] < 0)\\n\\n # 1-dimensional zero point\\n p = s.make_point((0,), 1)\\n self.assertTrue(p[1] == 0)\\n\\n # 1-dimensional zero point again but with normalize flag\\n p = s.make_point((0,), 1, normalize=True)\\n self.assertTrue(p[1] == 0)\",\n \"def is_vertex(self):\\n return False\",\n \"def add_vertex(self, vertex):\\n if vertex.id not in self.vertices.keys():\\n self.vertices[vertex.id] = vertex\",\n \"def add_vertex_fig(cls, quad, obj_temp):\\n\\n\\t\\tx = cls.get_address_value(quad.left_operand)\\n\\t\\ty = cls.get_address_value(quad.right_operand)\\n\\t\\tobj_temp.setNextVertex(x, y)\\n\\n\\t\\t#Verify reset figure figure\\n\\t\\t#commented before\\n\\t\\t# if not obj_temp.setNextVertex(x, y):\\n\\t\\t# \\ttype = abs(quad.result) // 1000\\n\\t\\t# \\tError.wrong_vertex_number(type)\",\n \"def __init__(self, polyhedron, data):\\n super(Vertex, self).__init__(polyhedron, data)\",\n \"def __init__(self) -> None:\\n self._vertices = {}\",\n \"def parse_vertex(lines):\\n print \\\" * Parsing vertex\\\"\\n return _parse_vn(lines, \\\"v %.6f %.6f %.6f\\\")\",\n \"def newVertex(self, inter):\\n try:\\n if inter.nV is None:\\n raise AttributeError\\n return inter.nV\\n except AttributeError:\\n vert = inter.v if type(inter) is intersector else inter\\n inter.nV = self.result.addVertex(vert.x, vert.y, vert.z)\\n assert inter.nV is not None\\n return inter.nV\",\n \"def addVertex(self, v, n, startIndex, apex=False):\\n for vv in self._sharedVertices[-1::-1]:\\n if self.verticesEqual(v, vv):\\n break\\n else:\\n self._sharedVertices.append(v)\\n if not apex:\\n # blend with the previous patch?\\n startIndex = min(startIndex, self._prevPatchStartIndex)\\n i = self._nVertices - 1\\n while i >= startIndex:\\n if self.verticesEqual(self._vertices[i], v):\\n # vertex found\\n # sum its normal with the duplicate vertex's normal\\n nn = QVector3D(*self._normals[i])\\n nn += QVector3D(*n)\\n nn.normalize()\\n self._normals[i] = [nn.x(), nn.y(), nn.z()]\\n return i\\n i -= 1\\n # vertex not found or it's an apex vertex\\n self._vertices.append(v)\\n self._normals.append(n)\\n self._nVertices += 1\\n return self._nVertices - 1\",\n \"def is_vertex(self):\\n return True\",\n \"def is_vertex(self):\\n return True\",\n \"def verify_vertex_values(self):\\n for (line, row) in [(ln, rw) for ln in range(9) for rw in range(9)]:\\n if self.grid[line][row] not in range(1, 10) and self.grid[line][row] is not None:\\n raise VertexValueError()\",\n \"def __init__(self, vertices):\\n if len(vertices) < 3:\\n raise LocationsTooLittle(\\\"Requires three or more vertices to form \\\"\\n \\\"a polygon\\\")\\n self.vertices = vertices\",\n \"def getStartVertex(self):\",\n \"def _create_vertex_skel(self, path):\\n self.vertices_path = os.path.join(path, \\\"vertices\\\")\\n os.makedirs(self.vertices_path)\\n\\n self.vertices_constraints_path = os.path.join(\\n self.vertices_path, \\\"constraints.json\\\"\\n )\\n with open(self.vertices_constraints_path, \\\"w\\\") as constraint_fh:\\n constraint_fh.write(\\\"[]\\\")\",\n \"def create_partition(mesh,polygons,enforce_exact=False):\",\n \"def remove_vertex(self, index):\\n\\n if len(self._coordinates) <= 6:\\n raise GeometryError(\\\"There must be at least three vertices\\\")\\n if not isinstance(index, int):\\n raise TypeError(\\\"Vertex index must be int\\\")\\n self._coordinates.pop(index * 2)\\n self._coordinates.pop(index * 2)\",\n \"def __init__(self):\\n self.vertices = {}\",\n \"def insert(self, vertex, start, end):\\n if vertex.xy == start.xy:\\n copy = vertex.copy()\\n self.replace(start, copy)\\n return # dont process further\\n\\n elif vertex.xy == end.xy:\\n copy = vertex.copy()\\n self.replace(end, copy)\\n return # dont process further\\n\\n # position based on alpha\\n curr = start\\n while curr != end and curr.alpha < vertex.alpha:\\n curr = curr.__next__\\n\\n if vertex.xy == curr.prev.xy:\\n## if vertex.xy == curr.xy: self.replace(curr, vertex)\\n## elif vertex.xy == curr.prev.xy: self.replace(curr, vertex.prev)\\n vertex.neighbour.neighbour = curr.prev\\n return # dont do it if same as a previously inserted intersection\\n\\n if vertex.xy == curr.xy:\\n## if vertex.xy == curr.xy: self.replace(curr, vertex)\\n## elif vertex.xy == curr.prev.xy: self.replace(curr, vertex.prev)\\n vertex.neighbour.neighbour = curr\\n return # dont do it if same as a previously inserted intersection\\n \\n vertex.next = curr\\n vertex.prev = curr.prev\\n vertex.next.prev = vertex\\n vertex.prev.next = vertex\\n #print \\\"inserted\\\",vertex\",\n \"def test_pointnum3():\\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(1000, -500), radius=5000, thickness=50)\\n assert len(shape.points) == 12\\n assert len(shape.processed_points) == 13\",\n \"def canonical_vertex(self):\\n return self.L.zero(), self.K.one()\",\n \"def test_pointnum2():\\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(100, -100), radius=400, thickness=25)\\n assert len(shape.points) == 12\\n assert len(shape.processed_points) == 13\",\n \"def SectionVertex(self, *args):\\n return _BRepAlgo.BRepAlgo_DSAccess_SectionVertex(self, *args)\",\n \"def __init__(self, nVertex, pVertex=None, pFace=None, nFace=None):\\n if type(nVertex) is vector:\\n self.pvt = vertex(nVertex)\\n self.nvt = vertex(0, 0, 0)\\n else:\\n self.pvt = pVertex # positive vertex\\n self.nvt = nVertex # negative vertex\\n self.pFace = pFace # positive face\\n self.nFace = nFace # negative face\",\n \"def test_pointnum1():\\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(0, 0), radius=300, thickness=10)\\n assert len(shape.points) == 12\\n assert len(shape.processed_points) == 13\",\n \"def redefinir_vertices(self):\\n self.nueva_posicion_posible_parte_inferior = [0,0]\\n self.nueva_posicion_posible_parte_superior = [0,0]\\n self.vertice_1 = self.posicion\\n self.vertice_2 = [self.posicion[0] + self.medidas, self.posicion[1]]\\n self.vertice_3 = [self.posicion[0], self.posicion[1] + self.medidas]\\n self.vertice_4 = [self.posicion[0] + self.medidas, self.posicion[1] + self.medidas]\",\n \"def add_vertex(self, v):\\n v = {'x': v[0], 'y': v[1]}\\n if v not in self:\\n self.append(v)\\n return len(self)-1\\n return self.index(v)\",\n \"def remove_vertex(self, index):\\n\\n if len(self._coordinates) <= 4:\\n raise GeometryError(\\\"There must be at least two vertices\\\")\\n if not isinstance(index, int):\\n raise TypeError(\\\"Vertex index must be int\\\")\\n self._coordinates.pop(index * 2)\\n self._coordinates.pop(index * 2)\",\n \"def get_vertex(self, p, v, x, y, z):\\n x.value, y.value, z.value = self._get_vertex(p, v, x.value, y.value, z.value)\",\n \"def copy(self):\\n return vertex(self.x, self.y, self.z)\",\n \"def add_vertex(self, event: matplotlib.backend_bases.LocationEvent) \\\\\\n -> None:\\n\\n transform_func = event.inaxes.transData.inverted().transform\\n new_coords = transform_func((event.x, event.y))\\n log.info(f'Adding Vertex @ {event.x} - {event.y}, axis: '\\n f'{new_coords}')\\n graph = self._get_connected_graph(event.inaxes)\\n vertex = Vertex()\\n vertex.attr['x'] = float(new_coords[0])\\n vertex.attr['y'] = float(new_coords[1])\\n graph.add(vertex)\\n self._redraw_graph()\",\n \"def __init__(self, mesh, V):\\n super().__init__(mesh, V)\\n self.source = Constant(0)\",\n \"def clearVertex(self, index):\\n Parameter.checkIndex(index, 0, len(self.V))\\n self.V[index] = None\",\n \"def add_vertex(self, vertex):\\n raise NotImplementedError\",\n \"def registerVertices(self,vl):\\n self.set('patchmesh.vertices',FuzzList(vl))\",\n \"def add_vertex(self, vertex):\\n if vertex not in self.graph_dict:\\n self.graph_dict[vertex] = []\\n return vertex\",\n \"def move_vertex(region, vertex, new_vertex, vert_dict):\\n # Skip useless moves\\n if vertex == new_vertex:\\n return\\n # Update the original region\\n new_vertex_list = [new_vertex if v == vertex else v for v in region.vertices]\\n region.set_vertices(new_vertex_list)\\n # Check the neighbours\\n for r in region.get_neighbors():\\n new_vertex_list = [new_vertex if v == vertex else v for v in r.vertices]\\n r.set_vertices(new_vertex_list)\\n # Update the point position in the graph\\n vert_dict[vertex] = new_vertex\",\n \"def makeSparse(self):\\n center = self.center\\n l = []\\n for point in self.points:\\n angle = Vector.createFromTwoPoints(point, center).angle\\n l.append((angle, copy.deepcopy(point)))\\n l = sorted(l, key=lambda x: x[0])\\n for i in range(len(l)):\\n self.points[i].set(l[i][1])\",\n \"def add_vertex(self, vertex_id):\\n # creates a vertex with an empty list as their neighboring vertices\\n self.vertices[vertex_id] = set()\",\n \"def relax_vertex(vertex, neighbor):\\n if vertex.distance + 1 < neighbor.distance:\\n neighbor.distance = vertex.distance + 1\\n neighbor.parent = vertex\",\n \"def __init__(self, g, v):\\n super().__init__(g, v, 'The node does not belong to the graph.')\",\n \"def addVertex(self, vertex):\\n if vertex not in self.adjList:\\n self.adjList[vertex] = []\",\n \"def _vertex_constraint_violated(self, vertex, **kwargs):\\n key_index = self._vconstraints.get(vertex.label, {})\\n\\n # first check the entity properties for constraint violations\\n # Then check any additional properties for constraint violations.\\n # Additional properties are for cases like `.set_property`\\n for props in [vertex.properties, kwargs]:\\n for key, value in props.items():\\n if key not in key_index:\\n continue\\n\\n for indexed_entity in key_index[key]:\\n if indexed_entity != vertex:\\n if indexed_entity.properties[key] == value:\\n raise interfaces.ConstraintViolation(\\n \\\"{!r} violated constraint {!r}\\\".format(\\n vertex, key\\n )\\n )\",\n \"def __init__(self, vertex):\\n self.id = vertex\\n self.neighbors = {}\",\n \"def add_vertex(self, vertex):\\n if vertex not in self.graph_dict:\\n self.graph_dict[vertex] = []\",\n \"def addPoint(self, p):\\n p = np.asarray(p)\\n idx = len(self.coords)\\n # print(\\\"coords[\\\", idx,\\\"] ->\\\",p)\\n self.coords.append(p)\\n\\n # Search the triangle(s) whose circumcircle contains p\\n bad_triangles = []\\n for T in self.triangles:\\n # Choose one method: inCircleRobust(T, p) or inCircleFast(T, p)\\n if self.inCircleFast(T, p):\\n bad_triangles.append(T)\\n\\n # Find the CCW boundary (star shape) of the bad triangles,\\n # expressed as a list of edges (point pairs) and the opposite\\n # triangle to each edge.\\n boundary = []\\n # Choose a \\\"random\\\" triangle and edge\\n T = bad_triangles[0]\\n edge = 0\\n # get the opposite triangle of this edge\\n while True:\\n # Check if edge of triangle T is on the boundary...\\n # if opposite triangle of this edge is external to the list\\n tri_op = self.triangles[T][edge]\\n if tri_op not in bad_triangles:\\n # Insert edge and external triangle into boundary list\\n boundary.append((T[(edge+1) % 3], T[(edge-1) % 3], tri_op))\\n\\n # Move to next CCW edge in this triangle\\n edge = (edge + 1) % 3\\n\\n # Check if boundary is a closed loop\\n if boundary[0][0] == boundary[-1][1]:\\n break\\n else:\\n # Move to next CCW edge in opposite triangle\\n edge = (self.triangles[tri_op].index(T) + 1) % 3\\n T = tri_op\\n\\n # Remove triangles too near of point p of our solution\\n for T in bad_triangles:\\n del self.triangles[T]\\n del self.circles[T]\\n\\n # Retriangle the hole left by bad_triangles\\n new_triangles = []\\n for (e0, e1, tri_op) in boundary:\\n # Create a new triangle using point p and edge extremes\\n T = (idx, e0, e1)\\n\\n # Store circumcenter and circumradius of the triangle\\n self.circles[T] = self.circumcenter(T)\\n\\n # Set opposite triangle of the edge as neighbour of T\\n self.triangles[T] = [tri_op, None, None]\\n\\n # Try to set T as neighbour of the opposite triangle\\n if tri_op:\\n # search the neighbour of tri_op that use edge (e1, e0)\\n for i, neigh in enumerate(self.triangles[tri_op]):\\n if neigh:\\n if e1 in neigh and e0 in neigh:\\n # change link to use our new triangle\\n self.triangles[tri_op][i] = T\\n\\n # Add triangle to a temporal list\\n new_triangles.append(T)\\n\\n # Link the new triangles each another\\n N = len(new_triangles)\\n for i, T in enumerate(new_triangles):\\n self.triangles[T][1] = new_triangles[(i+1) % N] # next\\n self.triangles[T][2] = new_triangles[(i-1) % N] # previous\",\n \"def __init__(self):\\n self.vert_dict = {}\\n # self.vert_dict = []\\n self.num_vertices = 0\",\n \"def __init__(self, start, end, oldLine = None):\\n self.__start = start\\n self.__end = end\\n if(self.__start == self.__end):\\n \\\"\\\"\\\"\\n If a zero length line is created that most likely means there is a\\n logic problem somewhere in the program. This does not throw and error\\n so that the output can still be examined to help diagnose the problem.\\n \\\"\\\"\\\"\\n# raise Exception('Zero length line')\\n logger.warning('A line was created with no length at: ' + \\n str(self.start))\\n \\\"\\\"\\\" The Point which is the upper left corner of the line's bounding box \\\"\\\"\\\"\\n self.__upperLeft = None\\n \\\"\\\"\\\" The Point of the lower right corner of the bounding box. \\\"\\\"\\\"\\n self.__lowerRight = None\\n self.__extrusionRate = 0\\n self.freezeExRate = False\\n if not(oldLine is None):\\n self.__extrusionRate = oldLine.extrusionRate\\n self.freezeExRate = oldLine.freezeExRate\\n self.vector = np.array([self.end.x-self.start.x,\\n self.end.y-self.start.y])\",\n \"def add_vertex(self, room):\\r\\n if room['room_id'] not in self.rooms:\\r\\n self.rooms[room['room_id']] = room\\r\\n # self.rooms[room['room_id']]['exits'] = {\\r\\n # d: '?' for d in room['exits']}\\r\",\n \"def test_polygon_with_duplicate_nodes_is_valid():\\n geom = query_row(db_conf, 'osm_landusages', 30005)['geometry']\\n assert geom.is_valid\\n assert len(geom.exterior.coords) == 4\",\n \"def add_vertex(self,vertex):\\n if vertex not in self.__graph_dict:\\n self.__graph_dict[vertex] = []\\n # logging.debug(\\\"vertex being initialized ..\\\", vertex)\\n else:\\n # logging.debug(\\\"vertex not added ..\\\", vertex)\\n pass\",\n \"def _create_vertex_list(self):\\n raise NotImplementedError('_create_vertex_list must be defined in '\\n 'order to use group or batch properties')\",\n \"def __validatePoint(self, point):\\n # print point\\n if point[0] > self.scn_width:\\n raise ValueError('X coordinate: %d out of range.' % point[0])\\n if point[1] > self.scn_height:\\n raise ValueError('Y coordinate: %d out of range.' % point[1])\\n return point\",\n \"def add_vertex(self, vertex_id): # O(1) time complexity\\n self.vertices[vertex_id] = set() \\n\\n # additional options (class)\\n '''\\n if vertex_id not in self.vertices:\\n self.vertices[vertex_id] = {}\\n\\n else:\\n return \\\"Vertex is already in Graph\\\"\\n '''\",\n \"def _remove_vertex(self, i):\\n if (len(self._xys) > 2 and\\n self._selection_completed and\\n i in (0, len(self._xys) - 1)):\\n # If selecting the first or final vertex, remove both first and\\n # last vertex as they are the same for a closed polygon\\n self._xys.pop(0)\\n self._xys.pop(-1)\\n # Close the polygon again by appending the new first vertex to the\\n # end\\n self._xys.append(self._xys[0])\\n else:\\n self._xys.pop(i)\\n if len(self._xys) <= 2:\\n # If only one point left, return to incomplete state to let user\\n # start drawing again\\n self._selection_completed = False\\n self._remove_box()\",\n \"def __init__(self):\\n self.vert_list = {}\\n self.num_vertices = 0\",\n \"def validate_mesh(self):\\n pass\",\n \"def is_legal(vtx, color):\\n for neighbor in vtx[\\\"adjacent\\\"]:\\n if VERTICES[neighbor][\\\"color\\\"] is color:\\n return False\\n return True\",\n \"def test_vertex_constructor(self):\\r\\n metros = {\\\"code\\\": \\\"SCL\\\", \\\"name\\\": \\\"Santiago\\\"}\\r\\n self.assertRaises(Exception, Vertex, metros)\\r\\n metros = {\\\"code\\\": \\\"SCL\\\", \\\"name\\\": \\\"Santiago\\\", \\\"country\\\": \\\"CL\\\", \\\"continent\\\": \\\"South America\\\", \\\"timezone\\\": -4,\\r\\n \\\"coordinates\\\": {\\\"S\\\": 33, \\\"W\\\": 71}, \\\"population\\\": 6000000, \\\"region\\\": 1}\\r\\n vertex = Vertex(metros)\\r\\n self.assertIsInstance(vertex, Vertex)\\r\\n self.assertIs(vertex.code, \\\"SCL\\\")\\r\\n self.assertIs(vertex.name, \\\"Santiago\\\")\\r\\n self.assertIs(vertex.country, \\\"CL\\\")\\r\\n self.assertIs(vertex.continent, \\\"South America\\\")\\r\\n self.assertIs(vertex.coordinates[\\\"S\\\"], 33)\\r\\n self.assertIs(vertex.coordinates[\\\"W\\\"], 71)\\r\\n self.assertIs(vertex.population, 6000000)\\r\\n self.assertIs(vertex.region, 1)\",\n \"def __init__(self, points, verbose=False):\\n assert(type(points) == np.ndarray)\\n assert(points.dtype==int)\\n assert(points.shape[1] == 3)\\n assert(points.shape[0]>1)\\n\\n # Make points unique to avoid duplicate vertices:\\n self.points = np.unique(points, axis=0)\\n self.verbose = verbose\\n self.g = self.__generate()\",\n \"def add_vertex(self, v):\\n self[v] = {}\",\n \"def add_vertex(self, v):\\n self[v] = {}\",\n \"def addVertices(self, n):\\n oldN = len(self.V)\\n for i in range(oldN, oldN+n):\\n self.V[i] = None\",\n \"def add_vertex(self, vertex):\\n if vertex not in self.__graph_dict:\\n self.__graph_dict[vertex] = []\",\n \"def add_vertex(self, vertex):\\n if vertex not in self.__graph_dict:\\n self.__graph_dict[vertex] = []\",\n \"def makeEdgeVertex(self, f, v):\\n newV = self.addVertex(0, 0, 0)\\n newE = self.addEdge(v, newV)\\n newE.pFace = f\\n return (newE, newV)\",\n \"def adicionaVertice(self, vertice):\\r\\n self.vertices.append(vertice)\",\n \"def __init__(self, v, w, weight):\\n if v < 0:\\n raise IllegalArgumentException(\\\"vertex index must be a nonnegative integer\\\")\\n if w < 0:\\n raise IllegalArgumentException(\\\"vertex index must be a nonnegative integer\\\")\\n if math.isnan(weight):\\n raise IllegalArgumentException(\\\"Weight is NaN\\\")\\n self._v = v\\n self._w = w\\n self._weight = weight\",\n \"def move_vertex(self, p, v, x, y, z):\\n self._move_vertex(p, v, x, y, z)\",\n \"def contract(self):\\n self.vertices[-1, :] = self.contracted\",\n \"def addVertex(self,x):\\n self.dictOut[x]=[]\",\n \"def add_vertex(self, vertex):\\n self[vertex] = {}\",\n \"def _init_V(self, V):\\n if V < 0: raise Exception(\\\"Number of vertices must be nonnegative\\\")\\n self._V = V\\n self._E = 0\\n self._adj = [set() for v in range(V)]\",\n \"def add_vertex(self, vertex_id):\\n pass # TODO\",\n \"def render(self, vertex_highlighting=False):\\n pass\",\n \"def _generate_vertexes(self):\\n # generate list of sets for each vms\\n self._graph = [set() for _ in range(self._vm_count)]\",\n \"def test_no_start_vertex_in_graph(self):\\n self.assertEquals(\\n Dijkstras().dijkstras(self.g13, 'a', 'b'),\\n '\\\\'a\\\\' as a start node not found')\",\n \"def __init__(self, vertices):\\n self.vertices = vertices\",\n \"def _ensure_mesh(self):\\n if self._knots_to_mesh is None:\\n self._mesh, self._knots_to_mesh = np.unique(self.kv, return_inverse=True)\",\n \"def prepare_point(infos: PointInfos):\\n point = GraphVisualizerPoint()\\n point.connected = infos.connected\\n point.set_text(infos.text)\\n return point\",\n \"def mutate_point_poly(mutated_genome):\\n seed = random.randint(0,7)\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if len(mutated_genome[index][2]) < 3: seed = 0\\n if seed == 0:\\n insert_point(mutated_genome,index)\\n elif seed == 1:\\n remove_point(mutated_genome,index)\\n elif seed == 2:\\n switch_points(mutated_genome,index)\\n elif seed == 3:\\n shuffle_points(mutated_genome,index)\\n elif seed == 4:\\n move_point(mutated_genome,index)\\n elif seed == 5:\\n shift_point(mutated_genome,index)\\n elif seed == 6:\\n increment_point(mutated_genome,index)\\n else: #seed == 7:\\n decrement_point(mutated_genome,index)\",\n \"def CreateDummyLowerDimensionalMesh(self):\\n\\n\\n sys.stdout = open(os.devnull, \\\"w\\\")\\n p = self.InferPolynomialDegree()\\n mesh = Mesh()\\n if self.element_type == \\\"tet\\\":\\n mesh.Rectangle(nx=1,ny=1, element_type=\\\"tri\\\")\\n mesh.GetHighOrderMesh(p=p)\\n elif self.element_type == \\\"hex\\\":\\n mesh.Rectangle(nx=1,ny=1, element_type=\\\"quad\\\")\\n mesh.GetHighOrderMesh(p=p)\\n elif self.element_type == \\\"tri\\\" or self.element_type == \\\"quad\\\":\\n mesh.Line(n=1, p=p)\\n elif self.element_type == \\\"line\\\":\\n mesh.element_type = \\\"point\\\"\\n mesh.nelem = 1\\n mesh.nnode = 1\\n mesh.degree = p\\n mesh.elements = np.array([[0]])\\n mesh.points = np.array([[0.,0.,0.]])\\n sys.stdout = sys.__stdout__\\n\\n return mesh\",\n \"def get_regular_points(self, npoints=None, device=\\\"gpu0\\\"):\\n if not self.npoints == npoints:\\n self.mesh = pymesh.generate_icosphere(1, [0, 0, 0], 4) # 2562 vertices\\n self.vertex = torch.from_numpy(self.mesh.vertices).to(device).float()\\n self.num_vertex = self.vertex.size(0)\\n self.vertex = self.vertex.transpose(0,1).contiguous().unsqueeze(0)\\n self.npoints = npoints\\n\\n return Variable(self.vertex.to(device))\",\n \"def clean_edges(self):\",\n \"def generaCubo(self):\\r\\n #Use Panda predefined format for vertex coordinate only\\r\\n format = GeomVertexFormat.getV3()\\r\\n \\r\\n #Build Vertex data using the created format. Vertex will never change so I use Static attribute \\r\\n vdata = GeomVertexData('CuboData', format, Geom.UHStatic)\\r\\n \\r\\n #I will have to write vertex data so I create a writer for these data\\r\\n vertex = GeomVertexWriter(vdata, 'vertex')\\r\\n \\r\\n #I now use the writer to add vertex data\\r\\n vertex.addData3f(0, 0, 0)\\r\\n vertex.addData3f(1, 1, 1)\\r\\n vertex.addData3f(0, 1, 1)\\r\\n vertex.addData3f(0, 1, 0)\\r\\n vertex.addData3f(0, 0, 1)\\r\\n vertex.addData3f(1, 0, 0)\\r\\n vertex.addData3f(1, 0, 1)\\r\\n vertex.addData3f(1, 1, 0)\\r\\n \\r\\n #I now create 12 triangles\\r\\n prim = GeomTriangles(Geom.UHStatic)\\r\\n\\r\\n #and then I add vertex to them\\r\\n #Next time use addVertices(0,1,2) !!!\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(3)\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n \\r\\n prim.addVertex(2)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(4)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(2)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(7)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(3)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(2)\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(3)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(0)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(4)\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(0)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(5)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(7)\\r\\n prim.closePrimitive()\\r\\n\\r\\n prim.addVertex(6)\\r\\n prim.addVertex(1)\\r\\n prim.addVertex(5)\\r\\n prim.closePrimitive()\\r\\n\\r\\n #Create a Geom to bing vertex data to primitives\\r\\n geom = Geom(vdata)\\r\\n geom.addPrimitive(prim)\\r\\n\\r\\n #Create a node for the Geom in order to be able to render it\\r\\n node = GeomNode('gnode')\\r\\n node.addGeom(geom)\\r\\n\\r\\n #Adde the node to the scene graph == render it!\\r\\n nodePath = render.attachNewNode(node)\\r\\n \\r\\n #is this needed?\\r\\n nodePath.setPos( 0, 5, 0)\\r\\n \\r\\n self.camera.lookAt(nodePath)\\r\\n \\r\\n base.setBackgroundColor( .0, .0, .0 )\\r\\n \\r\\n taskMgr.add(self.SpinCameraTask, \\\"SpinCameraTask\\\")\",\n \"def MeshVtxAdjacentVtxs (strMesh, index, blnAbsolutConnections=False, blnCreate=False):\\n \\\"\\\"\\\"custom function\\\"\\\"\\\"\\n #-----------------------------------------------------------------------------------------------------------------------------------------\\n def CullDuplicates(seq, idfun=None): \\n # order preserving \\n if idfun is None: \\n def idfun(x): return x \\n seen = {} \\n result = [] \\n for item in seq: \\n marker = idfun(item) \\n if marker in seen: continue \\n seen[marker] = 1 \\n result.append(item) \\n return result\\n #-----------------------------------------------------------------------------------------------------------------------------------------\\n MeshVtxAdjacentVtxs = []\\n if rs.IsMesh(strMesh)==False : \\n print \\\"strMesh is not an mesh\\\"\\n return None\\n if type(index)==type(\\\"string\\\"):\\n print \\\"index is not an integer\\\"\\n return None\\n if type(index)==type(0.1): index = int(index)\\n\\n arrVertices = rs.MeshVertices (strMesh)\\n arrFaceVertices = rs.MeshFaceVertices(strMesh)\\n\\n intCount = 0\\n arrAdjacentVtxs = []\\n for arrFace in arrFaceVertices:\\n blnIsAdjacent = False\\n for arrVtxIndex in arrFace:\\n if arrVtxIndex == index :\\n blnIsAdjacent = True\\n if blnIsAdjacent :\\n if blnAbsolutConnections :\\n if arrFace[2]==arrFace[3] :\\n for arrVtxIndex in arrFace :\\n if arrVtxIndex != index :\\n arrAdjacentVtxs.append( arrVtxIndex)\\n else :\\n if index == arrFace[0] :\\n arrAdjacentVtxs.append( arrFace[3] )\\n arrAdjacentVtxs.append( arrFace[1] )\\n elif index == arrFace[1] :\\n arrAdjacentVtxs.append( arrFace[0] )\\n arrAdjacentVtxs.append( arrFace[2] )\\n elif index == arrFace[2] :\\n arrAdjacentVtxs.append( arrFace[1] )\\n arrAdjacentVtxs.append( arrFace[3] )\\n elif index == arrFace(3) :\\n arrAdjacentVtxs.append( arrFace[2] )\\n arrAdjacentVtxs.append( arrFace[0] )\\n else :\\n for arrVtxIndex in arrFace :\\n if arrVtxIndex != index :\\n arrAdjacentVtxs.append( arrVtxIndex )\\n if type(arrAdjacentVtxs) != type([]) : return None\\n arrOrderAdjacentVtxs = CullDuplicates(arrAdjacentVtxs)\\n if blnCreate :\\n arrStrPts = []\\n for arrVtxIndex in arrOrderAdjacentVtxs:\\n rs.AddPoint ( arrVertices[arrVtxIndex] )\\n arrStrPts.append( arrVertices[arrVtxIndex] )\\n return arrStrPts\\n else :\\n return arrOrderAdjacentVtxs\",\n \"def _remove_unreferenced_vertices(self):\\n # convert vertices to an array\\n vertex_array = np.array(self.mesh_.vertices())\\n num_v = vertex_array.shape[0]\\n\\n # fill in a 1 for each referenced vertex\\n reffed_array = np.zeros([num_v, 1])\\n for f in self.mesh_.triangles():\\n if f[0] < num_v and f[1] < num_v and f[2] < num_v:\\n reffed_array[f[0]] = 1\\n reffed_array[f[1]] = 1\\n reffed_array[f[2]] = 1\\n\\n # trim out vertices that are not referenced\\n reffed_v_old_ind = np.where(reffed_array == 1)\\n reffed_v_old_ind = reffed_v_old_ind[0]\\n reffed_v_new_ind = np.cumsum(reffed_array).astype(np.int) - 1 # counts number of reffed v before each ind\\n\\n try:\\n self.mesh_.set_vertices(vertex_array[reffed_v_old_ind, :].tolist())\\n if self.mesh_.normals() is not None:\\n normals_array = np.array(self.mesh_.normals())\\n self.mesh_.set_normals(normals_array[reffed_v_old_ind, :].tolist())\\n except IndexError:\\n return False\\n\\n # create new face indices\\n new_triangles = []\\n for f in self.mesh_.triangles():\\n new_triangles.append([reffed_v_new_ind[f[0]], reffed_v_new_ind[f[1]], reffed_v_new_ind[f[2]]] )\\n self.mesh_.set_triangles(new_triangles)\\n return True\",\n \"def add_vertex(self, vertex_id):\\n if vertex_id not in self.vertices:\\n self.vertices[vertex_id] = set()\",\n \"def test_no_vertex_in_graph(self):\\n self.assertEquals(\\n Dijkstras().dijkstras(self.g11, 'a', 'b'),\\n 'No vertex found in graph')\",\n \"def validate(self):\\r\\n if self.eid is None:\\r\\n if self._inV is None:\\r\\n raise ValidationError('in vertex must be set before saving new edges')\\r\\n if self._outV is None:\\r\\n raise ValidationError('out vertex must be set before saving new edges')\\r\\n super(Edge, self).validate()\",\n \"def EuclidI12(self, line: Line, point: Point, interesting=True) -> Line:\\n if point in line:\\n raise ValueError(f'Cannot drop a perpendicular. Point {point} is on line {line}.')\\n # rename point as C\\n c = point\\n # Pick a point on the opposite side of line from c\\n d = self.pick_point_not_on_line_on_side(line, c, same_side=False)\\n circle_center_c_radius_cd = self.add_circle(c, d, interesting=interesting)\\n a, b = self.find_intersections_line_circle(line, circle_center_c_radius_cd)\\n side = d\\n f = self.ErectEquilateralTriangle(Line(a, b), side=side, interesting=interesting)\\n return self.add_line(c, f)\",\n \"def add_vertex(self, v, i=None):\\n if len(self) < 2:\\n return LineString.add_vertex(self, v, i)\",\n \"def add_vertex(self, item: Any, kind: str) -> None:\\n if item not in self._vertices:\\n self._vertices[item] = _Vertex(item, kind)\",\n \"def add_vertex(self, vertex):\\r\\n if vertex not in self.__graph_dict:\\r\\n self.__graph_dict[vertex] = {}\",\n \"def __init__(self, model, line, segments = None,head_target = 0,\\r\\n variables = [], priors=[]):\\r\\n\\r\\n import numpy as np\\r\\n from scipy.interpolate import interp1d\\r\\n import copy\\r\\n \\r\\n # Append this element to the specified model\\r\\n self.model = model\\r\\n model.elementlist.append(self)\\r\\n model.linear_solver = True\\r\\n\\r\\n # ---------------------------------------------------------------------\\r\\n # Subdivide the provided no flow boundary into segments pieces\\r\\n \\r\\n # Complexify the line, if it wasn't already complex\\r\\n line = self.complexify(line)\\r\\n \\r\\n # The subdivision algorith requires the line coordinates as a real N-by-2 matrix\\r\\n line = np.column_stack((\\r\\n np.real(line)[:,np.newaxis],\\r\\n np.imag(line)[:,np.newaxis]))\\r\\n \\r\\n self.line_raw = copy.copy(line)\\r\\n if segments is None:\\r\\n self.segments = line.shape[0]-1\\r\\n else:\\r\\n self.segments = segments\\r\\n \\r\\n if self.segments < self.line_raw.shape[0]-1:\\r\\n raise Exception('Prescribed number of line segments '+str(self.segments)+\\\" mustn't be smaller than base number of segments \\\"+str(line.shape[0]-1)+'.')\\r\\n \\r\\n if self.segments > self.line_raw.shape[0]-1:\\r\\n \\r\\n # Subdivide the line\\r\\n self.line = self.subdivide_line(line,self.segments)\\r\\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\\r\\n \\r\\n else:\\r\\n \\r\\n self.line = self.line_raw.copy()\\r\\n self.line_c = self.line[:,0] + 1j*self.line[:,1]\\r\\n \\r\\n # Also get the normal vector components to each segment\\r\\n self.line_nvec = self.line[:,1] - 1j*self.line[:,0]\\r\\n self.line_nvec = self.line_nvec/np.abs(self.line_nvec)\\r\\n\\r\\n # ---------------------------------------------------------------------\\r\\n \\r\\n # Get strength parameters for each vertex\\r\\n self.strength = np.ones(self.segments)\\r\\n \\r\\n \\r\\n self.zc = []\\r\\n self.segment_nvec = []\\r\\n self.L = []\\r\\n \\r\\n for seg in range(self.segments):\\r\\n \\r\\n self.zc += [(self.line_c[seg]+self.line_c[seg+1])/2]\\r\\n \\r\\n # Calculate the normal vector to this segment\\r\\n self.segment_nvec += [(self.line_c[seg]-self.line_c[seg+1])]\\r\\n self.segment_nvec[-1]= [np.imag(self.segment_nvec[-1])-1j*np.real(self.segment_nvec[-1])]\\r\\n \\r\\n self.L += [np.abs(self.line_c[seg+1] - self.line_c[seg])]\\r\\n \\r\\n self.zc = np.asarray(self.zc)\\r\\n \\r\\n # Extract target variables\\r\\n self.variables = variables\\r\\n self.priors = priors\\r\\n \\r\\n self.L = np.asarray(self.L)\\r\\n \\r\\n \\r\\n # Check if the prior matches the number of parameters\\r\\n if len(self.priors) != len(self.variables):\\r\\n raise Exception('Number of priors must match number of unknown variables. Number of priors: '+str(self.priors)+' / Number of unknown variables: '+str(len(self.variables)))\\r\\n \\r\\n # Go through all elements\\r\\n if len(self.variables) > 0:\\r\\n # There are some model variables specified\\r\\n for idx,var in enumerate(self.variables):\\r\\n self.model.num_params += 1\\r\\n exec(\\\"self.model.params += [self.%s]\\\" % var)\\r\\n self.model.priors += [self.priors[idx]]\\r\\n self.model.variables += [var]\\r\\n if 'name' in list(self.priors[idx].keys()):\\r\\n self.model.param_names += [self.priors[idx]['name']] \\r\\n else: \\r\\n self.model.param_names += ['unknown']\",\n \"def __init__(self, polyhedron, data):\\n super(Inequality, self).__init__(polyhedron, data)\",\n \"def add_vertex(self, vertex):\\n try:\\n vertex_idx = self.vertices.index(vertex)\\n # print \\\"{} already in {}\\\".format(vertex, self.vertices)\\n return self.vertices[vertex_idx]\\n except Exception:\\n self.vertices.append(vertex)\\n # print \\\"adding {} to {}\\\".format(vertex, self.vertices)\\n return vertex\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59776235","0.591074","0.56486434","0.562389","0.5610807","0.5493077","0.5428685","0.54126817","0.5402887","0.53902274","0.53565663","0.5349987","0.53480065","0.53480065","0.5347004","0.53421235","0.5341217","0.53389066","0.53311205","0.53235525","0.5322581","0.52903754","0.52821666","0.5277537","0.5262046","0.5259605","0.5255463","0.52497196","0.52450377","0.5236549","0.5226493","0.5223816","0.52083796","0.5191813","0.5183233","0.5177084","0.5176585","0.5159733","0.51568747","0.51491654","0.5141754","0.5139746","0.51386064","0.51369894","0.5132145","0.51284593","0.5124925","0.51237464","0.512167","0.5115757","0.51055086","0.51017267","0.50852406","0.5074868","0.50734663","0.5070689","0.50701284","0.5062975","0.5058098","0.5051113","0.504677","0.5042437","0.50420463","0.50393283","0.50393283","0.50391346","0.5033156","0.5033156","0.50331044","0.50322795","0.5029809","0.5027927","0.5002796","0.49906957","0.4988461","0.49876314","0.49786708","0.49782294","0.49780333","0.4975754","0.4972599","0.4965097","0.4962955","0.4956864","0.49552223","0.4953169","0.49517357","0.49460456","0.49449858","0.49382797","0.49321753","0.49320644","0.49318781","0.49310833","0.49283645","0.49249813","0.4921064","0.4920709","0.491946","0.4906282"],"string":"[\n \"0.59776235\",\n \"0.591074\",\n \"0.56486434\",\n \"0.562389\",\n \"0.5610807\",\n \"0.5493077\",\n \"0.5428685\",\n \"0.54126817\",\n \"0.5402887\",\n \"0.53902274\",\n \"0.53565663\",\n \"0.5349987\",\n \"0.53480065\",\n \"0.53480065\",\n \"0.5347004\",\n \"0.53421235\",\n \"0.5341217\",\n \"0.53389066\",\n \"0.53311205\",\n \"0.53235525\",\n \"0.5322581\",\n \"0.52903754\",\n \"0.52821666\",\n \"0.5277537\",\n \"0.5262046\",\n \"0.5259605\",\n \"0.5255463\",\n \"0.52497196\",\n \"0.52450377\",\n \"0.5236549\",\n \"0.5226493\",\n \"0.5223816\",\n \"0.52083796\",\n \"0.5191813\",\n \"0.5183233\",\n \"0.5177084\",\n \"0.5176585\",\n \"0.5159733\",\n \"0.51568747\",\n \"0.51491654\",\n \"0.5141754\",\n \"0.5139746\",\n \"0.51386064\",\n \"0.51369894\",\n \"0.5132145\",\n \"0.51284593\",\n \"0.5124925\",\n \"0.51237464\",\n \"0.512167\",\n \"0.5115757\",\n \"0.51055086\",\n \"0.51017267\",\n \"0.50852406\",\n \"0.5074868\",\n \"0.50734663\",\n \"0.5070689\",\n \"0.50701284\",\n \"0.5062975\",\n \"0.5058098\",\n \"0.5051113\",\n \"0.504677\",\n \"0.5042437\",\n \"0.50420463\",\n \"0.50393283\",\n \"0.50393283\",\n \"0.50391346\",\n \"0.5033156\",\n \"0.5033156\",\n \"0.50331044\",\n \"0.50322795\",\n \"0.5029809\",\n \"0.5027927\",\n \"0.5002796\",\n \"0.49906957\",\n \"0.4988461\",\n \"0.49876314\",\n \"0.49786708\",\n \"0.49782294\",\n \"0.49780333\",\n \"0.4975754\",\n \"0.4972599\",\n \"0.4965097\",\n \"0.4962955\",\n \"0.4956864\",\n \"0.49552223\",\n \"0.4953169\",\n \"0.49517357\",\n \"0.49460456\",\n \"0.49449858\",\n \"0.49382797\",\n \"0.49321753\",\n \"0.49320644\",\n \"0.49318781\",\n \"0.49310833\",\n \"0.49283645\",\n \"0.49249813\",\n \"0.4921064\",\n \"0.4920709\",\n \"0.491946\",\n \"0.4906282\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.57575715"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":78786,"cells":{"query":{"kind":"string","value":"SectionShape est soit un Vertex de section(NYI), soit une Edge de section. Propagation des shapes de section en partant de SectionShape. return un Compound de section."},"document":{"kind":"string","value":"def PropagateFromSection(self, *args):\n return _BRepAlgo.BRepAlgo_DSAccess_PropagateFromSection(self, *args)"},"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 test_compound_stiffened_isection():\n uc = steel_sections.i_section(d=400, b=400, t_f=25, t_w=25, r=30, n_r=8)\n plate1 = (\n sections.rectangular_section(b=500, d=10).align_center(uc).align_to(uc, \"top\")\n )\n plate2 = (\n sections.rectangular_section(b=500, d=10)\n .align_center(uc)\n .align_to(uc, \"bottom\")\n )\n geom = uc + plate1 + plate2\n\n new_geom = geom.offset_perimeter(-9)\n new_geom.create_mesh([100])\n section = Section(new_geom)\n\n new_geom = geom.offset_perimeter(-10)\n new_geom.create_mesh([100])\n section = Section(new_geom)\n\n new_geom = geom.offset_perimeter(-11)\n new_geom.create_mesh([100])\n section = Section(new_geom)","def build_section(self, section_map):\n section = []\n for coordinate_map in section_map['shape']:\n vertex = self.graph.add_vertex()\n\n # Build a property map containing the geolocation, speed, ID, and bearing.\n self.node_locations[vertex] = [coordinate_map['lon'], coordinate_map['lat']]\n self.node_id[vertex] = section_map['sectionID']\n self.node_speed_limit[vertex] = section_map['speed']\n self.node_width[vertex] = self.road_types[section_map['type']] * section_map['numLanes']\n\n if section:\n # The first node does not get a heading until the junction node has been added.\n self.node_heading[vertex] = coordinate_map['heading']\n previous_node = section[-1]\n edge = self.graph.add_edge(previous_node, vertex)\n previous_location = self.node_locations[previous_node]\n current_location = self.node_locations[vertex]\n self.edge_weights[edge] = utils.real_distance(previous_location, current_location)\n\n section.append(vertex)\n return section","def _generate_section_structures(self, distance, radius, structure=PILLARS, section=1):\n if section > self.num_sections:\n raise ValueError(\"Selected Section has to be less or equal than {0}\".format(self.num_sections));\n \n row = int((section - 1) / self.cols)\n col = int((section - 1) % self.cols)\n \n # Calculating starting coordinates of the section\n x = self.drawing_x + col * self.drawing_x_step\n y = self.drawing_y - row * self.drawing_y_step\n\n # Correcting width and height to respect the gap\n width = self.drawing_x_step - self.GAP_BETWEEN_SECTIONS/2 \n height = self.drawing_y_step - self.GAP_BETWEEN_SECTIONS/2\n\n polygons = []\n if structure == self.PILLARS:\n pillars = Pillar.generate_pilars_region(distance,\n radius, \n x, \n y, \n width, \n height)\n\n for pillar in pillars:\n poly = gdspy.Polygon(pillar, self.STRUCTURES_LAYER)\n polygons.append(poly)\n\n else:\n horizontal, vertical = Grid.generate_grid_region(distance,\n radius,\n x,\n y,\n width,\n height)\n if structure == self.GRID:\n\n for h in horizontal:\n poly = gdspy.Rectangle(h[0], h[1], self.STRUCTURES_LAYER )\n polygons.append(poly)\n\n for v in vertical:\n poly = gdspy.Rectangle(v[0], v[1], self.STRUCTURES_LAYER )\n polygons.append(poly)\n\n elif structure == self.LINES_H:\n\n for v in vertical:\n poly = gdspy.Rectangle(v[0], v[1], self.STRUCTURES_LAYER)\n polygons.append(poly)\n elif structure == self.LINES_V:\n\n for h in horizontal:\n poly = gdspy.Rectangle(h[0], h[1], self.STRUCTURES_LAYER)\n polygons.append(poly)\n\n self.setups[section] = {'radius': radius, 'distance': distance, 'structure': structure}\n # The fitting the generated rectangular section in the Margin area\n merged = gdspy.fast_boolean(polygons, self.margin_polygon, 'and', layer=self.STRUCTURES_LAYER,max_points=3000)\n self.cell.add(merged)","def shape(self) -> Shape:","def test_sections_flat_one_section(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(title=\"Background and context\",\n story=story,\n layout=layout,\n root=True)\n self.assertEqual(story.structure.sections_flat, [section1])","def define_sections (data_shape, xbin=1, ybin=1, tel=None):\n\n ysize, xsize = data_shape\n ny = get_par(set_bb.ny,tel)\n nx = get_par(set_bb.nx,tel)\n dy = ysize // ny\n dx = xsize // nx\n\n ysize_chan = get_par(set_bb.ysize_chan,tel) // ybin\n xsize_chan = get_par(set_bb.xsize_chan,tel) // xbin\n ysize_os = (ysize-ny*ysize_chan) // ny\n xsize_os = (xsize-nx*xsize_chan) // nx\n\n # the sections below are defined such that e.g. chan_sec[0] refers\n # to all pixels of the first channel, where the channel indices\n # are currently defined to be located on the CCD as follows:\n #\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\n\n # channel section slices including overscan; shape=(16,2)\n chan_sec = tuple([(slice(y,y+dy), slice(x,x+dx))\n for y in range(0,ysize,dy) for x in range(0,xsize,dx)])\n\n # channel data section slices; shape=(16,2)\n data_sec = tuple([(slice(y,y+ysize_chan), slice(x,x+xsize_chan))\n for y in range(0,ysize,dy+ysize_os) for x in range(0,xsize,dx)])\n\n # channel vertical overscan section slices; shape=(16,2)\n # cut off [ncut] pixels to avoid including pixels on the edge of the\n # overscan that are contaminated with flux from the image\n # and also discard last column as can have high value\n ncut = 5\n ncut_vert = max(ncut // xbin, 1)\n os_sec_vert = tuple([(slice(y,y+dy), slice(x+xsize_chan+ncut_vert,x+dx-1))\n for y in range(0,ysize,dy) for x in range(0,xsize,dx)])\n\n # channel horizontal overscan sections; shape=(16,2)\n # cut off [ncut] pixels to avoid including pixels on the edge of the\n # overscan that are contaminated with flux from the image\n ncut_hori = max(ncut // ybin, 1)\n ysize_os_cut = ysize_os - ncut_hori\n os_sec_hori = tuple([(slice(y,y+ysize_os_cut), slice(x,x+dx))\n for y in range(dy-ysize_os_cut,dy+ysize_os_cut,ysize_os_cut)\n for x in range(0,xsize,dx)])\n\n # channel reduced data section slices; shape=(16,2)\n data_sec_red = tuple([(slice(y,y+ysize_chan), slice(x,x+xsize_chan))\n for y in range(0,ysize-ny*ysize_os,ysize_chan)\n for x in range(0,xsize-nx*xsize_os,xsize_chan)])\n\n\n return chan_sec, data_sec, os_sec_hori, os_sec_vert, data_sec_red","def test_sections_flat_one_section(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n section1 = create_section(title=\"Background and context\",\n story=story,\n root=True)\n self.assertEqual(story.structure.sections_flat, [section1])","def __section_style(self):\n font = FontStyle()\n font.set(face=FONT_SERIF, size=10, italic=0, bold=0)\n para = ParagraphStyle()\n para.set_font(font)\n para.set(first_indent=-1.5, lmargin=1.5)\n para.set_top_margin(0.5)\n para.set_bottom_margin(0.25) \n para.set_description(_('The style used for each section.'))\n self.default_style.add_paragraph_style(\"PLC-Section\", para)","def test_sections_flat_no_root_section(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(title=\"Background and context\",\n story=story, layout=layout,\n root=False)\n self.assertEqual(story.structure.sections_flat, [])","def test_sections_flat_no_root_section(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n section1 = create_section(title=\"Background and context\",\n story=story,\n root=False)\n self.assertEqual(story.structure.sections_flat, [])","def get_categs_section(sect):\n return Category.objects.filter(section__section=sect)","def test_sections_flat_linear_nested(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(title=\"Background and context\",\n story=story,\n layout=layout,\n root=True)\n section2 = create_section(title=\"Decisions to be made\", story=story, layout=layout)\n section3 = create_section(title=\"Who has been involved\", \n story=story, layout=layout)\n section4 = create_section(title=\"Next steps\", story=story,\n layout=layout)\n SectionRelation.objects.create(parent=section1, child=section2)\n SectionRelation.objects.create(parent=section2, child=section3)\n SectionRelation.objects.create(parent=section3, child=section4)\n self.assertEqual(story.structure.sections_flat, [section1, section2, \n section3, section4])","def _create_sections(self):\n\t\t# NOTE: cell=self is required to tell NEURON of this object.\n\t\tself.node = [h.Section(name='node',cell=self) for x in range(self._axonNodes)]\n\t\tself.mysa = [h.Section(name='mysa',cell=self) for x in range(self._paraNodes1)]\n\t\tself.flut = [h.Section(name='flut',cell=self) for x in range(self._paraNodes2)]\n\t\tself.stin = [h.Section(name='stin',cell=self) for x in range(self._axonInter)]","def test_sections_flat_linear_nested(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n section1 = create_section(title=\"Background and context\",\n story=story,\n root=True)\n section2 = create_section(title=\"Decisions to be made\", story=story)\n section3 = create_section(title=\"Who has been involved\", \n story=story)\n section4 = create_section(title=\"Next steps\", story=story)\n SectionRelation.objects.create(parent=section1, child=section2)\n SectionRelation.objects.create(parent=section2, child=section3)\n SectionRelation.objects.create(parent=section3, child=section4)\n self.assertEqual(story.structure.sections_flat, [section1, section2, \n section3, section4])","def SectionVertex(self, *args):\n return _BRepAlgo.BRepAlgo_DSAccess_SectionVertex(self, *args)","def shape(self):","def shape(self):","def interior(self):\n return Shape(self - self.edge('inner'))","def getType(self):\n return ORGElement.ELEMENT_TYPE_SECTION","def drawCell(self, x, y, bgColor, closedSection=255, borderColor=\"\", bgPattern=\"\"):\n left = self.margin + y * self.cellSize\n right = left + self.cellSize\n top = self.margin + x * self.cellSize\n bottom = top + self.cellSize\n adjustValue = self.cellSize - self.pentPadding\n # sections tuple = ([rectangles], [lines])\n sections = ([], [])\n # main section\n sections[0].append(self.canvas.create_rectangle(\n left + self.pentPadding,\n top + self.pentPadding,\n 1 + right - self.pentPadding,\n 1 + bottom - self.pentPadding,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n # border sections\n if closedSection & (1 << 0):\n sections[0].append(self.canvas.create_rectangle(\n left,\n top,\n 1 + right - adjustValue,\n 1 + bottom - adjustValue,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n if closedSection & (1 << 1):\n sections[0].append(self.canvas.create_rectangle(\n left + self.pentPadding,\n top,\n 1 + right - self.pentPadding,\n 1 + bottom - adjustValue,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n if closedSection & (1 << 2):\n sections[0].append(self.canvas.create_rectangle(\n left + adjustValue,\n top,\n 1 + right,\n 1 + bottom - adjustValue,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n if closedSection & (1 << 3):\n sections[0].append(self.canvas.create_rectangle(\n left,\n top + self.pentPadding,\n 1 + right - adjustValue,\n 1 + bottom - self.pentPadding,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n if closedSection & (1 << 4):\n sections[0].append(self.canvas.create_rectangle(\n left + adjustValue,\n top + self.pentPadding,\n 1 + right,\n 1 + bottom - self.pentPadding,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n if closedSection & (1 << 5):\n sections[0].append(self.canvas.create_rectangle(\n left,\n top + adjustValue,\n 1 + right - adjustValue,\n 1 + bottom,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n if closedSection & (1 << 6):\n sections[0].append(self.canvas.create_rectangle(\n left + self.pentPadding,\n top + adjustValue,\n 1 + right - self.pentPadding,\n 1 + bottom,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n if closedSection & (1 << 7):\n sections[0].append(self.canvas.create_rectangle(\n left + adjustValue,\n top + adjustValue,\n 1 + right,\n 1 + bottom,\n fill=bgColor, outline=borderColor, stipple=bgPattern\n ))\n # main section's borders\n if not closedSection & (1 << 1):\n sections[1].append(self.canvas.create_line(\n left + self.pentPadding,\n top + self.pentPadding,\n 1 + right - self.pentPadding,\n bottom - adjustValue\n ))\n if not closedSection & (1 << 3):\n sections[1].append(self.canvas.create_line(\n left + self.pentPadding,\n top + self.pentPadding,\n right - adjustValue,\n 1 + bottom - self.pentPadding\n ))\n if not closedSection & (1 << 4):\n sections[1].append(self.canvas.create_line(\n left + adjustValue,\n top + self.pentPadding,\n right - self.pentPadding,\n 1 + bottom - self.pentPadding\n ))\n if not closedSection & (1 << 6):\n sections[1].append(self.canvas.create_line(\n left + self.pentPadding,\n top + adjustValue,\n 1 + right - self.pentPadding,\n bottom - self.pentPadding\n ))\n # border sections' borders\n if (closedSection & (1 << 1)) and not (closedSection & (1 << 0)):\n sections[1].append(self.canvas.create_line(\n left + self.pentPadding,\n top,\n right - adjustValue,\n 1 + bottom - adjustValue\n ))\n if (closedSection & (1 << 1)) and not (closedSection & (1 << 2)):\n sections[1].append(self.canvas.create_line(\n left + adjustValue,\n top,\n right - self.pentPadding,\n 1 + bottom - adjustValue\n ))\n if (closedSection & (1 << 4)) and not (closedSection & (1 << 2)):\n sections[1].append(self.canvas.create_line(\n left + adjustValue,\n top + self.pentPadding,\n 1 + right,\n bottom - adjustValue\n ))\n if (closedSection & (1 << 4)) and not (closedSection & (1 << 7)):\n sections[1].append(self.canvas.create_line(\n left + adjustValue,\n top + adjustValue,\n 1 + right,\n bottom - self.pentPadding\n ))\n if (closedSection & (1 << 6)) and not (closedSection & (1 << 7)):\n sections[1].append(self.canvas.create_line(\n left + adjustValue,\n top + adjustValue,\n right - self.pentPadding,\n 1 + bottom\n ))\n if (closedSection & (1 << 6)) and not (closedSection & (1 << 5)):\n sections[1].append(self.canvas.create_line(\n left + self.pentPadding,\n top + adjustValue,\n right - adjustValue,\n 1 + bottom\n ))\n if (closedSection & (1 << 3)) and not (closedSection & (1 << 5)):\n sections[1].append(self.canvas.create_line(\n left,\n top + adjustValue,\n 1 + right - adjustValue,\n bottom - self.pentPadding\n ))\n if (closedSection & (1 << 3)) and not (closedSection & (1 << 0)):\n sections[1].append(self.canvas.create_line(\n left,\n top + self.pentPadding,\n 1 + right - adjustValue,\n bottom - adjustValue\n ))\n return sections","def section(self):\n return SECTION_NAME_TO_SECTION[self.section_name]","def getNewIntersections(self):\n sections = []\n sections2D = []\n xs = np.array(self.XYProjections)[:,0]\n L = xs[-1] - xs[0]\n xis = xs / L\n R = self.XYZCoordinate.T\n if len(xis) != len(self.SkeletonPoints):\n raise Exception(\"Conflit between xis and SkeletonPoints.\", self.SKeletonPoints)\n for i in range(len(xis)):\n xi = xis[i]\n normalVec = self.returnTangentVectorAtXi(xi)\n originPoint = self.SkeletonPoints[i]\n \n # define transform manually\n T = np.zeros((4,4))\n T[:3,:3] = R[:,np.array([1,2,0])]; # 3rd axis is reduced by projection\n T[:3,3] = originPoint; \n T[3,3] = 1.0\n to_2D = (np.linalg.inv(T)).astype(float)\n \n try:\n slice = self.mesh.section(plane_origin=originPoint, plane_normal=normalVec)\n # 选取每个截面图中面积最大的子图，实现初步去噪\n if slice is not None:\n slice_2D, to_3D = slice.to_planar(to_2D=to_2D,check=False)\n slices_splited = slice_2D.split()\n sliceIndex = np.argmax([s.area for s in slices_splited])\n slice_2D = slices_splited[sliceIndex]\n if True: #slice_2D.area > 1e-1:\n sections2D.append(slice_2D)\n sections.append(slice_2D.to_3D(to_3D))\n except:\n pass\n \n self.Intersections2D = sections2D\n self.Intersections = sections","def test_sections_flat_spider(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n section1 = create_section(title=\"Background and context\",\n story=story,\n root=True)\n section2 = create_section(title=\"Decisions to be made\", story=story)\n section3 = create_section(title=\"Who has been involved\", \n story=story)\n section4 = create_section(title=\"Next steps\", story=story)\n SectionRelation.objects.create(parent=section1, child=section2,\n weight=0)\n SectionRelation.objects.create(parent=section1, child=section3,\n weight=1)\n SectionRelation.objects.create(parent=section1, child=section4,\n weight=2)\n self.assertEqual(story.structure.sections_flat, [section1, section2,\n section3, section4])","def test_sections_flat_spider(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(title=\"Background and context\",\n story=story,\n layout=layout,\n root=True)\n section2 = create_section(title=\"Decisions to be made\", story=story, layout=layout)\n section3 = create_section(title=\"Who has been involved\", \n story=story, layout=layout)\n section4 = create_section(title=\"Next steps\", story=story, layout=layout)\n SectionRelation.objects.create(parent=section1, child=section2,\n weight=0)\n SectionRelation.objects.create(parent=section1, child=section3,\n weight=1)\n SectionRelation.objects.create(parent=section1, child=section4,\n weight=2)\n self.assertEqual(story.structure.sections_flat, [section1, section2,\n section3, section4])","def getSect(self, h):\n coordtrasp=self.coord.T\n lefttomin=self.coord[1][:self.min+1]\n # left point\n lpnt = self.firstPointAfter_h(lefttomin[::-1], h)\n # find index of left point\n l_pnt = self.min - lpnt\n # find left intersection\n l_intersect = self.intersection(coordtrasp[l_pnt], coordtrasp[l_pnt+1], h)\n # right point\n rpnt = self.firstPointAfter_h(self.coord[1][self.min:], h)\n # find index of right point\n r_pnt = self.min + rpnt\n # find right intersection\n r_intersect = self.intersection(coordtrasp[r_pnt], coordtrasp[r_pnt-1], h)\n # make new section geometries\n sez = coordtrasp[l_pnt+1:r_pnt]\n # Add left intersection on the top\n sez=np.insert(sez, [0,], l_intersect,axis=0)\n # Add rightht intersection on the bottom\n sez=np.append(sez,[r_intersect],axis=0)\n return sez","def computeBoundingShape(scene, shape='ellipsoid'):\r\n \r\n gr= pgl.Group([ sh.geometry for sh in scene ])\r\n tglset = pgl.fit( shape, gr )\r\n #hull = pgl.Shape( tglSet, __Green )\r\n return tglset","def get_shape_type(self):\n import GEOM\n sgeom = self.get_sgeom()\n shape_type = sgeom.GetShapeType()\n if shape_type is GEOM.COMPOUND:\n node = self.node\n geom_eng = node.get_sobj().GetFatherComponent().GetObject()\n ops = geom_eng.GetIGroupOperations(node.get_std()._get_StudyId())\n sidx = ops.GetType(sgeom)\n shape_type = self._compound_types.get(sidx, shape_type)\n return shape_type","def circlePrimitive(self):\n\n def drawWireframe(self):\n\n # Draw line\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\n\n # Get Color\n # self.getColor(\"edge\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n \n def drawShaded(self):\n\n # Draw quad\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\n\n # Get Color\n # self.getColor(\"polygon\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\n\n # Draw lines\n if self.draw_type == 0 or self.draw_type == 2:\n drawWireframe(self)\n \n # Draww Polygons\n if self.draw_type == 1 or self.draw_type == 2:\n drawShaded(self)\n\n glFT.glEndList()","def get_section(self, sy: int) -> numpy.ndarray:\n if sy not in self._sections:\n self.create_section(sy)\n return self._sections[sy]","def sections(self):\n raise NotImplementedError()","def test_sections_flat_tree(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n section1 = create_section(title=\"Background and context\",\n story=story,\n root=True)\n section2 = create_section(title=\"Decisions to be made\", story=story)\n section3 = create_section(title=\"Who has been involved\", \n story=story)\n section4 = create_section(title=\"Next steps\", story=story)\n section5 = create_section(title=\"Last section\", story=story)\n SectionRelation.objects.create(parent=section1, child=section2,\n weight=0)\n SectionRelation.objects.create(parent=section2, child=section3,\n weight=0)\n SectionRelation.objects.create(parent=section2, child=section4,\n weight=1)\n SectionRelation.objects.create(parent=section1, child=section5,\n weight=1)\n self.assertEqual(story.structure.sections_flat, [section1, section2,\n section3, section4,\n section5])","def test_sections_flat_tree(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\"Side by Side\")\n section1 = create_section(title=\"Background and context\",\n story=story,\n layout=layout,\n root=True)\n section2 = create_section(title=\"Decisions to be made\", story=story, layout=layout)\n section3 = create_section(title=\"Who has been involved\", \n story=story, layout=layout)\n section4 = create_section(title=\"Next steps\", story=story, layout=layout)\n section5 = create_section(title=\"Last section\", story=story, layout=layout)\n SectionRelation.objects.create(parent=section1, child=section2,\n weight=0)\n SectionRelation.objects.create(parent=section2, child=section3,\n weight=0)\n SectionRelation.objects.create(parent=section2, child=section4,\n weight=1)\n SectionRelation.objects.create(parent=section1, child=section5,\n weight=1)\n self.assertEqual(story.structure.sections_flat, [section1, section2,\n section3, section4,\n section5])","def _create_section(self, parent, sectionid, title=None, term=None):\n\n idb = nodes.make_id(sectionid)\n section = nodes.section(ids=[idb])\n parent.append(section)\n\n if term:\n if term != '**':\n section.append(nodes.term('', term))\n\n definition = nodes.definition()\n section.append(definition)\n\n return definition\n\n if title:\n section.append(nodes.title('', title))\n\n return section","def sections(self):\n raise NotImplementedError()","def computePointSectionArea(self,wingIndex,segmentIndex,eta,xsi):\n # tigl.wingGetUpperPoint(wingIndex, segmentIndex, eta -> y, xsi->x)\n # WARNING there is a slight difference in the area computed with this\n # method ans CPACSCREATOR. At the moment it is undetermined who is more\n # accurate.\n N = 20\n xsi1 = np.linspace(0,1,N)\n upper = np.empty((N,3))\n lower = np.empty((N,3))\n\n\n # t = np.max(np.abs(upper[:][2] - lower[:][2]))\n \n for i in range(N):\n U = self.tigl.wingGetUpperPoint(wingIndex,segmentIndex,eta,xsi1[i])\n L = self.tigl.wingGetLowerPoint(wingIndex,segmentIndex,eta,xsi1[i])\n upper[i] = np.array(U)\n lower[i] = np.array(L)\n v1 = upper[0]-upper[-1]\n v2 = upper[7] - lower[7]\n c = np.abs(upper[0][0] - upper[-1][0])\n t = np.max(np.abs(upper[:][2] - lower[:][2]))\n print(c)\n area = c*0.1*t\n # sys.exit()\n # v1xv2 = np.cross(v1,v2)\n # upper = np.flip(upper,axis=0)\n # wingSectionPoints = np.concatenate((upper, lower))\n # ey_0 = np.array([0,1,0])\n # e_1 = v1xv2\n # # Computes the cross prodct\n # cross = np.cross(ey_0,e_1)\n # normCross = np.linalg.norm(cross)\n # cross = cross/normCross\n # if normCross < 1e-8:\n # # No need to rotate\n # wingSectionPoints = np.delete(wingSectionPoints,1,1)\n # hull = ConvexHull(wingSectionPoints)\n # area = hull.volume\n # else:\n # ab = inner1d(ey_0,e_1)\n # a = np.linalg.norm(ey_0)\n # b = np.linalg.norm(e_1)\n # angle = np.arccos(ab / (a*b))\n # logger.debug(\"angle: \"+str(angle))\n # quat = angle*cross\n # r = R.from_rotvec(quat)\n # # Deletes the y column since the Convex hull will struggle with\n # # a 3d plane otherwise\n # wingSectionPoints = r.apply(wingSectionPoints)\n # wingSectionPoints = np.delete(wingSectionPoints,1,1)\n # hull = ConvexHull(wingSectionPoints)\n # # WARNING since we have built a 2D surface, the function is set up\n # # in a way that this is correct!\n # area = hull.volume\n\n logger.debug(\"Computed section area: \"+str(area))\n\n return area","def get_g_sect(self):\n return self.translation['g_sect']","def csm_shape(csm):\r\n return csm_properties(csm)[3]","def shape(self) -> Shape:\n raise NotImplementedError()","def topods_solid(self):\n return self.topods_shape()","def shape_type(self):\n return \"circle\"","def subdivision(mesh):\n\t\n\t\n\t# 1. generate new nodes in the centre of quad\n\t# 1/4 o-------o 1/4 o: existing vertices\n\t# | | *: newly-generated vertices\n\t# | * |\n\t# | |\n\t# 1/4 o-------o 1/4\n\n\tnew_coor = mesh.give_nodes().give_coor()\n\t\n\tfor face_index in range(mesh.give_model_inf()[2]): \n\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\tfor vertex_index in range(4):\n\t\t\tmesh.give_faces()\n\t\t\tnode_index = mesh.give_faces().give_node_list(face_index)[vertex_index]\n\n\t\t\tnew_x += 0.25*mesh.give_nodes().give_coor(node_index)[0]\n\t\t\tnew_y += 0.25*mesh.give_nodes().give_coor(node_index)[1]\n\t\t\tnew_z += 0.25*mesh.give_nodes().give_coor(node_index)[2]\n\t\t\t\n\t\tnew_coor.append((new_x, new_y, new_z))\n\t\t\n\t# generating new nodes on the edge\n\t# figure out one edge is shared by how many surfaces\n\tedge_shared_by_faces_list = helper.find_edge_shared_by_which_faces(mesh.give_edges(), mesh.give_faces())\n\t\n\tfor edge_index in range(mesh.give_model_inf()[1]):\n\n\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\n\t# 2. generate new node on boundary edge\n\t# o: existing vertices\n\t# 1/2 o---*---o 1/2 *: newly-generated vertices\n\t# \n\n\t\tnew_coor = mesh.give_nodes().give_coor()\n\t\tif len(edge_shared_by_faces_list[edge_index]) == 1:\t\n\t\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\tfor vertex_index in range(2):\n\t\t\t\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\n\t\t\t\tnew_x += 0.5*mesh.give_nodes().give_coor()[this_node][0]\n\t\t\t\tnew_y += 0.5*mesh.give_nodes().give_coor()[this_node][1]\n\t\t\t\tnew_z += 0.5*mesh.give_nodes().give_coor()[this_node][2]\n\t\t\t\t\n\t\t\tnew_coor.append((new_x, new_y, new_z))\n\t\t\t\t\n\t# 3. generate new node on interior edge\n\t# 1/16 o-------o 1/16 o: existing vertices\n\t# | | *: newly-generated vertices\n\t# 3/8 o---*---o 3/8\n\t# | |\n\t# 1/16 o-------o 1/16\n\n\t\telse:\n\t\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\tconsidered_node = []\n\t\t\tfor vertex_index in range(2):\n\t\t\t\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\n\t\t\t\tconsidered_node.append(this_node)\n\t\t\t\tnew_x += 3./8.*mesh.give_nodes().give_coor()[this_node][0]\n\t\t\t\tnew_y += 3./8.*mesh.give_nodes().give_coor()[this_node][1]\n\t\t\t\tnew_z += 3./8.*mesh.give_nodes().give_coor()[this_node][2]\n\t\t\t\n\t\t\t# faces contain this node\n\t\t\tpotential_node = []\n\t\t\tfor face_index in edge_shared_by_faces_list[edge_index]:\t\t\n\t\t\t\tfor vertex_index in range(4):\n\t\t\t\t\t\tpotential_node.append(mesh.give_faces().give_node_list(face_index)[vertex_index])\n\t\t\t\n\t\t\touter_node = []\n\t\t\tfor node in potential_node:\n\t\t\t\tif (node not in considered_node) & (node not in outer_node):\n\t\t\t\t\touter_node.append(node)\n\t\t\t\t\t\n\t\t\tfor vertex_index in outer_node:\n\t\t\t\tnew_x += 1./16.*mesh.give_nodes().give_coor()[vertex_index][0]\n\t\t\t\tnew_y += 1./16.*mesh.give_nodes().give_coor()[vertex_index][1]\n\t\t\t\tnew_z += 1./16.*mesh.give_nodes().give_coor()[vertex_index][2]\n\t\t\t\n\t\t\tnew_coor.append((new_x, new_y, new_z))\n\n\t# update the links of edges and surfaces\n\tnew_edge_list = []\n\tnew_face_list = []\n\tfor face_index in range(mesh.give_model_inf()[2]):\n\t\told_node0 = mesh.give_faces().give_node_list(face_index)[0]\n\t\told_node1 = mesh.give_faces().give_node_list(face_index)[1]\n\t\told_node2 = mesh.give_faces().give_node_list(face_index)[2]\n\t\told_node3 = mesh.give_faces().give_node_list(face_index)[3]\n\t\t\n\t\told_edge0 = mesh.give_faces().give_edge_list(face_index)[0]\n\t\told_edge1 = mesh.give_faces().give_edge_list(face_index)[1]\n\t\told_edge2 = mesh.give_faces().give_edge_list(face_index)[2]\n\t\told_edge3 = mesh.give_faces().give_edge_list(face_index)[3]\n\t\t\n\t\tnew_node4 = old_edge0 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2] \n\t\tnew_node5 = old_edge1 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\n\t\tnew_node6 = old_edge2 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\n\t\tnew_node7 = old_edge3 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\t\n\t\tnew_node8 = mesh.give_model_inf()[0] + face_index\n\t\t\n\t\tif helper.in_list((old_node0, new_node4), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node0, new_node4))\n\t\tif helper.in_list((new_node4, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node4, new_node8))\n\t\tif helper.in_list((new_node8, new_node7), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node8, new_node7))\n\t\tif helper.in_list((new_node7, old_node0), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node7, old_node0))\n\t\tif helper.in_list((new_node4, old_node1), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node4, old_node1))\n\t\tif helper.in_list((old_node1, new_node5), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node1, new_node5))\n\t\tif helper.in_list((new_node5, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node5, new_node8))\n\t\tif helper.in_list((new_node7, old_node3), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node7, old_node3))\n\t\tif helper.in_list((old_node3, new_node6), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node3, new_node6))\n\t\tif helper.in_list((new_node6, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node6, new_node8))\n\t\tif helper.in_list((new_node6, old_node2), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node6, old_node2))\n\t\tif helper.in_list((old_node2, new_node5), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node2, new_node5))\n\t\n\t\tnew_face_list.append((old_node0, new_node4, new_node8, new_node7))\n\t\tnew_face_list.append((new_node4, old_node1, new_node5, new_node8))\n\t\tnew_face_list.append((new_node7, new_node8, new_node6, old_node3))\n\t\tnew_face_list.append((new_node8, new_node5, old_node2, new_node6))\n\t\t\n\tnew_edges = geo.Edge(new_edge_list)\n\t\n\tnew_faces = geo.Face(new_face_list, new_edges)\n\t\t\n\t# update existing nodes\t\n\tfor node_index in range(mesh.give_model_inf()[0]):\n\t\t\n\t\tring1, ring2 = helper.find_neighbour_node(new_edges, new_faces, node_index)\n\t\tvalence = helper.find_valence(node_index, new_faces) \n\t\t#: valence: the number of faces sharing on specific edge\n\n\t# 4. update existing corner vertex\n\t# 2/4 @---* 1/4 *: newly-generated vertices\n\t# | | @: existing vertices to be updated\n\t# 1/4 *---* 0 The higher mask values on neighbouring vertices, \n\t# the more likely a square mesh will be refined into a sphere.\n\t \n\t\tif valence == 1:\n\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tprint\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tnew_x += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\tnew_y += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\tnew_z += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\n\t\t\tfor node_in_ring2 in ring2:\n\t\t\t\tnew_x += 0.*mesh.give_nodes().give_coor()[node_in_ring2][0]\n\t\t\t\tnew_y += 0.*mesh.give_nodes().give_coor()[node_in_ring2][1]\n\t\t\t\tnew_z += 0.*mesh.give_nodes().give_coor()[node_in_ring2][2]\n\t\t\t\t\n\t\t\tnew_x += 2./4.*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += 2./4.*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += 2./4.*mesh.give_nodes().give_coor()[node_index][2]\n\n\t# 5. update existing boundary joint vertex\n\t# 3/4\n\t# 1/8 *---*---* 1/8 *: newly-generated vertices\n\t# | | | @: existing vertices to be updated\n\t# 0 *---*---* 0\n\n\t\telif valence == 2:\n\t\t\t\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tif helper.find_valence(node_in_ring1, new_faces) <= 2: \n\t\t\t\t\tnew_x += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\t\tnew_y += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\t\tnew_z += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\t\t\t\t\t\n\t\t\tnew_x += 3./4.*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += 3./4.*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += 3./4.*mesh.give_nodes().give_coor()[node_index][2]\n\t\n\t# 6. update new node on interior edge\n\t# * r/k\n\t# /\\ b/k*\n\t# *__/ \\___ r/k\n\t# \\ \\ /¬¬/ *: newly-generated vertices: \n\t# \\ \\/ / b = 3/2/valence, r = 1/4/valence\n\t# *--@--* b/k\t @: existing vertices to be updated: 1-b-r\t\t\n\t# / /\\ \\\n\t# /__/ \\__\\\n\t# * \\ / * r/k\n\t# \\/\n\t\t\n\t\telse:\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tbeta = 3./2./valence\n\t\t\tgamma = 1./4./valence\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tnew_x += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\tnew_y += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\tnew_z += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\t\t\t\n\t\t\tfor node_in_ring2 in ring2:\n\t\t\t\tnew_x += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][0]\n\t\t\t\tnew_y += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][1]\n\t\t\t\tnew_z += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][2]\n\t\t\t\n\t\t\tnew_x += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][2]\n\t\t\n\t\tnew_coor[node_index] = (new_x, new_y, new_z)\n\t\n\tnew_nodes = geo.Node(new_coor)\n\t\n\tmesh.update(new_nodes, new_edges, new_faces)\n\t\n\t# return new_mesh\n\treturn mesh","def defineCircleLayout(self):\n # Define a 2-D array representing the position of each mesh point\n self.xPoints = self.frange(0,self.R,self.h)\n self.yPoints = self.frange(0,self.R,self.h)\n\n # Position of internal mesh points\n internal_xyCoord = [(i,j) for i in self.xPoints for j in self.yPoints if (i - self.R)**2 + (j - self.R)**2 < self.R^2] \n\n # Define the dictionary containing internal points\n for k in internal_xyCoord:\n x = k[0]\n y = k[1]\n xLabel = xPoints.index(x)\n yLabel = yPoints.index(y)\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n\n # Position of the boundary points\n # Find the intersection of each mesh line with the circle\n # For a given vertical mesh line: \n # y = R - sqrt(R^2 - (x-R)^2) & y = R + sqrt(R^2 - (x-R)^2)\n # For a given horizontal mesh line: \n # x = R - sqrt(R^2 - (y-R)^2) & x = R + sqrt(R^2 - (y-R)^2)\n boundary_xyCoord = [(0,self.R),(self.R,0),(self.R,2*self.R),(2*self.R,self.R)] + [(x,self.R - math.sqrt(self.R**2 - (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(x,self.R - math.sqrt(self.R**2 + (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(self.R - math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] + [(self.R + math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] \n\n # Define the dictionary containing boundary points\n for k in boundary_xyCoord:\n x = k[0]\n y = k[1]\n [xLabel,yLabel] = self.findLabel(x,y)\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \n \n # Now that we have assigned the labels we can define fE, fW, fN and fS\n self.fCalc()","def sketch_und_part(self):\n if (self.dimension == '3D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseSolidExtrude(\n sketch=self.sketch_Wuerfel,\n depth=self.laenge_z/2.0) #z-Symmetrie\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Ellipsoid' ):\n matlab.ellipsoidIgesOut(\n self.porenparameter_x,\n self.porenparameter_y,\n self.porenparameter_z,\n 'Ellipsoid')\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.sketch_Pore.ConstructionLine(\n # point1=(0.0, -100.0),\n # point2=(0.0, 100.0))\n # self.sketch_Pore.EllipseByCenterPerimeter(\n # center=(0.0, 0.0),\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\n # self.sketch_Pore.autoTrimCurve(\n # curve1=self.sketch_Pore.geometry[3],\n # point1=(-self.porenparameter_x/2.0, 0.0))\n # self.sketch_Pore.Line(\n # point1=(0.0, self.porenparameter_y/2.0),\n # point2=(0.0, -self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n if (self.typ_Pore == 'Ellipsoid' ):\n # if (self.porenparameter_x == self.porenparameter_z):\n # self.part_Pore.BaseSolidRevolve(\n # sketch=self.sketch_Pore,\n # angle=360.0,\n # flipRevolveDirection=OFF)\n self.iges_Datei = mdb.openIges(\n 'Ellipsoid.igs',\n msbo=False,\n trimCurve=DEFAULT,\n scaleFromFile=OFF)\n self.model.PartFromGeometryFile(\n name=self.name+'_Pore',\n geometryFile=self.iges_Datei,\n combine=False,\n stitchTolerance=1.0,\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY,\n convertToAnalytical=1,\n stitchEdges=1,\n scale=1) # Skalierung\n self.part_Pore = self.model.parts[self.name+'_Pore']\n self.part_Pore.AddCells(\n faceList = self.part_Pore.faces,\n flipped=False)\n del self.iges_Datei\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\n os.remove('temp-Ellipsoid-new.sat')\n os.remove('Ellipsoid.igs')\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=THREE_D,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseSolidExtrude(\n sketch=self.sketch_Pore,\n depth=self.porenparameter_z)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n #Translation\n self.assembly.translate(\n instanceList=(self.name+'_Wuerfel', ),\n vector=(0.0, 0.0, -self.laenge_z/2.0))\n if (self.typ_Pore == 'Ellipsoid'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, 0.0))\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\n self.assembly.translate(\n instanceList=(self.name+'_Pore', ),\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\n #Rotation\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(1.0, 0.0, 0.0),\n angle=self.porenparameter_rx)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 1.0, 0.0),\n angle=self.porenparameter_ry)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, 0.0),\n axisDirection=(0.0, 0.0,1.0),\n angle=self.porenparameter_rz)\n #Schneiden\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n # del self.model.parts[self.name+'_Wuerfel']\n # del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n elif (self.dimension == '2D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point1=(0.0, 0.0),\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\n #Part Wuerfel generieren\n self.part_Wuerfel = self.model.Part(\n name=self.name+'_Wuerfel',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\n #Sketch Pore zeichnen\n self.sketch_Pore = self.model.ConstrainedSketch(\n name='Seitenansicht_Pore',\n sheetSize=200.0)\n if (self.typ_Pore == 'Ellipsoid'):\n self.sketch_Pore.ConstructionLine(\n point1=(0.0, -100.0),\n point2=(0.0, 100.0))\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n self.sketch_Pore.autoTrimCurve(\n curve1=self.sketch_Pore.geometry[3],\n point1=(-self.porenparameter_x/2.0, 0.0))\n self.sketch_Pore.Line(\n point1=(0.0, self.porenparameter_y/2.0),\n point2=(0.0, -self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Quader'):\n self.sketch_Pore.rectangle(\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\n elif (self.typ_Pore == 'Zylinder'):\n self.sketch_Pore.EllipseByCenterPerimeter(\n center=(0.0, 0.0),\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\n axisPoint2=(0.0, self.porenparameter_y/2.0))\n else:\n print('typ_Pore Error!')\n #Part Pore generieren\n self.part_Pore = self.model.Part(\n name=self.name+'_Pore',\n dimensionality=TWO_D_PLANAR,\n type=DEFORMABLE_BODY)\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\n #Assemble\n self.assembly = self.model.rootAssembly\n self.assembly.DatumCsysByDefault(CARTESIAN)\n self.assembly.Instance(\n name=self.name+'_Wuerfel',\n part=self.part_Wuerfel,\n dependent=ON)\n self.assembly.Instance(\n name=self.name+'_Pore',\n part=self.part_Pore,\n dependent=ON)\n self.assembly.rotate(\n instanceList=(self.name+'_Pore', ),\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\n angle=self.porenparameter_rz)\n self.assembly.InstanceFromBooleanCut(\n name='RVE',\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\n originalInstances=SUPPRESS)\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\n del self.model.parts[self.name+'_Wuerfel']\n #del self.model.parts[self.name+'_Pore']\n self.part_RVE = self.model.parts[self.name]\n else:\n print('dimension Error!')","def fill_paths_section():\n section = _SectionData(\"Paths\")\n section.props.append((\"ProjectPath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.scs_project_path)))\n section.props.append((\"\", \"\"))\n section.props.append((\"ShaderPresetsFilePath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.shader_presets_filepath)))\n section.props.append((\"TriggerActionsRelFilePath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_rel_path)))\n section.props.append((\"TriggerActionsUseInfixed\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_use_infixed))))\n section.props.append((\"SignRelFilePath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_rel_path)))\n section.props.append((\"SignUseInfixed\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_use_infixed))))\n section.props.append((\"TSemProfileRelFilePath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_rel_path)))\n section.props.append((\"TSemProfileUseInfixed\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_use_infixed))))\n section.props.append((\"TrafficRulesRelFilePath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_rel_path)))\n section.props.append((\"TrafficRulesUseInfixed\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_use_infixed))))\n section.props.append((\"HookupRelDirPath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.hookup_library_rel_path)))\n section.props.append((\"MatSubsRelFilePath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.matsubs_library_rel_path)))\n section.props.append((\"ConvertersPath\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.conv_hlpr_converters_path)))\n section.props.append((\"UseAlternativeBases\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.use_alternative_bases))))\n return section","def defineBLOCKSECTION(f,layernamelist):\r\n feilinname_lineheight=2.5\r\n #note_lineheigh=4\r\n layercount=0\r\n feilin_name_pos=[70.0+globalconfig.CUTLINE_X_OFFSET,185.0+globalconfig.CUTLINE_Y_OFFSET]\r\n #note_pos=[190.0+globalconfig.CUTLINE_X_OFFSET,80.0+globalconfig.CUTLINE_Y_OFFSET]\r\n f.write(\"0\\nSECTION\\n2\\nBLOCKS\\n\") #绘制块定义\r\n f.write(\"0\\nBLOCK\\n8\\n0\\n2\\nROUND_1\\n70\\n0\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n\")\r\n f.write(\"0\\nPOLYLINE\\n8\\n0\\n5\\n3F\\n66\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n70\\n1\\n\")\r\n f.write(\"40\\n0.04\\n41\\n0.04\")\r\n f.write(\"\\n0\\nVERTEX\\n5\\n406\\n8\\n0\\n10\\n-0.02\\n20\\n0.0\\n30\\n0.0\\n42\\n1.0\")\r\n f.write(\"\\n0\\nVERTEX\\n5\\n407\\n8\\n0\\n10\\n0.02\\n20\\n0.0\\n30\\n0.0\\n42\\n1.0\\n0\\nSEQEND\\n5\\n408\\n8\\n0\\n\")\r\n f.write(\"0\\nENDBLK\\n5\\n43\\n8\\n0\\n\") \r\n \r\n for layername in layernamelist:\r\n layercount=layercount+1\r\n f.write(\"0\\nBLOCK\\n8\\n0\\n2\\n*U\"+str(layercount)+\"\\n\") \r\n f.write(\"70\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n\") \r\n f.write(\"0\\nTEXT\\n5\\n46\\n8\\n\"+layername+\"\\n6\\nCONTINUOUS\\n10\\n\"+str(feilin_name_pos[0])+\"\\n20\\n\"+str(feilin_name_pos[1])+\"\\n30\\n0.0\\n\")\r\n f.write(\"40\\n\"+str(feilinname_lineheight)+\"\\n1\\n\"+globalconfig.NAME_OF_FEILIN+\"-\"+layername+\"\\n0\\nENDBLK\\n5\\n47\\n8\\n\"+layername+\"\\n\")\r\n \r\n# layercount=layercount+1\r\n# f.write(\"0\\nBLOCK\\n8\\n0\\n2\\n*U\"+str(layercount)+\"\\n\") \r\n# f.write(\"70\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n\") \r\n# f.write(\"0\\nTEXT\\n5\\n46\\n8\\n\"+layername+\"\\n6\\nCONTINUOUS\\n10\\n\"+str(note_pos[0])+\"\\n20\\n\"+str(note_pos[1])+\"\\n30\\n0.0\\n\")\r\n# f.write(\"40\\n\"+str(note_lineheigh)+\"\\n1\\n\")\r\n# f.write(\"\")\r\n# f.write(\"\\n0\\nENDBLK\\n5\\n47\\n8\\n0\\n\") \r\n \r\n f.write(\"0\\nENDSEC\\n\")","def find_section(amdpar_xml):\n siblings = [s for s in amdpar_xml.itersiblings()]\n\n if len(siblings) == 0:\n return find_lost_section(amdpar_xml)\n\n for sibling in siblings:\n if sibling.tag == 'SECTION':\n return sibling\n\n paragraphs = [s for s in siblings if s.tag == 'P']\n if len(paragraphs) > 0:\n return fix_section_node(paragraphs, amdpar_xml)","def fix_section_node(paragraphs, amdpar_xml):\n\n sections = [s for s in amdpar_xml.itersiblings(preceding=True)\n if s.tag == 'SECTION']\n\n # Let's only do this if we find one section tag.\n if len(sections) == 1:\n section = deepcopy(sections[0])\n for paragraph in paragraphs:\n section.append(deepcopy(paragraph))\n return section","def __getGeometryComponents(self):\n # get dagPath and member components of skined shape\n # the deformerSet pretty controls which vertex is deformed by the skinCluster\n # the deformerSet will allows us to pull out that components(vertex) mobject that we need\n fnSet = openmaya.MFnSet(self.fn.deformerSet())\n members = openmaya.MSelectionList()\n # the MSelectionList contains the vertex information in the deformerSet above\n fnSet.getMembers(members, False)\n\n dagPath = openmaya.MDagPath()\n components = openmaya.MObject()\n\n # dagPath: dagPath of influence objects(joint)\n # components: mesh components(vertex)\n members.getDagPath(0, dagPath, components)\n\n return dagPath, components","def calib2sections(dirname):\n\n if os.path.isfile(dirname):\n return v2calib2sections(dirname)\n\n # Get centres of the sections, and apply corrections.\n s_cen = calib2tensor3(dirname, \"center\") \\\n + calib2tensor3(dirname, \"center_corr\")\n\n # Get the rotation of sections, and apply corrections. Note that\n # sections 0, 1 and 4, 5 are antiparallel!\n s_rot = calib2tensor3(dirname, \"rotation\") \\\n + calib2tensor3(dirname, \"tilt\")\n\n # Get the margin, gap, and shift adjustments of the sections within\n # each quadrant.\n s_mgs = calib2tensor3(dirname, \"marg_gap_shift\")\n\n # Get offsets of the quadrants, and apply corrections.\n q_off = calib2tensor3(dirname, \"offset\") \\\n + calib2tensor3(dirname, \"offset_corr\")\n\n # Get rotation of the quadrants, and apply corrections.\n q_rot = calib2tensor3(dirname, \"quad_rotation\") \\\n + calib2tensor3(dirname, \"quad_tilt\")\n\n # The third coordinate is ignored for now, even though optical\n # measurement gives a variation in Z up to 0.6 mm.\n sections = []\n for q in range(s_cen.shape[0]):\n sections.append([])\n for s in range(s_cen.shape[1]):\n sec = Section()\n sec.translate((s_mgs[0, 0] + s_cen[q, s, 0],\n s_mgs[1, 0] + s_cen[q, s, 1]))\n sec.srotate(s_rot[q, s])\n sec.qrotate(q_rot[q])\n sec.translate((s_mgs[0, 1] + q_off[0, q],\n s_mgs[1, 1] + q_off[1, q]))\n\n # XXX I still don't understand this bit!\n if (q == 0):\n sec.translate((-s_mgs[0, 2] + s_mgs[0, 3],\n -s_mgs[1, 2] - s_mgs[1, 3]))\n elif (q == 1):\n sec.translate((-s_mgs[0, 2] - s_mgs[0, 3],\n +s_mgs[1, 2] - s_mgs[1, 3]))\n elif (q == 2):\n sec.translate((+s_mgs[0, 2] - s_mgs[0, 3],\n +s_mgs[1, 2] + s_mgs[1, 3]))\n elif (q == 3):\n sec.translate((+s_mgs[0, 2] + s_mgs[0, 3],\n -s_mgs[1, 2] + s_mgs[1, 3]))\n\n sections[q].append(sec)\n return (sections)","def getShape(transform):\n\n pass","def get_section(self, section_name: str) -> NetSection:\n return self.sections[section_name]","def create_partition(mesh,polygons,enforce_exact=False):","def squarePrimitive(self):\n\n def drawWireframe(self):\n\n # Draw line\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\n\n # Get Color\n # self.getColor(\"edge\")\n\n for edges in SQUARE[\"EDGES\"]:\n for edge in edges:\n\n point = OpenMaya.MVector(edge[0], edge[1], edge[2])\n point *= self.shape_size\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n \n \n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n\n def drawShaded(self):\n\n # Draw quad\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\n\n # Get Color\n # self.getColor(\"polygon\")\n\n for polygons in SQUARE[\"POLYGONS\"]:\n for polygon in polygons:\n\n point = OpenMaya.MVector(polygon[0], polygon[1], polygon[2])\n point *= self.shape_size\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\n\n # Draw lines\n if self.draw_type == 0 or self.draw_type == 2:\n drawWireframe(self)\n \n # Draww Polygons\n if self.draw_type == 1 or self.draw_type == 2:\n drawShaded(self)\n\n glFT.glEndList()","def draw_shape(self, image, shape, p, color):\n # Get the center x, y and the size s\n p = p['shape_attributes']\n if shape == 'rect':\n image = cv2.rectangle(\n image, (p['x'], p['y']), (p['x'] + p['width'], p['y'] + p['height']), color, -1)\n elif shape == \"circle\":\n #image = cv2.circle(image, (p['cx'], p['cy']), np.int(p['r']), color, -1)\n image = cv2.rectangle(image, (p['cx']-np.int32(p['r']/2.0), p['cy']-np.int32(\n p['r']/2.0)), (p['cx'] + np.int32(p['r']), p['cy'] + np.int32(p['r'])), color, -1)\n elif shape == \"point\":\n #image = cv2.circle(image, (p['cx'], p['cy']), 15, color, -1)\n image = cv2.rectangle(\n image, (p['cx']-8, p['cy']-8), (p['cx']+16, p['cy']+16), color, -1)\n elif shape == \"polygon\":\n pts = np.zeros((len(p['all_points_x']), 2), np.int32)\n for i in range(len(p['all_points_x'])):\n pts[i] = [p['all_points_x'][i], p['all_points_y'][i]]\n if (self.config.MODE == \"Combined\"):\n pts = pts.reshape((-1, 1, 2))\n elif (self.config.MODE == \"Separate\"):\n pts = pts.reshape((1, -1, 2))\n image = cv2.fillPoly(image, pts, color, lineType=cv2.LINE_AA)\n\n return image","def test_sections_flat_no_sections(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n self.assertEqual(story.structure.sections_flat, [])","def test_sections_flat_no_sections(self):\n title = (\"Neighborhood Outreach for I-70 Alignment Impacting \"\n \"Elyria, Globeville and Swansea\")\n summary = \"\"\"\n The City of Denver and Colorado Department of Transportation \n (CDOT) are working together to do neighborhood outreach\n regarding the I-70 alignment between Brighton Boulevard and\n Colorado. For detailed information on the neighborhood outreach\n efforts please visit www.DenverGov.org/ccdI70.\n \"\"\"\n byline = \"Denver Public Works and CDOT\"\n story = create_story(title=title, summary=summary, byline=byline)\n self.assertEqual(story.structure.sections_flat, [])","def shape(self):\n return self._shape","def _fix_section(self, section):\n section_copy = copy.deepcopy(section)\n\n # Formulate characteristics based on name if they weren't provided.\n if not section_copy.Characteristics:\n _characteristics = [construct.IMAGE_SCN_MEM_READ]\n if section_copy.Name == u'.text':\n _characteristics += [construct.IMAGE_SCN_CNT_CODE, construct.IMAGE_SCN_MEM_EXECUTE]\n else:\n _characteristics += [construct.IMAGE_SCN_CNT_INITIALIZED_DATA]\n if section_copy.Name == u'.data':\n _characteristics += [construct.IMAGE_SCN_MEM_WRITE]\n if section_copy.Name == u'.reloc':\n _characteristics += [construct.IMAGE_SCN_MEM_DISCARDABLE]\n section_copy.Characteristics = _characteristics\n\n # FlagEnums must be a dictionary.\n if isinstance(section_copy.Characteristics, list):\n section_copy.Characteristics = {flag: True for flag in section_copy.Characteristics}\n\n # Fix up data to be consistent.\n data_size = max(section_copy.SizeOfRawData, len(section_copy.data))\n section_copy.SizeOfRawData = data_size\n section_copy.data = section_copy.data.ljust(data_size, b'\\x00')[:data_size]\n\n return section_copy","def plate_sections(self):\n return avl.SectionFromCurve(quantify=len(self.sections),\n curve_in=self.sections[child.index].curve)","def _getshapepoly(self, polygon, compound=False):\n if self._resizemode == \"user\" or compound:\n t11, t12, t21, t22 = self._shapetrafo\n elif self._resizemode == \"auto\":\n l = max(1, self._pensize/5.0)\n t11, t12, t21, t22 = l, 0, 0, l\n elif self._resizemode == \"noresize\":\n return polygon\n return tuple((t11*x + t12*y, t21*x + t22*y) for (x, y) in polygon)","def htmlFoldingSection(header, content, isClosed=True,\n headerClass='section-header',\n contentClass='section-content'):\n if isClosed:\n s = '<div class=\"section-closed\" onclick=\"toggleSection(this);\">'\n else:\n s = '<div class=\"section-open\" onclick=\"toggleSection(this);\">'\n s += '<span class=\"%s\">%s</span></div>\\n' % (headerClass,header)\n h = ' hidden' if isClosed else ''\n s += '<div class=\"%s%s\">\\n%s</div>\\n' % (contentClass,h,content)\n return s","def processed_shape(self, shape):\n return shape","def scenarioReference_factory(i, section_type, root, this):\n \n # no loops in section, should print 0\n if i == 0:\n return ScenarioReference()\n \n if section_type == SectionType.Plant:\n name = root.plants.nameof(i)\n scen = ScenarioReference(SectionType.Plant, name, root, this)\n \n elif section_type == SectionType.Op:\n name = root.ops.nameof(i)\n scen = ScenarioReference(SectionType.Op, name, root, this)\n \n elif section_type == SectionType.Ini:\n name = root.inis.nameof(i)\n scen = ScenarioReference(SectionType.Ini, name, root, this)\n \n elif section_type == SectionType.Surf:\n name = root.surfs.nameof(i)\n scen = ScenarioReference(SectionType.Surf, name, root, this)\n \n elif section_type == SectionType.Contour:\n name = root.contours.nameof(i)\n scen = ScenarioReference(SectionType.Contour, name, root, this)\n \n elif section_type == SectionType.Drain:\n name = root.drains.nameof(i)\n scen = ScenarioReference(SectionType.Drain, name, root, this)\n \n elif section_type == SectionType.Year:\n name = root.years.nameof(i)\n scen = ScenarioReference(SectionType.Year, name, root, this)\n \n else:\n raise ValueError('Unknown SectionType')\n \n return scen","def shape(self):\r\n return self._shape","def shape(self) -> str:\n return \"circle\"","def shape(self):\n return None","def get_section(\n self,\n *,\n position: Union[List[float], float] = None,\n min_positions: int = None,\n load_case: int = None,\n ) -> Tuple[List[float], List[Section]]:\n\n if self.beam is None:\n raise SectionOnlyError(\n f\"get_section does not apply to Section based CodeCheck objects.\"\n )\n\n return self.beam.get_section(\n position=position, min_positions=min_positions, load_case=load_case\n )","def _section0(self):\n h = self._sectionheader()\n s = Section0(h)\n s.p = []\n\n # fixed pointers for 12 sections (0-11)\n for _ in range(0, 12):\n pointer = self._sectionpointer()\n s.p.append(pointer)\n\n # additional section pointers\n # each pointer 10 bytes\n # 12 pointers length = 120\n restlen = h.len - 120 - 16\n if restlen > 0:\n # FIXME check starting range\n for _ in range(1, restlen/10):\n pointer = self._sectionpointer()\n s.p.append(pointer)\n return s","def create_sections(self, checkpoints):\n # create map for constant computing of the current sector\n s = np.shape(self.track)\n # reduce number of checkpoints and convert it to pygame format\n #checkpoints = checkpoints[::20] <- this is now done immediately after the watershed algorithm\n checkpoint_map = np.ones(s, dtype=np.int) * len(checkpoints)\n for i in range(s[0]):\n for j in range(s[1]):\n if self.track[i, j]: # if current point is not an obstacle\n checkpoint_map[i, j] = int(find_closest_point_index((j, i), checkpoints))\n\n # flip x and y axis\n checkpoints = np.flip(checkpoints, axis=1)\n section_counter = [0] * len(checkpoints)\n\n return checkpoints, section_counter, checkpoint_map","def corners_asic(self):\n a = int(round(self.angle / 90.0)) % 4\n c = self.corners(True)\n\n if (a == 0):\n # The section is \"standing up\", and the top left corner is given\n # by the first corner.\n ul0 = [int(round(c[a][0])), int(round(c[a][1]))]\n ul1 = [ul0[0] + 194 + 3, ul0[1]]\n dlr = [194, 185]\n elif (a == 2):\n # The section is \"standing up\", and the top left corner is given\n # by the third corner.\n ul1 = [int(round(c[a][0])), int(round(c[a][1]))]\n ul0 = [ul1[0] + 194 + 3, ul1[1]]\n dlr = [194, 185]\n elif (a == 1):\n # The section is \"laying down\", and the top left corner is given\n # by the second corner.\n ul0 = [int(round(c[a][0])), int(round(c[a][1]))]\n ul1 = [ul0[0], ul0[1] + 194 + 3]\n dlr = [185, 194]\n elif (a == 3):\n # The section is \"laying down\", and the top left corner is given\n # by the forth corner.\n ul1 = [int(round(c[a][0])), int(round(c[a][1]))]\n ul0 = [ul1[0], ul1[1] + 194 + 3]\n dlr = [185, 194]\n\n coords = [\n [ul0[0], ul0[1], ul0[0] + dlr[0], ul0[1] + dlr[1]],\n [ul1[0], ul1[1], ul1[0] + dlr[0], ul1[1] + dlr[1]]]\n return (coords)","def _section(self, node, offset_mngr):\n infon = self.infon_dict(node)\n type_ = infon.get('type')\n text = self._text(node)\n if not text:\n # Text and annotations at sentence level.\n offset = offset_mngr.start(node)\n text, anno = [], []\n for sent in self._iterfind(node, 'sentence'):\n text.append(self._sentence(sent, offset_mngr))\n anno.extend(self._get_annotations(sent, offset_mngr))\n else:\n # Text and annotations at passage level.\n offset = offset_mngr.update(node, text)\n anno = list(self._get_annotations(node, offset_mngr))\n return type_, text, offset, infon, anno","def fill_import_section():\n section = _SectionData(\"Import\")\n section.props.append((\"ImportScale\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.import_scale)))\n section.props.append((\"PreservePathForExport\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_preserve_path_for_export))))\n section.props.append((\"ImportPimFile\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pim_file))))\n section.props.append((\"UseWelding\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_use_welding))))\n section.props.append((\"WeldingPrecision\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_welding_precision))))\n section.props.append((\"UseNormals\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_use_normals))))\n section.props.append((\"ImportPitFile\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pit_file))))\n section.props.append((\"LoadTextures\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_load_textures))))\n section.props.append((\"ImportPicFile\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pic_file))))\n section.props.append((\"ImportPipFile\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pip_file))))\n section.props.append((\"ImportPisFile\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pis_file))))\n section.props.append((\"ConnectedBones\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_connected_bones))))\n section.props.append((\"BoneImportScale\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.import_bone_scale)))\n section.props.append((\"ImportPiaFile\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pia_file))))\n section.props.append((\"IncludeSubdirsForPia\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_include_subdirs_for_pia))))\n return section","def get_shape(network):\n from openpnm.topotools.generators.tools import get_shape\n d = {'vert.coords': network.coords, 'edge.conns': network.conns}\n shp = get_shape(d)\n return shp","def compound(self):\n return self._compound","def Draw(self,SectionFunction=circlespacking,Secargs = None,standalone=True,fig = None):\n # Local imports\n import random\n import inPy.Backend.BackendPlot as PlotBundle\n\n # if the user did not specify Secargs, set to\n # (self.R,self.BundleR,self.SparsingCoeff)\n if Secargs == None:\n Secargs = (self.R,self.BundleR,self.SparsingCoeff)\n\n # R = 0 should not be Used\n # but just in case\n if self.R == 0:\n Rprime = 1\n else:\n Rprime = self.R\n\n # if Rprime == 1\n # this means only one filament in the strands\n if Rprime == 1:\n for path in self.CCWpath:\n fig = PlotBundle.Plot_Path(path.Lx, path.Ly, path.Lz,fig,tube_radius=self.FilR)\n for path in self.CWpath:\n fig = PlotBundle.Plot_Path(path.Lx, path.Ly, path.Lz,fig,tube_radius=self.FilR)\n else:\n # multiple filaments\n Coords = SectionFunction(*Secargs)\n for path in self.CCWpath:\n for Position in Coords:\n fig = PlotBundle.Plot_Path(np.array(path.Lx)+Position[0], np.array(path.Ly)+Position[1], path.Lz,fig,tube_radius=self.FilR)\n for path in self.CWpath:\n for Position in Coords:\n fig = PlotBundle.Plot_Path(np.array(path.Lx)+Position[0], np.array(path.Ly)+Position[1], path.Lz,fig,tube_radius=self.FilR)\n if standalone:\n PlotBundle.show()\n else:\n return fig","def XCAFDoc_ShapeTool_IsCompound(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_IsCompound(*args)","def do_section(parser, token, template='parts/section.html', end='endsection'):\n bits = token.split_contents()[1:]\n if len(bits) is 0:\n title, attrs = '', {}\n elif len(bits) is 1:\n title, attrs = bits[0], {}\n elif len(bits) % 2 is 0:\n raise template.TemplateSyntaxError(\"Your attributes don't match up: %s\" % ', '.join(bits[1:]))\n else:\n title = bits[0]\n attrs = dict(zip(bits[1::2], bits[2::2]))\n nodelist = parser.parse((end,))\n parser.delete_first_token()\n return SectionNode(template, title, attrs, nodelist)","def convert_shape(g, op, block):\n\n x = g.get_node(op.input(\"Input\")[0])\n out = shape_of(x, dtype=\"int32\")\n g.add_node(op.output(\"Out\")[0], out)","def get_shape_line_intersections(cls, shape, line):\n shape_inter = IntCurvesFace_ShapeIntersector()\n shape_inter.Load(shape, 1e-3)\n shape_inter.PerformNearest(line, float(\"-inf\"), float(\"+inf\"))\n with assert_isdone(shape_inter, \"failed to computer shape / line intersection\"):\n intersections = [(shape_inter.Pnt(i), shape_inter.Face(i), line) for i in\n range(1, shape_inter.NbPnt() + 1)] # Indices start at 1 :(\n return intersections","def subdivide(network, pores, shape, labels=[]):\n mro = network._mro()\n if 'Cubic' not in mro:\n raise Exception('Subdivide is only supported for Cubic Networks')\n from openpnm.network import Cubic\n pores = network._parse_indices(pores)\n\n # Checks to find boundary pores in the selected pores\n if 'pore.boundary' in network.labels():\n if (np.in1d(pores, network.pores('boundary'))).any():\n raise Exception('boundary pores cannot be subdivided!')\n if not hasattr(network, '_subdivide_flag'):\n network._subdivide_flag = True\n else:\n raise Exception('The network has subdivided pores, so the method \\\n does not support another subdivision')\n # Assigning right shape and division\n if np.size(shape) != 2 and np.size(shape) != 3:\n raise Exception('Subdivide not implemented for Networks other than 2D and 3D')\n if np.size(shape) == 3 and 1 not in shape:\n div = np.array(shape, ndmin=1)\n single_dim = None\n else:\n single_dim = np.where(np.array(get_shape(network)) == 1)[0]\n if np.size(single_dim) == 0:\n single_dim = None\n if np.size(shape) == 3:\n div = np.array(shape, ndmin=1)\n else:\n div = np.zeros(3, dtype=np.int32)\n if single_dim is None:\n dim = 2\n else:\n dim = single_dim\n div[dim] = 1\n div[-np.array(div, ndmin=1, dtype=bool)] = np.array(shape, ndmin=1)\n\n # Creating small network and handling labels\n networkspacing = get_spacing(network)\n new_netspacing = networkspacing/div\n new_net = Cubic(shape=div, spacing=new_netspacing)\n main_labels = ['front', 'back', 'left', 'right', 'top', 'bottom']\n if single_dim is not None:\n label_groups = np.array([['left', 'right'],\n ['front', 'back'],\n ['top', 'bottom']])\n non_single_labels = label_groups[np.array([0, 1, 2]) != single_dim]\n for label in main_labels:\n new_net['pore.surface_' + label] = False\n network['pore.surface_' + label] = False\n if single_dim is None:\n new_net['pore.surface_' + label][new_net.pores(labels=label)] = True\n else:\n for ind in [0, 1]:\n loc = (non_single_labels[ind] == label)\n temp_pores = new_net.pores(non_single_labels[ind][loc])\n new_net['pore.surface_' + label][temp_pores] = True\n\n old_coords = np.copy(new_net['pore.coords'])\n if labels == []:\n labels = ['pore.subdivided_' + new_net.name]\n for P in pores:\n # Shifting the new network to the right location and attaching it to\n # the main network\n shift = network['pore.coords'][P] - networkspacing/2\n new_net['pore.coords'] += shift\n Pn = network.find_neighbor_pores(pores=P)\n try:\n Pn_new_net = network.pores(labels)\n except KeyError:\n Pn_new_net = []\n Pn_old_net = Pn[~np.in1d(Pn, Pn_new_net)]\n Np1 = network.Np\n extend(pore_coords=new_net['pore.coords'],\n throat_conns=new_net['throat.conns'] + Np1,\n labels=labels, network=network)\n\n # Moving the temporary labels to the big network\n for label in main_labels:\n network['pore.surface_' + label][Np1:] = new_net['pore.surface_' + label]\n\n # Stitching the old pores of the main network to the new extended pores\n surf_pores = network.pores('surface_*')\n surf_coord = network['pore.coords'][surf_pores]\n for neighbor in Pn:\n neighbor_coord = network['pore.coords'][neighbor]\n dist = [round(np.inner(neighbor_coord-x, neighbor_coord-x),\n 20) for x in surf_coord]\n nearest_neighbor = surf_pores[dist == np.amin(dist)]\n if neighbor in Pn_old_net:\n coplanar_labels = network.labels(pores=nearest_neighbor)\n new_neighbors = network.pores(coplanar_labels,\n mode='and')\n # This might happen to the edge of the small network\n if np.size(new_neighbors) == 0:\n labels = network.labels(pores=nearest_neighbor,\n mode='and')\n common_label = [label for label in labels if 'surface_' in label]\n new_neighbors = network.pores(common_label)\n elif neighbor in Pn_new_net:\n new_neighbors = nearest_neighbor\n connect_pores(network=network, pores1=neighbor,\n pores2=new_neighbors, labels=labels)\n\n # Removing temporary labels\n for label in main_labels:\n network['pore.surface_' + label] = False\n new_net['pore.coords'] = np.copy(old_coords)\n\n label_faces(network=network)\n for label in main_labels:\n del network['pore.surface_' + label]\n trim(network=network, pores=pores)\n ws = network.project.workspace\n ws.close_project(new_net.project)","def render(self, scene):\n if self.degenerate:\n return\n # The number of subdivisions around the hoop's radial direction.\n if self.thickness:\n band_coverage = scene.pixel_coverage(self.pos, self.thickness)\n else:\n band_coverage = scene.pixel_coverage(self.pos, self.radius * 0.1)\n if band_coverage < 0:\n band_coverage = 1000\n bands = sqrt(band_coverage * 4.0)\n bands = clamp(4, bands, 40)\n # The number of subdivisions around the hoop's tangential direction.\n ring_coverage = scene.pixel_coverage(self.pos, self.radius)\n if ring_coverage < 0:\n ring_coverage = 1000\n rings = sqrt(ring_coverage * 4.0)\n rings = clamp(4, rings, 80)\n slices = int(rings)\n inner_slices = int(bands)\n radius = self.radius\n inner_radius = self.thickness\n\n # Create the vertex and normal arrays.\n vertices = []\n normals = []\n\n outer_angle_step = 2 * pi / (slices - 1)\n inner_angle_step = 2 * pi / (inner_slices - 1)\n outer_angle = 0.\n for i in range(slices):\n cos_outer_angle = cos(outer_angle)\n sin_outer_angle = sin(outer_angle)\n inner_angle = 0.\n for j in range(inner_slices):\n cos_inner_angle = cos(inner_angle)\n sin_inner_angle = sin(inner_angle)\n\n diameter = (radius + inner_radius * cos_inner_angle)\n vertex_x = diameter * cos_outer_angle\n vertex_y = diameter * sin_outer_angle\n vertex_z = inner_radius * sin_inner_angle\n\n normal_x = cos_outer_angle * cos_inner_angle\n normal_y = sin_outer_angle * cos_inner_angle\n normal_z = sin_inner_angle\n\n vertices.extend([vertex_x, vertex_y, vertex_z])\n normals.extend([normal_x, normal_y, normal_z])\n inner_angle += inner_angle_step\n outer_angle += outer_angle_step\n\n # Create ctypes arrays of the lists\n vertices = (gl.GLfloat *len(vertices))(*vertices)\n normals = (gl.GLfloat * len(normals))(*normals)\n\n # Create a list of triangle indices.\n indices = []\n for i in range(slices - 1):\n for j in range(inner_slices - 1):\n pos = i * inner_slices + j\n indices.extend([pos, pos + inner_slices, pos + inner_slices +\n 1])\n indices.extend([pos, pos + inner_slices + 1, pos + 1])\n indices = (gl.GLuint * len(indices))(*indices)\n\n # Compile a display list\n self.list = gl.glGenLists(1)\n gl.glNewList(self.list, gl.GL_COMPILE)\n self.color.gl_set(self.opacity)\n\n gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)\n gl.glEnableClientState(gl.GL_VERTEX_ARRAY)\n gl.glEnableClientState(gl.GL_NORMAL_ARRAY)\n self.model_world_transform(scene.gcf,\n Vector([self.radius, self.radius,\n self.radius])).gl_mult()\n\n gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)\n gl.glNormalPointer(gl.GL_FLOAT, 0, normals)\n gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,\n indices)\n gl.glPopClientAttrib()\n\n gl.glEndList()\n gl.glCallList(self.list)","def _create_main_shape(self):\n\n a, b = gc( self.size/2,\n self._ZERO_DEGREES - self.angle,\n self._180_DEGREES + self.angle)\n self.wafer_points = zip(a,b)\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\n self.cell.add(self.wafer_polygon)","def split_edges(self, maximum_distance):\n \"\"\" Iterate through the vertices of each section. For each vertex v, evaluate edges for which v is a source.\n If an edge of weight greater than maximum_distance, then split it. \"\"\"\n for section_id in self.sections:\n utils.print_progress(len(self.sections), prefix='splitting edges')\n current_section = [] # Need to update the section data after splitting the edges.\n for source in self.sections[section_id]:\n current_section.append(source)\n edges_to_remove = [] # If an edge is split, it will need to be removed.\n for edge in self.graph.get_out_edges(source):\n if self.edge_weights[edge] > maximum_distance:\n target = edge[1] # edge is a numpy array of [source, target, edge]. Select target.\n edges_to_remove.append(self.graph.edge(edge[0], edge[\n 1])) # If an edge is split, the original edge should be removed.\n\n new_edge_count = int(math.ceil(self.edge_weights[edge] / maximum_distance))\n new_edge_distance = self.edge_weights[edge] / new_edge_count\n current_point = shapes.Point.from_list(\n list(self.node_locations[source]) + [self.node_heading[target]])\n previous_vertex = source\n for _ in range(new_edge_count):\n current_point = utils.offset_point(current_point, new_edge_distance, current_point.bearing)\n current_vertex = self.graph.add_vertex()\n current_section.append(current_vertex) # The new vertex becomes a part of the section.\n \"\"\" Populate the property map for the new vertex. Inherit values from the target node,\n unless the target node is a junction node. Then inherit values from the source. \"\"\"\n self.node_locations[current_vertex] = current_point.as_list()\n self.node_heading[current_vertex] = current_point.bearing\n property_vertex = source if not self.junctions[target] else target\n self.node_speed_limit[current_vertex] = self.node_speed_limit[property_vertex]\n self.node_width[current_vertex] = self.node_width[property_vertex]\n self.node_id[current_vertex] = self.node_id[property_vertex]\n\n \"\"\" Create an edge between the previous vertex and the newly created vertex, \n and update the edge weight property map. \"\"\"\n current_edge = self.graph.add_edge(previous_vertex, current_vertex)\n self.edge_weights[current_edge] = new_edge_distance\n\n # The current vertex becomes the previous vertex in the next step.\n previous_vertex = current_vertex\n\n \"\"\" Create an edge between the last new vertex that was created and the target of the\n original edge which is being split, and update the property map. \"\"\"\n self.edge_weights[self.graph.add_edge(previous_vertex, target)] = new_edge_distance\n list(map(self.graph.remove_edge, edges_to_remove)) # Remove all relevant edges\n self.sections[section_id] = current_section # Update the section with the new vertices","def get_sections(self):\n return tuple(self._sections)","def test_no_section_by_section(self):\n notice = {\n \"document_number\": \"111-22\",\n \"fr_volume\": 22,\n \"cfr_part\": \"100\",\n \"publication_date\": \"2010-10-10\"\n }\n s = SectionBySection(None, notices=[notice])\n self.assertEqual(None, s.process(Node(label=['100', '22'])))","def _getSections(self):\r\n\r\n sections = self.cf.sections()\r\n return sections","def shape(self):\n return self.active.shape","def m4_make_middle_shape_points_list(tx, ty, m4_info, SEN_info):\n \"\"\"\n 1 Get information from m1_info & SEN_info\n \"\"\"\n x_m4 = m4_info[0]\n y_m4 = m4_info[1]\n z_m = m4_info[2]\n\n m4_points = m4_info[3]\n\n m4_p0 = m4_points[0]\n m4_p1 = m4_points[1]\n m4_p2 = m4_points[2]\n m4_p3 = m4_points[3]\n\n w_sen = SEN_info[0]\n n_w_sen = SEN_info[1]\n h_sen = SEN_info[2]\n t_sen = SEN_info[3]\n u_n = SEN_info[4]\n l_n = SEN_info[5]\n set = SEN_info[6]\n u_offset = SEN_info[7]\n l_offset = SEN_info[8]\n\n \"\"\"\n 2 Make lists.\n middle_shape_upper_left_row list\n middle_shape_upper_right_row list\n\n middle_shape_lower_left_row list\n middle_shape_lower_right_row list\n \"\"\"\n # upper side\n middle_shape_upper_left_row = []\n middle_shape_upper_right_row = []\n\n for i in range(u_n - 1, -1, -1):\n # left row\n ix = tx - (x_m4 - t_sen)\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p3, p4, p1, p2]\n middle_shape_upper_left_row.extend((left_points))\n\n for i in range(u_n):\n # right row\n ix = tx - t_sen\n iy = ty + (i * u_offset + set) + 10\n\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p1, p2, p3, p4]\n middle_shape_upper_right_row.extend(right_points)\n\n # lower side\n middle_shape_lower_left_row = []\n middle_shape_lower_right_row = []\n\n for i in range(l_n):\n # left row\n ix = tx - (x_m4 - t_sen)\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n left_points = [p3, p4, p1, p2]\n middle_shape_lower_left_row.extend((left_points))\n\n for i in range(l_n - 1, -1, -1):\n # right row\n ix = tx - t_sen\n iy = ty - (i * l_offset + set) - 10\n\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\n right_points = [p1, p2, p3, p4]\n middle_shape_lower_right_row.extend(right_points)\n\n middle_shape_upper = [middle_shape_upper_left_row, middle_shape_upper_right_row]\n middle_shape_lower = [middle_shape_lower_left_row, middle_shape_lower_right_row]\n\n return middle_shape_upper, middle_shape_lower","def plot_sections(wiggle, sections, threshold):\n\n fig = plt.figure()\n axis = fig.add_subplot(111)\n axis.plot(wiggle)\n axis.axhline(y=threshold)\n for sect in sections:\n # mark active sections\n positions = list()\n codes = list()\n start, stop = sect\n positions.append([start, 0.6])\n codes.append(Path.MOVETO)\n positions.append([stop, 0.6])\n codes.append(Path.LINETO)\n positions.append([stop, 0.05])\n codes.append(Path.LINETO)\n positions.append([start, 0.05])\n codes.append(Path.LINETO)\n positions.append([start, 0.6])\n codes.append(Path.LINETO)\n positions.append([start, 0.6])\n codes.append(Path.CLOSEPOLY)\n path = Path(positions, codes)\n patch = patches.PathPatch(path, lw=1)\n axis.add_patch(patch)\n plt.show()","def shape(self):\n # detection mouse hover on arc path\n path = QPainterPath()\n path.addPolygon(QPolygonF([self.line().p1(), self.line().p2()]))\n # add handles at the start and end of arc\n path.addRect(QRectF(\n self.line().p1().x() - 5,\n self.line().p1().y() - 5,\n self.line().p1().x() + 5,\n self.line().p1().y() + 5\n ))\n path.addRect(QRectF(\n self.line().p2().x() - 5,\n self.line().p2().y() - 5,\n self.line().p2().x() + 5,\n self.line().p2().y() + 5\n ))\n return path","def chunk(self, shape, split) -> NotImplementedError:\n raise NotImplementedError()","def calc_section_force(aoa, mac, rot_center, casenum=1, networknum=1):\r\n\r\n chord = \"x\"\r\n span = \"y\"\r\n height = \"z\"\r\n coor2id = {\"x\": 1, \"y\": 2, \"z\": 3}\r\n chord_id = coor2id[chord]\r\n span_id = coor2id[span]\r\n height_id = coor2id[height]\r\n\r\n rot_center = np.asarray(rot_center)[[chord_id - 1, height_id - 1]]\r\n\r\n # read the pressure distribution from agps\r\n data = read_agps()\r\n network = data[int(networknum - 1)]\r\n result = []\r\n\r\n # calculate the local aerodynamic coefficients for each line in the network\r\n for line in network:\r\n if np.array_equal(line[0, 1:4], line[-1, 1:4]):\r\n line = line[:-1] # omit the last point in the line if it has the same xyz-coordinates as the first point\r\n y = float(line[0, span_id]) # coordinate of spanwise position\r\n line_clip = line[:, [chord_id, height_id]] # coordinate of cross section\r\n chord = np.max(line_clip[:, 0]) - np.min(line_clip[:, 0])\r\n\r\n # local coefficients are nan if chord is 0\r\n if chord == 0:\r\n nan = float(\"nan\")\r\n result.append([y, chord, nan, nan, nan])\r\n continue\r\n\r\n diff_coord = line_clip - np.roll(line_clip, 1, axis=0)\r\n length = np.linalg.norm(diff_coord, axis=1) # length between each vertex\r\n norm = np.fliplr(diff_coord / length[:, np.newaxis]) # norm vector between each vertex\r\n min_id = np.argmin(line_clip, axis=0) # vertex_id with the minimum coordinate\r\n flip = np.array([-1 if col[i] < 0 else 1 for (col, i) in zip(norm.T, min_id)])\r\n norm *= flip # flip the norm vectors to make them point inward\r\n\r\n coeff_all = [y, chord]\r\n # the definition of each variable is explained in the reference\r\n cp2 = line.T[int(3 + casenum)]\r\n cp1 = np.roll(cp2, 1, axis=0)\r\n cp3 = np.roll(cp2, -1, axis=0)\r\n n21 = norm\r\n n23 = np.roll(n21, -1, axis=0)\r\n l21 = length * 0.5\r\n l23 = np.roll(l21, -1, axis=0)\r\n cp21 = (0.75 * cp2 + 0.25 * cp1)[:, np.newaxis] * n21\r\n cp23 = (0.75 * cp2 + 0.25 * cp3)[:, np.newaxis] * n23\r\n cpdl = cp21 * l21[:, np.newaxis] + cp23 * l23[:, np.newaxis]\r\n cp_moment = cpdl * np.fliplr(line_clip - rot_center)\r\n cp_moment = cp_moment[:, 0] - cp_moment[:, 1]\r\n liftdragcoef = np.sum(cpdl, axis=0) / chord\r\n liftdragcoef = rot(liftdragcoef, aoa)\r\n cm = np.sum(cp_moment, axis=0) / (mac * chord)\r\n coeff = liftdragcoef.tolist()\r\n coeff.append(cm)\r\n coeff_all += coeff\r\n result.append(coeff_all)\r\n result = np.array(result)\r\n columns = [\"pos\", \"chord\", \"cd\", \"cl\", \"cm\"]\r\n result = pd.DataFrame(result, columns=columns)\r\n result.to_csv(\"section_force.csv\", index=False)","def fancy_section_type(section):\n return {\n 'LEC': 'Lecture',\n 'LAB': 'Laboratory',\n 'TUT': 'Tutorial',\n 'PRA': 'Practicum',\n 'COR': 'Correspondence',\n 'SEM': 'Seminar',\n 'ONL': 'Online',\n }.get(section, section)","def sections(self) -> List[Section]:\n\n if self.beam is None:\n return [self.section]\n\n return self.beam.sections","def segment_by_shape(self, dt, criterion):\n enumerate_crit = Criterion(\n 'patterns', criterion.column_name+'_derivatives_patterns_clusters',\n 'enumerate')\n return self.segment_by_enumerate(dt, enumerate_crit)","def section(data):\n if len(data['index']) == 2 and data['index'][1][0].isdigit():\n element = {}\n element['is_section'] = True\n element['section_id'] = '-'.join(data['index'])\n if u\"§§ \" == data['title'][:3]:\n element['is_section_span'] = True\n else:\n element['is_section_span'] = False\n match = SECTION_TITLE_REGEX.match(data['title'])\n element['label'] = match.group(1)\n element['sub_label'] = match.group(2)\n return element","def read_section(geo_file_path, section_marker):\n read = False\n section = []\n\n with open(geo_file_path) as file:\n lines = file.readlines()\n for line in lines:\n if line.startswith(section_marker):\n read = True\n\n if line.startswith(SECTION_END_MARKER):\n # Don't stop, section can be split\n read = False\n\n if read:\n section.append(line)\n\n return section","def segment(self, intersect=True):\n from scipy.spatial import Voronoi\n from shapely.geometry import LineString\n from shapely.ops import polygonize\n\n vor = Voronoi(self._centered_coords)\n lines = [LineString(vor.vertices[line]) for line in vor.ridge_vertices if -1 not in line]\n poly_generator = polygonize(lines)\n\n series = gpd.GeoSeries(poly_generator)\n series = self.translate(series)\n series.crs = self.detection_base.height_model.crs\n\n if intersect:\n series = series.intersection(self.detection_base.height_model._bounding_box_poly)\n\n return series","def shape(self):\n return self._shape","def shape(self):\n return self._shape","def CSGToPShape(mesh, scale):\n result = createShape(GROUP) # allocate a PShape group\n # for each polygon (Note: these can have 3,4 or more vertices)\n for p in mesh.getPolygons():\n # make a child PShape\n polyShape = createShape()\n # begin setting vertices to it\n polyShape.beginShape()\n # for each vertex in the polygon\n for v in p.vertices:\n # add each (scaled) polygon vertex\n polyShape.vertex(v.pos.getX() * scale,\n v.pos.getY() * scale,\n v.pos.getZ() * scale)\n\n # finish this polygon\n polyShape.endShape()\n # append the child PShape to the parent\n result.addChild(polyShape)\n\n return result"],"string":"[\n \"def test_compound_stiffened_isection():\\n uc = steel_sections.i_section(d=400, b=400, t_f=25, t_w=25, r=30, n_r=8)\\n plate1 = (\\n sections.rectangular_section(b=500, d=10).align_center(uc).align_to(uc, \\\"top\\\")\\n )\\n plate2 = (\\n sections.rectangular_section(b=500, d=10)\\n .align_center(uc)\\n .align_to(uc, \\\"bottom\\\")\\n )\\n geom = uc + plate1 + plate2\\n\\n new_geom = geom.offset_perimeter(-9)\\n new_geom.create_mesh([100])\\n section = Section(new_geom)\\n\\n new_geom = geom.offset_perimeter(-10)\\n new_geom.create_mesh([100])\\n section = Section(new_geom)\\n\\n new_geom = geom.offset_perimeter(-11)\\n new_geom.create_mesh([100])\\n section = Section(new_geom)\",\n \"def build_section(self, section_map):\\n section = []\\n for coordinate_map in section_map['shape']:\\n vertex = self.graph.add_vertex()\\n\\n # Build a property map containing the geolocation, speed, ID, and bearing.\\n self.node_locations[vertex] = [coordinate_map['lon'], coordinate_map['lat']]\\n self.node_id[vertex] = section_map['sectionID']\\n self.node_speed_limit[vertex] = section_map['speed']\\n self.node_width[vertex] = self.road_types[section_map['type']] * section_map['numLanes']\\n\\n if section:\\n # The first node does not get a heading until the junction node has been added.\\n self.node_heading[vertex] = coordinate_map['heading']\\n previous_node = section[-1]\\n edge = self.graph.add_edge(previous_node, vertex)\\n previous_location = self.node_locations[previous_node]\\n current_location = self.node_locations[vertex]\\n self.edge_weights[edge] = utils.real_distance(previous_location, current_location)\\n\\n section.append(vertex)\\n return section\",\n \"def _generate_section_structures(self, distance, radius, structure=PILLARS, section=1):\\n if section > self.num_sections:\\n raise ValueError(\\\"Selected Section has to be less or equal than {0}\\\".format(self.num_sections));\\n \\n row = int((section - 1) / self.cols)\\n col = int((section - 1) % self.cols)\\n \\n # Calculating starting coordinates of the section\\n x = self.drawing_x + col * self.drawing_x_step\\n y = self.drawing_y - row * self.drawing_y_step\\n\\n # Correcting width and height to respect the gap\\n width = self.drawing_x_step - self.GAP_BETWEEN_SECTIONS/2 \\n height = self.drawing_y_step - self.GAP_BETWEEN_SECTIONS/2\\n\\n polygons = []\\n if structure == self.PILLARS:\\n pillars = Pillar.generate_pilars_region(distance,\\n radius, \\n x, \\n y, \\n width, \\n height)\\n\\n for pillar in pillars:\\n poly = gdspy.Polygon(pillar, self.STRUCTURES_LAYER)\\n polygons.append(poly)\\n\\n else:\\n horizontal, vertical = Grid.generate_grid_region(distance,\\n radius,\\n x,\\n y,\\n width,\\n height)\\n if structure == self.GRID:\\n\\n for h in horizontal:\\n poly = gdspy.Rectangle(h[0], h[1], self.STRUCTURES_LAYER )\\n polygons.append(poly)\\n\\n for v in vertical:\\n poly = gdspy.Rectangle(v[0], v[1], self.STRUCTURES_LAYER )\\n polygons.append(poly)\\n\\n elif structure == self.LINES_H:\\n\\n for v in vertical:\\n poly = gdspy.Rectangle(v[0], v[1], self.STRUCTURES_LAYER)\\n polygons.append(poly)\\n elif structure == self.LINES_V:\\n\\n for h in horizontal:\\n poly = gdspy.Rectangle(h[0], h[1], self.STRUCTURES_LAYER)\\n polygons.append(poly)\\n\\n self.setups[section] = {'radius': radius, 'distance': distance, 'structure': structure}\\n # The fitting the generated rectangular section in the Margin area\\n merged = gdspy.fast_boolean(polygons, self.margin_polygon, 'and', layer=self.STRUCTURES_LAYER,max_points=3000)\\n self.cell.add(merged)\",\n \"def shape(self) -> Shape:\",\n \"def test_sections_flat_one_section(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n layout=layout,\\n root=True)\\n self.assertEqual(story.structure.sections_flat, [section1])\",\n \"def define_sections (data_shape, xbin=1, ybin=1, tel=None):\\n\\n ysize, xsize = data_shape\\n ny = get_par(set_bb.ny,tel)\\n nx = get_par(set_bb.nx,tel)\\n dy = ysize // ny\\n dx = xsize // nx\\n\\n ysize_chan = get_par(set_bb.ysize_chan,tel) // ybin\\n xsize_chan = get_par(set_bb.xsize_chan,tel) // xbin\\n ysize_os = (ysize-ny*ysize_chan) // ny\\n xsize_os = (xsize-nx*xsize_chan) // nx\\n\\n # the sections below are defined such that e.g. chan_sec[0] refers\\n # to all pixels of the first channel, where the channel indices\\n # are currently defined to be located on the CCD as follows:\\n #\\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\\n # [ 8, 9, 10, 11, 12, 13, 14, 15]\\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\\n # [ 0, 1, 2, 3, 4, 5, 6, 7]\\n\\n # channel section slices including overscan; shape=(16,2)\\n chan_sec = tuple([(slice(y,y+dy), slice(x,x+dx))\\n for y in range(0,ysize,dy) for x in range(0,xsize,dx)])\\n\\n # channel data section slices; shape=(16,2)\\n data_sec = tuple([(slice(y,y+ysize_chan), slice(x,x+xsize_chan))\\n for y in range(0,ysize,dy+ysize_os) for x in range(0,xsize,dx)])\\n\\n # channel vertical overscan section slices; shape=(16,2)\\n # cut off [ncut] pixels to avoid including pixels on the edge of the\\n # overscan that are contaminated with flux from the image\\n # and also discard last column as can have high value\\n ncut = 5\\n ncut_vert = max(ncut // xbin, 1)\\n os_sec_vert = tuple([(slice(y,y+dy), slice(x+xsize_chan+ncut_vert,x+dx-1))\\n for y in range(0,ysize,dy) for x in range(0,xsize,dx)])\\n\\n # channel horizontal overscan sections; shape=(16,2)\\n # cut off [ncut] pixels to avoid including pixels on the edge of the\\n # overscan that are contaminated with flux from the image\\n ncut_hori = max(ncut // ybin, 1)\\n ysize_os_cut = ysize_os - ncut_hori\\n os_sec_hori = tuple([(slice(y,y+ysize_os_cut), slice(x,x+dx))\\n for y in range(dy-ysize_os_cut,dy+ysize_os_cut,ysize_os_cut)\\n for x in range(0,xsize,dx)])\\n\\n # channel reduced data section slices; shape=(16,2)\\n data_sec_red = tuple([(slice(y,y+ysize_chan), slice(x,x+xsize_chan))\\n for y in range(0,ysize-ny*ysize_os,ysize_chan)\\n for x in range(0,xsize-nx*xsize_os,xsize_chan)])\\n\\n\\n return chan_sec, data_sec, os_sec_hori, os_sec_vert, data_sec_red\",\n \"def test_sections_flat_one_section(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n root=True)\\n self.assertEqual(story.structure.sections_flat, [section1])\",\n \"def __section_style(self):\\n font = FontStyle()\\n font.set(face=FONT_SERIF, size=10, italic=0, bold=0)\\n para = ParagraphStyle()\\n para.set_font(font)\\n para.set(first_indent=-1.5, lmargin=1.5)\\n para.set_top_margin(0.5)\\n para.set_bottom_margin(0.25) \\n para.set_description(_('The style used for each section.'))\\n self.default_style.add_paragraph_style(\\\"PLC-Section\\\", para)\",\n \"def test_sections_flat_no_root_section(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story, layout=layout,\\n root=False)\\n self.assertEqual(story.structure.sections_flat, [])\",\n \"def test_sections_flat_no_root_section(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n root=False)\\n self.assertEqual(story.structure.sections_flat, [])\",\n \"def get_categs_section(sect):\\n return Category.objects.filter(section__section=sect)\",\n \"def test_sections_flat_linear_nested(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n layout=layout,\\n root=True)\\n section2 = create_section(title=\\\"Decisions to be made\\\", story=story, layout=layout)\\n section3 = create_section(title=\\\"Who has been involved\\\", \\n story=story, layout=layout)\\n section4 = create_section(title=\\\"Next steps\\\", story=story,\\n layout=layout)\\n SectionRelation.objects.create(parent=section1, child=section2)\\n SectionRelation.objects.create(parent=section2, child=section3)\\n SectionRelation.objects.create(parent=section3, child=section4)\\n self.assertEqual(story.structure.sections_flat, [section1, section2, \\n section3, section4])\",\n \"def _create_sections(self):\\n\\t\\t# NOTE: cell=self is required to tell NEURON of this object.\\n\\t\\tself.node = [h.Section(name='node',cell=self) for x in range(self._axonNodes)]\\n\\t\\tself.mysa = [h.Section(name='mysa',cell=self) for x in range(self._paraNodes1)]\\n\\t\\tself.flut = [h.Section(name='flut',cell=self) for x in range(self._paraNodes2)]\\n\\t\\tself.stin = [h.Section(name='stin',cell=self) for x in range(self._axonInter)]\",\n \"def test_sections_flat_linear_nested(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n root=True)\\n section2 = create_section(title=\\\"Decisions to be made\\\", story=story)\\n section3 = create_section(title=\\\"Who has been involved\\\", \\n story=story)\\n section4 = create_section(title=\\\"Next steps\\\", story=story)\\n SectionRelation.objects.create(parent=section1, child=section2)\\n SectionRelation.objects.create(parent=section2, child=section3)\\n SectionRelation.objects.create(parent=section3, child=section4)\\n self.assertEqual(story.structure.sections_flat, [section1, section2, \\n section3, section4])\",\n \"def SectionVertex(self, *args):\\n return _BRepAlgo.BRepAlgo_DSAccess_SectionVertex(self, *args)\",\n \"def shape(self):\",\n \"def shape(self):\",\n \"def interior(self):\\n return Shape(self - self.edge('inner'))\",\n \"def getType(self):\\n return ORGElement.ELEMENT_TYPE_SECTION\",\n \"def drawCell(self, x, y, bgColor, closedSection=255, borderColor=\\\"\\\", bgPattern=\\\"\\\"):\\n left = self.margin + y * self.cellSize\\n right = left + self.cellSize\\n top = self.margin + x * self.cellSize\\n bottom = top + self.cellSize\\n adjustValue = self.cellSize - self.pentPadding\\n # sections tuple = ([rectangles], [lines])\\n sections = ([], [])\\n # main section\\n sections[0].append(self.canvas.create_rectangle(\\n left + self.pentPadding,\\n top + self.pentPadding,\\n 1 + right - self.pentPadding,\\n 1 + bottom - self.pentPadding,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n # border sections\\n if closedSection & (1 << 0):\\n sections[0].append(self.canvas.create_rectangle(\\n left,\\n top,\\n 1 + right - adjustValue,\\n 1 + bottom - adjustValue,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n if closedSection & (1 << 1):\\n sections[0].append(self.canvas.create_rectangle(\\n left + self.pentPadding,\\n top,\\n 1 + right - self.pentPadding,\\n 1 + bottom - adjustValue,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n if closedSection & (1 << 2):\\n sections[0].append(self.canvas.create_rectangle(\\n left + adjustValue,\\n top,\\n 1 + right,\\n 1 + bottom - adjustValue,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n if closedSection & (1 << 3):\\n sections[0].append(self.canvas.create_rectangle(\\n left,\\n top + self.pentPadding,\\n 1 + right - adjustValue,\\n 1 + bottom - self.pentPadding,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n if closedSection & (1 << 4):\\n sections[0].append(self.canvas.create_rectangle(\\n left + adjustValue,\\n top + self.pentPadding,\\n 1 + right,\\n 1 + bottom - self.pentPadding,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n if closedSection & (1 << 5):\\n sections[0].append(self.canvas.create_rectangle(\\n left,\\n top + adjustValue,\\n 1 + right - adjustValue,\\n 1 + bottom,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n if closedSection & (1 << 6):\\n sections[0].append(self.canvas.create_rectangle(\\n left + self.pentPadding,\\n top + adjustValue,\\n 1 + right - self.pentPadding,\\n 1 + bottom,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n if closedSection & (1 << 7):\\n sections[0].append(self.canvas.create_rectangle(\\n left + adjustValue,\\n top + adjustValue,\\n 1 + right,\\n 1 + bottom,\\n fill=bgColor, outline=borderColor, stipple=bgPattern\\n ))\\n # main section's borders\\n if not closedSection & (1 << 1):\\n sections[1].append(self.canvas.create_line(\\n left + self.pentPadding,\\n top + self.pentPadding,\\n 1 + right - self.pentPadding,\\n bottom - adjustValue\\n ))\\n if not closedSection & (1 << 3):\\n sections[1].append(self.canvas.create_line(\\n left + self.pentPadding,\\n top + self.pentPadding,\\n right - adjustValue,\\n 1 + bottom - self.pentPadding\\n ))\\n if not closedSection & (1 << 4):\\n sections[1].append(self.canvas.create_line(\\n left + adjustValue,\\n top + self.pentPadding,\\n right - self.pentPadding,\\n 1 + bottom - self.pentPadding\\n ))\\n if not closedSection & (1 << 6):\\n sections[1].append(self.canvas.create_line(\\n left + self.pentPadding,\\n top + adjustValue,\\n 1 + right - self.pentPadding,\\n bottom - self.pentPadding\\n ))\\n # border sections' borders\\n if (closedSection & (1 << 1)) and not (closedSection & (1 << 0)):\\n sections[1].append(self.canvas.create_line(\\n left + self.pentPadding,\\n top,\\n right - adjustValue,\\n 1 + bottom - adjustValue\\n ))\\n if (closedSection & (1 << 1)) and not (closedSection & (1 << 2)):\\n sections[1].append(self.canvas.create_line(\\n left + adjustValue,\\n top,\\n right - self.pentPadding,\\n 1 + bottom - adjustValue\\n ))\\n if (closedSection & (1 << 4)) and not (closedSection & (1 << 2)):\\n sections[1].append(self.canvas.create_line(\\n left + adjustValue,\\n top + self.pentPadding,\\n 1 + right,\\n bottom - adjustValue\\n ))\\n if (closedSection & (1 << 4)) and not (closedSection & (1 << 7)):\\n sections[1].append(self.canvas.create_line(\\n left + adjustValue,\\n top + adjustValue,\\n 1 + right,\\n bottom - self.pentPadding\\n ))\\n if (closedSection & (1 << 6)) and not (closedSection & (1 << 7)):\\n sections[1].append(self.canvas.create_line(\\n left + adjustValue,\\n top + adjustValue,\\n right - self.pentPadding,\\n 1 + bottom\\n ))\\n if (closedSection & (1 << 6)) and not (closedSection & (1 << 5)):\\n sections[1].append(self.canvas.create_line(\\n left + self.pentPadding,\\n top + adjustValue,\\n right - adjustValue,\\n 1 + bottom\\n ))\\n if (closedSection & (1 << 3)) and not (closedSection & (1 << 5)):\\n sections[1].append(self.canvas.create_line(\\n left,\\n top + adjustValue,\\n 1 + right - adjustValue,\\n bottom - self.pentPadding\\n ))\\n if (closedSection & (1 << 3)) and not (closedSection & (1 << 0)):\\n sections[1].append(self.canvas.create_line(\\n left,\\n top + self.pentPadding,\\n 1 + right - adjustValue,\\n bottom - adjustValue\\n ))\\n return sections\",\n \"def section(self):\\n return SECTION_NAME_TO_SECTION[self.section_name]\",\n \"def getNewIntersections(self):\\n sections = []\\n sections2D = []\\n xs = np.array(self.XYProjections)[:,0]\\n L = xs[-1] - xs[0]\\n xis = xs / L\\n R = self.XYZCoordinate.T\\n if len(xis) != len(self.SkeletonPoints):\\n raise Exception(\\\"Conflit between xis and SkeletonPoints.\\\", self.SKeletonPoints)\\n for i in range(len(xis)):\\n xi = xis[i]\\n normalVec = self.returnTangentVectorAtXi(xi)\\n originPoint = self.SkeletonPoints[i]\\n \\n # define transform manually\\n T = np.zeros((4,4))\\n T[:3,:3] = R[:,np.array([1,2,0])]; # 3rd axis is reduced by projection\\n T[:3,3] = originPoint; \\n T[3,3] = 1.0\\n to_2D = (np.linalg.inv(T)).astype(float)\\n \\n try:\\n slice = self.mesh.section(plane_origin=originPoint, plane_normal=normalVec)\\n # 选取每个截面图中面积最大的子图，实现初步去噪\\n if slice is not None:\\n slice_2D, to_3D = slice.to_planar(to_2D=to_2D,check=False)\\n slices_splited = slice_2D.split()\\n sliceIndex = np.argmax([s.area for s in slices_splited])\\n slice_2D = slices_splited[sliceIndex]\\n if True: #slice_2D.area > 1e-1:\\n sections2D.append(slice_2D)\\n sections.append(slice_2D.to_3D(to_3D))\\n except:\\n pass\\n \\n self.Intersections2D = sections2D\\n self.Intersections = sections\",\n \"def test_sections_flat_spider(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n root=True)\\n section2 = create_section(title=\\\"Decisions to be made\\\", story=story)\\n section3 = create_section(title=\\\"Who has been involved\\\", \\n story=story)\\n section4 = create_section(title=\\\"Next steps\\\", story=story)\\n SectionRelation.objects.create(parent=section1, child=section2,\\n weight=0)\\n SectionRelation.objects.create(parent=section1, child=section3,\\n weight=1)\\n SectionRelation.objects.create(parent=section1, child=section4,\\n weight=2)\\n self.assertEqual(story.structure.sections_flat, [section1, section2,\\n section3, section4])\",\n \"def test_sections_flat_spider(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n layout=layout,\\n root=True)\\n section2 = create_section(title=\\\"Decisions to be made\\\", story=story, layout=layout)\\n section3 = create_section(title=\\\"Who has been involved\\\", \\n story=story, layout=layout)\\n section4 = create_section(title=\\\"Next steps\\\", story=story, layout=layout)\\n SectionRelation.objects.create(parent=section1, child=section2,\\n weight=0)\\n SectionRelation.objects.create(parent=section1, child=section3,\\n weight=1)\\n SectionRelation.objects.create(parent=section1, child=section4,\\n weight=2)\\n self.assertEqual(story.structure.sections_flat, [section1, section2,\\n section3, section4])\",\n \"def getSect(self, h):\\n coordtrasp=self.coord.T\\n lefttomin=self.coord[1][:self.min+1]\\n # left point\\n lpnt = self.firstPointAfter_h(lefttomin[::-1], h)\\n # find index of left point\\n l_pnt = self.min - lpnt\\n # find left intersection\\n l_intersect = self.intersection(coordtrasp[l_pnt], coordtrasp[l_pnt+1], h)\\n # right point\\n rpnt = self.firstPointAfter_h(self.coord[1][self.min:], h)\\n # find index of right point\\n r_pnt = self.min + rpnt\\n # find right intersection\\n r_intersect = self.intersection(coordtrasp[r_pnt], coordtrasp[r_pnt-1], h)\\n # make new section geometries\\n sez = coordtrasp[l_pnt+1:r_pnt]\\n # Add left intersection on the top\\n sez=np.insert(sez, [0,], l_intersect,axis=0)\\n # Add rightht intersection on the bottom\\n sez=np.append(sez,[r_intersect],axis=0)\\n return sez\",\n \"def computeBoundingShape(scene, shape='ellipsoid'):\\r\\n \\r\\n gr= pgl.Group([ sh.geometry for sh in scene ])\\r\\n tglset = pgl.fit( shape, gr )\\r\\n #hull = pgl.Shape( tglSet, __Green )\\r\\n return tglset\",\n \"def get_shape_type(self):\\n import GEOM\\n sgeom = self.get_sgeom()\\n shape_type = sgeom.GetShapeType()\\n if shape_type is GEOM.COMPOUND:\\n node = self.node\\n geom_eng = node.get_sobj().GetFatherComponent().GetObject()\\n ops = geom_eng.GetIGroupOperations(node.get_std()._get_StudyId())\\n sidx = ops.GetType(sgeom)\\n shape_type = self._compound_types.get(sidx, shape_type)\\n return shape_type\",\n \"def circlePrimitive(self):\\n\\n def drawWireframe(self):\\n\\n # Draw line\\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\\n\\n # Get Color\\n # self.getColor(\\\"edge\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n \\n def drawShaded(self):\\n\\n # Draw quad\\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\\n\\n # Get Color\\n # self.getColor(\\\"polygon\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n\\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\\n\\n # Draw lines\\n if self.draw_type == 0 or self.draw_type == 2:\\n drawWireframe(self)\\n \\n # Draww Polygons\\n if self.draw_type == 1 or self.draw_type == 2:\\n drawShaded(self)\\n\\n glFT.glEndList()\",\n \"def get_section(self, sy: int) -> numpy.ndarray:\\n if sy not in self._sections:\\n self.create_section(sy)\\n return self._sections[sy]\",\n \"def sections(self):\\n raise NotImplementedError()\",\n \"def test_sections_flat_tree(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n root=True)\\n section2 = create_section(title=\\\"Decisions to be made\\\", story=story)\\n section3 = create_section(title=\\\"Who has been involved\\\", \\n story=story)\\n section4 = create_section(title=\\\"Next steps\\\", story=story)\\n section5 = create_section(title=\\\"Last section\\\", story=story)\\n SectionRelation.objects.create(parent=section1, child=section2,\\n weight=0)\\n SectionRelation.objects.create(parent=section2, child=section3,\\n weight=0)\\n SectionRelation.objects.create(parent=section2, child=section4,\\n weight=1)\\n SectionRelation.objects.create(parent=section1, child=section5,\\n weight=1)\\n self.assertEqual(story.structure.sections_flat, [section1, section2,\\n section3, section4,\\n section5])\",\n \"def test_sections_flat_tree(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n layout = SectionLayout.objects.get(sectionlayouttranslation__name=\\\"Side by Side\\\")\\n section1 = create_section(title=\\\"Background and context\\\",\\n story=story,\\n layout=layout,\\n root=True)\\n section2 = create_section(title=\\\"Decisions to be made\\\", story=story, layout=layout)\\n section3 = create_section(title=\\\"Who has been involved\\\", \\n story=story, layout=layout)\\n section4 = create_section(title=\\\"Next steps\\\", story=story, layout=layout)\\n section5 = create_section(title=\\\"Last section\\\", story=story, layout=layout)\\n SectionRelation.objects.create(parent=section1, child=section2,\\n weight=0)\\n SectionRelation.objects.create(parent=section2, child=section3,\\n weight=0)\\n SectionRelation.objects.create(parent=section2, child=section4,\\n weight=1)\\n SectionRelation.objects.create(parent=section1, child=section5,\\n weight=1)\\n self.assertEqual(story.structure.sections_flat, [section1, section2,\\n section3, section4,\\n section5])\",\n \"def _create_section(self, parent, sectionid, title=None, term=None):\\n\\n idb = nodes.make_id(sectionid)\\n section = nodes.section(ids=[idb])\\n parent.append(section)\\n\\n if term:\\n if term != '**':\\n section.append(nodes.term('', term))\\n\\n definition = nodes.definition()\\n section.append(definition)\\n\\n return definition\\n\\n if title:\\n section.append(nodes.title('', title))\\n\\n return section\",\n \"def sections(self):\\n raise NotImplementedError()\",\n \"def computePointSectionArea(self,wingIndex,segmentIndex,eta,xsi):\\n # tigl.wingGetUpperPoint(wingIndex, segmentIndex, eta -> y, xsi->x)\\n # WARNING there is a slight difference in the area computed with this\\n # method ans CPACSCREATOR. At the moment it is undetermined who is more\\n # accurate.\\n N = 20\\n xsi1 = np.linspace(0,1,N)\\n upper = np.empty((N,3))\\n lower = np.empty((N,3))\\n\\n\\n # t = np.max(np.abs(upper[:][2] - lower[:][2]))\\n \\n for i in range(N):\\n U = self.tigl.wingGetUpperPoint(wingIndex,segmentIndex,eta,xsi1[i])\\n L = self.tigl.wingGetLowerPoint(wingIndex,segmentIndex,eta,xsi1[i])\\n upper[i] = np.array(U)\\n lower[i] = np.array(L)\\n v1 = upper[0]-upper[-1]\\n v2 = upper[7] - lower[7]\\n c = np.abs(upper[0][0] - upper[-1][0])\\n t = np.max(np.abs(upper[:][2] - lower[:][2]))\\n print(c)\\n area = c*0.1*t\\n # sys.exit()\\n # v1xv2 = np.cross(v1,v2)\\n # upper = np.flip(upper,axis=0)\\n # wingSectionPoints = np.concatenate((upper, lower))\\n # ey_0 = np.array([0,1,0])\\n # e_1 = v1xv2\\n # # Computes the cross prodct\\n # cross = np.cross(ey_0,e_1)\\n # normCross = np.linalg.norm(cross)\\n # cross = cross/normCross\\n # if normCross < 1e-8:\\n # # No need to rotate\\n # wingSectionPoints = np.delete(wingSectionPoints,1,1)\\n # hull = ConvexHull(wingSectionPoints)\\n # area = hull.volume\\n # else:\\n # ab = inner1d(ey_0,e_1)\\n # a = np.linalg.norm(ey_0)\\n # b = np.linalg.norm(e_1)\\n # angle = np.arccos(ab / (a*b))\\n # logger.debug(\\\"angle: \\\"+str(angle))\\n # quat = angle*cross\\n # r = R.from_rotvec(quat)\\n # # Deletes the y column since the Convex hull will struggle with\\n # # a 3d plane otherwise\\n # wingSectionPoints = r.apply(wingSectionPoints)\\n # wingSectionPoints = np.delete(wingSectionPoints,1,1)\\n # hull = ConvexHull(wingSectionPoints)\\n # # WARNING since we have built a 2D surface, the function is set up\\n # # in a way that this is correct!\\n # area = hull.volume\\n\\n logger.debug(\\\"Computed section area: \\\"+str(area))\\n\\n return area\",\n \"def get_g_sect(self):\\n return self.translation['g_sect']\",\n \"def csm_shape(csm):\\r\\n return csm_properties(csm)[3]\",\n \"def shape(self) -> Shape:\\n raise NotImplementedError()\",\n \"def topods_solid(self):\\n return self.topods_shape()\",\n \"def shape_type(self):\\n return \\\"circle\\\"\",\n \"def subdivision(mesh):\\n\\t\\n\\t\\n\\t# 1. generate new nodes in the centre of quad\\n\\t# 1/4 o-------o 1/4 o: existing vertices\\n\\t# | | *: newly-generated vertices\\n\\t# | * |\\n\\t# | |\\n\\t# 1/4 o-------o 1/4\\n\\n\\tnew_coor = mesh.give_nodes().give_coor()\\n\\t\\n\\tfor face_index in range(mesh.give_model_inf()[2]): \\n\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\tfor vertex_index in range(4):\\n\\t\\t\\tmesh.give_faces()\\n\\t\\t\\tnode_index = mesh.give_faces().give_node_list(face_index)[vertex_index]\\n\\n\\t\\t\\tnew_x += 0.25*mesh.give_nodes().give_coor(node_index)[0]\\n\\t\\t\\tnew_y += 0.25*mesh.give_nodes().give_coor(node_index)[1]\\n\\t\\t\\tnew_z += 0.25*mesh.give_nodes().give_coor(node_index)[2]\\n\\t\\t\\t\\n\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\t\\t\\n\\t# generating new nodes on the edge\\n\\t# figure out one edge is shared by how many surfaces\\n\\tedge_shared_by_faces_list = helper.find_edge_shared_by_which_faces(mesh.give_edges(), mesh.give_faces())\\n\\t\\n\\tfor edge_index in range(mesh.give_model_inf()[1]):\\n\\n\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\n\\t# 2. generate new node on boundary edge\\n\\t# o: existing vertices\\n\\t# 1/2 o---*---o 1/2 *: newly-generated vertices\\n\\t# \\n\\n\\t\\tnew_coor = mesh.give_nodes().give_coor()\\n\\t\\tif len(edge_shared_by_faces_list[edge_index]) == 1:\\t\\n\\t\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\tfor vertex_index in range(2):\\n\\t\\t\\t\\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\\n\\t\\t\\t\\tnew_x += 0.5*mesh.give_nodes().give_coor()[this_node][0]\\n\\t\\t\\t\\tnew_y += 0.5*mesh.give_nodes().give_coor()[this_node][1]\\n\\t\\t\\t\\tnew_z += 0.5*mesh.give_nodes().give_coor()[this_node][2]\\n\\t\\t\\t\\t\\n\\t\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\t\\t\\t\\t\\n\\t# 3. generate new node on interior edge\\n\\t# 1/16 o-------o 1/16 o: existing vertices\\n\\t# | | *: newly-generated vertices\\n\\t# 3/8 o---*---o 3/8\\n\\t# | |\\n\\t# 1/16 o-------o 1/16\\n\\n\\t\\telse:\\n\\t\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\tconsidered_node = []\\n\\t\\t\\tfor vertex_index in range(2):\\n\\t\\t\\t\\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\\n\\t\\t\\t\\tconsidered_node.append(this_node)\\n\\t\\t\\t\\tnew_x += 3./8.*mesh.give_nodes().give_coor()[this_node][0]\\n\\t\\t\\t\\tnew_y += 3./8.*mesh.give_nodes().give_coor()[this_node][1]\\n\\t\\t\\t\\tnew_z += 3./8.*mesh.give_nodes().give_coor()[this_node][2]\\n\\t\\t\\t\\n\\t\\t\\t# faces contain this node\\n\\t\\t\\tpotential_node = []\\n\\t\\t\\tfor face_index in edge_shared_by_faces_list[edge_index]:\\t\\t\\n\\t\\t\\t\\tfor vertex_index in range(4):\\n\\t\\t\\t\\t\\t\\tpotential_node.append(mesh.give_faces().give_node_list(face_index)[vertex_index])\\n\\t\\t\\t\\n\\t\\t\\touter_node = []\\n\\t\\t\\tfor node in potential_node:\\n\\t\\t\\t\\tif (node not in considered_node) & (node not in outer_node):\\n\\t\\t\\t\\t\\touter_node.append(node)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tfor vertex_index in outer_node:\\n\\t\\t\\t\\tnew_x += 1./16.*mesh.give_nodes().give_coor()[vertex_index][0]\\n\\t\\t\\t\\tnew_y += 1./16.*mesh.give_nodes().give_coor()[vertex_index][1]\\n\\t\\t\\t\\tnew_z += 1./16.*mesh.give_nodes().give_coor()[vertex_index][2]\\n\\t\\t\\t\\n\\t\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\n\\t# update the links of edges and surfaces\\n\\tnew_edge_list = []\\n\\tnew_face_list = []\\n\\tfor face_index in range(mesh.give_model_inf()[2]):\\n\\t\\told_node0 = mesh.give_faces().give_node_list(face_index)[0]\\n\\t\\told_node1 = mesh.give_faces().give_node_list(face_index)[1]\\n\\t\\told_node2 = mesh.give_faces().give_node_list(face_index)[2]\\n\\t\\told_node3 = mesh.give_faces().give_node_list(face_index)[3]\\n\\t\\t\\n\\t\\told_edge0 = mesh.give_faces().give_edge_list(face_index)[0]\\n\\t\\told_edge1 = mesh.give_faces().give_edge_list(face_index)[1]\\n\\t\\told_edge2 = mesh.give_faces().give_edge_list(face_index)[2]\\n\\t\\told_edge3 = mesh.give_faces().give_edge_list(face_index)[3]\\n\\t\\t\\n\\t\\tnew_node4 = old_edge0 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2] \\n\\t\\tnew_node5 = old_edge1 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\n\\t\\tnew_node6 = old_edge2 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\n\\t\\tnew_node7 = old_edge3 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\t\\n\\t\\tnew_node8 = mesh.give_model_inf()[0] + face_index\\n\\t\\t\\n\\t\\tif helper.in_list((old_node0, new_node4), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node0, new_node4))\\n\\t\\tif helper.in_list((new_node4, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node4, new_node8))\\n\\t\\tif helper.in_list((new_node8, new_node7), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node8, new_node7))\\n\\t\\tif helper.in_list((new_node7, old_node0), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node7, old_node0))\\n\\t\\tif helper.in_list((new_node4, old_node1), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node4, old_node1))\\n\\t\\tif helper.in_list((old_node1, new_node5), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node1, new_node5))\\n\\t\\tif helper.in_list((new_node5, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node5, new_node8))\\n\\t\\tif helper.in_list((new_node7, old_node3), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node7, old_node3))\\n\\t\\tif helper.in_list((old_node3, new_node6), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node3, new_node6))\\n\\t\\tif helper.in_list((new_node6, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node6, new_node8))\\n\\t\\tif helper.in_list((new_node6, old_node2), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node6, old_node2))\\n\\t\\tif helper.in_list((old_node2, new_node5), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node2, new_node5))\\n\\t\\n\\t\\tnew_face_list.append((old_node0, new_node4, new_node8, new_node7))\\n\\t\\tnew_face_list.append((new_node4, old_node1, new_node5, new_node8))\\n\\t\\tnew_face_list.append((new_node7, new_node8, new_node6, old_node3))\\n\\t\\tnew_face_list.append((new_node8, new_node5, old_node2, new_node6))\\n\\t\\t\\n\\tnew_edges = geo.Edge(new_edge_list)\\n\\t\\n\\tnew_faces = geo.Face(new_face_list, new_edges)\\n\\t\\t\\n\\t# update existing nodes\\t\\n\\tfor node_index in range(mesh.give_model_inf()[0]):\\n\\t\\t\\n\\t\\tring1, ring2 = helper.find_neighbour_node(new_edges, new_faces, node_index)\\n\\t\\tvalence = helper.find_valence(node_index, new_faces) \\n\\t\\t#: valence: the number of faces sharing on specific edge\\n\\n\\t# 4. update existing corner vertex\\n\\t# 2/4 @---* 1/4 *: newly-generated vertices\\n\\t# | | @: existing vertices to be updated\\n\\t# 1/4 *---* 0 The higher mask values on neighbouring vertices, \\n\\t# the more likely a square mesh will be refined into a sphere.\\n\\t \\n\\t\\tif valence == 1:\\n\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tprint\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tnew_x += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\tnew_y += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\tnew_z += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\n\\t\\t\\tfor node_in_ring2 in ring2:\\n\\t\\t\\t\\tnew_x += 0.*mesh.give_nodes().give_coor()[node_in_ring2][0]\\n\\t\\t\\t\\tnew_y += 0.*mesh.give_nodes().give_coor()[node_in_ring2][1]\\n\\t\\t\\t\\tnew_z += 0.*mesh.give_nodes().give_coor()[node_in_ring2][2]\\n\\t\\t\\t\\t\\n\\t\\t\\tnew_x += 2./4.*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += 2./4.*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += 2./4.*mesh.give_nodes().give_coor()[node_index][2]\\n\\n\\t# 5. update existing boundary joint vertex\\n\\t# 3/4\\n\\t# 1/8 *---*---* 1/8 *: newly-generated vertices\\n\\t# | | | @: existing vertices to be updated\\n\\t# 0 *---*---* 0\\n\\n\\t\\telif valence == 2:\\n\\t\\t\\t\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tif helper.find_valence(node_in_ring1, new_faces) <= 2: \\n\\t\\t\\t\\t\\tnew_x += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\t\\tnew_y += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\t\\tnew_z += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tnew_x += 3./4.*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += 3./4.*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += 3./4.*mesh.give_nodes().give_coor()[node_index][2]\\n\\t\\n\\t# 6. update new node on interior edge\\n\\t# * r/k\\n\\t# /\\\\ b/k*\\n\\t# *__/ \\\\___ r/k\\n\\t# \\\\ \\\\ /¬¬/ *: newly-generated vertices: \\n\\t# \\\\ \\\\/ / b = 3/2/valence, r = 1/4/valence\\n\\t# *--@--* b/k\\t @: existing vertices to be updated: 1-b-r\\t\\t\\n\\t# / /\\\\ \\\\\\n\\t# /__/ \\\\__\\\\\\n\\t# * \\\\ / * r/k\\n\\t# \\\\/\\n\\t\\t\\n\\t\\telse:\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tbeta = 3./2./valence\\n\\t\\t\\tgamma = 1./4./valence\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tnew_x += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\tnew_y += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\tnew_z += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\t\\t\\t\\n\\t\\t\\tfor node_in_ring2 in ring2:\\n\\t\\t\\t\\tnew_x += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][0]\\n\\t\\t\\t\\tnew_y += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][1]\\n\\t\\t\\t\\tnew_z += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][2]\\n\\t\\t\\t\\n\\t\\t\\tnew_x += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][2]\\n\\t\\t\\n\\t\\tnew_coor[node_index] = (new_x, new_y, new_z)\\n\\t\\n\\tnew_nodes = geo.Node(new_coor)\\n\\t\\n\\tmesh.update(new_nodes, new_edges, new_faces)\\n\\t\\n\\t# return new_mesh\\n\\treturn mesh\",\n \"def defineCircleLayout(self):\\n # Define a 2-D array representing the position of each mesh point\\n self.xPoints = self.frange(0,self.R,self.h)\\n self.yPoints = self.frange(0,self.R,self.h)\\n\\n # Position of internal mesh points\\n internal_xyCoord = [(i,j) for i in self.xPoints for j in self.yPoints if (i - self.R)**2 + (j - self.R)**2 < self.R^2] \\n\\n # Define the dictionary containing internal points\\n for k in internal_xyCoord:\\n x = k[0]\\n y = k[1]\\n xLabel = xPoints.index(x)\\n yLabel = yPoints.index(y)\\n self.internalPoints[(xLabel,yLabel)] = meshPoint(type = 'internal',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n\\n # Position of the boundary points\\n # Find the intersection of each mesh line with the circle\\n # For a given vertical mesh line: \\n # y = R - sqrt(R^2 - (x-R)^2) & y = R + sqrt(R^2 - (x-R)^2)\\n # For a given horizontal mesh line: \\n # x = R - sqrt(R^2 - (y-R)^2) & x = R + sqrt(R^2 - (y-R)^2)\\n boundary_xyCoord = [(0,self.R),(self.R,0),(self.R,2*self.R),(2*self.R,self.R)] + [(x,self.R - math.sqrt(self.R**2 - (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(x,self.R - math.sqrt(self.R**2 + (x-self.R)**2)) for x in self.xPoints[1:len(self.xPoints)-1]] + [(self.R - math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] + [(self.R + math.sqrt(self.R**2 - (y-self.R)**2),y) for y in self.yPoints[1:len(yPoints)-1]] \\n\\n # Define the dictionary containing boundary points\\n for k in boundary_xyCoord:\\n x = k[0]\\n y = k[1]\\n [xLabel,yLabel] = self.findLabel(x,y)\\n self.boundaryPoints[(xLabel,yLabel)] = meshPoint(type = 'boundary',x = x, y = y, xLabel = xLabel, yLabel = yLabel) \\n \\n # Now that we have assigned the labels we can define fE, fW, fN and fS\\n self.fCalc()\",\n \"def sketch_und_part(self):\\n if (self.dimension == '3D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(-self.laenge_x/2.0, -self.laenge_y/2.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0))\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseSolidExtrude(\\n sketch=self.sketch_Wuerfel,\\n depth=self.laenge_z/2.0) #z-Symmetrie\\n #Sketch Pore zeichnen (fuer Quader und Zylinder)\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Ellipsoid' ):\\n matlab.ellipsoidIgesOut(\\n self.porenparameter_x,\\n self.porenparameter_y,\\n self.porenparameter_z,\\n 'Ellipsoid')\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.sketch_Pore.ConstructionLine(\\n # point1=(0.0, -100.0),\\n # point2=(0.0, 100.0))\\n # self.sketch_Pore.EllipseByCenterPerimeter(\\n # center=(0.0, 0.0),\\n # axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n # axisPoint2=(0.0, self.porenparameter_y/2.0))\\n # self.sketch_Pore.autoTrimCurve(\\n # curve1=self.sketch_Pore.geometry[3],\\n # point1=(-self.porenparameter_x/2.0, 0.0))\\n # self.sketch_Pore.Line(\\n # point1=(0.0, self.porenparameter_y/2.0),\\n # point2=(0.0, -self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n if (self.typ_Pore == 'Ellipsoid' ):\\n # if (self.porenparameter_x == self.porenparameter_z):\\n # self.part_Pore.BaseSolidRevolve(\\n # sketch=self.sketch_Pore,\\n # angle=360.0,\\n # flipRevolveDirection=OFF)\\n self.iges_Datei = mdb.openIges(\\n 'Ellipsoid.igs',\\n msbo=False,\\n trimCurve=DEFAULT,\\n scaleFromFile=OFF)\\n self.model.PartFromGeometryFile(\\n name=self.name+'_Pore',\\n geometryFile=self.iges_Datei,\\n combine=False,\\n stitchTolerance=1.0,\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY,\\n convertToAnalytical=1,\\n stitchEdges=1,\\n scale=1) # Skalierung\\n self.part_Pore = self.model.parts[self.name+'_Pore']\\n self.part_Pore.AddCells(\\n faceList = self.part_Pore.faces,\\n flipped=False)\\n del self.iges_Datei\\n os.remove('abaqus_read_iges0.log') #Arbeitsordner aufraeumen\\n os.remove('temp-Ellipsoid-new.sat')\\n os.remove('Ellipsoid.igs')\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=THREE_D,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseSolidExtrude(\\n sketch=self.sketch_Pore,\\n depth=self.porenparameter_z)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n #Translation\\n self.assembly.translate(\\n instanceList=(self.name+'_Wuerfel', ),\\n vector=(0.0, 0.0, -self.laenge_z/2.0))\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, 0.0))\\n elif (self.typ_Pore == 'Quader' or 'Zylinder'):\\n self.assembly.translate(\\n instanceList=(self.name+'_Pore', ),\\n vector=(0.0, 0.0, -self.porenparameter_z/2.0))\\n #Rotation\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(1.0, 0.0, 0.0),\\n angle=self.porenparameter_rx)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 1.0, 0.0),\\n angle=self.porenparameter_ry)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, 0.0),\\n axisDirection=(0.0, 0.0,1.0),\\n angle=self.porenparameter_rz)\\n #Schneiden\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n # del self.model.parts[self.name+'_Wuerfel']\\n # del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n elif (self.dimension == '2D'):\\n #Sketch Wuerfel zeichnen\\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\\n name='Seitenansicht_Wuerfel',\\n sheetSize=200.0)\\n self.sketch_Wuerfel.rectangle(\\n point1=(0.0, 0.0),\\n point2=(self.laenge_x/2.0, self.laenge_y/2.0)) #x- und y-Symmetrie\\n #Part Wuerfel generieren\\n self.part_Wuerfel = self.model.Part(\\n name=self.name+'_Wuerfel',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Wuerfel.BaseShell(sketch=self.sketch_Wuerfel)\\n #Sketch Pore zeichnen\\n self.sketch_Pore = self.model.ConstrainedSketch(\\n name='Seitenansicht_Pore',\\n sheetSize=200.0)\\n if (self.typ_Pore == 'Ellipsoid'):\\n self.sketch_Pore.ConstructionLine(\\n point1=(0.0, -100.0),\\n point2=(0.0, 100.0))\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n self.sketch_Pore.autoTrimCurve(\\n curve1=self.sketch_Pore.geometry[3],\\n point1=(-self.porenparameter_x/2.0, 0.0))\\n self.sketch_Pore.Line(\\n point1=(0.0, self.porenparameter_y/2.0),\\n point2=(0.0, -self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Quader'):\\n self.sketch_Pore.rectangle(\\n point1=(-self.porenparameter_x/2.0, -self.porenparameter_y/2.0),\\n point2=(self.porenparameter_x/2.0, self.porenparameter_y/2.0))\\n elif (self.typ_Pore == 'Zylinder'):\\n self.sketch_Pore.EllipseByCenterPerimeter(\\n center=(0.0, 0.0),\\n axisPoint1=(self.porenparameter_x/2.0, 0.0),\\n axisPoint2=(0.0, self.porenparameter_y/2.0))\\n else:\\n print('typ_Pore Error!')\\n #Part Pore generieren\\n self.part_Pore = self.model.Part(\\n name=self.name+'_Pore',\\n dimensionality=TWO_D_PLANAR,\\n type=DEFORMABLE_BODY)\\n self.part_Pore.BaseShell(sketch=self.sketch_Pore)\\n #Assemble\\n self.assembly = self.model.rootAssembly\\n self.assembly.DatumCsysByDefault(CARTESIAN)\\n self.assembly.Instance(\\n name=self.name+'_Wuerfel',\\n part=self.part_Wuerfel,\\n dependent=ON)\\n self.assembly.Instance(\\n name=self.name+'_Pore',\\n part=self.part_Pore,\\n dependent=ON)\\n self.assembly.rotate(\\n instanceList=(self.name+'_Pore', ),\\n axisPoint=(0.0, 0.0, self.laenge_z/2.0),\\n axisDirection=(0.0, 0.0, self.laenge_z/2.0+1),\\n angle=self.porenparameter_rz)\\n self.assembly.InstanceFromBooleanCut(\\n name='RVE',\\n instanceToBeCut=self.assembly.instances[self.name+'_Wuerfel'],\\n cuttingInstances=(self.assembly.instances[self.name+'_Pore'], ),\\n originalInstances=SUPPRESS)\\n self.assembly.deleteFeatures((self.name+'_Wuerfel', self.name+'_Pore', ))\\n del self.model.parts[self.name+'_Wuerfel']\\n #del self.model.parts[self.name+'_Pore']\\n self.part_RVE = self.model.parts[self.name]\\n else:\\n print('dimension Error!')\",\n \"def fill_paths_section():\\n section = _SectionData(\\\"Paths\\\")\\n section.props.append((\\\"ProjectPath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.scs_project_path)))\\n section.props.append((\\\"\\\", \\\"\\\"))\\n section.props.append((\\\"ShaderPresetsFilePath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.shader_presets_filepath)))\\n section.props.append((\\\"TriggerActionsRelFilePath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_rel_path)))\\n section.props.append((\\\"TriggerActionsUseInfixed\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.trigger_actions_use_infixed))))\\n section.props.append((\\\"SignRelFilePath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_rel_path)))\\n section.props.append((\\\"SignUseInfixed\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.sign_library_use_infixed))))\\n section.props.append((\\\"TSemProfileRelFilePath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_rel_path)))\\n section.props.append((\\\"TSemProfileUseInfixed\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.tsem_library_use_infixed))))\\n section.props.append((\\\"TrafficRulesRelFilePath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_rel_path)))\\n section.props.append((\\\"TrafficRulesUseInfixed\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.traffic_rules_library_use_infixed))))\\n section.props.append((\\\"HookupRelDirPath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.hookup_library_rel_path)))\\n section.props.append((\\\"MatSubsRelFilePath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.matsubs_library_rel_path)))\\n section.props.append((\\\"ConvertersPath\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.conv_hlpr_converters_path)))\\n section.props.append((\\\"UseAlternativeBases\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.use_alternative_bases))))\\n return section\",\n \"def defineBLOCKSECTION(f,layernamelist):\\r\\n feilinname_lineheight=2.5\\r\\n #note_lineheigh=4\\r\\n layercount=0\\r\\n feilin_name_pos=[70.0+globalconfig.CUTLINE_X_OFFSET,185.0+globalconfig.CUTLINE_Y_OFFSET]\\r\\n #note_pos=[190.0+globalconfig.CUTLINE_X_OFFSET,80.0+globalconfig.CUTLINE_Y_OFFSET]\\r\\n f.write(\\\"0\\\\nSECTION\\\\n2\\\\nBLOCKS\\\\n\\\") #绘制块定义\\r\\n f.write(\\\"0\\\\nBLOCK\\\\n8\\\\n0\\\\n2\\\\nROUND_1\\\\n70\\\\n0\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n\\\")\\r\\n f.write(\\\"0\\\\nPOLYLINE\\\\n8\\\\n0\\\\n5\\\\n3F\\\\n66\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n70\\\\n1\\\\n\\\")\\r\\n f.write(\\\"40\\\\n0.04\\\\n41\\\\n0.04\\\")\\r\\n f.write(\\\"\\\\n0\\\\nVERTEX\\\\n5\\\\n406\\\\n8\\\\n0\\\\n10\\\\n-0.02\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n42\\\\n1.0\\\")\\r\\n f.write(\\\"\\\\n0\\\\nVERTEX\\\\n5\\\\n407\\\\n8\\\\n0\\\\n10\\\\n0.02\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n42\\\\n1.0\\\\n0\\\\nSEQEND\\\\n5\\\\n408\\\\n8\\\\n0\\\\n\\\")\\r\\n f.write(\\\"0\\\\nENDBLK\\\\n5\\\\n43\\\\n8\\\\n0\\\\n\\\") \\r\\n \\r\\n for layername in layernamelist:\\r\\n layercount=layercount+1\\r\\n f.write(\\\"0\\\\nBLOCK\\\\n8\\\\n0\\\\n2\\\\n*U\\\"+str(layercount)+\\\"\\\\n\\\") \\r\\n f.write(\\\"70\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n\\\") \\r\\n f.write(\\\"0\\\\nTEXT\\\\n5\\\\n46\\\\n8\\\\n\\\"+layername+\\\"\\\\n6\\\\nCONTINUOUS\\\\n10\\\\n\\\"+str(feilin_name_pos[0])+\\\"\\\\n20\\\\n\\\"+str(feilin_name_pos[1])+\\\"\\\\n30\\\\n0.0\\\\n\\\")\\r\\n f.write(\\\"40\\\\n\\\"+str(feilinname_lineheight)+\\\"\\\\n1\\\\n\\\"+globalconfig.NAME_OF_FEILIN+\\\"-\\\"+layername+\\\"\\\\n0\\\\nENDBLK\\\\n5\\\\n47\\\\n8\\\\n\\\"+layername+\\\"\\\\n\\\")\\r\\n \\r\\n# layercount=layercount+1\\r\\n# f.write(\\\"0\\\\nBLOCK\\\\n8\\\\n0\\\\n2\\\\n*U\\\"+str(layercount)+\\\"\\\\n\\\") \\r\\n# f.write(\\\"70\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n\\\") \\r\\n# f.write(\\\"0\\\\nTEXT\\\\n5\\\\n46\\\\n8\\\\n\\\"+layername+\\\"\\\\n6\\\\nCONTINUOUS\\\\n10\\\\n\\\"+str(note_pos[0])+\\\"\\\\n20\\\\n\\\"+str(note_pos[1])+\\\"\\\\n30\\\\n0.0\\\\n\\\")\\r\\n# f.write(\\\"40\\\\n\\\"+str(note_lineheigh)+\\\"\\\\n1\\\\n\\\")\\r\\n# f.write(\\\"\\\")\\r\\n# f.write(\\\"\\\\n0\\\\nENDBLK\\\\n5\\\\n47\\\\n8\\\\n0\\\\n\\\") \\r\\n \\r\\n f.write(\\\"0\\\\nENDSEC\\\\n\\\")\",\n \"def find_section(amdpar_xml):\\n siblings = [s for s in amdpar_xml.itersiblings()]\\n\\n if len(siblings) == 0:\\n return find_lost_section(amdpar_xml)\\n\\n for sibling in siblings:\\n if sibling.tag == 'SECTION':\\n return sibling\\n\\n paragraphs = [s for s in siblings if s.tag == 'P']\\n if len(paragraphs) > 0:\\n return fix_section_node(paragraphs, amdpar_xml)\",\n \"def fix_section_node(paragraphs, amdpar_xml):\\n\\n sections = [s for s in amdpar_xml.itersiblings(preceding=True)\\n if s.tag == 'SECTION']\\n\\n # Let's only do this if we find one section tag.\\n if len(sections) == 1:\\n section = deepcopy(sections[0])\\n for paragraph in paragraphs:\\n section.append(deepcopy(paragraph))\\n return section\",\n \"def __getGeometryComponents(self):\\n # get dagPath and member components of skined shape\\n # the deformerSet pretty controls which vertex is deformed by the skinCluster\\n # the deformerSet will allows us to pull out that components(vertex) mobject that we need\\n fnSet = openmaya.MFnSet(self.fn.deformerSet())\\n members = openmaya.MSelectionList()\\n # the MSelectionList contains the vertex information in the deformerSet above\\n fnSet.getMembers(members, False)\\n\\n dagPath = openmaya.MDagPath()\\n components = openmaya.MObject()\\n\\n # dagPath: dagPath of influence objects(joint)\\n # components: mesh components(vertex)\\n members.getDagPath(0, dagPath, components)\\n\\n return dagPath, components\",\n \"def calib2sections(dirname):\\n\\n if os.path.isfile(dirname):\\n return v2calib2sections(dirname)\\n\\n # Get centres of the sections, and apply corrections.\\n s_cen = calib2tensor3(dirname, \\\"center\\\") \\\\\\n + calib2tensor3(dirname, \\\"center_corr\\\")\\n\\n # Get the rotation of sections, and apply corrections. Note that\\n # sections 0, 1 and 4, 5 are antiparallel!\\n s_rot = calib2tensor3(dirname, \\\"rotation\\\") \\\\\\n + calib2tensor3(dirname, \\\"tilt\\\")\\n\\n # Get the margin, gap, and shift adjustments of the sections within\\n # each quadrant.\\n s_mgs = calib2tensor3(dirname, \\\"marg_gap_shift\\\")\\n\\n # Get offsets of the quadrants, and apply corrections.\\n q_off = calib2tensor3(dirname, \\\"offset\\\") \\\\\\n + calib2tensor3(dirname, \\\"offset_corr\\\")\\n\\n # Get rotation of the quadrants, and apply corrections.\\n q_rot = calib2tensor3(dirname, \\\"quad_rotation\\\") \\\\\\n + calib2tensor3(dirname, \\\"quad_tilt\\\")\\n\\n # The third coordinate is ignored for now, even though optical\\n # measurement gives a variation in Z up to 0.6 mm.\\n sections = []\\n for q in range(s_cen.shape[0]):\\n sections.append([])\\n for s in range(s_cen.shape[1]):\\n sec = Section()\\n sec.translate((s_mgs[0, 0] + s_cen[q, s, 0],\\n s_mgs[1, 0] + s_cen[q, s, 1]))\\n sec.srotate(s_rot[q, s])\\n sec.qrotate(q_rot[q])\\n sec.translate((s_mgs[0, 1] + q_off[0, q],\\n s_mgs[1, 1] + q_off[1, q]))\\n\\n # XXX I still don't understand this bit!\\n if (q == 0):\\n sec.translate((-s_mgs[0, 2] + s_mgs[0, 3],\\n -s_mgs[1, 2] - s_mgs[1, 3]))\\n elif (q == 1):\\n sec.translate((-s_mgs[0, 2] - s_mgs[0, 3],\\n +s_mgs[1, 2] - s_mgs[1, 3]))\\n elif (q == 2):\\n sec.translate((+s_mgs[0, 2] - s_mgs[0, 3],\\n +s_mgs[1, 2] + s_mgs[1, 3]))\\n elif (q == 3):\\n sec.translate((+s_mgs[0, 2] + s_mgs[0, 3],\\n -s_mgs[1, 2] + s_mgs[1, 3]))\\n\\n sections[q].append(sec)\\n return (sections)\",\n \"def getShape(transform):\\n\\n pass\",\n \"def get_section(self, section_name: str) -> NetSection:\\n return self.sections[section_name]\",\n \"def create_partition(mesh,polygons,enforce_exact=False):\",\n \"def squarePrimitive(self):\\n\\n def drawWireframe(self):\\n\\n # Draw line\\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\\n\\n # Get Color\\n # self.getColor(\\\"edge\\\")\\n\\n for edges in SQUARE[\\\"EDGES\\\"]:\\n for edge in edges:\\n\\n point = OpenMaya.MVector(edge[0], edge[1], edge[2])\\n point *= self.shape_size\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n \\n \\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n\\n def drawShaded(self):\\n\\n # Draw quad\\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\\n\\n # Get Color\\n # self.getColor(\\\"polygon\\\")\\n\\n for polygons in SQUARE[\\\"POLYGONS\\\"]:\\n for polygon in polygons:\\n\\n point = OpenMaya.MVector(polygon[0], polygon[1], polygon[2])\\n point *= self.shape_size\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n\\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\\n\\n # Draw lines\\n if self.draw_type == 0 or self.draw_type == 2:\\n drawWireframe(self)\\n \\n # Draww Polygons\\n if self.draw_type == 1 or self.draw_type == 2:\\n drawShaded(self)\\n\\n glFT.glEndList()\",\n \"def draw_shape(self, image, shape, p, color):\\n # Get the center x, y and the size s\\n p = p['shape_attributes']\\n if shape == 'rect':\\n image = cv2.rectangle(\\n image, (p['x'], p['y']), (p['x'] + p['width'], p['y'] + p['height']), color, -1)\\n elif shape == \\\"circle\\\":\\n #image = cv2.circle(image, (p['cx'], p['cy']), np.int(p['r']), color, -1)\\n image = cv2.rectangle(image, (p['cx']-np.int32(p['r']/2.0), p['cy']-np.int32(\\n p['r']/2.0)), (p['cx'] + np.int32(p['r']), p['cy'] + np.int32(p['r'])), color, -1)\\n elif shape == \\\"point\\\":\\n #image = cv2.circle(image, (p['cx'], p['cy']), 15, color, -1)\\n image = cv2.rectangle(\\n image, (p['cx']-8, p['cy']-8), (p['cx']+16, p['cy']+16), color, -1)\\n elif shape == \\\"polygon\\\":\\n pts = np.zeros((len(p['all_points_x']), 2), np.int32)\\n for i in range(len(p['all_points_x'])):\\n pts[i] = [p['all_points_x'][i], p['all_points_y'][i]]\\n if (self.config.MODE == \\\"Combined\\\"):\\n pts = pts.reshape((-1, 1, 2))\\n elif (self.config.MODE == \\\"Separate\\\"):\\n pts = pts.reshape((1, -1, 2))\\n image = cv2.fillPoly(image, pts, color, lineType=cv2.LINE_AA)\\n\\n return image\",\n \"def test_sections_flat_no_sections(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n self.assertEqual(story.structure.sections_flat, [])\",\n \"def test_sections_flat_no_sections(self):\\n title = (\\\"Neighborhood Outreach for I-70 Alignment Impacting \\\"\\n \\\"Elyria, Globeville and Swansea\\\")\\n summary = \\\"\\\"\\\"\\n The City of Denver and Colorado Department of Transportation \\n (CDOT) are working together to do neighborhood outreach\\n regarding the I-70 alignment between Brighton Boulevard and\\n Colorado. For detailed information on the neighborhood outreach\\n efforts please visit www.DenverGov.org/ccdI70.\\n \\\"\\\"\\\"\\n byline = \\\"Denver Public Works and CDOT\\\"\\n story = create_story(title=title, summary=summary, byline=byline)\\n self.assertEqual(story.structure.sections_flat, [])\",\n \"def shape(self):\\n return self._shape\",\n \"def _fix_section(self, section):\\n section_copy = copy.deepcopy(section)\\n\\n # Formulate characteristics based on name if they weren't provided.\\n if not section_copy.Characteristics:\\n _characteristics = [construct.IMAGE_SCN_MEM_READ]\\n if section_copy.Name == u'.text':\\n _characteristics += [construct.IMAGE_SCN_CNT_CODE, construct.IMAGE_SCN_MEM_EXECUTE]\\n else:\\n _characteristics += [construct.IMAGE_SCN_CNT_INITIALIZED_DATA]\\n if section_copy.Name == u'.data':\\n _characteristics += [construct.IMAGE_SCN_MEM_WRITE]\\n if section_copy.Name == u'.reloc':\\n _characteristics += [construct.IMAGE_SCN_MEM_DISCARDABLE]\\n section_copy.Characteristics = _characteristics\\n\\n # FlagEnums must be a dictionary.\\n if isinstance(section_copy.Characteristics, list):\\n section_copy.Characteristics = {flag: True for flag in section_copy.Characteristics}\\n\\n # Fix up data to be consistent.\\n data_size = max(section_copy.SizeOfRawData, len(section_copy.data))\\n section_copy.SizeOfRawData = data_size\\n section_copy.data = section_copy.data.ljust(data_size, b'\\\\x00')[:data_size]\\n\\n return section_copy\",\n \"def plate_sections(self):\\n return avl.SectionFromCurve(quantify=len(self.sections),\\n curve_in=self.sections[child.index].curve)\",\n \"def _getshapepoly(self, polygon, compound=False):\\n if self._resizemode == \\\"user\\\" or compound:\\n t11, t12, t21, t22 = self._shapetrafo\\n elif self._resizemode == \\\"auto\\\":\\n l = max(1, self._pensize/5.0)\\n t11, t12, t21, t22 = l, 0, 0, l\\n elif self._resizemode == \\\"noresize\\\":\\n return polygon\\n return tuple((t11*x + t12*y, t21*x + t22*y) for (x, y) in polygon)\",\n \"def htmlFoldingSection(header, content, isClosed=True,\\n headerClass='section-header',\\n contentClass='section-content'):\\n if isClosed:\\n s = '<div class=\\\"section-closed\\\" onclick=\\\"toggleSection(this);\\\">'\\n else:\\n s = '<div class=\\\"section-open\\\" onclick=\\\"toggleSection(this);\\\">'\\n s += '<span class=\\\"%s\\\">%s</span></div>\\\\n' % (headerClass,header)\\n h = ' hidden' if isClosed else ''\\n s += '<div class=\\\"%s%s\\\">\\\\n%s</div>\\\\n' % (contentClass,h,content)\\n return s\",\n \"def processed_shape(self, shape):\\n return shape\",\n \"def scenarioReference_factory(i, section_type, root, this):\\n \\n # no loops in section, should print 0\\n if i == 0:\\n return ScenarioReference()\\n \\n if section_type == SectionType.Plant:\\n name = root.plants.nameof(i)\\n scen = ScenarioReference(SectionType.Plant, name, root, this)\\n \\n elif section_type == SectionType.Op:\\n name = root.ops.nameof(i)\\n scen = ScenarioReference(SectionType.Op, name, root, this)\\n \\n elif section_type == SectionType.Ini:\\n name = root.inis.nameof(i)\\n scen = ScenarioReference(SectionType.Ini, name, root, this)\\n \\n elif section_type == SectionType.Surf:\\n name = root.surfs.nameof(i)\\n scen = ScenarioReference(SectionType.Surf, name, root, this)\\n \\n elif section_type == SectionType.Contour:\\n name = root.contours.nameof(i)\\n scen = ScenarioReference(SectionType.Contour, name, root, this)\\n \\n elif section_type == SectionType.Drain:\\n name = root.drains.nameof(i)\\n scen = ScenarioReference(SectionType.Drain, name, root, this)\\n \\n elif section_type == SectionType.Year:\\n name = root.years.nameof(i)\\n scen = ScenarioReference(SectionType.Year, name, root, this)\\n \\n else:\\n raise ValueError('Unknown SectionType')\\n \\n return scen\",\n \"def shape(self):\\r\\n return self._shape\",\n \"def shape(self) -> str:\\n return \\\"circle\\\"\",\n \"def shape(self):\\n return None\",\n \"def get_section(\\n self,\\n *,\\n position: Union[List[float], float] = None,\\n min_positions: int = None,\\n load_case: int = None,\\n ) -> Tuple[List[float], List[Section]]:\\n\\n if self.beam is None:\\n raise SectionOnlyError(\\n f\\\"get_section does not apply to Section based CodeCheck objects.\\\"\\n )\\n\\n return self.beam.get_section(\\n position=position, min_positions=min_positions, load_case=load_case\\n )\",\n \"def _section0(self):\\n h = self._sectionheader()\\n s = Section0(h)\\n s.p = []\\n\\n # fixed pointers for 12 sections (0-11)\\n for _ in range(0, 12):\\n pointer = self._sectionpointer()\\n s.p.append(pointer)\\n\\n # additional section pointers\\n # each pointer 10 bytes\\n # 12 pointers length = 120\\n restlen = h.len - 120 - 16\\n if restlen > 0:\\n # FIXME check starting range\\n for _ in range(1, restlen/10):\\n pointer = self._sectionpointer()\\n s.p.append(pointer)\\n return s\",\n \"def create_sections(self, checkpoints):\\n # create map for constant computing of the current sector\\n s = np.shape(self.track)\\n # reduce number of checkpoints and convert it to pygame format\\n #checkpoints = checkpoints[::20] <- this is now done immediately after the watershed algorithm\\n checkpoint_map = np.ones(s, dtype=np.int) * len(checkpoints)\\n for i in range(s[0]):\\n for j in range(s[1]):\\n if self.track[i, j]: # if current point is not an obstacle\\n checkpoint_map[i, j] = int(find_closest_point_index((j, i), checkpoints))\\n\\n # flip x and y axis\\n checkpoints = np.flip(checkpoints, axis=1)\\n section_counter = [0] * len(checkpoints)\\n\\n return checkpoints, section_counter, checkpoint_map\",\n \"def corners_asic(self):\\n a = int(round(self.angle / 90.0)) % 4\\n c = self.corners(True)\\n\\n if (a == 0):\\n # The section is \\\"standing up\\\", and the top left corner is given\\n # by the first corner.\\n ul0 = [int(round(c[a][0])), int(round(c[a][1]))]\\n ul1 = [ul0[0] + 194 + 3, ul0[1]]\\n dlr = [194, 185]\\n elif (a == 2):\\n # The section is \\\"standing up\\\", and the top left corner is given\\n # by the third corner.\\n ul1 = [int(round(c[a][0])), int(round(c[a][1]))]\\n ul0 = [ul1[0] + 194 + 3, ul1[1]]\\n dlr = [194, 185]\\n elif (a == 1):\\n # The section is \\\"laying down\\\", and the top left corner is given\\n # by the second corner.\\n ul0 = [int(round(c[a][0])), int(round(c[a][1]))]\\n ul1 = [ul0[0], ul0[1] + 194 + 3]\\n dlr = [185, 194]\\n elif (a == 3):\\n # The section is \\\"laying down\\\", and the top left corner is given\\n # by the forth corner.\\n ul1 = [int(round(c[a][0])), int(round(c[a][1]))]\\n ul0 = [ul1[0], ul1[1] + 194 + 3]\\n dlr = [185, 194]\\n\\n coords = [\\n [ul0[0], ul0[1], ul0[0] + dlr[0], ul0[1] + dlr[1]],\\n [ul1[0], ul1[1], ul1[0] + dlr[0], ul1[1] + dlr[1]]]\\n return (coords)\",\n \"def _section(self, node, offset_mngr):\\n infon = self.infon_dict(node)\\n type_ = infon.get('type')\\n text = self._text(node)\\n if not text:\\n # Text and annotations at sentence level.\\n offset = offset_mngr.start(node)\\n text, anno = [], []\\n for sent in self._iterfind(node, 'sentence'):\\n text.append(self._sentence(sent, offset_mngr))\\n anno.extend(self._get_annotations(sent, offset_mngr))\\n else:\\n # Text and annotations at passage level.\\n offset = offset_mngr.update(node, text)\\n anno = list(self._get_annotations(node, offset_mngr))\\n return type_, text, offset, infon, anno\",\n \"def fill_import_section():\\n section = _SectionData(\\\"Import\\\")\\n section.props.append((\\\"ImportScale\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.import_scale)))\\n section.props.append((\\\"PreservePathForExport\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_preserve_path_for_export))))\\n section.props.append((\\\"ImportPimFile\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pim_file))))\\n section.props.append((\\\"UseWelding\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_use_welding))))\\n section.props.append((\\\"WeldingPrecision\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_welding_precision))))\\n section.props.append((\\\"UseNormals\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_use_normals))))\\n section.props.append((\\\"ImportPitFile\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pit_file))))\\n section.props.append((\\\"LoadTextures\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_load_textures))))\\n section.props.append((\\\"ImportPicFile\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pic_file))))\\n section.props.append((\\\"ImportPipFile\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pip_file))))\\n section.props.append((\\\"ImportPisFile\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pis_file))))\\n section.props.append((\\\"ConnectedBones\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_connected_bones))))\\n section.props.append((\\\"BoneImportScale\\\", _property_utils.get_by_type(bpy.types.GlobalSCSProps.import_bone_scale)))\\n section.props.append((\\\"ImportPiaFile\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_pia_file))))\\n section.props.append((\\\"IncludeSubdirsForPia\\\", int(_property_utils.get_by_type(bpy.types.GlobalSCSProps.import_include_subdirs_for_pia))))\\n return section\",\n \"def get_shape(network):\\n from openpnm.topotools.generators.tools import get_shape\\n d = {'vert.coords': network.coords, 'edge.conns': network.conns}\\n shp = get_shape(d)\\n return shp\",\n \"def compound(self):\\n return self._compound\",\n \"def Draw(self,SectionFunction=circlespacking,Secargs = None,standalone=True,fig = None):\\n # Local imports\\n import random\\n import inPy.Backend.BackendPlot as PlotBundle\\n\\n # if the user did not specify Secargs, set to\\n # (self.R,self.BundleR,self.SparsingCoeff)\\n if Secargs == None:\\n Secargs = (self.R,self.BundleR,self.SparsingCoeff)\\n\\n # R = 0 should not be Used\\n # but just in case\\n if self.R == 0:\\n Rprime = 1\\n else:\\n Rprime = self.R\\n\\n # if Rprime == 1\\n # this means only one filament in the strands\\n if Rprime == 1:\\n for path in self.CCWpath:\\n fig = PlotBundle.Plot_Path(path.Lx, path.Ly, path.Lz,fig,tube_radius=self.FilR)\\n for path in self.CWpath:\\n fig = PlotBundle.Plot_Path(path.Lx, path.Ly, path.Lz,fig,tube_radius=self.FilR)\\n else:\\n # multiple filaments\\n Coords = SectionFunction(*Secargs)\\n for path in self.CCWpath:\\n for Position in Coords:\\n fig = PlotBundle.Plot_Path(np.array(path.Lx)+Position[0], np.array(path.Ly)+Position[1], path.Lz,fig,tube_radius=self.FilR)\\n for path in self.CWpath:\\n for Position in Coords:\\n fig = PlotBundle.Plot_Path(np.array(path.Lx)+Position[0], np.array(path.Ly)+Position[1], path.Lz,fig,tube_radius=self.FilR)\\n if standalone:\\n PlotBundle.show()\\n else:\\n return fig\",\n \"def XCAFDoc_ShapeTool_IsCompound(*args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_IsCompound(*args)\",\n \"def do_section(parser, token, template='parts/section.html', end='endsection'):\\n bits = token.split_contents()[1:]\\n if len(bits) is 0:\\n title, attrs = '', {}\\n elif len(bits) is 1:\\n title, attrs = bits[0], {}\\n elif len(bits) % 2 is 0:\\n raise template.TemplateSyntaxError(\\\"Your attributes don't match up: %s\\\" % ', '.join(bits[1:]))\\n else:\\n title = bits[0]\\n attrs = dict(zip(bits[1::2], bits[2::2]))\\n nodelist = parser.parse((end,))\\n parser.delete_first_token()\\n return SectionNode(template, title, attrs, nodelist)\",\n \"def convert_shape(g, op, block):\\n\\n x = g.get_node(op.input(\\\"Input\\\")[0])\\n out = shape_of(x, dtype=\\\"int32\\\")\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def get_shape_line_intersections(cls, shape, line):\\n shape_inter = IntCurvesFace_ShapeIntersector()\\n shape_inter.Load(shape, 1e-3)\\n shape_inter.PerformNearest(line, float(\\\"-inf\\\"), float(\\\"+inf\\\"))\\n with assert_isdone(shape_inter, \\\"failed to computer shape / line intersection\\\"):\\n intersections = [(shape_inter.Pnt(i), shape_inter.Face(i), line) for i in\\n range(1, shape_inter.NbPnt() + 1)] # Indices start at 1 :(\\n return intersections\",\n \"def subdivide(network, pores, shape, labels=[]):\\n mro = network._mro()\\n if 'Cubic' not in mro:\\n raise Exception('Subdivide is only supported for Cubic Networks')\\n from openpnm.network import Cubic\\n pores = network._parse_indices(pores)\\n\\n # Checks to find boundary pores in the selected pores\\n if 'pore.boundary' in network.labels():\\n if (np.in1d(pores, network.pores('boundary'))).any():\\n raise Exception('boundary pores cannot be subdivided!')\\n if not hasattr(network, '_subdivide_flag'):\\n network._subdivide_flag = True\\n else:\\n raise Exception('The network has subdivided pores, so the method \\\\\\n does not support another subdivision')\\n # Assigning right shape and division\\n if np.size(shape) != 2 and np.size(shape) != 3:\\n raise Exception('Subdivide not implemented for Networks other than 2D and 3D')\\n if np.size(shape) == 3 and 1 not in shape:\\n div = np.array(shape, ndmin=1)\\n single_dim = None\\n else:\\n single_dim = np.where(np.array(get_shape(network)) == 1)[0]\\n if np.size(single_dim) == 0:\\n single_dim = None\\n if np.size(shape) == 3:\\n div = np.array(shape, ndmin=1)\\n else:\\n div = np.zeros(3, dtype=np.int32)\\n if single_dim is None:\\n dim = 2\\n else:\\n dim = single_dim\\n div[dim] = 1\\n div[-np.array(div, ndmin=1, dtype=bool)] = np.array(shape, ndmin=1)\\n\\n # Creating small network and handling labels\\n networkspacing = get_spacing(network)\\n new_netspacing = networkspacing/div\\n new_net = Cubic(shape=div, spacing=new_netspacing)\\n main_labels = ['front', 'back', 'left', 'right', 'top', 'bottom']\\n if single_dim is not None:\\n label_groups = np.array([['left', 'right'],\\n ['front', 'back'],\\n ['top', 'bottom']])\\n non_single_labels = label_groups[np.array([0, 1, 2]) != single_dim]\\n for label in main_labels:\\n new_net['pore.surface_' + label] = False\\n network['pore.surface_' + label] = False\\n if single_dim is None:\\n new_net['pore.surface_' + label][new_net.pores(labels=label)] = True\\n else:\\n for ind in [0, 1]:\\n loc = (non_single_labels[ind] == label)\\n temp_pores = new_net.pores(non_single_labels[ind][loc])\\n new_net['pore.surface_' + label][temp_pores] = True\\n\\n old_coords = np.copy(new_net['pore.coords'])\\n if labels == []:\\n labels = ['pore.subdivided_' + new_net.name]\\n for P in pores:\\n # Shifting the new network to the right location and attaching it to\\n # the main network\\n shift = network['pore.coords'][P] - networkspacing/2\\n new_net['pore.coords'] += shift\\n Pn = network.find_neighbor_pores(pores=P)\\n try:\\n Pn_new_net = network.pores(labels)\\n except KeyError:\\n Pn_new_net = []\\n Pn_old_net = Pn[~np.in1d(Pn, Pn_new_net)]\\n Np1 = network.Np\\n extend(pore_coords=new_net['pore.coords'],\\n throat_conns=new_net['throat.conns'] + Np1,\\n labels=labels, network=network)\\n\\n # Moving the temporary labels to the big network\\n for label in main_labels:\\n network['pore.surface_' + label][Np1:] = new_net['pore.surface_' + label]\\n\\n # Stitching the old pores of the main network to the new extended pores\\n surf_pores = network.pores('surface_*')\\n surf_coord = network['pore.coords'][surf_pores]\\n for neighbor in Pn:\\n neighbor_coord = network['pore.coords'][neighbor]\\n dist = [round(np.inner(neighbor_coord-x, neighbor_coord-x),\\n 20) for x in surf_coord]\\n nearest_neighbor = surf_pores[dist == np.amin(dist)]\\n if neighbor in Pn_old_net:\\n coplanar_labels = network.labels(pores=nearest_neighbor)\\n new_neighbors = network.pores(coplanar_labels,\\n mode='and')\\n # This might happen to the edge of the small network\\n if np.size(new_neighbors) == 0:\\n labels = network.labels(pores=nearest_neighbor,\\n mode='and')\\n common_label = [label for label in labels if 'surface_' in label]\\n new_neighbors = network.pores(common_label)\\n elif neighbor in Pn_new_net:\\n new_neighbors = nearest_neighbor\\n connect_pores(network=network, pores1=neighbor,\\n pores2=new_neighbors, labels=labels)\\n\\n # Removing temporary labels\\n for label in main_labels:\\n network['pore.surface_' + label] = False\\n new_net['pore.coords'] = np.copy(old_coords)\\n\\n label_faces(network=network)\\n for label in main_labels:\\n del network['pore.surface_' + label]\\n trim(network=network, pores=pores)\\n ws = network.project.workspace\\n ws.close_project(new_net.project)\",\n \"def render(self, scene):\\n if self.degenerate:\\n return\\n # The number of subdivisions around the hoop's radial direction.\\n if self.thickness:\\n band_coverage = scene.pixel_coverage(self.pos, self.thickness)\\n else:\\n band_coverage = scene.pixel_coverage(self.pos, self.radius * 0.1)\\n if band_coverage < 0:\\n band_coverage = 1000\\n bands = sqrt(band_coverage * 4.0)\\n bands = clamp(4, bands, 40)\\n # The number of subdivisions around the hoop's tangential direction.\\n ring_coverage = scene.pixel_coverage(self.pos, self.radius)\\n if ring_coverage < 0:\\n ring_coverage = 1000\\n rings = sqrt(ring_coverage * 4.0)\\n rings = clamp(4, rings, 80)\\n slices = int(rings)\\n inner_slices = int(bands)\\n radius = self.radius\\n inner_radius = self.thickness\\n\\n # Create the vertex and normal arrays.\\n vertices = []\\n normals = []\\n\\n outer_angle_step = 2 * pi / (slices - 1)\\n inner_angle_step = 2 * pi / (inner_slices - 1)\\n outer_angle = 0.\\n for i in range(slices):\\n cos_outer_angle = cos(outer_angle)\\n sin_outer_angle = sin(outer_angle)\\n inner_angle = 0.\\n for j in range(inner_slices):\\n cos_inner_angle = cos(inner_angle)\\n sin_inner_angle = sin(inner_angle)\\n\\n diameter = (radius + inner_radius * cos_inner_angle)\\n vertex_x = diameter * cos_outer_angle\\n vertex_y = diameter * sin_outer_angle\\n vertex_z = inner_radius * sin_inner_angle\\n\\n normal_x = cos_outer_angle * cos_inner_angle\\n normal_y = sin_outer_angle * cos_inner_angle\\n normal_z = sin_inner_angle\\n\\n vertices.extend([vertex_x, vertex_y, vertex_z])\\n normals.extend([normal_x, normal_y, normal_z])\\n inner_angle += inner_angle_step\\n outer_angle += outer_angle_step\\n\\n # Create ctypes arrays of the lists\\n vertices = (gl.GLfloat *len(vertices))(*vertices)\\n normals = (gl.GLfloat * len(normals))(*normals)\\n\\n # Create a list of triangle indices.\\n indices = []\\n for i in range(slices - 1):\\n for j in range(inner_slices - 1):\\n pos = i * inner_slices + j\\n indices.extend([pos, pos + inner_slices, pos + inner_slices +\\n 1])\\n indices.extend([pos, pos + inner_slices + 1, pos + 1])\\n indices = (gl.GLuint * len(indices))(*indices)\\n\\n # Compile a display list\\n self.list = gl.glGenLists(1)\\n gl.glNewList(self.list, gl.GL_COMPILE)\\n self.color.gl_set(self.opacity)\\n\\n gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)\\n gl.glEnableClientState(gl.GL_VERTEX_ARRAY)\\n gl.glEnableClientState(gl.GL_NORMAL_ARRAY)\\n self.model_world_transform(scene.gcf,\\n Vector([self.radius, self.radius,\\n self.radius])).gl_mult()\\n\\n gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)\\n gl.glNormalPointer(gl.GL_FLOAT, 0, normals)\\n gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,\\n indices)\\n gl.glPopClientAttrib()\\n\\n gl.glEndList()\\n gl.glCallList(self.list)\",\n \"def _create_main_shape(self):\\n\\n a, b = gc( self.size/2,\\n self._ZERO_DEGREES - self.angle,\\n self._180_DEGREES + self.angle)\\n self.wafer_points = zip(a,b)\\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\\n self.cell.add(self.wafer_polygon)\",\n \"def split_edges(self, maximum_distance):\\n \\\"\\\"\\\" Iterate through the vertices of each section. For each vertex v, evaluate edges for which v is a source.\\n If an edge of weight greater than maximum_distance, then split it. \\\"\\\"\\\"\\n for section_id in self.sections:\\n utils.print_progress(len(self.sections), prefix='splitting edges')\\n current_section = [] # Need to update the section data after splitting the edges.\\n for source in self.sections[section_id]:\\n current_section.append(source)\\n edges_to_remove = [] # If an edge is split, it will need to be removed.\\n for edge in self.graph.get_out_edges(source):\\n if self.edge_weights[edge] > maximum_distance:\\n target = edge[1] # edge is a numpy array of [source, target, edge]. Select target.\\n edges_to_remove.append(self.graph.edge(edge[0], edge[\\n 1])) # If an edge is split, the original edge should be removed.\\n\\n new_edge_count = int(math.ceil(self.edge_weights[edge] / maximum_distance))\\n new_edge_distance = self.edge_weights[edge] / new_edge_count\\n current_point = shapes.Point.from_list(\\n list(self.node_locations[source]) + [self.node_heading[target]])\\n previous_vertex = source\\n for _ in range(new_edge_count):\\n current_point = utils.offset_point(current_point, new_edge_distance, current_point.bearing)\\n current_vertex = self.graph.add_vertex()\\n current_section.append(current_vertex) # The new vertex becomes a part of the section.\\n \\\"\\\"\\\" Populate the property map for the new vertex. Inherit values from the target node,\\n unless the target node is a junction node. Then inherit values from the source. \\\"\\\"\\\"\\n self.node_locations[current_vertex] = current_point.as_list()\\n self.node_heading[current_vertex] = current_point.bearing\\n property_vertex = source if not self.junctions[target] else target\\n self.node_speed_limit[current_vertex] = self.node_speed_limit[property_vertex]\\n self.node_width[current_vertex] = self.node_width[property_vertex]\\n self.node_id[current_vertex] = self.node_id[property_vertex]\\n\\n \\\"\\\"\\\" Create an edge between the previous vertex and the newly created vertex, \\n and update the edge weight property map. \\\"\\\"\\\"\\n current_edge = self.graph.add_edge(previous_vertex, current_vertex)\\n self.edge_weights[current_edge] = new_edge_distance\\n\\n # The current vertex becomes the previous vertex in the next step.\\n previous_vertex = current_vertex\\n\\n \\\"\\\"\\\" Create an edge between the last new vertex that was created and the target of the\\n original edge which is being split, and update the property map. \\\"\\\"\\\"\\n self.edge_weights[self.graph.add_edge(previous_vertex, target)] = new_edge_distance\\n list(map(self.graph.remove_edge, edges_to_remove)) # Remove all relevant edges\\n self.sections[section_id] = current_section # Update the section with the new vertices\",\n \"def get_sections(self):\\n return tuple(self._sections)\",\n \"def test_no_section_by_section(self):\\n notice = {\\n \\\"document_number\\\": \\\"111-22\\\",\\n \\\"fr_volume\\\": 22,\\n \\\"cfr_part\\\": \\\"100\\\",\\n \\\"publication_date\\\": \\\"2010-10-10\\\"\\n }\\n s = SectionBySection(None, notices=[notice])\\n self.assertEqual(None, s.process(Node(label=['100', '22'])))\",\n \"def _getSections(self):\\r\\n\\r\\n sections = self.cf.sections()\\r\\n return sections\",\n \"def shape(self):\\n return self.active.shape\",\n \"def m4_make_middle_shape_points_list(tx, ty, m4_info, SEN_info):\\n \\\"\\\"\\\"\\n 1 Get information from m1_info & SEN_info\\n \\\"\\\"\\\"\\n x_m4 = m4_info[0]\\n y_m4 = m4_info[1]\\n z_m = m4_info[2]\\n\\n m4_points = m4_info[3]\\n\\n m4_p0 = m4_points[0]\\n m4_p1 = m4_points[1]\\n m4_p2 = m4_points[2]\\n m4_p3 = m4_points[3]\\n\\n w_sen = SEN_info[0]\\n n_w_sen = SEN_info[1]\\n h_sen = SEN_info[2]\\n t_sen = SEN_info[3]\\n u_n = SEN_info[4]\\n l_n = SEN_info[5]\\n set = SEN_info[6]\\n u_offset = SEN_info[7]\\n l_offset = SEN_info[8]\\n\\n \\\"\\\"\\\"\\n 2 Make lists.\\n middle_shape_upper_left_row list\\n middle_shape_upper_right_row list\\n\\n middle_shape_lower_left_row list\\n middle_shape_lower_right_row list\\n \\\"\\\"\\\"\\n # upper side\\n middle_shape_upper_left_row = []\\n middle_shape_upper_right_row = []\\n\\n for i in range(u_n - 1, -1, -1):\\n # left row\\n ix = tx - (x_m4 - t_sen)\\n iy = ty + (i * u_offset + set) + 10\\n\\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n left_points = [p3, p4, p1, p2]\\n middle_shape_upper_left_row.extend((left_points))\\n\\n for i in range(u_n):\\n # right row\\n ix = tx - t_sen\\n iy = ty + (i * u_offset + set) + 10\\n\\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n right_points = [p1, p2, p3, p4]\\n middle_shape_upper_right_row.extend(right_points)\\n\\n # lower side\\n middle_shape_lower_left_row = []\\n middle_shape_lower_right_row = []\\n\\n for i in range(l_n):\\n # left row\\n ix = tx - (x_m4 - t_sen)\\n iy = ty - (i * l_offset + set) - 10\\n\\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n left_points = [p3, p4, p1, p2]\\n middle_shape_lower_left_row.extend((left_points))\\n\\n for i in range(l_n - 1, -1, -1):\\n # right row\\n ix = tx - t_sen\\n iy = ty - (i * l_offset + set) - 10\\n\\n p0, p1, p2, p3, p4 = Y_middle_shape_points(ix, iy, w_sen, t_sen, n_w_sen)\\n right_points = [p1, p2, p3, p4]\\n middle_shape_lower_right_row.extend(right_points)\\n\\n middle_shape_upper = [middle_shape_upper_left_row, middle_shape_upper_right_row]\\n middle_shape_lower = [middle_shape_lower_left_row, middle_shape_lower_right_row]\\n\\n return middle_shape_upper, middle_shape_lower\",\n \"def plot_sections(wiggle, sections, threshold):\\n\\n fig = plt.figure()\\n axis = fig.add_subplot(111)\\n axis.plot(wiggle)\\n axis.axhline(y=threshold)\\n for sect in sections:\\n # mark active sections\\n positions = list()\\n codes = list()\\n start, stop = sect\\n positions.append([start, 0.6])\\n codes.append(Path.MOVETO)\\n positions.append([stop, 0.6])\\n codes.append(Path.LINETO)\\n positions.append([stop, 0.05])\\n codes.append(Path.LINETO)\\n positions.append([start, 0.05])\\n codes.append(Path.LINETO)\\n positions.append([start, 0.6])\\n codes.append(Path.LINETO)\\n positions.append([start, 0.6])\\n codes.append(Path.CLOSEPOLY)\\n path = Path(positions, codes)\\n patch = patches.PathPatch(path, lw=1)\\n axis.add_patch(patch)\\n plt.show()\",\n \"def shape(self):\\n # detection mouse hover on arc path\\n path = QPainterPath()\\n path.addPolygon(QPolygonF([self.line().p1(), self.line().p2()]))\\n # add handles at the start and end of arc\\n path.addRect(QRectF(\\n self.line().p1().x() - 5,\\n self.line().p1().y() - 5,\\n self.line().p1().x() + 5,\\n self.line().p1().y() + 5\\n ))\\n path.addRect(QRectF(\\n self.line().p2().x() - 5,\\n self.line().p2().y() - 5,\\n self.line().p2().x() + 5,\\n self.line().p2().y() + 5\\n ))\\n return path\",\n \"def chunk(self, shape, split) -> NotImplementedError:\\n raise NotImplementedError()\",\n \"def calc_section_force(aoa, mac, rot_center, casenum=1, networknum=1):\\r\\n\\r\\n chord = \\\"x\\\"\\r\\n span = \\\"y\\\"\\r\\n height = \\\"z\\\"\\r\\n coor2id = {\\\"x\\\": 1, \\\"y\\\": 2, \\\"z\\\": 3}\\r\\n chord_id = coor2id[chord]\\r\\n span_id = coor2id[span]\\r\\n height_id = coor2id[height]\\r\\n\\r\\n rot_center = np.asarray(rot_center)[[chord_id - 1, height_id - 1]]\\r\\n\\r\\n # read the pressure distribution from agps\\r\\n data = read_agps()\\r\\n network = data[int(networknum - 1)]\\r\\n result = []\\r\\n\\r\\n # calculate the local aerodynamic coefficients for each line in the network\\r\\n for line in network:\\r\\n if np.array_equal(line[0, 1:4], line[-1, 1:4]):\\r\\n line = line[:-1] # omit the last point in the line if it has the same xyz-coordinates as the first point\\r\\n y = float(line[0, span_id]) # coordinate of spanwise position\\r\\n line_clip = line[:, [chord_id, height_id]] # coordinate of cross section\\r\\n chord = np.max(line_clip[:, 0]) - np.min(line_clip[:, 0])\\r\\n\\r\\n # local coefficients are nan if chord is 0\\r\\n if chord == 0:\\r\\n nan = float(\\\"nan\\\")\\r\\n result.append([y, chord, nan, nan, nan])\\r\\n continue\\r\\n\\r\\n diff_coord = line_clip - np.roll(line_clip, 1, axis=0)\\r\\n length = np.linalg.norm(diff_coord, axis=1) # length between each vertex\\r\\n norm = np.fliplr(diff_coord / length[:, np.newaxis]) # norm vector between each vertex\\r\\n min_id = np.argmin(line_clip, axis=0) # vertex_id with the minimum coordinate\\r\\n flip = np.array([-1 if col[i] < 0 else 1 for (col, i) in zip(norm.T, min_id)])\\r\\n norm *= flip # flip the norm vectors to make them point inward\\r\\n\\r\\n coeff_all = [y, chord]\\r\\n # the definition of each variable is explained in the reference\\r\\n cp2 = line.T[int(3 + casenum)]\\r\\n cp1 = np.roll(cp2, 1, axis=0)\\r\\n cp3 = np.roll(cp2, -1, axis=0)\\r\\n n21 = norm\\r\\n n23 = np.roll(n21, -1, axis=0)\\r\\n l21 = length * 0.5\\r\\n l23 = np.roll(l21, -1, axis=0)\\r\\n cp21 = (0.75 * cp2 + 0.25 * cp1)[:, np.newaxis] * n21\\r\\n cp23 = (0.75 * cp2 + 0.25 * cp3)[:, np.newaxis] * n23\\r\\n cpdl = cp21 * l21[:, np.newaxis] + cp23 * l23[:, np.newaxis]\\r\\n cp_moment = cpdl * np.fliplr(line_clip - rot_center)\\r\\n cp_moment = cp_moment[:, 0] - cp_moment[:, 1]\\r\\n liftdragcoef = np.sum(cpdl, axis=0) / chord\\r\\n liftdragcoef = rot(liftdragcoef, aoa)\\r\\n cm = np.sum(cp_moment, axis=0) / (mac * chord)\\r\\n coeff = liftdragcoef.tolist()\\r\\n coeff.append(cm)\\r\\n coeff_all += coeff\\r\\n result.append(coeff_all)\\r\\n result = np.array(result)\\r\\n columns = [\\\"pos\\\", \\\"chord\\\", \\\"cd\\\", \\\"cl\\\", \\\"cm\\\"]\\r\\n result = pd.DataFrame(result, columns=columns)\\r\\n result.to_csv(\\\"section_force.csv\\\", index=False)\",\n \"def fancy_section_type(section):\\n return {\\n 'LEC': 'Lecture',\\n 'LAB': 'Laboratory',\\n 'TUT': 'Tutorial',\\n 'PRA': 'Practicum',\\n 'COR': 'Correspondence',\\n 'SEM': 'Seminar',\\n 'ONL': 'Online',\\n }.get(section, section)\",\n \"def sections(self) -> List[Section]:\\n\\n if self.beam is None:\\n return [self.section]\\n\\n return self.beam.sections\",\n \"def segment_by_shape(self, dt, criterion):\\n enumerate_crit = Criterion(\\n 'patterns', criterion.column_name+'_derivatives_patterns_clusters',\\n 'enumerate')\\n return self.segment_by_enumerate(dt, enumerate_crit)\",\n \"def section(data):\\n if len(data['index']) == 2 and data['index'][1][0].isdigit():\\n element = {}\\n element['is_section'] = True\\n element['section_id'] = '-'.join(data['index'])\\n if u\\\"§§ \\\" == data['title'][:3]:\\n element['is_section_span'] = True\\n else:\\n element['is_section_span'] = False\\n match = SECTION_TITLE_REGEX.match(data['title'])\\n element['label'] = match.group(1)\\n element['sub_label'] = match.group(2)\\n return element\",\n \"def read_section(geo_file_path, section_marker):\\n read = False\\n section = []\\n\\n with open(geo_file_path) as file:\\n lines = file.readlines()\\n for line in lines:\\n if line.startswith(section_marker):\\n read = True\\n\\n if line.startswith(SECTION_END_MARKER):\\n # Don't stop, section can be split\\n read = False\\n\\n if read:\\n section.append(line)\\n\\n return section\",\n \"def segment(self, intersect=True):\\n from scipy.spatial import Voronoi\\n from shapely.geometry import LineString\\n from shapely.ops import polygonize\\n\\n vor = Voronoi(self._centered_coords)\\n lines = [LineString(vor.vertices[line]) for line in vor.ridge_vertices if -1 not in line]\\n poly_generator = polygonize(lines)\\n\\n series = gpd.GeoSeries(poly_generator)\\n series = self.translate(series)\\n series.crs = self.detection_base.height_model.crs\\n\\n if intersect:\\n series = series.intersection(self.detection_base.height_model._bounding_box_poly)\\n\\n return series\",\n \"def shape(self):\\n return self._shape\",\n \"def shape(self):\\n return self._shape\",\n \"def CSGToPShape(mesh, scale):\\n result = createShape(GROUP) # allocate a PShape group\\n # for each polygon (Note: these can have 3,4 or more vertices)\\n for p in mesh.getPolygons():\\n # make a child PShape\\n polyShape = createShape()\\n # begin setting vertices to it\\n polyShape.beginShape()\\n # for each vertex in the polygon\\n for v in p.vertices:\\n # add each (scaled) polygon vertex\\n polyShape.vertex(v.pos.getX() * scale,\\n v.pos.getY() * scale,\\n v.pos.getZ() * scale)\\n\\n # finish this polygon\\n polyShape.endShape()\\n # append the child PShape to the parent\\n result.addChild(polyShape)\\n\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57629484","0.57139105","0.55810535","0.53494585","0.5339676","0.53303343","0.5307979","0.52796847","0.5153275","0.5118574","0.50900316","0.50871176","0.50563085","0.5051936","0.5004477","0.5000257","0.5000257","0.49977192","0.49440226","0.49164158","0.48840088","0.48748946","0.4853134","0.4852611","0.4841622","0.4837647","0.48306128","0.48086238","0.4795133","0.4791963","0.47759023","0.47558802","0.4749944","0.4740666","0.4720435","0.4713057","0.47043562","0.47029552","0.46948817","0.4684544","0.46765873","0.4676109","0.46606287","0.46583343","0.46560308","0.46304312","0.46303198","0.46270394","0.46116483","0.4608184","0.45950875","0.45922658","0.45712286","0.45659113","0.45587027","0.45587027","0.45537007","0.45510736","0.4540663","0.45376962","0.45364186","0.45018634","0.4500829","0.449153","0.44720474","0.44693792","0.44537905","0.44512585","0.44477603","0.4446962","0.44432175","0.44358364","0.44322923","0.44054317","0.44002807","0.43919116","0.43884015","0.4385814","0.43832943","0.4379225","0.43614802","0.435653","0.43483612","0.43446353","0.43329185","0.4329793","0.43297908","0.431821","0.4316736","0.43153045","0.43144092","0.43076816","0.4305438","0.4300527","0.42980456","0.42912057","0.4289144","0.42853877","0.42825064","0.42825064","0.42802316"],"string":"[\n \"0.57629484\",\n \"0.57139105\",\n \"0.55810535\",\n \"0.53494585\",\n \"0.5339676\",\n \"0.53303343\",\n \"0.5307979\",\n \"0.52796847\",\n \"0.5153275\",\n \"0.5118574\",\n \"0.50900316\",\n \"0.50871176\",\n \"0.50563085\",\n \"0.5051936\",\n \"0.5004477\",\n \"0.5000257\",\n \"0.5000257\",\n \"0.49977192\",\n \"0.49440226\",\n \"0.49164158\",\n \"0.48840088\",\n \"0.48748946\",\n \"0.4853134\",\n \"0.4852611\",\n \"0.4841622\",\n \"0.4837647\",\n \"0.48306128\",\n \"0.48086238\",\n \"0.4795133\",\n \"0.4791963\",\n \"0.47759023\",\n \"0.47558802\",\n \"0.4749944\",\n \"0.4740666\",\n \"0.4720435\",\n \"0.4713057\",\n \"0.47043562\",\n \"0.47029552\",\n \"0.46948817\",\n \"0.4684544\",\n \"0.46765873\",\n \"0.4676109\",\n \"0.46606287\",\n \"0.46583343\",\n \"0.46560308\",\n \"0.46304312\",\n \"0.46303198\",\n \"0.46270394\",\n \"0.46116483\",\n \"0.4608184\",\n \"0.45950875\",\n \"0.45922658\",\n \"0.45712286\",\n \"0.45659113\",\n \"0.45587027\",\n \"0.45587027\",\n \"0.45537007\",\n \"0.45510736\",\n \"0.4540663\",\n \"0.45376962\",\n \"0.45364186\",\n \"0.45018634\",\n \"0.4500829\",\n \"0.449153\",\n \"0.44720474\",\n \"0.44693792\",\n \"0.44537905\",\n \"0.44512585\",\n \"0.44477603\",\n \"0.4446962\",\n \"0.44432175\",\n \"0.44358364\",\n \"0.44322923\",\n \"0.44054317\",\n \"0.44002807\",\n \"0.43919116\",\n \"0.43884015\",\n \"0.4385814\",\n \"0.43832943\",\n \"0.4379225\",\n \"0.43614802\",\n \"0.435653\",\n \"0.43483612\",\n \"0.43446353\",\n \"0.43329185\",\n \"0.4329793\",\n \"0.43297908\",\n \"0.431821\",\n \"0.4316736\",\n \"0.43153045\",\n \"0.43144092\",\n \"0.43076816\",\n \"0.4305438\",\n \"0.4300527\",\n \"0.42980456\",\n \"0.42912057\",\n \"0.4289144\",\n \"0.42853877\",\n \"0.42825064\",\n \"0.42825064\",\n \"0.42802316\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78787,"cells":{"query":{"kind":"string","value":"Returns the list of the descendant shapes of the shape ."},"document":{"kind":"string","value":"def Modified(self, *args):\n return _BRepAlgo.BRepAlgo_DSAccess_Modified(self, *args)"},"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 shapes(self):\n return [load_node(item) for item in self.get_attribute('shapes')]","def shapes(self):\n return self.container['shapes']","def XCAFDoc_ShapeTool_GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)","def type_shapes(self):\n return self._type_shapes","def GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)","def getshapes(self):\n return sorted(self._shapes.keys())","def get_children(self):\n children = []\n for node in self.node.get_children():\n children.append(Geom(node))\n return children","def _get_nodes(self, selector):\r\n arr = []\r\n def traverse(cont):\r\n children = cont.get_children()\r\n for n in xrange(len(children)):\r\n child = children[n]\r\n if child.node_type == selector:\r\n arr.append(child)\r\n elif child.node_type != 'Shape':\r\n traverse(child)\r\n traverse(self)\r\n return arr","def explore_shapes(node):\n nodeshape=node.getShape()\n print( \"shape: \",nodeshape)\n for i in range(len(nodeshape)):\n axis=get_mds_axis(node,i,strict=False)\n try:\n print( axis.getNodeName(),axis.getShape())\n except:\n print(\"blank: \",axis.getShape())","def shapes(self):\n return self._frame.getshapes()","def shape(self):","def shape(self):","def made_shapes(self):\n return self._made_shapes","def get_mds_shape(node):\n try: \n #This will fail if node.getShape doesn't exist or if shape is 0\n shape=list(node.getShape())\n assert len(shape)>0\n except (mds.mdsExceptions.MDSplusException,AssertionError):\n return []\n shape.reverse() #put in the python order\n return shape","def shapes_for(self, ent):\n return self._ent_to_shapes[ent]","def pshape(self):\n try:\n return plist([x.pshape() for x in self], root=self.__root__)\n except Exception:\n return plist([len(self)], root=self.__root__)","def GetShapes(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetShapes(self, *args)","def shapes(self):\n assert self._shapes is not None, (\"BaseSlide.shapes referenced \"\n \"before assigned\")\n return self._shapes","def shape(self) -> Shape:","def shapes():\n # -- Define a list of locations to search for, starting by\n # -- adding in our builtin shape locations\n paths = [\n os.path.join(\n os.path.dirname(os.path.dirname(__file__)),\n 'shapes',\n ),\n ]\n\n # -- If we have any paths defined by environment\n # -- variables we should add them here\n if constants.PLUGIN_ENVIRONMENT_VARIABLE in os.environ:\n paths.extend(\n os.environ[constants.PLUGIN_ENVIRONMENT_VARIABLE].split(';'),\n )\n\n shape_list = list()\n\n for path in paths:\n for root, _, files in os.walk(path):\n for filename in files:\n if filename.endswith('.json'):\n shape_list.append(\n os.path.join(\n root,\n filename,\n ),\n )\n\n return shape_list","def data_shapes(self):","def output_type_shapes(self):\n return self._output_type_shapes","def get_path_class_shapes(self):\n df = self.df_roi\n self.tumor_shape = MultiPolygon([self._get_shape(i) for i in df[df.class_ == \"Tumor\"]['geometry']])\n self.stroma_shape = MultiPolygon([self._get_shape(i) for i in df[df.class_ == \"Stroma\"]['geometry']])\n self.dcis_shape = MultiPolygon([self._get_shape(i) for i in df[df.class_ == \"Other\"]['geometry']]) \n\n # path_class_qupath_names = [\"Tumor\", \"Stroma\", \"Other\"]\n # for path_class in path_class_qupath_names:\n # mpolygon = MultiPolygon([self._get_shape(i) for i in df[df.class_ == path_class]['geometry']])\n\n # # replace name\n # if path_class == \"Other\":\n # path_class = \"dcis\"\n\n # attr_name = path_class.lower() + \"_shape\"\n # setattr(self, path_class, mpolygon)","def getHierarchies():","def getHierarchies():","def get_svg_classes(self):\n ld = set()\n lt = set()\n for element in itertools.chain(self.polygons, self.paths):\n ld.update(zip(element.layers, element.datatypes))\n for label in self.labels:\n lt.add((label.layer, label.texttype))\n for reference in self.references:\n ref_cell = reference.ref_cell\n if isinstance(ref_cell, Cell):\n ref = ref_cell.get_svg_classes()\n ld.update(ref[0])\n lt.update(ref[1])\n return ld, lt","def getOutShapes(self):\n\t\treturn self.output_shape","def auto_shapes(self):\n return self.container['auto_shapes']","def get_data_shapes():\n return [None, None, None], [None, None], [None, ]","def shape_in(self):\n return [c.size for c in self.coords]","def getChildren(self):\n return []","def get_data_shapes():\r\n return ([None, None, None], [None, None], [None, None, None])","def getChildren(self):\n return self.child_edges","def get_children(self):\n return []","def getChildren():","def get(self, selector):\r\n stage = self.get_stage()\r\n arr = []\r\n key = selector[1:]\r\n if selector[0] == '#':\r\n arr = [stage.ids[key]] if stage.ids[key] else []\r\n elif selector[0] == '.':\r\n arr = [stage.name[key]] if stage.name[key] else []\r\n elif selector == 'Shape' or selector == 'Group' or selector == 'Layer':\r\n return self._get_nodes(selector)\r\n else:\r\n return []\r\n\r\n retr_arr = []\r\n for n in xrange(len(arr)):\r\n node = arr[n]\r\n if self.is_ancestor_of(node):\r\n retr_arr.append(node)\r\n\r\n return retr_arr","def children(self) -> Iterable[Heirarchical]:\n return []","def _get_border_children(self, quad, location):\n bounds = [[2, 3], [0, 2], [0, 1], [1, 3]]\n bound_location = bounds[location]\n if not quad.is_leaf:\n for i in bound_location:\n yield from self._get_border_children(quad.children[i], location)\n else:\n yield quad","def input_type_shapes(self):\n return self._input_type_shapes","def get_elements():\n elements = { 'Shapes':[], 'Strokes':[] }\n curves_knob = rp_node['curves']\n root_layer = curves_knob.rootLayer\n elements = parse_layer(root_layer, elements, [root_layer])\n print elements","def get_children(self):\n return self.children","def _get_shape(t):\n return [x.value for x in t.shape]","def get_drawables(self):\n to_draw = []\n for k,v in self._to_draw.items():\n if isinstance(v,Iterable):\n for i in v:\n to_draw.append(i)\n else:\n to_draw.append(v)\n return to_draw","def _all_subnodes(self):\n return self.__dict__.values()","def shape(self):\n return self.child_mode.shape()","def FindSubShape(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeTool_FindSubShape(self, *args)","def AllSubElements(self):\n return []","def shape(self):\n return self._shape","def get_all_drawables(self): \n drawables = []\n if len(self.component_list) > 0:\n for c in self.component_list:\n drawables.append(c.get_drawables())\n return drawables","def get_components_drawables(self):\n # print self.component_list\n print len(self.component_list)\n for c in self.component_list:\n return c.get_drawables()","def matches_shapes(self, shape_):\n m = []\n for i, spec in enumerate(self.shapes):\n if matches(spec, shape_):\n m.append(i)\n return m","def shape(self):\n for component in ('x', 'y', 'z', 'r', 't'):\n arr = getattr(self, component)\n if arr is not None:\n return arr.shape\n return ()","def get_shape_bin_edges(shapes_path, datacard_bin):\n shapes_file = ROOT.TFile.Open(shapes_path)\n print 'tfile path is', shapes_path\n print 'list of keys'\n #ROOT.gDirectory.GetListOfKeys().ls()\n print 'gonnad cd', datacard_bin\n print shapes_file.cd(datacard_bin)\n shapes = ROOT.gDirectory.GetListOfKeys()\n #print 'list of Keys is', ROOT.gDirectory.GetListOfKeys().ls()\n # Since the nominal and varied shapes share the same binning,\n # take any of the histograms found in the shapes file.\n print 'debug0'\n shape = ROOT.gDirectory.Get(shapes[0].GetName())\n print 'debug'\n bin_edges = np.array(\n [shape.GetXaxis().GetBinLowEdge(i) for i in xrange(1, shape.GetNbinsX() + 1)],\n dtype=np.float64,\n )\n shapes_file.Close()\n print 'bin_edges for datacard_bin is', bin_edges\n #sys.exit()\n return bin_edges","def get_orphans(self):\n return self.orphans","def get_children(self, *types: str) -> List[TgnObject]:\n pass","def draw(hyp):\r\n print 'g.createShape(',hyp.getAttList(),')'\r\n print type(hyp.getAttList())\r\n g.createShape(hyp.getAttList())","def computeBoundingShape(scene, shape='ellipsoid'):\r\n \r\n gr= pgl.Group([ sh.geometry for sh in scene ])\r\n tglset = pgl.fit( shape, gr )\r\n #hull = pgl.Shape( tglSet, __Green )\r\n return tglset","def nodes(self): \n return [n for n in self.iternodes()]","def get_childs(self):\n\t\treturn self.__childs","def descendant_classes(self):\n response = check_defined(self, inspect.stack()[0][3])\n if not response:\n return response\n descendants = nx.descendants(self.se.full_class_only_graph,\n self.uri)\n result = restructure_output(self,\n descendants,\n inspect.stack()[0][3],\n self.output_type)\n return result","def __call__(self):\n paths = []\n for root in self._intf.manage.schemas._trees.values():\n paths.extend(datatype_attributes(root, self._get_datatype()))\n return paths","def childWells(self):\n if self.childWellIndices() is None:\n return []\n tcs=[]\n for idx in self.childWellIndices():\n tcs.append(self.clsParent.clsWells[idx])\n\n return tcs","def draw(hyp):\n print 'g.createShape(',hyp.getAttList(),')'\n print type(hyp.getAttList())\n g.createShape(hyp.getAttList())","def locate_shape(shape):","def GetChildren( self ):\n children = [\n cWrpr \n for cWrpr in GameNodePath.GetChildren( self ) \n if not cWrpr.data.getPythonTag( TAG_IGNORE )\n ]\n return children","def get_children(self):\r\n return self.children","def descendants(self):\n for a in self._related(set(), 'children'):\n yield a","def children(node):\n\n return snd(node)","def _get_children(self):\n if not self.ontology:\n raise ValueError(\"No associated ontology.\")\n\n return self.ontology.get_sub_properties(self)","def get_subnodes(self) -> List[SubNode]:\n\t\treturn sorted(self.subnodes, key=lambda x: attrib_key(x.name))","def Children(self) -> _n_1_t_2:","def shape_list(x):\n shape = list(x.shape)\n\n return shape","def _get_shapes(self, state_dim, measurement_dim):\n shapes = super()._get_shapes(state_dim, measurement_dim)\n shapes[\"b\"] = (state_dim,)\n shapes[\"d\"] = (measurement_dim,)\n return shapes","def s_all_descendants(node):\r\n if len(node.children)==0:\r\n return []\r\n else:\r\n children = node.children[:]\r\n for child in node.children:\r\n children.extend(Node.s_all_descendants(child))\r\n return children","def getShape(transform):\n\n pass","def __getGeometryComponents(self):\n # get dagPath and member components of skined shape\n # the deformerSet pretty controls which vertex is deformed by the skinCluster\n # the deformerSet will allows us to pull out that components(vertex) mobject that we need\n fnSet = openmaya.MFnSet(self.fn.deformerSet())\n members = openmaya.MSelectionList()\n # the MSelectionList contains the vertex information in the deformerSet above\n fnSet.getMembers(members, False)\n\n dagPath = openmaya.MDagPath()\n components = openmaya.MObject()\n\n # dagPath: dagPath of influence objects(joint)\n # components: mesh components(vertex)\n members.getDagPath(0, dagPath, components)\n\n return dagPath, components","def children(self):\n return [self.cut]","def shape_halo(self):\n return [c.size for c in self.coords_halo]","def shape(self):\n return self._observe_list.shape","def GetShapesOfLayer(self, *args):\n return _XCAFDoc.XCAFDoc_LayerTool_GetShapesOfLayer(self, *args)","def get_array_of_children(self):\n children = [self.posXposYposZ,self.posXposYnegZ,self.posXnegYposZ,self.posXposYnegZ,self.negXposYposZ,self.negXposYnegZ,self.negXnegYposZ,self.negXnegYnegZ ] \n return children","def get_child_nodes(self):\n parts = []\n for child in sorted(self.children, key=lambda c: c.start):\n child_part = (child.start, child.end, child)\n parts.append(child_part)\n return parts","def descendant_properties(self):\n response = check_defined(self, inspect.stack()[0][3])\n if not response:\n return response\n descendants = nx.descendants(self.se.property_only_graph,\n self.uri)\n result = restructure_output(self,\n descendants,\n inspect.stack()[0][3],\n self.output_type)\n return result","def get_path(self) -> list:\n path = []\n if self.parent:\n path = [a.name for a in self.parent.ancestors(include_self=True)]\n\n return path + [self.name]","def children(self) -> Tuple[CombinatorialClassType, ...]:\n if self._children is None:\n self._children = self._strategy.decomposition_function(self.comb_class)\n if self._children is None:\n raise StrategyDoesNotApply(\"{} does not apply\".format(self._strategy))\n return self._children","def get_shape_info(self, obj):\r\n return obj.shape","def get_all_children(self):\n return tuple(self.children)","def extract_shapefuns(self, parent_folder):\n shapelist = []\n cwd = os.getcwd()\n print('Extracting shapes')\n has_shapefun_file = False\n found_shapes = False #to see if KKRnano produced some shapes as output (better than using shapefun)\n parent_folder_listdir = parent_folder.listdir() #quicker this way as based on SSH tunneling\n for filename in parent_folder_listdir:\n if filename.find('shape.') >= 0:\n if has_shapefun_file:\n shapelist = []\n abs_path = f'{cwd}/{filename}'\n parent_folder.getfile(filename, f'{cwd}/{filename}')\n self.put_object_from_file(abs_path, filename)\n self.set_attribute(filename.replace('.', ''), filename)\n os.remove(filename)\n with self.open(filename, 'r') as _f:\n shapelist.append(SinglefileData(_f.name))\n print('Found shape in repsitory:')\n print(_f.name)\n has_shapefun_file = False\n found_shapes = True\n if 'shapefun' in parent_folder_listdir and not found_shapes:\n filename = 'shapefun'\n print('Shapefun in dir, this part of the program might need more testing')\n abs_path = f'{cwd}/{filename}'\n parent_folder.getfile(filename, f'{cwd}/{filename}')\n\n with open(filename, 'r') as reader:\n shapes = reader.readlines()\n\n\n# print(os.path.realpath(reader.name))\n lines = []\n for line in range(len(shapes)):\n if shapes[line].find('Shape') > 0:\n lines.append(line)\n lines.append(len(shapes))\n for j in range(len(lines) - 1):\n shape_string = ''\n for k in range(lines[j], lines[j + 1]):\n shape_string += shapes[k]\n\n shape_no_filename = 'shape.' + str(j + 1).zfill(7)\n with open(shape_no_filename, 'w') as file:\n file.write(shape_string)\n path = os.path.realpath(file.name)\n print(path)\n abs_path = f'{cwd}/{shape_no_filename}'\n self.put_object_from_file(abs_path, shape_no_filename) #Problem has to be called via instance\n self.set_attribute(shape_no_filename.replace('.', ''), shape_no_filename)\n with self.open(shape_no_filename, 'r') as _f:\n shapelist.append(SinglefileData(_f.name))\n os.remove(shape_no_filename)\n has_shapefun_file = True\n if has_shapefun_file:\n print(\n 'WARNING: Only a shapefun from some Voronoi input was found, it is possible that the potential does not match the shapefun parameters, unless they are set this way explicitly in the respective input file! It is advisable to use the `write_shapes=1` command in input.conf'\n )\n print('Found shapelist:')\n print(shapelist)\n return shapelist","def shape(self):\r\n return self._shape","def children(self) -> List[Region]:\n return []","def get_children_types(self) -> set[FakeAnnotation]:\n result: set[FakeAnnotation] = set()\n for child in self.children:\n result.update(child.iterate_types())\n return result","def getchildren(self):\n return self.root.getchildren()","def output_shapes(self):\n return nest.map_structure(\n lambda component_spec: component_spec._to_legacy_output_shapes(), # pylint: disable=protected-access\n self._element_spec)","def output_shapes(self):\n return nest.map_structure(\n lambda component_spec: component_spec._to_legacy_output_shapes(), # pylint: disable=protected-access\n self._element_spec)","def default_infer_shape(self, node, i_shapes):\r\n rval = []\r\n for r in node.outputs:\r\n try:\r\n rval.append(self.shape_tuple(r))\r\n except AttributeError:\r\n rval.append(None)\r\n return rval","def getAlembicHolder(cls=False, node_name=\"\"):\n\n tr = cmds.ls(node_name)\n if len(tr) == 0:\n return []\n shape_list = []\n for x in tr:\n if cmds.nodeType(x) == \"alembicHolder\":\n shape = x\n else:\n shapes = cmds.listRelatives(x, shapes=True, f=1)\n if not shapes:\n continue\n shape = shapes[0]\n shape_list += pm.ls(shape)\n return main(cls, shape_list)","def get_shapes_for_route(route_short_name):\n cur = get_cursor();\n SQLExec(cur, \"\"\"SELECT gtf_shapes.*,shape_dirtag.dirtag \n FROM gtf_shapes,shape_dirtag\n WHERE gtf_shapes.shape_id = shape_dirtag.shape_id \n and gtf_shapes.shape_id IN \n (select distinct(shape_id) from gtf_trips \n where route_id IN\n (select route_id from gtf_routes \n where route_short_name = %(route_short_name)s\n )\n )\n ORDER BY gtf_shapes.shape_id asc, \n gtf_shapes.shape_pt_sequence asc\"\"\",\n {'route_short_name':route_short_name});\n ret = [r for r in cur];\n\n cur.close();\n return ret;","def get_shape(cls, leaf_type, g_scale, scale, scale_x):\n u_v = []\n\n if leaf_type < 0: # blossom\n if leaf_type < -3: # out of range\n leaf_type = -1\n shape = leaf_geom.blossom(abs(leaf_type + 1))\n\n else: # leaf\n if leaf_type < 1 or leaf_type > 10: # is out of range or explicitly default\n leaf_type = 8\n shape = leaf_geom.leaves(leaf_type - 1)\n\n verts = shape[0]\n faces = shape[1]\n if len(shape) == 3:\n u_v = shape[2]\n\n for vert in verts:\n vert *= scale * g_scale\n vert.x *= scale_x\n\n return verts, faces, u_v","def __init__(self):\n self.superelevations = []\n self.shapes = []","def elements(self) -> Geometry:\n return self._elements","def ordered_descendants(\n self: InheritingObjectT, schema: s_schema.Schema\n ) -> List[InheritingObjectT]:\n graph = {}\n for descendant in self.descendants(schema):\n graph[descendant] = topological.DepGraphEntry(\n item=descendant,\n deps=ordered.OrderedSet(\n descendant.get_bases(schema).objects(schema),\n ),\n extra=False,\n )\n\n return list(topological.sort(graph, allow_unresolved=True))"],"string":"[\n \"def shapes(self):\\n return [load_node(item) for item in self.get_attribute('shapes')]\",\n \"def shapes(self):\\n return self.container['shapes']\",\n \"def XCAFDoc_ShapeTool_GetSubShapes(*args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)\",\n \"def type_shapes(self):\\n return self._type_shapes\",\n \"def GetSubShapes(*args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)\",\n \"def getshapes(self):\\n return sorted(self._shapes.keys())\",\n \"def get_children(self):\\n children = []\\n for node in self.node.get_children():\\n children.append(Geom(node))\\n return children\",\n \"def _get_nodes(self, selector):\\r\\n arr = []\\r\\n def traverse(cont):\\r\\n children = cont.get_children()\\r\\n for n in xrange(len(children)):\\r\\n child = children[n]\\r\\n if child.node_type == selector:\\r\\n arr.append(child)\\r\\n elif child.node_type != 'Shape':\\r\\n traverse(child)\\r\\n traverse(self)\\r\\n return arr\",\n \"def explore_shapes(node):\\n nodeshape=node.getShape()\\n print( \\\"shape: \\\",nodeshape)\\n for i in range(len(nodeshape)):\\n axis=get_mds_axis(node,i,strict=False)\\n try:\\n print( axis.getNodeName(),axis.getShape())\\n except:\\n print(\\\"blank: \\\",axis.getShape())\",\n \"def shapes(self):\\n return self._frame.getshapes()\",\n \"def shape(self):\",\n \"def shape(self):\",\n \"def made_shapes(self):\\n return self._made_shapes\",\n \"def get_mds_shape(node):\\n try: \\n #This will fail if node.getShape doesn't exist or if shape is 0\\n shape=list(node.getShape())\\n assert len(shape)>0\\n except (mds.mdsExceptions.MDSplusException,AssertionError):\\n return []\\n shape.reverse() #put in the python order\\n return shape\",\n \"def shapes_for(self, ent):\\n return self._ent_to_shapes[ent]\",\n \"def pshape(self):\\n try:\\n return plist([x.pshape() for x in self], root=self.__root__)\\n except Exception:\\n return plist([len(self)], root=self.__root__)\",\n \"def GetShapes(self, *args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_GetShapes(self, *args)\",\n \"def shapes(self):\\n assert self._shapes is not None, (\\\"BaseSlide.shapes referenced \\\"\\n \\\"before assigned\\\")\\n return self._shapes\",\n \"def shape(self) -> Shape:\",\n \"def shapes():\\n # -- Define a list of locations to search for, starting by\\n # -- adding in our builtin shape locations\\n paths = [\\n os.path.join(\\n os.path.dirname(os.path.dirname(__file__)),\\n 'shapes',\\n ),\\n ]\\n\\n # -- If we have any paths defined by environment\\n # -- variables we should add them here\\n if constants.PLUGIN_ENVIRONMENT_VARIABLE in os.environ:\\n paths.extend(\\n os.environ[constants.PLUGIN_ENVIRONMENT_VARIABLE].split(';'),\\n )\\n\\n shape_list = list()\\n\\n for path in paths:\\n for root, _, files in os.walk(path):\\n for filename in files:\\n if filename.endswith('.json'):\\n shape_list.append(\\n os.path.join(\\n root,\\n filename,\\n ),\\n )\\n\\n return shape_list\",\n \"def data_shapes(self):\",\n \"def output_type_shapes(self):\\n return self._output_type_shapes\",\n \"def get_path_class_shapes(self):\\n df = self.df_roi\\n self.tumor_shape = MultiPolygon([self._get_shape(i) for i in df[df.class_ == \\\"Tumor\\\"]['geometry']])\\n self.stroma_shape = MultiPolygon([self._get_shape(i) for i in df[df.class_ == \\\"Stroma\\\"]['geometry']])\\n self.dcis_shape = MultiPolygon([self._get_shape(i) for i in df[df.class_ == \\\"Other\\\"]['geometry']]) \\n\\n # path_class_qupath_names = [\\\"Tumor\\\", \\\"Stroma\\\", \\\"Other\\\"]\\n # for path_class in path_class_qupath_names:\\n # mpolygon = MultiPolygon([self._get_shape(i) for i in df[df.class_ == path_class]['geometry']])\\n\\n # # replace name\\n # if path_class == \\\"Other\\\":\\n # path_class = \\\"dcis\\\"\\n\\n # attr_name = path_class.lower() + \\\"_shape\\\"\\n # setattr(self, path_class, mpolygon)\",\n \"def getHierarchies():\",\n \"def getHierarchies():\",\n \"def get_svg_classes(self):\\n ld = set()\\n lt = set()\\n for element in itertools.chain(self.polygons, self.paths):\\n ld.update(zip(element.layers, element.datatypes))\\n for label in self.labels:\\n lt.add((label.layer, label.texttype))\\n for reference in self.references:\\n ref_cell = reference.ref_cell\\n if isinstance(ref_cell, Cell):\\n ref = ref_cell.get_svg_classes()\\n ld.update(ref[0])\\n lt.update(ref[1])\\n return ld, lt\",\n \"def getOutShapes(self):\\n\\t\\treturn self.output_shape\",\n \"def auto_shapes(self):\\n return self.container['auto_shapes']\",\n \"def get_data_shapes():\\n return [None, None, None], [None, None], [None, ]\",\n \"def shape_in(self):\\n return [c.size for c in self.coords]\",\n \"def getChildren(self):\\n return []\",\n \"def get_data_shapes():\\r\\n return ([None, None, None], [None, None], [None, None, None])\",\n \"def getChildren(self):\\n return self.child_edges\",\n \"def get_children(self):\\n return []\",\n \"def getChildren():\",\n \"def get(self, selector):\\r\\n stage = self.get_stage()\\r\\n arr = []\\r\\n key = selector[1:]\\r\\n if selector[0] == '#':\\r\\n arr = [stage.ids[key]] if stage.ids[key] else []\\r\\n elif selector[0] == '.':\\r\\n arr = [stage.name[key]] if stage.name[key] else []\\r\\n elif selector == 'Shape' or selector == 'Group' or selector == 'Layer':\\r\\n return self._get_nodes(selector)\\r\\n else:\\r\\n return []\\r\\n\\r\\n retr_arr = []\\r\\n for n in xrange(len(arr)):\\r\\n node = arr[n]\\r\\n if self.is_ancestor_of(node):\\r\\n retr_arr.append(node)\\r\\n\\r\\n return retr_arr\",\n \"def children(self) -> Iterable[Heirarchical]:\\n return []\",\n \"def _get_border_children(self, quad, location):\\n bounds = [[2, 3], [0, 2], [0, 1], [1, 3]]\\n bound_location = bounds[location]\\n if not quad.is_leaf:\\n for i in bound_location:\\n yield from self._get_border_children(quad.children[i], location)\\n else:\\n yield quad\",\n \"def input_type_shapes(self):\\n return self._input_type_shapes\",\n \"def get_elements():\\n elements = { 'Shapes':[], 'Strokes':[] }\\n curves_knob = rp_node['curves']\\n root_layer = curves_knob.rootLayer\\n elements = parse_layer(root_layer, elements, [root_layer])\\n print elements\",\n \"def get_children(self):\\n return self.children\",\n \"def _get_shape(t):\\n return [x.value for x in t.shape]\",\n \"def get_drawables(self):\\n to_draw = []\\n for k,v in self._to_draw.items():\\n if isinstance(v,Iterable):\\n for i in v:\\n to_draw.append(i)\\n else:\\n to_draw.append(v)\\n return to_draw\",\n \"def _all_subnodes(self):\\n return self.__dict__.values()\",\n \"def shape(self):\\n return self.child_mode.shape()\",\n \"def FindSubShape(self, *args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_FindSubShape(self, *args)\",\n \"def AllSubElements(self):\\n return []\",\n \"def shape(self):\\n return self._shape\",\n \"def get_all_drawables(self): \\n drawables = []\\n if len(self.component_list) > 0:\\n for c in self.component_list:\\n drawables.append(c.get_drawables())\\n return drawables\",\n \"def get_components_drawables(self):\\n # print self.component_list\\n print len(self.component_list)\\n for c in self.component_list:\\n return c.get_drawables()\",\n \"def matches_shapes(self, shape_):\\n m = []\\n for i, spec in enumerate(self.shapes):\\n if matches(spec, shape_):\\n m.append(i)\\n return m\",\n \"def shape(self):\\n for component in ('x', 'y', 'z', 'r', 't'):\\n arr = getattr(self, component)\\n if arr is not None:\\n return arr.shape\\n return ()\",\n \"def get_shape_bin_edges(shapes_path, datacard_bin):\\n shapes_file = ROOT.TFile.Open(shapes_path)\\n print 'tfile path is', shapes_path\\n print 'list of keys'\\n #ROOT.gDirectory.GetListOfKeys().ls()\\n print 'gonnad cd', datacard_bin\\n print shapes_file.cd(datacard_bin)\\n shapes = ROOT.gDirectory.GetListOfKeys()\\n #print 'list of Keys is', ROOT.gDirectory.GetListOfKeys().ls()\\n # Since the nominal and varied shapes share the same binning,\\n # take any of the histograms found in the shapes file.\\n print 'debug0'\\n shape = ROOT.gDirectory.Get(shapes[0].GetName())\\n print 'debug'\\n bin_edges = np.array(\\n [shape.GetXaxis().GetBinLowEdge(i) for i in xrange(1, shape.GetNbinsX() + 1)],\\n dtype=np.float64,\\n )\\n shapes_file.Close()\\n print 'bin_edges for datacard_bin is', bin_edges\\n #sys.exit()\\n return bin_edges\",\n \"def get_orphans(self):\\n return self.orphans\",\n \"def get_children(self, *types: str) -> List[TgnObject]:\\n pass\",\n \"def draw(hyp):\\r\\n print 'g.createShape(',hyp.getAttList(),')'\\r\\n print type(hyp.getAttList())\\r\\n g.createShape(hyp.getAttList())\",\n \"def computeBoundingShape(scene, shape='ellipsoid'):\\r\\n \\r\\n gr= pgl.Group([ sh.geometry for sh in scene ])\\r\\n tglset = pgl.fit( shape, gr )\\r\\n #hull = pgl.Shape( tglSet, __Green )\\r\\n return tglset\",\n \"def nodes(self): \\n return [n for n in self.iternodes()]\",\n \"def get_childs(self):\\n\\t\\treturn self.__childs\",\n \"def descendant_classes(self):\\n response = check_defined(self, inspect.stack()[0][3])\\n if not response:\\n return response\\n descendants = nx.descendants(self.se.full_class_only_graph,\\n self.uri)\\n result = restructure_output(self,\\n descendants,\\n inspect.stack()[0][3],\\n self.output_type)\\n return result\",\n \"def __call__(self):\\n paths = []\\n for root in self._intf.manage.schemas._trees.values():\\n paths.extend(datatype_attributes(root, self._get_datatype()))\\n return paths\",\n \"def childWells(self):\\n if self.childWellIndices() is None:\\n return []\\n tcs=[]\\n for idx in self.childWellIndices():\\n tcs.append(self.clsParent.clsWells[idx])\\n\\n return tcs\",\n \"def draw(hyp):\\n print 'g.createShape(',hyp.getAttList(),')'\\n print type(hyp.getAttList())\\n g.createShape(hyp.getAttList())\",\n \"def locate_shape(shape):\",\n \"def GetChildren( self ):\\n children = [\\n cWrpr \\n for cWrpr in GameNodePath.GetChildren( self ) \\n if not cWrpr.data.getPythonTag( TAG_IGNORE )\\n ]\\n return children\",\n \"def get_children(self):\\r\\n return self.children\",\n \"def descendants(self):\\n for a in self._related(set(), 'children'):\\n yield a\",\n \"def children(node):\\n\\n return snd(node)\",\n \"def _get_children(self):\\n if not self.ontology:\\n raise ValueError(\\\"No associated ontology.\\\")\\n\\n return self.ontology.get_sub_properties(self)\",\n \"def get_subnodes(self) -> List[SubNode]:\\n\\t\\treturn sorted(self.subnodes, key=lambda x: attrib_key(x.name))\",\n \"def Children(self) -> _n_1_t_2:\",\n \"def shape_list(x):\\n shape = list(x.shape)\\n\\n return shape\",\n \"def _get_shapes(self, state_dim, measurement_dim):\\n shapes = super()._get_shapes(state_dim, measurement_dim)\\n shapes[\\\"b\\\"] = (state_dim,)\\n shapes[\\\"d\\\"] = (measurement_dim,)\\n return shapes\",\n \"def s_all_descendants(node):\\r\\n if len(node.children)==0:\\r\\n return []\\r\\n else:\\r\\n children = node.children[:]\\r\\n for child in node.children:\\r\\n children.extend(Node.s_all_descendants(child))\\r\\n return children\",\n \"def getShape(transform):\\n\\n pass\",\n \"def __getGeometryComponents(self):\\n # get dagPath and member components of skined shape\\n # the deformerSet pretty controls which vertex is deformed by the skinCluster\\n # the deformerSet will allows us to pull out that components(vertex) mobject that we need\\n fnSet = openmaya.MFnSet(self.fn.deformerSet())\\n members = openmaya.MSelectionList()\\n # the MSelectionList contains the vertex information in the deformerSet above\\n fnSet.getMembers(members, False)\\n\\n dagPath = openmaya.MDagPath()\\n components = openmaya.MObject()\\n\\n # dagPath: dagPath of influence objects(joint)\\n # components: mesh components(vertex)\\n members.getDagPath(0, dagPath, components)\\n\\n return dagPath, components\",\n \"def children(self):\\n return [self.cut]\",\n \"def shape_halo(self):\\n return [c.size for c in self.coords_halo]\",\n \"def shape(self):\\n return self._observe_list.shape\",\n \"def GetShapesOfLayer(self, *args):\\n return _XCAFDoc.XCAFDoc_LayerTool_GetShapesOfLayer(self, *args)\",\n \"def get_array_of_children(self):\\n children = [self.posXposYposZ,self.posXposYnegZ,self.posXnegYposZ,self.posXposYnegZ,self.negXposYposZ,self.negXposYnegZ,self.negXnegYposZ,self.negXnegYnegZ ] \\n return children\",\n \"def get_child_nodes(self):\\n parts = []\\n for child in sorted(self.children, key=lambda c: c.start):\\n child_part = (child.start, child.end, child)\\n parts.append(child_part)\\n return parts\",\n \"def descendant_properties(self):\\n response = check_defined(self, inspect.stack()[0][3])\\n if not response:\\n return response\\n descendants = nx.descendants(self.se.property_only_graph,\\n self.uri)\\n result = restructure_output(self,\\n descendants,\\n inspect.stack()[0][3],\\n self.output_type)\\n return result\",\n \"def get_path(self) -> list:\\n path = []\\n if self.parent:\\n path = [a.name for a in self.parent.ancestors(include_self=True)]\\n\\n return path + [self.name]\",\n \"def children(self) -> Tuple[CombinatorialClassType, ...]:\\n if self._children is None:\\n self._children = self._strategy.decomposition_function(self.comb_class)\\n if self._children is None:\\n raise StrategyDoesNotApply(\\\"{} does not apply\\\".format(self._strategy))\\n return self._children\",\n \"def get_shape_info(self, obj):\\r\\n return obj.shape\",\n \"def get_all_children(self):\\n return tuple(self.children)\",\n \"def extract_shapefuns(self, parent_folder):\\n shapelist = []\\n cwd = os.getcwd()\\n print('Extracting shapes')\\n has_shapefun_file = False\\n found_shapes = False #to see if KKRnano produced some shapes as output (better than using shapefun)\\n parent_folder_listdir = parent_folder.listdir() #quicker this way as based on SSH tunneling\\n for filename in parent_folder_listdir:\\n if filename.find('shape.') >= 0:\\n if has_shapefun_file:\\n shapelist = []\\n abs_path = f'{cwd}/{filename}'\\n parent_folder.getfile(filename, f'{cwd}/{filename}')\\n self.put_object_from_file(abs_path, filename)\\n self.set_attribute(filename.replace('.', ''), filename)\\n os.remove(filename)\\n with self.open(filename, 'r') as _f:\\n shapelist.append(SinglefileData(_f.name))\\n print('Found shape in repsitory:')\\n print(_f.name)\\n has_shapefun_file = False\\n found_shapes = True\\n if 'shapefun' in parent_folder_listdir and not found_shapes:\\n filename = 'shapefun'\\n print('Shapefun in dir, this part of the program might need more testing')\\n abs_path = f'{cwd}/{filename}'\\n parent_folder.getfile(filename, f'{cwd}/{filename}')\\n\\n with open(filename, 'r') as reader:\\n shapes = reader.readlines()\\n\\n\\n# print(os.path.realpath(reader.name))\\n lines = []\\n for line in range(len(shapes)):\\n if shapes[line].find('Shape') > 0:\\n lines.append(line)\\n lines.append(len(shapes))\\n for j in range(len(lines) - 1):\\n shape_string = ''\\n for k in range(lines[j], lines[j + 1]):\\n shape_string += shapes[k]\\n\\n shape_no_filename = 'shape.' + str(j + 1).zfill(7)\\n with open(shape_no_filename, 'w') as file:\\n file.write(shape_string)\\n path = os.path.realpath(file.name)\\n print(path)\\n abs_path = f'{cwd}/{shape_no_filename}'\\n self.put_object_from_file(abs_path, shape_no_filename) #Problem has to be called via instance\\n self.set_attribute(shape_no_filename.replace('.', ''), shape_no_filename)\\n with self.open(shape_no_filename, 'r') as _f:\\n shapelist.append(SinglefileData(_f.name))\\n os.remove(shape_no_filename)\\n has_shapefun_file = True\\n if has_shapefun_file:\\n print(\\n 'WARNING: Only a shapefun from some Voronoi input was found, it is possible that the potential does not match the shapefun parameters, unless they are set this way explicitly in the respective input file! It is advisable to use the `write_shapes=1` command in input.conf'\\n )\\n print('Found shapelist:')\\n print(shapelist)\\n return shapelist\",\n \"def shape(self):\\r\\n return self._shape\",\n \"def children(self) -> List[Region]:\\n return []\",\n \"def get_children_types(self) -> set[FakeAnnotation]:\\n result: set[FakeAnnotation] = set()\\n for child in self.children:\\n result.update(child.iterate_types())\\n return result\",\n \"def getchildren(self):\\n return self.root.getchildren()\",\n \"def output_shapes(self):\\n return nest.map_structure(\\n lambda component_spec: component_spec._to_legacy_output_shapes(), # pylint: disable=protected-access\\n self._element_spec)\",\n \"def output_shapes(self):\\n return nest.map_structure(\\n lambda component_spec: component_spec._to_legacy_output_shapes(), # pylint: disable=protected-access\\n self._element_spec)\",\n \"def default_infer_shape(self, node, i_shapes):\\r\\n rval = []\\r\\n for r in node.outputs:\\r\\n try:\\r\\n rval.append(self.shape_tuple(r))\\r\\n except AttributeError:\\r\\n rval.append(None)\\r\\n return rval\",\n \"def getAlembicHolder(cls=False, node_name=\\\"\\\"):\\n\\n tr = cmds.ls(node_name)\\n if len(tr) == 0:\\n return []\\n shape_list = []\\n for x in tr:\\n if cmds.nodeType(x) == \\\"alembicHolder\\\":\\n shape = x\\n else:\\n shapes = cmds.listRelatives(x, shapes=True, f=1)\\n if not shapes:\\n continue\\n shape = shapes[0]\\n shape_list += pm.ls(shape)\\n return main(cls, shape_list)\",\n \"def get_shapes_for_route(route_short_name):\\n cur = get_cursor();\\n SQLExec(cur, \\\"\\\"\\\"SELECT gtf_shapes.*,shape_dirtag.dirtag \\n FROM gtf_shapes,shape_dirtag\\n WHERE gtf_shapes.shape_id = shape_dirtag.shape_id \\n and gtf_shapes.shape_id IN \\n (select distinct(shape_id) from gtf_trips \\n where route_id IN\\n (select route_id from gtf_routes \\n where route_short_name = %(route_short_name)s\\n )\\n )\\n ORDER BY gtf_shapes.shape_id asc, \\n gtf_shapes.shape_pt_sequence asc\\\"\\\"\\\",\\n {'route_short_name':route_short_name});\\n ret = [r for r in cur];\\n\\n cur.close();\\n return ret;\",\n \"def get_shape(cls, leaf_type, g_scale, scale, scale_x):\\n u_v = []\\n\\n if leaf_type < 0: # blossom\\n if leaf_type < -3: # out of range\\n leaf_type = -1\\n shape = leaf_geom.blossom(abs(leaf_type + 1))\\n\\n else: # leaf\\n if leaf_type < 1 or leaf_type > 10: # is out of range or explicitly default\\n leaf_type = 8\\n shape = leaf_geom.leaves(leaf_type - 1)\\n\\n verts = shape[0]\\n faces = shape[1]\\n if len(shape) == 3:\\n u_v = shape[2]\\n\\n for vert in verts:\\n vert *= scale * g_scale\\n vert.x *= scale_x\\n\\n return verts, faces, u_v\",\n \"def __init__(self):\\n self.superelevations = []\\n self.shapes = []\",\n \"def elements(self) -> Geometry:\\n return self._elements\",\n \"def ordered_descendants(\\n self: InheritingObjectT, schema: s_schema.Schema\\n ) -> List[InheritingObjectT]:\\n graph = {}\\n for descendant in self.descendants(schema):\\n graph[descendant] = topological.DepGraphEntry(\\n item=descendant,\\n deps=ordered.OrderedSet(\\n descendant.get_bases(schema).objects(schema),\\n ),\\n extra=False,\\n )\\n\\n return list(topological.sort(graph, allow_unresolved=True))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73384356","0.7060281","0.6672472","0.662404","0.65109956","0.64910746","0.6474879","0.63651323","0.6347653","0.6231355","0.618104","0.618104","0.6144639","0.6126819","0.6074737","0.6026544","0.6010485","0.59775174","0.59462196","0.59245396","0.5912519","0.5910949","0.5904081","0.58678466","0.58678466","0.5854793","0.5854701","0.5838471","0.58194816","0.580151","0.5792261","0.5773636","0.5741643","0.5729149","0.5707281","0.5701267","0.5697823","0.56653684","0.56636834","0.5658952","0.56571096","0.56463116","0.5625949","0.5611809","0.558891","0.5581613","0.5581584","0.557987","0.5559163","0.5557641","0.55533546","0.5549397","0.5548464","0.55452335","0.55403626","0.55379933","0.5536849","0.55344635","0.5530725","0.5526566","0.55188984","0.55002457","0.5499192","0.5481141","0.5478981","0.54742354","0.54696196","0.54599535","0.54549384","0.54488915","0.54337066","0.5407299","0.54057217","0.5405189","0.5399168","0.5398806","0.53986377","0.5396382","0.53961617","0.5391875","0.539052","0.53853536","0.5384087","0.5383005","0.5378129","0.53777266","0.5373981","0.5372203","0.5357943","0.53578067","0.53481704","0.5341932","0.5340506","0.5340506","0.53383535","0.5336724","0.5333644","0.53236103","0.53132886","0.53125256","0.5311775"],"string":"[\n \"0.73384356\",\n \"0.7060281\",\n \"0.6672472\",\n \"0.662404\",\n \"0.65109956\",\n \"0.64910746\",\n \"0.6474879\",\n \"0.63651323\",\n \"0.6347653\",\n \"0.6231355\",\n \"0.618104\",\n \"0.618104\",\n \"0.6144639\",\n \"0.6126819\",\n \"0.6074737\",\n \"0.6026544\",\n \"0.6010485\",\n \"0.59775174\",\n \"0.59462196\",\n \"0.59245396\",\n \"0.5912519\",\n \"0.5910949\",\n \"0.5904081\",\n \"0.58678466\",\n \"0.58678466\",\n \"0.5854793\",\n \"0.5854701\",\n \"0.5838471\",\n \"0.58194816\",\n \"0.580151\",\n \"0.5792261\",\n \"0.5773636\",\n \"0.5741643\",\n \"0.5729149\",\n \"0.5707281\",\n \"0.5701267\",\n \"0.5697823\",\n \"0.56653684\",\n \"0.56636834\",\n \"0.5658952\",\n \"0.56571096\",\n \"0.56463116\",\n \"0.5625949\",\n \"0.5611809\",\n \"0.558891\",\n \"0.5581613\",\n \"0.5581584\",\n \"0.557987\",\n \"0.5559163\",\n \"0.5557641\",\n \"0.55533546\",\n \"0.5549397\",\n \"0.5548464\",\n \"0.55452335\",\n \"0.55403626\",\n \"0.55379933\",\n \"0.5536849\",\n \"0.55344635\",\n \"0.5530725\",\n \"0.5526566\",\n \"0.55188984\",\n \"0.55002457\",\n \"0.5499192\",\n \"0.5481141\",\n \"0.5478981\",\n \"0.54742354\",\n \"0.54696196\",\n \"0.54599535\",\n \"0.54549384\",\n \"0.54488915\",\n \"0.54337066\",\n \"0.5407299\",\n \"0.54057217\",\n \"0.5405189\",\n \"0.5399168\",\n \"0.5398806\",\n \"0.53986377\",\n \"0.5396382\",\n \"0.53961617\",\n \"0.5391875\",\n \"0.539052\",\n \"0.53853536\",\n \"0.5384087\",\n \"0.5383005\",\n \"0.5378129\",\n \"0.53777266\",\n \"0.5373981\",\n \"0.5372203\",\n \"0.5357943\",\n \"0.53578067\",\n \"0.53481704\",\n \"0.5341932\",\n \"0.5340506\",\n \"0.5340506\",\n \"0.53383535\",\n \"0.5336724\",\n \"0.5333644\",\n \"0.53236103\",\n \"0.53132886\",\n \"0.53125256\",\n \"0.5311775\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78788,"cells":{"query":{"kind":"string","value":"NYI coherence of the internal Data Structure."},"document":{"kind":"string","value":"def Check(self, *args):\n return _BRepAlgo.BRepAlgo_DSAccess_Check(self, *args)"},"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 nits(self):","def __init__(self):\n # set of lists of nodal differences\n self.di = {}\n # self of upper boudns\n self.i = {}","def n_cs(self):\n pass","def COMBI(self):\n\n self.FB()\n self.LAT()\n self.ROT()","def CL(self):","def centrality(self):\n\n raise NotImplementedError","def ustvari(self):\n raise NotImplementedError","def __getstate__(self):\n return {\n 'token_embeddings' : self.token_embeddings,\n 'fee_embeddings' : self.fee_embeddings,\n 'all_fee_spans' : self.all_fee_spans,\n 'fee_indices' : self.fee_indices,\n 'labels' : self.labels,\n 'lemma_pos' : self.lemma_pos,\n 'dependency_labels' : self.all_dependency_labels,\n 'dependency_heads' : self.all_dependency_heads,\n 'n' : self.n,\n 'dim' : self.dim,\n 'loaded' : self.loaded,\n 'statistics' : self.statistics,\n 'version' : CURRENT_DATASET_VERSION\n }","def get_coco_dataset():\n ds = AttrDict()\n # classes = [\n # '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\n # 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',\n # 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',\n # 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',\n # 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',\n # 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',\n # 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',\n # 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',\n # 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',\n # 'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',\n # 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',\n # 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',\n # 'scissors', 'teddy bear', 'hair drier', 'toothbrush'\n # ]\n # classes = ['__background__', 'lane']\n #\n base_classes = [\n '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\n 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',\n 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',\n 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',\n 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',\n 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',\n 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',\n 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',\n 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',\n 'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',\n 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',\n 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',\n 'scissors', 'teddy bear', 'hair drier', 'toothbrush'\n ]\n classes = ['__background__',\n 'guard rail',\n # 'car',\n 'dashed',\n 'solid',\n 'solid solid',\n 'dashed dashed',\n 'dashed-solid',\n 'solid-dashed',\n 'yellow dashed',\n 'yellow solid',\n 'yellow solid solid',\n 'yellow dashed dashed',\n 'yellow dashed-solid',\n 'yellow solid-dashed',\n 'boundary',\n 'fork_line',\n 'fork_edge',\n 'arrow_s',\n 'arrow_r',\n 'arrow_l',\n 'arrow_lr',\n 'arrow_inclined_r',\n 'arrow_r_s',\n 'arrow_l_s',\n 'sidewalk',\n 'handrail'\n ]\n base_classes.extend(classes[1:])\n classes = base_classes\n ds.classes = {i: name for i, name in enumerate(classes)}\n return ds","def get_coulomb_info(self):\n return","def c(self):\n pass","def c(self):\n pass","def covariates(self):\n return None","def __init__(self):\r\n self.tied_indices = []\r\n self.fixed_indices = []\r\n self.fixed_values = []\r\n self.constrained_indices = []\r\n self.constraints = []","def benchmark(self):\n nsites = []\n for m in self.methods:\n for name, structure in self.test_structures.items():\n cns = []\n if self.unique_sites:\n es = SpacegroupAnalyzer(structure).get_symmetrized_structure().equivalent_sites\n sites = [structure.index(x[0]) for x in es]\n else:\n sites = range(len(structure))\n\n for key, val in self.hi.items():\n if name == key:\n for j in sites:\n if isinstance(m, NearNeighbors):\n tmpcn = m.get_cn_dict(structure, j, self.use_weights)\n else:\n tmpcn = m.compute(structure, j)\n if tmpcn == \"null\":\n continue\n if self.nround:\n self._roundcns(tmpcn, self.nround)\n cns.append((structure[j].species_string, tmpcn))\n if self.cation_anion:\n for mat, cat in self.cations.items():\n if (name == mat) and cat:\n cns = self._popel(cns, cat)\n elif self.anion_cation:\n for mat, an in self.anions.items():\n if name == mat:\n cns = self._popel(cns, an)\n m._cns[name] = cns\n nsites.append(len(cns))\n self.nsites = max(nsites)","def create_observation(self):","def create_observation(self):","def ncore(self):","def iteridents(self):\n raise NotImplementedError","def observation_space():","def getNY(self):\n return self._get_ny( )","def __init__(self, synonyme_cache, intersection_cache, data, evaluator):\n self.SYNSET_CACHE = synonyme_cache\n self.INTERSECTION_CACHE = intersection_cache\n self.pen = Penalties()\n self.evaluator = evaluator\n self.data = data","def test_curie_consistency(self):\n t = self.OntTerm('RO:0000087')","def __init__(self):\n self.rho=[]\n self.te=[]\n self.ti=[]\n self.ne=[]\n self.ni=[]\n self.ni1=[]\n self.ni2=[]\n self.ni3=[]\n self.vtor=[]\n self.zeff=[]\n\n self.nion=1\n self.Z=[]\n self.A=[]\n self.coll_mode=[]","def __init__(self):\n self.currSyms = {}\n Traversable.__init__(self)","def _get_observation(self, observation):","def observation_value(self):\n pass","def associated_coroot(self):","def solvate(self):\n\n pass","def __post_init__(self):\n assert self.data.shape == self.theory.shape","def __init__(self):\n self.born = None\n self.sex = None\n self.dnp = None\n self.grid_queue = None\n self.name = None\n \n self.time_of_infection = np.Inf \n self.last_match = -np.Inf\n self.attributes = {}","def __init__(self):\n self.data = None\n self.decisionTree = {}\n self.enClass = 0\n self.nlClass = 0\n self.listAttributes = [\"Contains-het\", \"Contains-de\", \"Contains-een\", \"Contains-en/aan\", \"Contains-ij\", \"wordLength14\",\n \"Contains-a/an\", \"Contains-are/were\", \"Contains-and\", \"Contains-on/to\", \"Contains-the\"]\n self.infoGain = []\n self.entropy = 0","def __init__(self):\n self.data = []\n self.idx = {}","def _set_init(self):\n ## Main information\n self.idxs = None\n self.sp_relative_pos = None\n ## Auxiliar information\n self.ks = None\n self.iss = [0]\n ## Class structural information\n self._setted = False\n self._constant_rel_pos = False\n self.staticneighs = None\n self.staticneighs_set = None","def _get_information(self):\n pass","def narration_self(self):\n pass","def closeness_centrality(self):\n try:\n self.logger.info('正在计算网络的接近中心性 ...')\n return self.order_dict(nx.closeness_centrality(self.G), index=1)\n except Exception as e:\n self.logger.error(\"计算失败，原因：{0}\".format(e))","def spatial(self):","def __init__(self):\n self._tyrannosaurus = []\n self._triceratops = []","def get_iiai_dataset():\n ds = AttrDict()\n \n # classes = [\n # '__background__','Planes', 'Civilian Passenger', 'Civ Jet', 'Civ Light Aircraft', \n # 'Civ Transport', 'Mil Bomber', 'Mil Fighter', 'Mil Transport', 'Plane Engine', \n # 'Ships', 'Destroyer', 'Frigate', 'Cruiser', 'Aircraft Carrier', 'Cargo Ship', \n # 'Boats', 'Submarines', 'Sailing Ships/Boats', 'Tanker', 'Helicopter', 'Civilian', \n # 'Military', 'Vehicles', 'Cars', 'Pickup Trucks', 'Motorcycles', 'Semi Truck', 'Bus', \n # 'Ambulance', 'Fire Truck', 'Bridges', 'Pedestrian', 'Buildings', 'Mosques', 'Towers', \n # 'Residential', 'Other', 'Greenhouse', 'Warehouses', 'Parking Lots', 'Air Traffic Control Tower', \n # 'Runway', 'Hangar', 'Taxiways', 'Aprons', 'Helipad', 'Satellite Dish', 'Solar Panels', 'Storage Tank', \n # 'Roundabout', 'Swimming Pool', 'Sports Stadium/Field', 'Tennis Court', 'Basketball Court', \n # 'Soccer Field', 'Baseball Diamond', 'Stadium', 'Athletic Track', 'Rail(train)', 'Intersection/Crossroads', \n # 'Shipping Container Lot', 'Shipping Containers', 'Crane', 'Construction', 'Floating', 'Gantry', 'Tower', \n # 'Train', 'Engine', 'Boxcar', 'Passenger Car', 'Flatbed Car', 'Hopper', 'Tanker', 'Breakwater', 'Pier', \n # 'Quay', 'Harbor', 'Drydocks', 'Floating Docks', 'Slip', 'Telephone Poles', 'Hovercraft', 'Mil Vehicles', \n # 'Tanks', 'Self-propelled Artillery', 'Towed Artillery', 'APC', 'Fighting Veh.', 'Support Vehicles', \n # 'Missiles/Missile Systems', 'Comms Towers', 'Power Station'\n # ]\n\n # classes = ['__background__',\n # 'Planes', \n # 'Ships', \n # 'Helicopter', \n # 'Vehicles', \n # 'Bridges', \n # 'Pedestrian', \n # 'Buildings', \n # 'Parking Lots', \n # 'Airports', \n # 'Satellite Dish', \n # 'Solar Panels', \n # 'Storage Tank', \n # 'Roundabout', \n # 'Swimming Pool',\n # 'Sports Stadium/Field',\n # 'Rail(train)', \n # 'Intersection/Crossroads', \n # 'Shipping Container Lot', \n # 'Shipping Containers', \n # 'Crane',\n # 'Train', \n # 'Port' ,\n # 'Telephone Poles', \n # 'Hovercraft', \n # 'Mil Vehicles',\n # 'Missiles/Missile Systems', \n # 'Comms Towers', \n # 'Power Station'\n # ]\n\n # classes = ['__background__', \n # 'Planes', \n # 'Ships', \n # 'Helicopter', \n # 'Vehicles', \n # 'Bridges', \n # 'Buildings', \n # 'Parking Lots', \n # 'Satellite Dish', \n # 'Solar Panels', \n # 'Storage Tank', \n # 'Swimming Pool', \n # 'Sports Stadium/Field', \n # 'Shipping Containers', \n # 'Crane', 'Train', \n # 'Mil Vehicles', \n # 'Missiles/Missile Systems', \n # 'Comms Towers']\n\n #12\n classes = ['__background__', \n 'Planes', \n 'Ships', \n 'Helicopter', \n 'Vehicles', \n 'Buildings', \n 'Parking Lots', \n 'Storage Tank', \n 'Swimming Pool', \n 'Sports Stadium/Field', \n 'Shipping Containers', \n 'Crane', \n 'Comms Towers']\n\n\n\n\n\n\n ds.classes = {i: name for i, name in enumerate(classes)}\n return ds","def __init__(self):\r\n # sample ID -> (ref individual count,\r\n # {size -> (estimate, std err, ci_low, ci_high)})\r\n self._data = {}","def get_perfect_information(self):\n raise NotImplementedError","def identity(self):\r\n self.piDD = {\"[1]\": None}\r\n self.top_node = \"[1]\"\r\n self.dim = 0","def observation_space(self):\n pass","def __post_init__(self):\n all_vecs = {}\n for n2 in self._get_n2():\n all_vecs[n2] = all_vecs.get(n2, 0) + 1\n\n object.__setattr__(self, \"_n2\", np.array(list(all_vecs.keys())).reshape(-1, 1))\n object.__setattr__(\n self, \"_multiplicity\", np.array(list(all_vecs.values())).reshape(-1, 1)\n )\n object.__setattr__(\n self,\n \"_normalization\",\n 2 * np.pi * np.log(self.N)\n if self.spherical\n else 2 * np.pi * np.log(self.N) - 4 * (CATALAN - np.pi / 2 * np.log(2)),\n )","def setIInternal(self):\n # if the di vectors are defined this method populates the upper limit vector\n self.i = {}\n for label in self.di.keys():\n self.i[label] = []\n L = 0\n for l in self.di[label]:\n L += l\n self.i[label].append(L)","def Ncen(self, m):\n pass","def test_nti(self):\r\n # using the input of the distance matrix generated from this tree\r\n # '(((sp1:.06,sp2:.1)A:.031,(sp3:.001,sp4:.01)B:.2)AB:.4,((sp5:.03,sp6:.02)C:.13,(sp7:.01,sp8:.005)D:.1)CD:.3)root;'\r\n # using this tree and this clumping we get almost exact agreement\r\n # between phylocom and relatedness.py\r\n distmat = array(\r\n [[0., 0.16, 0.292, 0.301, 0.951, 0.941, 0.901, 0.896],\r\n [0.16,\r\n 0.,\r\n 0.332,\r\n 0.341,\r\n 0.991,\r\n 0.981,\r\n 0.941,\r\n 0.936],\r\n [0.292,\r\n 0.332,\r\n 0.,\r\n 0.011,\r\n 1.061,\r\n 1.051,\r\n 1.011,\r\n 1.006],\r\n [0.301,\r\n 0.341,\r\n 0.011,\r\n 0.,\r\n 1.07,\r\n 1.06,\r\n 1.02,\r\n 1.015],\r\n [0.951,\r\n 0.991,\r\n 1.061,\r\n 1.07,\r\n 0.,\r\n 0.05,\r\n 0.27,\r\n 0.265],\r\n [0.941,\r\n 0.981,\r\n 1.051,\r\n 1.06,\r\n 0.05,\r\n 0.,\r\n 0.26,\r\n 0.255],\r\n [0.901,\r\n 0.941,\r\n 1.011,\r\n 1.02,\r\n 0.27,\r\n 0.26,\r\n 0.,\r\n 0.015],\r\n [0.896, 0.936, 1.006, 1.015, 0.265, 0.255, 0.015, 0.]])\r\n\r\n seed(0)\r\n obs_nti = nti(distmat, list(arange(8)), [0, 1, 3, 6], 1000)\r\n assert_almost_equal(-1.2046544711672049, obs_nti)","def initialize(self): \n \n \n fixed_counts = {}\n partial_counts = {}\n \n self.ctx.static = []\n self.ctx.partial = {}\n self.ctx.select = []\n \n self.ctx.compositions = []\n self.ctx.sites_refactored = {}\n \n # We collect the sites into their composition and calculate the theoretical number of occupied sites\n for site in self.ctx.structure:\n if self.__is_partial(site):\n self.ctx.sites_refactored.setdefault(site.species_and_occu, [])\n if site.species_and_occu not in self.ctx.compositions:\n self.ctx.compositions.append(site.species_and_occu)\n \n self.ctx.partial.setdefault(site.species_and_occu, [[]])\n self.ctx.partial.get(site.species_and_occu)[0].append(site)\n \n partial_counts.setdefault(site.species_and_occu, [[0, 0] for s in site.species_and_occu])\n \n for i, element in enumerate(site.species_and_occu):\n partial_counts[site.species_and_occu][i][0] += site.species_and_occu.get(element)\n partial_counts[site.species_and_occu][i][1] += site.species_and_occu.get(element)\n else:\n self.ctx.static.append(PeriodicSite(site.specie, site.coords, site.lattice, True, True))\n fixed_counts.setdefault(site.specie, 0)\n fixed_counts[site.specie] += 1\n \n # If all sites are static, then no need to do anything.\n if len(self.ctx.static) == len(self.ctx.structure):\n self.ctx.do_break = 0\n self.out('structures.%s' % self.inputs.structure.uuid, self.inputs.structure)\n return\n \n # We compile the number of occupied site for each partial composition while not going over the theoretical number\n for comp in partial_counts:\n self.ctx.rs.shuffle(self.ctx.partial.get(comp)[0])\n for i, sp in enumerate(comp):\n partial_counts[comp][i][0] = np.floor(partial_counts[comp][i][0])\n \n # Calculation of the departure from the composition. \n error = {\n el: self.ctx.structure.composition.get(el) - fixed_counts.get(el, 0)\n for el in self.ctx.structure.composition\n }\n\n for comp in partial_counts:\n for i, sp in enumerate(comp):\n error[sp] -= partial_counts.get(comp)[i][0]\n\n # Adding ions to sites with the highest departure from theoretical number as long as the error\n # is greater than 0.5.\n for element in error:\n while error[element] > 0.5:\n if error[element] > 0:\n max_error = (None, 0)\n for i, comp in enumerate(partial_counts):\n if element in comp:\n for j, sp in enumerate(comp):\n if sp == element:\n err = (partial_counts.get(comp)[j][1] - partial_counts.get(comp)[j][0]) ** 2\n if err > max_error[1]:\n max_error = ((comp, j), err)\n partial_counts.get(max_error[0][0])[max_error[0][1]][0] += 1\n error[element] -= 1\n \n self.ctx.configurations = tuple()\n self.ctx.configuration_hashes = tuple()\n self.ctx.configuration_steps = tuple()\n self.ctx.configuration_energies = tuple()\n \n for comp in partial_counts:\n # For each site, calculate log10 of the multinomial factor,\n # it will be used to scale the probability of each site to \n # be used for a swap.\n n = 0\n for i in range(len(self.ctx.partial.get(comp)[-1])):\n n += np.log10(i + 1)\n \n for i, sp in enumerate(comp):\n for j in range(int(partial_counts.get(comp)[i][0])):\n n -= np.log10(j + 1)\n \n for _ in range(int(partial_counts.get(comp)[i][0])):\n site = self.ctx.partial.get(comp)[-1].pop(0)\n self.ctx.partial.get(comp).insert(0, PeriodicSite(Specie(sp, self.ctx.charges.get(sp.value, 0)), \n site.coords, site.lattice, True, True))\n self.ctx.sites_refactored.get(comp).append(sp)\n leftovers = self.ctx.partial.get(comp).pop()\n \n for j in range(len(leftovers)):\n n -= np.log10(j + 1)\n \n for site in leftovers:\n self.ctx.partial.get(comp).insert(0, PeriodicSite(self.ctx.vacancy, \n site.coords, site.lattice, True, True))\n self.ctx.sites_refactored.get(comp).append(self.ctx.vacancy.element)\n\n for _ in range(np.ceil(n).astype(int)):\n self.ctx.select.append(comp)\n \n for sites_refactored in self.ctx.sites_refactored.values():\n self.ctx.rs.shuffle(sites_refactored)\n \n self.ctx.idxes = [idx for idx in range(len(self.ctx.select))]\n self.ctx.sites = self.ctx.partial\n del self.ctx.partial\n \n self.ctx.partial_refactored = []\n # (site #, element) -> particle #\n self.ctx.indices = {}\n i = 0\n \n for site in self.ctx.structure:\n if self.__is_partial(site):\n for element in site.species_and_occu.keys():\n self.ctx.indices[(i, element)] = len(self.ctx.partial_refactored)\n self.ctx.partial_refactored.append(PeriodicSite(Specie(element, self.ctx.charges.get(element.value)), site.coords, site.lattice, True, True))\n i += 1\n \n self.ctx.all_indices = set(range(len(self.ctx.partial_refactored)))\n structure = Structure.from_sites(self.ctx.partial_refactored)\n self.ctx.ewald = EwaldSummation(structure)\n\n self.ctx.energy = self.__ewald(self.ctx.sites_refactored) * np.ones(1)\n self.ctx.tested = np.empty(0, dtype=np.float)\n self.ctx.accepted = np.empty(0, dtype=np.float)\n\n if self.inputs.verbose:\n self.report('Starting structure: E = %f' % self.ctx.energy[-1])","def __init__(self):\n\t\tself.freq_count = [0] * 4 \n\t\t\"\"\" \n\t\ta connection priority value is defined as the \n\t\tno of occurrences of this particular relation between this pair of taxa \n\t\tminus the sum of no of occurrences of other relation types between this couplet\n\t\t\"\"\"\n\t\tself.priority_reln = [0] * 4 \n\t\t\"\"\" \n\t\tthis is the support score for different types of relations between a couplet\n\t\t\"\"\"\n\t\tself.support_score = [0] * 4\n\t\t\"\"\" \n\t\tFor this couplet, it stores the extra gene count with respect to all the gene trees\n\t\t\"\"\"\n\t\tself.XL_sum_gene_trees = []\n\t\t\"\"\" \n\t\tthis variable stores the no of trees supporting the taxa pair \n\t\t\"\"\"\n\t\tself.supporting_trees = 0\n\t\t\"\"\"\n\t\tthis list maintains the consensus relations for this couplet\n\t\twith respect to the input trees\n\t\t\"\"\"\n\t\tself.consensus_reln_list = []\n\t\t\"\"\"\n\t\tthis list contains the union of taxa list underlying the LCA of this couplet\n\t\tfor individual input trees\n\t\t\"\"\"\n\t\tself.LCA_Underlying_Taxa_List = []\n\t\t\"\"\"\n\t\tthis is a variable containing the binned average of the XL values\n\t\tof very high frequency\n\t\tinitially the value is set as -1, to signify that the computation is not done\n\t\tonce the computation (for a couplet) is done, the value is subsequently used and returned\n\t\t\"\"\"\n\t\tself.binned_avg_XL = -1\n\t\t\"\"\"\n\t\tallowed relation list which are included in the support score queue\n\t\t\"\"\"\n\t\tself.Allowed_Reln_List = []","def moi(self):\n\n pass","def __init__(self):\n self.memory = {}\n self.sum_ = {}","def __init__(self):\n self.dGrph = {}\n self.__prime_ip = []\n self.__prime_op = []\n self.__op_fanout = {}","def annihilate(cls):\n pass","def __init__(self):\n\n self.st = {} # symbol table\n self.st[\"itrs\"] = [{}, {}, {}]\n self.existVecs = False\n self.existMats = False\n self.applyOnce = {}","def __init__(self):\n self.incidents_models = {}\n self.risks = []\n self.incidents_models = None","def learn(self):\n pass","def learn(self):\n pass","def common(self):","def __init__(self):\n self.__currentnode__ = None\n self.__colordict__ = {}","def __init__(self):\n NodeObject.__init__(self)\n self.priv = None\n self.sex = 0\n self.confidence = \"\"\n self.sortname = \"\"\n self.dates = None # Daterange: Estimated datetype, date1, date2\n\n self.birth_low = None\n self.death_low = None\n self.birth_high = None\n self.death_high = None","def reckon(self):","def info(self):\n print 'A= ', self.application\n print 'C= ', self.city\n print 'D= ', self.dataset.shape","def update(self):\n self.haveCouncil = len(self.councils()) > 0","def __init__(self):\n self.tree = nx.Graph() \n self.orig_dist_matrix = pd.DataFrame()\n self.work_dist_matrix = pd.DataFrame() \n self.cluster_map = {} \n self.class_map = {}","def __init__(self):\n\t\tself.clust_idx_part = -1\n\t\t\"\"\"\n\t\tthis list stores the indices of input trees having this taxon\n\t\t\"\"\"\n\t\tself.Support_Tree_List = []","def a_priori_state_covariance(self) -> NONEARRAY:\n pass","def __init__(self):\r\n self.idents = []\r\n self.names = []\r\n self.costs = []\r\n self.leadtimes = []","def _get_graph_based_ic_dictionary(self):\n\n\t\t# TODO find the literature reference or presentation where this equation is from instead of just the presentation.\n\n\t\t#ic_dict = {}\n\t\t#num_terms_in_ontology = len(self)\n\t\t#for term in self.terms():\n\t\t#\tdepth = self._depth_dict[term.id]\n\t\t#\tnum_descendants = len(list(term.subclasses(with_self=False)))\n\t\t#\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\n\t\t#\tic_dict[term.id] = ic_value\n\t\t#return(ic_dict)\n\n\n\t\t# Getting the information content of each term in the ontology based on graph structure.\n\t\tic_dict = {}\n\t\tnum_terms_in_ontology = len(self)\n\t\tfor term in self.terms():\n\t\t\tdepth = self._depth_dict[term.id]\n\t\t\tnum_descendants = len(list(term.subclasses(with_self=False)))\n\t\t\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\n\t\t\tic_dict[term.id] = ic_value\n\n\n\t\t# Converting to weights based on information content rather than raw value.\n\t\tic_dict_as_weights = {}\n\t\tic_values = ic_dict.values()\n\t\tmin_ic = min(ic_values)\n\t\tmax_ic = max(ic_values)\n\t\tnew_max = 1.00\n\t\tnew_min = 0.00\n\t\tfor k,v in ic_dict.items():\n\t\t\told_range = max_ic-min_ic\n\t\t\tnew_range = new_max-new_min\n\t\t\tnew_value = (((v - min_ic) * new_range) / old_range) + new_min\n\t\t\tic_dict_as_weights[k] = new_value\n\n\t\treturn(ic_dict, ic_dict_as_weights)","def ionization(self):\n return self._ionization","def __init__(self):\n self._store: ObservationStore = {}\n self._memory_lower_bound = 0","def __init__(self, structure: Structure):\n self.structure = structure\n self.metal_indices = [\n i for i, species in enumerate(self.structure.species) if species.is_metal\n ]\n self.porous_adjustment = True\n self.charges = None\n self.metal_features = None\n self._open_indices: set = set()\n self._has_oms = None\n self._cnn = None\n self._cnn_method = None\n self._filename = None\n self._atomic_overlaps = None\n self._name = None\n self.c_indices = [\n i for i, species in enumerate(self.structure.species) if str(species) == \"C\"\n ]\n self.h_indices = [\n i for i, species in enumerate(self.structure.species) if str(species) == \"H\"\n ]\n self.n_indices = [\n i for i, species in enumerate(self.structure.species) if str(species) == \"N\"\n ]\n self._overvalent_c = None\n self._overvalent_n = None\n self._overvalent_h = None\n self._undercoordinated_carbon = None\n self._undercoordinated_nitrogen = None\n self.check_expected_values = EXPECTED_CHECK_VALUES\n self.check_descriptions = CHECK_DESCRIPTIONS\n\n self._graph = None\n self._connected_sites = {}\n self._cns = {}\n self._set_cnn()\n\n try:\n from openbabel import ( # pylint:disable=import-outside-toplevel, unused-import\n pybel,\n )\n except ImportError:\n warnings.warn(\n \"For the charge check openbabel needs to be installed. \\\n This can be done, for example using conda install -c openbabel openbabel\"\n )","def __init__(self):\n self.n=0\n self.K=0\n self.tuple_data=False\n self.optimal=0","def learn(self):\n raise NotImplementedError","def __init__(self):\n self.seen = {}","def objective(self):\n pass","def __init__(self):\n \n self._citydb = CityDB()\n self._depression = 6 # Set default depression in degrees","def attributes(self):","def test_condense_structure_sym(self):\n sc = StructureCondenser(use_symmetry_equivalent_sites=True)\n data = sc.condense_structure(self.tin_dioxide)\n\n # check the right number of sites and that the site data is correct\n # for one site\n assert len(data[\"sites\"].keys()) == 2\n assert data[\"sites\"][0][\"element\"] == \"Sn4+\"\n assert data[\"sites\"][0][\"geometry\"][\"type\"] == \"octahedral\"\n assert data[\"sites\"][0][\"geometry\"][\"likeness\"] == approx(0.9349817375244279)\n assert len(data[\"sites\"][0][\"nn\"]) == 6\n assert len(data[\"sites\"][0][\"nnn\"][\"corner\"]) == 8\n assert len(data[\"sites\"][0][\"nnn\"][\"edge\"]) == 2\n assert data[\"sites\"][0][\"poly_formula\"] == \"O6\"\n assert data[\"sites\"][0][\"sym_labels\"] == (1,)\n\n # check distances\n assert len(data[\"distances\"][0][2]) == 6\n assert len(data[\"distances\"][2][0]) == 3\n assert data[\"distances\"][0][2][0] == approx(2.092210570377848)\n\n # check angles\n assert len(data[\"angles\"][0][0][\"corner\"]) == 8\n assert len(data[\"angles\"][0][0][\"edge\"]) == 4\n assert data[\"angles\"][0][0][\"edge\"][0] == approx(101.62284671698572)\n\n # check nnn distances\n assert len(data[\"nnn_distances\"][0][0][\"corner\"]) == 8\n assert len(data[\"nnn_distances\"][0][0][\"edge\"]) == 2\n assert data[\"nnn_distances\"][0][0][\"edge\"][0] == approx(3.24322132)\n\n # check components\n assert data[\"components\"][0][\"dimensionality\"] == 3\n assert data[\"components\"][0][\"orientation\"] is None\n assert data[\"components\"][0][\"formula\"] == \"SnO2\"\n assert data[\"components\"][0][\"molecule_name\"] is None\n assert data[\"components\"][0][\"sites\"] == [0, 0, 2, 2, 2, 2]\n assert data[\"component_makeup\"] == [0]","def data_for_twos() -> NoReturn:\n raise NotImplementedError","def find_data_association(self, obs):\n prob = 0\n ass_obs = np.zeros((2,1))\n ass_jacobian = np.zeros((2,2))\n ass_adjcov = np.zeros((2,2))\n landmark_idx = -1\n for idx, landmark in enumerate(self.landmarks):\n predicted_obs, jacobian, adj_cov = self.compute_jacobians(landmark)\n p = multi_normal(np.transpose(np.array([obs])), predicted_obs, adj_cov)\n if p > prob:\n prob = p\n ass_obs = predicted_obs\n ass_jacobian = jacobian\n ass_adjcov = adj_cov\n landmark_idx = idx\n return prob, landmark_idx, ass_obs, ass_jacobian, ass_adjcov","def _init_index(self):\n\n if self._check_idx:\n self._index = bamnostic.bai.Bai(self._index_path)\n self.__nocoordinate = self._index.n_no_coor\n self.__mapped = sum(self._index.unmapped[mapped].n_mapped for mapped in self._index.unmapped) + self.nocoordinate\n self.__unmapped = sum(self._index.unmapped[unmapped].n_unmapped for unmapped in self._index.unmapped) + self.nocoordinate","def info_cache(self):\n self.info.info()\n self.dataset.info()\n self.category.info()","def mezclar_bolsa(self):","def counties(self) -> Iterable[County]:\n return self._counties","def test_observed_species(self):\n c = array([4,3,4,0,1,0,2])\n obs = observed_species(c)\n exp = 5\n self.assertEqual(obs, exp)\n c = array([0,0,0])\n obs = observed_species(c)\n exp = 0\n self.assertEqual(obs, exp)\n self.assertEqual(observed_species(self.TestData), 9)","def __init__(self):\n self.TECRDB_compounds_data_dict = {}\n self.TECRDB_compounds_pH7_species_id_dict = {}\n self.TECRDB_compounds_least_H_sid_dict = {}\n self.get_TECRDB_compounds_data()","def __init__(self):\n self.x = {}\n self.len = 0\n self.annotations = {}","def observation_space(self) -> Dict[str, Any]:","def ndata(self):\n raise Exception(\"Graph store doesn't support access data of all nodes.\")","def __getstate__(self):\n state = Object.__getstate__(self)\n state['_strain'] = set()\n return state","def __init__(self):\n self.cnt = {}","def substantiate():","def observation_spec(self):\r\n pass","def get_domain_otu(self):\n for leaf in self.feature_tree.get_terminals():\n leaf.domain_otu = leaf.name\n self.feature_tree = self.get_node_domain_otu(self.feature_tree)\n #print(temp)\n\n \"\"\"\n for clade in self.feature_tree.find_clades(order='level'):\n if not clade.clades:\n continue\n if clade.clades[0].abu < clade.clades[1].abu:\n clade.domain_otu = clade.clades[1].name\n else:\n clade.domain_otu = clade.clades[0].name\n print('self feature tree root abu')\n print(self.feature_tree.domain_otu)\n \"\"\"","def test_getObservationCount(self):\r\n # Verified with iNEXT.\r\n self.assertEqual(self.est1.getObservationCount(), 5)\r\n\r\n # Verified against results in Colwell 2012 paper.\r\n self.assertEqual(self.est2.getObservationCount(), 140)\r\n self.assertEqual(self.est3.getObservationCount(), 112)","def __setstate__(self,state):\n self.__dict__.update(state)\n self.KDTreeFinder = spatial.KDTree(self.featureVals)","def __init__(self):\n self.__locusts__ = {}\n return","def observation_space(self):\n raise NotImplementedError","def getstate(self):\r\n return [self.tied_indices,\r\n self.fixed_indices,\r\n self.fixed_values,\r\n self.constrained_indices,\r\n self.constraints]","def county_split_details(self,part):\n assignment = dict(part.assignment)\n return {county: reduce(lambda districts, node: districts | set([assignment[node]]), self.nodes_by_county[county], set()) for county in self.counties}"],"string":"[\n \"def nits(self):\",\n \"def __init__(self):\\n # set of lists of nodal differences\\n self.di = {}\\n # self of upper boudns\\n self.i = {}\",\n \"def n_cs(self):\\n pass\",\n \"def COMBI(self):\\n\\n self.FB()\\n self.LAT()\\n self.ROT()\",\n \"def CL(self):\",\n \"def centrality(self):\\n\\n raise NotImplementedError\",\n \"def ustvari(self):\\n raise NotImplementedError\",\n \"def __getstate__(self):\\n return {\\n 'token_embeddings' : self.token_embeddings,\\n 'fee_embeddings' : self.fee_embeddings,\\n 'all_fee_spans' : self.all_fee_spans,\\n 'fee_indices' : self.fee_indices,\\n 'labels' : self.labels,\\n 'lemma_pos' : self.lemma_pos,\\n 'dependency_labels' : self.all_dependency_labels,\\n 'dependency_heads' : self.all_dependency_heads,\\n 'n' : self.n,\\n 'dim' : self.dim,\\n 'loaded' : self.loaded,\\n 'statistics' : self.statistics,\\n 'version' : CURRENT_DATASET_VERSION\\n }\",\n \"def get_coco_dataset():\\n ds = AttrDict()\\n # classes = [\\n # '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\\n # 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',\\n # 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',\\n # 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',\\n # 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',\\n # 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',\\n # 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',\\n # 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',\\n # 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',\\n # 'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',\\n # 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',\\n # 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',\\n # 'scissors', 'teddy bear', 'hair drier', 'toothbrush'\\n # ]\\n # classes = ['__background__', 'lane']\\n #\\n base_classes = [\\n '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',\\n 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',\\n 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',\\n 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',\\n 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',\\n 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',\\n 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',\\n 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',\\n 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',\\n 'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',\\n 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',\\n 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',\\n 'scissors', 'teddy bear', 'hair drier', 'toothbrush'\\n ]\\n classes = ['__background__',\\n 'guard rail',\\n # 'car',\\n 'dashed',\\n 'solid',\\n 'solid solid',\\n 'dashed dashed',\\n 'dashed-solid',\\n 'solid-dashed',\\n 'yellow dashed',\\n 'yellow solid',\\n 'yellow solid solid',\\n 'yellow dashed dashed',\\n 'yellow dashed-solid',\\n 'yellow solid-dashed',\\n 'boundary',\\n 'fork_line',\\n 'fork_edge',\\n 'arrow_s',\\n 'arrow_r',\\n 'arrow_l',\\n 'arrow_lr',\\n 'arrow_inclined_r',\\n 'arrow_r_s',\\n 'arrow_l_s',\\n 'sidewalk',\\n 'handrail'\\n ]\\n base_classes.extend(classes[1:])\\n classes = base_classes\\n ds.classes = {i: name for i, name in enumerate(classes)}\\n return ds\",\n \"def get_coulomb_info(self):\\n return\",\n \"def c(self):\\n pass\",\n \"def c(self):\\n pass\",\n \"def covariates(self):\\n return None\",\n \"def __init__(self):\\r\\n self.tied_indices = []\\r\\n self.fixed_indices = []\\r\\n self.fixed_values = []\\r\\n self.constrained_indices = []\\r\\n self.constraints = []\",\n \"def benchmark(self):\\n nsites = []\\n for m in self.methods:\\n for name, structure in self.test_structures.items():\\n cns = []\\n if self.unique_sites:\\n es = SpacegroupAnalyzer(structure).get_symmetrized_structure().equivalent_sites\\n sites = [structure.index(x[0]) for x in es]\\n else:\\n sites = range(len(structure))\\n\\n for key, val in self.hi.items():\\n if name == key:\\n for j in sites:\\n if isinstance(m, NearNeighbors):\\n tmpcn = m.get_cn_dict(structure, j, self.use_weights)\\n else:\\n tmpcn = m.compute(structure, j)\\n if tmpcn == \\\"null\\\":\\n continue\\n if self.nround:\\n self._roundcns(tmpcn, self.nround)\\n cns.append((structure[j].species_string, tmpcn))\\n if self.cation_anion:\\n for mat, cat in self.cations.items():\\n if (name == mat) and cat:\\n cns = self._popel(cns, cat)\\n elif self.anion_cation:\\n for mat, an in self.anions.items():\\n if name == mat:\\n cns = self._popel(cns, an)\\n m._cns[name] = cns\\n nsites.append(len(cns))\\n self.nsites = max(nsites)\",\n \"def create_observation(self):\",\n \"def create_observation(self):\",\n \"def ncore(self):\",\n \"def iteridents(self):\\n raise NotImplementedError\",\n \"def observation_space():\",\n \"def getNY(self):\\n return self._get_ny( )\",\n \"def __init__(self, synonyme_cache, intersection_cache, data, evaluator):\\n self.SYNSET_CACHE = synonyme_cache\\n self.INTERSECTION_CACHE = intersection_cache\\n self.pen = Penalties()\\n self.evaluator = evaluator\\n self.data = data\",\n \"def test_curie_consistency(self):\\n t = self.OntTerm('RO:0000087')\",\n \"def __init__(self):\\n self.rho=[]\\n self.te=[]\\n self.ti=[]\\n self.ne=[]\\n self.ni=[]\\n self.ni1=[]\\n self.ni2=[]\\n self.ni3=[]\\n self.vtor=[]\\n self.zeff=[]\\n\\n self.nion=1\\n self.Z=[]\\n self.A=[]\\n self.coll_mode=[]\",\n \"def __init__(self):\\n self.currSyms = {}\\n Traversable.__init__(self)\",\n \"def _get_observation(self, observation):\",\n \"def observation_value(self):\\n pass\",\n \"def associated_coroot(self):\",\n \"def solvate(self):\\n\\n pass\",\n \"def __post_init__(self):\\n assert self.data.shape == self.theory.shape\",\n \"def __init__(self):\\n self.born = None\\n self.sex = None\\n self.dnp = None\\n self.grid_queue = None\\n self.name = None\\n \\n self.time_of_infection = np.Inf \\n self.last_match = -np.Inf\\n self.attributes = {}\",\n \"def __init__(self):\\n self.data = None\\n self.decisionTree = {}\\n self.enClass = 0\\n self.nlClass = 0\\n self.listAttributes = [\\\"Contains-het\\\", \\\"Contains-de\\\", \\\"Contains-een\\\", \\\"Contains-en/aan\\\", \\\"Contains-ij\\\", \\\"wordLength14\\\",\\n \\\"Contains-a/an\\\", \\\"Contains-are/were\\\", \\\"Contains-and\\\", \\\"Contains-on/to\\\", \\\"Contains-the\\\"]\\n self.infoGain = []\\n self.entropy = 0\",\n \"def __init__(self):\\n self.data = []\\n self.idx = {}\",\n \"def _set_init(self):\\n ## Main information\\n self.idxs = None\\n self.sp_relative_pos = None\\n ## Auxiliar information\\n self.ks = None\\n self.iss = [0]\\n ## Class structural information\\n self._setted = False\\n self._constant_rel_pos = False\\n self.staticneighs = None\\n self.staticneighs_set = None\",\n \"def _get_information(self):\\n pass\",\n \"def narration_self(self):\\n pass\",\n \"def closeness_centrality(self):\\n try:\\n self.logger.info('正在计算网络的接近中心性 ...')\\n return self.order_dict(nx.closeness_centrality(self.G), index=1)\\n except Exception as e:\\n self.logger.error(\\\"计算失败，原因：{0}\\\".format(e))\",\n \"def spatial(self):\",\n \"def __init__(self):\\n self._tyrannosaurus = []\\n self._triceratops = []\",\n \"def get_iiai_dataset():\\n ds = AttrDict()\\n \\n # classes = [\\n # '__background__','Planes', 'Civilian Passenger', 'Civ Jet', 'Civ Light Aircraft', \\n # 'Civ Transport', 'Mil Bomber', 'Mil Fighter', 'Mil Transport', 'Plane Engine', \\n # 'Ships', 'Destroyer', 'Frigate', 'Cruiser', 'Aircraft Carrier', 'Cargo Ship', \\n # 'Boats', 'Submarines', 'Sailing Ships/Boats', 'Tanker', 'Helicopter', 'Civilian', \\n # 'Military', 'Vehicles', 'Cars', 'Pickup Trucks', 'Motorcycles', 'Semi Truck', 'Bus', \\n # 'Ambulance', 'Fire Truck', 'Bridges', 'Pedestrian', 'Buildings', 'Mosques', 'Towers', \\n # 'Residential', 'Other', 'Greenhouse', 'Warehouses', 'Parking Lots', 'Air Traffic Control Tower', \\n # 'Runway', 'Hangar', 'Taxiways', 'Aprons', 'Helipad', 'Satellite Dish', 'Solar Panels', 'Storage Tank', \\n # 'Roundabout', 'Swimming Pool', 'Sports Stadium/Field', 'Tennis Court', 'Basketball Court', \\n # 'Soccer Field', 'Baseball Diamond', 'Stadium', 'Athletic Track', 'Rail(train)', 'Intersection/Crossroads', \\n # 'Shipping Container Lot', 'Shipping Containers', 'Crane', 'Construction', 'Floating', 'Gantry', 'Tower', \\n # 'Train', 'Engine', 'Boxcar', 'Passenger Car', 'Flatbed Car', 'Hopper', 'Tanker', 'Breakwater', 'Pier', \\n # 'Quay', 'Harbor', 'Drydocks', 'Floating Docks', 'Slip', 'Telephone Poles', 'Hovercraft', 'Mil Vehicles', \\n # 'Tanks', 'Self-propelled Artillery', 'Towed Artillery', 'APC', 'Fighting Veh.', 'Support Vehicles', \\n # 'Missiles/Missile Systems', 'Comms Towers', 'Power Station'\\n # ]\\n\\n # classes = ['__background__',\\n # 'Planes', \\n # 'Ships', \\n # 'Helicopter', \\n # 'Vehicles', \\n # 'Bridges', \\n # 'Pedestrian', \\n # 'Buildings', \\n # 'Parking Lots', \\n # 'Airports', \\n # 'Satellite Dish', \\n # 'Solar Panels', \\n # 'Storage Tank', \\n # 'Roundabout', \\n # 'Swimming Pool',\\n # 'Sports Stadium/Field',\\n # 'Rail(train)', \\n # 'Intersection/Crossroads', \\n # 'Shipping Container Lot', \\n # 'Shipping Containers', \\n # 'Crane',\\n # 'Train', \\n # 'Port' ,\\n # 'Telephone Poles', \\n # 'Hovercraft', \\n # 'Mil Vehicles',\\n # 'Missiles/Missile Systems', \\n # 'Comms Towers', \\n # 'Power Station'\\n # ]\\n\\n # classes = ['__background__', \\n # 'Planes', \\n # 'Ships', \\n # 'Helicopter', \\n # 'Vehicles', \\n # 'Bridges', \\n # 'Buildings', \\n # 'Parking Lots', \\n # 'Satellite Dish', \\n # 'Solar Panels', \\n # 'Storage Tank', \\n # 'Swimming Pool', \\n # 'Sports Stadium/Field', \\n # 'Shipping Containers', \\n # 'Crane', 'Train', \\n # 'Mil Vehicles', \\n # 'Missiles/Missile Systems', \\n # 'Comms Towers']\\n\\n #12\\n classes = ['__background__', \\n 'Planes', \\n 'Ships', \\n 'Helicopter', \\n 'Vehicles', \\n 'Buildings', \\n 'Parking Lots', \\n 'Storage Tank', \\n 'Swimming Pool', \\n 'Sports Stadium/Field', \\n 'Shipping Containers', \\n 'Crane', \\n 'Comms Towers']\\n\\n\\n\\n\\n\\n\\n ds.classes = {i: name for i, name in enumerate(classes)}\\n return ds\",\n \"def __init__(self):\\r\\n # sample ID -> (ref individual count,\\r\\n # {size -> (estimate, std err, ci_low, ci_high)})\\r\\n self._data = {}\",\n \"def get_perfect_information(self):\\n raise NotImplementedError\",\n \"def identity(self):\\r\\n self.piDD = {\\\"[1]\\\": None}\\r\\n self.top_node = \\\"[1]\\\"\\r\\n self.dim = 0\",\n \"def observation_space(self):\\n pass\",\n \"def __post_init__(self):\\n all_vecs = {}\\n for n2 in self._get_n2():\\n all_vecs[n2] = all_vecs.get(n2, 0) + 1\\n\\n object.__setattr__(self, \\\"_n2\\\", np.array(list(all_vecs.keys())).reshape(-1, 1))\\n object.__setattr__(\\n self, \\\"_multiplicity\\\", np.array(list(all_vecs.values())).reshape(-1, 1)\\n )\\n object.__setattr__(\\n self,\\n \\\"_normalization\\\",\\n 2 * np.pi * np.log(self.N)\\n if self.spherical\\n else 2 * np.pi * np.log(self.N) - 4 * (CATALAN - np.pi / 2 * np.log(2)),\\n )\",\n \"def setIInternal(self):\\n # if the di vectors are defined this method populates the upper limit vector\\n self.i = {}\\n for label in self.di.keys():\\n self.i[label] = []\\n L = 0\\n for l in self.di[label]:\\n L += l\\n self.i[label].append(L)\",\n \"def Ncen(self, m):\\n pass\",\n \"def test_nti(self):\\r\\n # using the input of the distance matrix generated from this tree\\r\\n # '(((sp1:.06,sp2:.1)A:.031,(sp3:.001,sp4:.01)B:.2)AB:.4,((sp5:.03,sp6:.02)C:.13,(sp7:.01,sp8:.005)D:.1)CD:.3)root;'\\r\\n # using this tree and this clumping we get almost exact agreement\\r\\n # between phylocom and relatedness.py\\r\\n distmat = array(\\r\\n [[0., 0.16, 0.292, 0.301, 0.951, 0.941, 0.901, 0.896],\\r\\n [0.16,\\r\\n 0.,\\r\\n 0.332,\\r\\n 0.341,\\r\\n 0.991,\\r\\n 0.981,\\r\\n 0.941,\\r\\n 0.936],\\r\\n [0.292,\\r\\n 0.332,\\r\\n 0.,\\r\\n 0.011,\\r\\n 1.061,\\r\\n 1.051,\\r\\n 1.011,\\r\\n 1.006],\\r\\n [0.301,\\r\\n 0.341,\\r\\n 0.011,\\r\\n 0.,\\r\\n 1.07,\\r\\n 1.06,\\r\\n 1.02,\\r\\n 1.015],\\r\\n [0.951,\\r\\n 0.991,\\r\\n 1.061,\\r\\n 1.07,\\r\\n 0.,\\r\\n 0.05,\\r\\n 0.27,\\r\\n 0.265],\\r\\n [0.941,\\r\\n 0.981,\\r\\n 1.051,\\r\\n 1.06,\\r\\n 0.05,\\r\\n 0.,\\r\\n 0.26,\\r\\n 0.255],\\r\\n [0.901,\\r\\n 0.941,\\r\\n 1.011,\\r\\n 1.02,\\r\\n 0.27,\\r\\n 0.26,\\r\\n 0.,\\r\\n 0.015],\\r\\n [0.896, 0.936, 1.006, 1.015, 0.265, 0.255, 0.015, 0.]])\\r\\n\\r\\n seed(0)\\r\\n obs_nti = nti(distmat, list(arange(8)), [0, 1, 3, 6], 1000)\\r\\n assert_almost_equal(-1.2046544711672049, obs_nti)\",\n \"def initialize(self): \\n \\n \\n fixed_counts = {}\\n partial_counts = {}\\n \\n self.ctx.static = []\\n self.ctx.partial = {}\\n self.ctx.select = []\\n \\n self.ctx.compositions = []\\n self.ctx.sites_refactored = {}\\n \\n # We collect the sites into their composition and calculate the theoretical number of occupied sites\\n for site in self.ctx.structure:\\n if self.__is_partial(site):\\n self.ctx.sites_refactored.setdefault(site.species_and_occu, [])\\n if site.species_and_occu not in self.ctx.compositions:\\n self.ctx.compositions.append(site.species_and_occu)\\n \\n self.ctx.partial.setdefault(site.species_and_occu, [[]])\\n self.ctx.partial.get(site.species_and_occu)[0].append(site)\\n \\n partial_counts.setdefault(site.species_and_occu, [[0, 0] for s in site.species_and_occu])\\n \\n for i, element in enumerate(site.species_and_occu):\\n partial_counts[site.species_and_occu][i][0] += site.species_and_occu.get(element)\\n partial_counts[site.species_and_occu][i][1] += site.species_and_occu.get(element)\\n else:\\n self.ctx.static.append(PeriodicSite(site.specie, site.coords, site.lattice, True, True))\\n fixed_counts.setdefault(site.specie, 0)\\n fixed_counts[site.specie] += 1\\n \\n # If all sites are static, then no need to do anything.\\n if len(self.ctx.static) == len(self.ctx.structure):\\n self.ctx.do_break = 0\\n self.out('structures.%s' % self.inputs.structure.uuid, self.inputs.structure)\\n return\\n \\n # We compile the number of occupied site for each partial composition while not going over the theoretical number\\n for comp in partial_counts:\\n self.ctx.rs.shuffle(self.ctx.partial.get(comp)[0])\\n for i, sp in enumerate(comp):\\n partial_counts[comp][i][0] = np.floor(partial_counts[comp][i][0])\\n \\n # Calculation of the departure from the composition. \\n error = {\\n el: self.ctx.structure.composition.get(el) - fixed_counts.get(el, 0)\\n for el in self.ctx.structure.composition\\n }\\n\\n for comp in partial_counts:\\n for i, sp in enumerate(comp):\\n error[sp] -= partial_counts.get(comp)[i][0]\\n\\n # Adding ions to sites with the highest departure from theoretical number as long as the error\\n # is greater than 0.5.\\n for element in error:\\n while error[element] > 0.5:\\n if error[element] > 0:\\n max_error = (None, 0)\\n for i, comp in enumerate(partial_counts):\\n if element in comp:\\n for j, sp in enumerate(comp):\\n if sp == element:\\n err = (partial_counts.get(comp)[j][1] - partial_counts.get(comp)[j][0]) ** 2\\n if err > max_error[1]:\\n max_error = ((comp, j), err)\\n partial_counts.get(max_error[0][0])[max_error[0][1]][0] += 1\\n error[element] -= 1\\n \\n self.ctx.configurations = tuple()\\n self.ctx.configuration_hashes = tuple()\\n self.ctx.configuration_steps = tuple()\\n self.ctx.configuration_energies = tuple()\\n \\n for comp in partial_counts:\\n # For each site, calculate log10 of the multinomial factor,\\n # it will be used to scale the probability of each site to \\n # be used for a swap.\\n n = 0\\n for i in range(len(self.ctx.partial.get(comp)[-1])):\\n n += np.log10(i + 1)\\n \\n for i, sp in enumerate(comp):\\n for j in range(int(partial_counts.get(comp)[i][0])):\\n n -= np.log10(j + 1)\\n \\n for _ in range(int(partial_counts.get(comp)[i][0])):\\n site = self.ctx.partial.get(comp)[-1].pop(0)\\n self.ctx.partial.get(comp).insert(0, PeriodicSite(Specie(sp, self.ctx.charges.get(sp.value, 0)), \\n site.coords, site.lattice, True, True))\\n self.ctx.sites_refactored.get(comp).append(sp)\\n leftovers = self.ctx.partial.get(comp).pop()\\n \\n for j in range(len(leftovers)):\\n n -= np.log10(j + 1)\\n \\n for site in leftovers:\\n self.ctx.partial.get(comp).insert(0, PeriodicSite(self.ctx.vacancy, \\n site.coords, site.lattice, True, True))\\n self.ctx.sites_refactored.get(comp).append(self.ctx.vacancy.element)\\n\\n for _ in range(np.ceil(n).astype(int)):\\n self.ctx.select.append(comp)\\n \\n for sites_refactored in self.ctx.sites_refactored.values():\\n self.ctx.rs.shuffle(sites_refactored)\\n \\n self.ctx.idxes = [idx for idx in range(len(self.ctx.select))]\\n self.ctx.sites = self.ctx.partial\\n del self.ctx.partial\\n \\n self.ctx.partial_refactored = []\\n # (site #, element) -> particle #\\n self.ctx.indices = {}\\n i = 0\\n \\n for site in self.ctx.structure:\\n if self.__is_partial(site):\\n for element in site.species_and_occu.keys():\\n self.ctx.indices[(i, element)] = len(self.ctx.partial_refactored)\\n self.ctx.partial_refactored.append(PeriodicSite(Specie(element, self.ctx.charges.get(element.value)), site.coords, site.lattice, True, True))\\n i += 1\\n \\n self.ctx.all_indices = set(range(len(self.ctx.partial_refactored)))\\n structure = Structure.from_sites(self.ctx.partial_refactored)\\n self.ctx.ewald = EwaldSummation(structure)\\n\\n self.ctx.energy = self.__ewald(self.ctx.sites_refactored) * np.ones(1)\\n self.ctx.tested = np.empty(0, dtype=np.float)\\n self.ctx.accepted = np.empty(0, dtype=np.float)\\n\\n if self.inputs.verbose:\\n self.report('Starting structure: E = %f' % self.ctx.energy[-1])\",\n \"def __init__(self):\\n\\t\\tself.freq_count = [0] * 4 \\n\\t\\t\\\"\\\"\\\" \\n\\t\\ta connection priority value is defined as the \\n\\t\\tno of occurrences of this particular relation between this pair of taxa \\n\\t\\tminus the sum of no of occurrences of other relation types between this couplet\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.priority_reln = [0] * 4 \\n\\t\\t\\\"\\\"\\\" \\n\\t\\tthis is the support score for different types of relations between a couplet\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.support_score = [0] * 4\\n\\t\\t\\\"\\\"\\\" \\n\\t\\tFor this couplet, it stores the extra gene count with respect to all the gene trees\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.XL_sum_gene_trees = []\\n\\t\\t\\\"\\\"\\\" \\n\\t\\tthis variable stores the no of trees supporting the taxa pair \\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.supporting_trees = 0\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tthis list maintains the consensus relations for this couplet\\n\\t\\twith respect to the input trees\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.consensus_reln_list = []\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tthis list contains the union of taxa list underlying the LCA of this couplet\\n\\t\\tfor individual input trees\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.LCA_Underlying_Taxa_List = []\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tthis is a variable containing the binned average of the XL values\\n\\t\\tof very high frequency\\n\\t\\tinitially the value is set as -1, to signify that the computation is not done\\n\\t\\tonce the computation (for a couplet) is done, the value is subsequently used and returned\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.binned_avg_XL = -1\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tallowed relation list which are included in the support score queue\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.Allowed_Reln_List = []\",\n \"def moi(self):\\n\\n pass\",\n \"def __init__(self):\\n self.memory = {}\\n self.sum_ = {}\",\n \"def __init__(self):\\n self.dGrph = {}\\n self.__prime_ip = []\\n self.__prime_op = []\\n self.__op_fanout = {}\",\n \"def annihilate(cls):\\n pass\",\n \"def __init__(self):\\n\\n self.st = {} # symbol table\\n self.st[\\\"itrs\\\"] = [{}, {}, {}]\\n self.existVecs = False\\n self.existMats = False\\n self.applyOnce = {}\",\n \"def __init__(self):\\n self.incidents_models = {}\\n self.risks = []\\n self.incidents_models = None\",\n \"def learn(self):\\n pass\",\n \"def learn(self):\\n pass\",\n \"def common(self):\",\n \"def __init__(self):\\n self.__currentnode__ = None\\n self.__colordict__ = {}\",\n \"def __init__(self):\\n NodeObject.__init__(self)\\n self.priv = None\\n self.sex = 0\\n self.confidence = \\\"\\\"\\n self.sortname = \\\"\\\"\\n self.dates = None # Daterange: Estimated datetype, date1, date2\\n\\n self.birth_low = None\\n self.death_low = None\\n self.birth_high = None\\n self.death_high = None\",\n \"def reckon(self):\",\n \"def info(self):\\n print 'A= ', self.application\\n print 'C= ', self.city\\n print 'D= ', self.dataset.shape\",\n \"def update(self):\\n self.haveCouncil = len(self.councils()) > 0\",\n \"def __init__(self):\\n self.tree = nx.Graph() \\n self.orig_dist_matrix = pd.DataFrame()\\n self.work_dist_matrix = pd.DataFrame() \\n self.cluster_map = {} \\n self.class_map = {}\",\n \"def __init__(self):\\n\\t\\tself.clust_idx_part = -1\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tthis list stores the indices of input trees having this taxon\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tself.Support_Tree_List = []\",\n \"def a_priori_state_covariance(self) -> NONEARRAY:\\n pass\",\n \"def __init__(self):\\r\\n self.idents = []\\r\\n self.names = []\\r\\n self.costs = []\\r\\n self.leadtimes = []\",\n \"def _get_graph_based_ic_dictionary(self):\\n\\n\\t\\t# TODO find the literature reference or presentation where this equation is from instead of just the presentation.\\n\\n\\t\\t#ic_dict = {}\\n\\t\\t#num_terms_in_ontology = len(self)\\n\\t\\t#for term in self.terms():\\n\\t\\t#\\tdepth = self._depth_dict[term.id]\\n\\t\\t#\\tnum_descendants = len(list(term.subclasses(with_self=False)))\\n\\t\\t#\\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\\n\\t\\t#\\tic_dict[term.id] = ic_value\\n\\t\\t#return(ic_dict)\\n\\n\\n\\t\\t# Getting the information content of each term in the ontology based on graph structure.\\n\\t\\tic_dict = {}\\n\\t\\tnum_terms_in_ontology = len(self)\\n\\t\\tfor term in self.terms():\\n\\t\\t\\tdepth = self._depth_dict[term.id]\\n\\t\\t\\tnum_descendants = len(list(term.subclasses(with_self=False)))\\n\\t\\t\\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\\n\\t\\t\\tic_dict[term.id] = ic_value\\n\\n\\n\\t\\t# Converting to weights based on information content rather than raw value.\\n\\t\\tic_dict_as_weights = {}\\n\\t\\tic_values = ic_dict.values()\\n\\t\\tmin_ic = min(ic_values)\\n\\t\\tmax_ic = max(ic_values)\\n\\t\\tnew_max = 1.00\\n\\t\\tnew_min = 0.00\\n\\t\\tfor k,v in ic_dict.items():\\n\\t\\t\\told_range = max_ic-min_ic\\n\\t\\t\\tnew_range = new_max-new_min\\n\\t\\t\\tnew_value = (((v - min_ic) * new_range) / old_range) + new_min\\n\\t\\t\\tic_dict_as_weights[k] = new_value\\n\\n\\t\\treturn(ic_dict, ic_dict_as_weights)\",\n \"def ionization(self):\\n return self._ionization\",\n \"def __init__(self):\\n self._store: ObservationStore = {}\\n self._memory_lower_bound = 0\",\n \"def __init__(self, structure: Structure):\\n self.structure = structure\\n self.metal_indices = [\\n i for i, species in enumerate(self.structure.species) if species.is_metal\\n ]\\n self.porous_adjustment = True\\n self.charges = None\\n self.metal_features = None\\n self._open_indices: set = set()\\n self._has_oms = None\\n self._cnn = None\\n self._cnn_method = None\\n self._filename = None\\n self._atomic_overlaps = None\\n self._name = None\\n self.c_indices = [\\n i for i, species in enumerate(self.structure.species) if str(species) == \\\"C\\\"\\n ]\\n self.h_indices = [\\n i for i, species in enumerate(self.structure.species) if str(species) == \\\"H\\\"\\n ]\\n self.n_indices = [\\n i for i, species in enumerate(self.structure.species) if str(species) == \\\"N\\\"\\n ]\\n self._overvalent_c = None\\n self._overvalent_n = None\\n self._overvalent_h = None\\n self._undercoordinated_carbon = None\\n self._undercoordinated_nitrogen = None\\n self.check_expected_values = EXPECTED_CHECK_VALUES\\n self.check_descriptions = CHECK_DESCRIPTIONS\\n\\n self._graph = None\\n self._connected_sites = {}\\n self._cns = {}\\n self._set_cnn()\\n\\n try:\\n from openbabel import ( # pylint:disable=import-outside-toplevel, unused-import\\n pybel,\\n )\\n except ImportError:\\n warnings.warn(\\n \\\"For the charge check openbabel needs to be installed. \\\\\\n This can be done, for example using conda install -c openbabel openbabel\\\"\\n )\",\n \"def __init__(self):\\n self.n=0\\n self.K=0\\n self.tuple_data=False\\n self.optimal=0\",\n \"def learn(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n self.seen = {}\",\n \"def objective(self):\\n pass\",\n \"def __init__(self):\\n \\n self._citydb = CityDB()\\n self._depression = 6 # Set default depression in degrees\",\n \"def attributes(self):\",\n \"def test_condense_structure_sym(self):\\n sc = StructureCondenser(use_symmetry_equivalent_sites=True)\\n data = sc.condense_structure(self.tin_dioxide)\\n\\n # check the right number of sites and that the site data is correct\\n # for one site\\n assert len(data[\\\"sites\\\"].keys()) == 2\\n assert data[\\\"sites\\\"][0][\\\"element\\\"] == \\\"Sn4+\\\"\\n assert data[\\\"sites\\\"][0][\\\"geometry\\\"][\\\"type\\\"] == \\\"octahedral\\\"\\n assert data[\\\"sites\\\"][0][\\\"geometry\\\"][\\\"likeness\\\"] == approx(0.9349817375244279)\\n assert len(data[\\\"sites\\\"][0][\\\"nn\\\"]) == 6\\n assert len(data[\\\"sites\\\"][0][\\\"nnn\\\"][\\\"corner\\\"]) == 8\\n assert len(data[\\\"sites\\\"][0][\\\"nnn\\\"][\\\"edge\\\"]) == 2\\n assert data[\\\"sites\\\"][0][\\\"poly_formula\\\"] == \\\"O6\\\"\\n assert data[\\\"sites\\\"][0][\\\"sym_labels\\\"] == (1,)\\n\\n # check distances\\n assert len(data[\\\"distances\\\"][0][2]) == 6\\n assert len(data[\\\"distances\\\"][2][0]) == 3\\n assert data[\\\"distances\\\"][0][2][0] == approx(2.092210570377848)\\n\\n # check angles\\n assert len(data[\\\"angles\\\"][0][0][\\\"corner\\\"]) == 8\\n assert len(data[\\\"angles\\\"][0][0][\\\"edge\\\"]) == 4\\n assert data[\\\"angles\\\"][0][0][\\\"edge\\\"][0] == approx(101.62284671698572)\\n\\n # check nnn distances\\n assert len(data[\\\"nnn_distances\\\"][0][0][\\\"corner\\\"]) == 8\\n assert len(data[\\\"nnn_distances\\\"][0][0][\\\"edge\\\"]) == 2\\n assert data[\\\"nnn_distances\\\"][0][0][\\\"edge\\\"][0] == approx(3.24322132)\\n\\n # check components\\n assert data[\\\"components\\\"][0][\\\"dimensionality\\\"] == 3\\n assert data[\\\"components\\\"][0][\\\"orientation\\\"] is None\\n assert data[\\\"components\\\"][0][\\\"formula\\\"] == \\\"SnO2\\\"\\n assert data[\\\"components\\\"][0][\\\"molecule_name\\\"] is None\\n assert data[\\\"components\\\"][0][\\\"sites\\\"] == [0, 0, 2, 2, 2, 2]\\n assert data[\\\"component_makeup\\\"] == [0]\",\n \"def data_for_twos() -> NoReturn:\\n raise NotImplementedError\",\n \"def find_data_association(self, obs):\\n prob = 0\\n ass_obs = np.zeros((2,1))\\n ass_jacobian = np.zeros((2,2))\\n ass_adjcov = np.zeros((2,2))\\n landmark_idx = -1\\n for idx, landmark in enumerate(self.landmarks):\\n predicted_obs, jacobian, adj_cov = self.compute_jacobians(landmark)\\n p = multi_normal(np.transpose(np.array([obs])), predicted_obs, adj_cov)\\n if p > prob:\\n prob = p\\n ass_obs = predicted_obs\\n ass_jacobian = jacobian\\n ass_adjcov = adj_cov\\n landmark_idx = idx\\n return prob, landmark_idx, ass_obs, ass_jacobian, ass_adjcov\",\n \"def _init_index(self):\\n\\n if self._check_idx:\\n self._index = bamnostic.bai.Bai(self._index_path)\\n self.__nocoordinate = self._index.n_no_coor\\n self.__mapped = sum(self._index.unmapped[mapped].n_mapped for mapped in self._index.unmapped) + self.nocoordinate\\n self.__unmapped = sum(self._index.unmapped[unmapped].n_unmapped for unmapped in self._index.unmapped) + self.nocoordinate\",\n \"def info_cache(self):\\n self.info.info()\\n self.dataset.info()\\n self.category.info()\",\n \"def mezclar_bolsa(self):\",\n \"def counties(self) -> Iterable[County]:\\n return self._counties\",\n \"def test_observed_species(self):\\n c = array([4,3,4,0,1,0,2])\\n obs = observed_species(c)\\n exp = 5\\n self.assertEqual(obs, exp)\\n c = array([0,0,0])\\n obs = observed_species(c)\\n exp = 0\\n self.assertEqual(obs, exp)\\n self.assertEqual(observed_species(self.TestData), 9)\",\n \"def __init__(self):\\n self.TECRDB_compounds_data_dict = {}\\n self.TECRDB_compounds_pH7_species_id_dict = {}\\n self.TECRDB_compounds_least_H_sid_dict = {}\\n self.get_TECRDB_compounds_data()\",\n \"def __init__(self):\\n self.x = {}\\n self.len = 0\\n self.annotations = {}\",\n \"def observation_space(self) -> Dict[str, Any]:\",\n \"def ndata(self):\\n raise Exception(\\\"Graph store doesn't support access data of all nodes.\\\")\",\n \"def __getstate__(self):\\n state = Object.__getstate__(self)\\n state['_strain'] = set()\\n return state\",\n \"def __init__(self):\\n self.cnt = {}\",\n \"def substantiate():\",\n \"def observation_spec(self):\\r\\n pass\",\n \"def get_domain_otu(self):\\n for leaf in self.feature_tree.get_terminals():\\n leaf.domain_otu = leaf.name\\n self.feature_tree = self.get_node_domain_otu(self.feature_tree)\\n #print(temp)\\n\\n \\\"\\\"\\\"\\n for clade in self.feature_tree.find_clades(order='level'):\\n if not clade.clades:\\n continue\\n if clade.clades[0].abu < clade.clades[1].abu:\\n clade.domain_otu = clade.clades[1].name\\n else:\\n clade.domain_otu = clade.clades[0].name\\n print('self feature tree root abu')\\n print(self.feature_tree.domain_otu)\\n \\\"\\\"\\\"\",\n \"def test_getObservationCount(self):\\r\\n # Verified with iNEXT.\\r\\n self.assertEqual(self.est1.getObservationCount(), 5)\\r\\n\\r\\n # Verified against results in Colwell 2012 paper.\\r\\n self.assertEqual(self.est2.getObservationCount(), 140)\\r\\n self.assertEqual(self.est3.getObservationCount(), 112)\",\n \"def __setstate__(self,state):\\n self.__dict__.update(state)\\n self.KDTreeFinder = spatial.KDTree(self.featureVals)\",\n \"def __init__(self):\\n self.__locusts__ = {}\\n return\",\n \"def observation_space(self):\\n raise NotImplementedError\",\n \"def getstate(self):\\r\\n return [self.tied_indices,\\r\\n self.fixed_indices,\\r\\n self.fixed_values,\\r\\n self.constrained_indices,\\r\\n self.constraints]\",\n \"def county_split_details(self,part):\\n assignment = dict(part.assignment)\\n return {county: reduce(lambda districts, node: districts | set([assignment[node]]), self.nodes_by_county[county], set()) for county in self.counties}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63208634","0.6317959","0.5812783","0.57412237","0.5726633","0.5572401","0.5542451","0.5523592","0.5466767","0.5457007","0.54446673","0.54446673","0.5427072","0.5396151","0.538998","0.5379538","0.5379538","0.5344213","0.5321583","0.5319438","0.53033674","0.53006214","0.5294461","0.5276476","0.526909","0.52541894","0.52475834","0.52371174","0.5213969","0.5201879","0.51946175","0.5163235","0.51624244","0.51324475","0.51320124","0.5125145","0.51234734","0.51207155","0.511593","0.5114871","0.5112265","0.5111006","0.5109737","0.51083314","0.51070386","0.5103637","0.51031005","0.5095795","0.5093273","0.50917125","0.50894344","0.50886637","0.50854826","0.50806904","0.50782335","0.5076582","0.50738","0.50738","0.5065916","0.50634784","0.50611967","0.50550723","0.5053155","0.504057","0.5036193","0.5036077","0.5035884","0.5031637","0.50233126","0.5017305","0.5014176","0.501369","0.50128317","0.50084317","0.50062186","0.5004094","0.5004004","0.50031054","0.49985895","0.499346","0.4992854","0.499118","0.49893275","0.49892986","0.4986087","0.49850616","0.4983238","0.4983027","0.49778187","0.49721035","0.49646825","0.4955434","0.4953889","0.49522543","0.49499086","0.49451268","0.4943884","0.49385655","0.49337834","0.49334067","0.49317968"],"string":"[\n \"0.63208634\",\n \"0.6317959\",\n \"0.5812783\",\n \"0.57412237\",\n \"0.5726633\",\n \"0.5572401\",\n \"0.5542451\",\n \"0.5523592\",\n \"0.5466767\",\n \"0.5457007\",\n \"0.54446673\",\n \"0.54446673\",\n \"0.5427072\",\n \"0.5396151\",\n \"0.538998\",\n \"0.5379538\",\n \"0.5379538\",\n \"0.5344213\",\n \"0.5321583\",\n \"0.5319438\",\n \"0.53033674\",\n \"0.53006214\",\n \"0.5294461\",\n \"0.5276476\",\n \"0.526909\",\n \"0.52541894\",\n \"0.52475834\",\n \"0.52371174\",\n \"0.5213969\",\n \"0.5201879\",\n \"0.51946175\",\n \"0.5163235\",\n \"0.51624244\",\n \"0.51324475\",\n \"0.51320124\",\n \"0.5125145\",\n \"0.51234734\",\n \"0.51207155\",\n \"0.511593\",\n \"0.5114871\",\n \"0.5112265\",\n \"0.5111006\",\n \"0.5109737\",\n \"0.51083314\",\n \"0.51070386\",\n \"0.5103637\",\n \"0.51031005\",\n \"0.5095795\",\n \"0.5093273\",\n \"0.50917125\",\n \"0.50894344\",\n \"0.50886637\",\n \"0.50854826\",\n \"0.50806904\",\n \"0.50782335\",\n \"0.5076582\",\n \"0.50738\",\n \"0.50738\",\n \"0.5065916\",\n \"0.50634784\",\n \"0.50611967\",\n \"0.50550723\",\n \"0.5053155\",\n \"0.504057\",\n \"0.5036193\",\n \"0.5036077\",\n \"0.5035884\",\n \"0.5031637\",\n \"0.50233126\",\n \"0.5017305\",\n \"0.5014176\",\n \"0.501369\",\n \"0.50128317\",\n \"0.50084317\",\n \"0.50062186\",\n \"0.5004094\",\n \"0.5004004\",\n \"0.50031054\",\n \"0.49985895\",\n \"0.499346\",\n \"0.4992854\",\n \"0.499118\",\n \"0.49893275\",\n \"0.49892986\",\n \"0.4986087\",\n \"0.49850616\",\n \"0.4983238\",\n \"0.4983027\",\n \"0.49778187\",\n \"0.49721035\",\n \"0.49646825\",\n \"0.4955434\",\n \"0.4953889\",\n \"0.49522543\",\n \"0.49499086\",\n \"0.49451268\",\n \"0.4943884\",\n \"0.49385655\",\n \"0.49337834\",\n \"0.49334067\",\n \"0.49317968\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78789,"cells":{"query":{"kind":"string","value":"GetValue(BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean self) > Standard_Boolean"},"document":{"kind":"string","value":"def GetValue(self):\n return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_GetValue(self)"},"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 __bool__(self):\n return bool(self.get_value())","def __bool__(self):\n raise RuntimeError(\"Cannot evaluate CrypTensors to boolean values\")","def __bool__(self):\n raise RuntimeError(\"Cannot evaluate BinarySharedTensors to boolean values\")","def SetValue(self, *args):\n return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_SetValue(self, *args)","def get_boolean(self, df):\n if not self.value:\n return False\n elif not self.par:\n return ()\n if self.variable_type == 'interval':\n return self._interval_boolean(df)\n elif self.variable_type == 'list':\n return self._list_boolean(df)","def __bool__(self):\n # Do explicit cast to bool, as value can be a NumPy type, resulting in\n # an np.bool_ type for the expression (not allowed for __bool__)\n return bool(self.value != self.default_value)","def __bool__(x):\n if x.value == 1:\n return True\n elif x.value == -1:\n return False\n else:\n raise ValueError('cannot determine boolean value of Unknown')","def __bool__(self):\n return bool(self._value)","def get_bool(self, x, y, name):\r\n\r\n value = self.get_tile(x, y).get(name)\r\n return value in (True, 1, 'true', 'yes', 'True', 'Yes', '1', 'on', 'On')","def __nonzero__(self):\n raise RuntimeError(\"Cannot evaluate CrypTensors to boolean values\")","def __nonzero__(self):\n raise RuntimeError(\"Cannot evaluate BinarySharedTensors to boolean values\")","def get_bool2(self):\n pass","def to_bool(self):\n return _uhd_swig.sensor_value_t_to_bool(self)","def __bool__(self):\n return self is TRUE","def __bool__(self):\n return self.__nonzero__()","def value(self) -> bool:","def bool(self) -> bool:\n if isinstance(self, ps.DataFrame):\n df = self\n elif isinstance(self, ps.Series):\n df = self.to_dataframe()\n return df.head(2)._to_internal_pandas().bool()","def getBool(self):\n try:\n data, n = self._buf.pop(_B_LEN)\n \n if n != _B_LEN:\n raise SerializationError('There is not enough data left.')\n \n return bool(_B_STRUCT.unpack(data)[0])\n except StructError as e:\n raise SerializationError('Data is not a valid boolean: '\n '{0}'.format(e))","def is_flag(self):\n return (self.__type & NODE_TAG) and isinstance(self.__value, bool)","def get_state(rapid_data):\n try:\n if rapid_data.RapidType == 'bool':\n if rapid_data.Value.ToString().lower() == 'true':\n return True\n elif rapid_data.Value.ToString().lower() == 'false':\n return False\n else:\n err = 'DataType is ' + rapid_data.RapidType + ' and not bool.'\n return err\n except Exception, err:\n return err","def __bool__(self):\n return self.fam.c_nonzero(self)","def __bool__(self):\n return self[0] != 0.0 or self[1] != 0.0","def __nonzero__(self):\n return self.__bool__()","def __nonzero__(self):\n return self.__bool__()","def as_bool(self):\n return self.as_type(bool)","def __bool__(self):\n return (self.value == POS)","def __bool__(self) -> bool:\n\n nonzeroes = np.absolute(self.value) > _eps\n\n if nonzeroes.any():\n return True\n else:\n return False","def boolval(space, w_obj):\n return space.newbool(space.is_true(w_obj))","def is_data_true(data):\n\n if not data:\n return False\n\n if not isinstance(data, dict):\n if not util.get_value_from_health_internal_tuple(data):\n return False\n return True\n\n for _k in data:\n if is_data_true(data[_k]):\n return True\n\n return False","def __bool__(self):\n raise ValueError(\"bool() not permitted\")","def read_bool(self):\n return self.read_uint32() == 1","def get_dict_of_bool2(self):\n pass","def __bool__(self):\r\n raise TypeError('cannot use secure type in Boolean expressions')","def CONST_BOOL(self, t):\n t.value = False if t.value == '#false' else True\n return t","def bool(a):\n # Booleans need to be converted to integers for Theano\n if cf.use_theano and isinstance(a, (builtins.bool, np.bool_)):\n return np.int8(a)\n elif cf.use_theano or is_theano_object(a):\n return a\n else:\n return builtins.bool(a)","def __nonzero__(self):\n return True","def pythonvalue(self, value):\n return value in (\"true\", \"1\")","def ISLOGICAL(value):\n return isinstance(value, bool)","def __nonzero__(self):\n return self.value.__nonzero__()","def bool_value(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"bool_value\")","def test_get_value_bool(self):\n val = self.setting_bool.get_value()\n self.assertIsInstance(val, bool)\n self.assertEqual(val, True)","def test_get_value_bool(self):\n val = self.setting_bool.get_value()\n self.assertIsInstance(val, bool)\n self.assertEqual(val, True)","def is_bool(self):\n return False","def test_for_bool(self, parse_input_mocked_metadata):\n bb = parse_input_mocked_metadata(\n \"for bool b in [True, False]\\n\\tUnaryGate(b, 0) | 0\"\n )\n assert np.all(\n bb._forvar[\"b\"] == np.array([True, False])\n )","def getBoolean(self, int: int, int2: int) -> bool:\n ...","def __bool__(self):\n return _uhd_swig.range_vector_t___bool__(self)","def bool(self):\n return bool(self.int(2))","def as_bool(self):\n return InvenTree.helpers.str2bool(self.value)","def _has_numeric_or_bool(self) -> bool:\n dtypes: Set[str] = set(self._data.keys())\n return 'i' in dtypes or 'f' in dtypes or 'b' in dtypes","def get_bool(self, key, default):\n value = self.get(key, default)\n if isinstance(value, bool):\n return value\n return value.lower() in (\"true\", \"t\", \"yes\", \"y\")","def read_bool(self):\n return bool(self.read_and_unpack('l')[0])","def __gt__(self, other: t.Any) -> bool:\n return self._op_bool('__gt__', other)","def bool_attr(attr):\n if attr.lower() == \"true\":\n val = True\n elif attr.lower() == \"false\":\n val = False\n else:\n raise EzXMLError(\"Must be \"\\\n \"'true' or 'false'. Not %s\" % (attr))\n return val","def __bool__(self):\n return _uhd_swig.uhd_size_vector_t___bool__(self)","def _getBoolFeature(self):\n\n # create args\n valueToGet = c_bool()\n\n errorCode = VimbaDLL.featureBoolGet(self._handle,\n self._name,\n byref(valueToGet))\n if errorCode != 0:\n raise VimbaException(errorCode)\n\n return valueToGet.value","def add_bool_as_scalar(self, node):\n if node.value == 'true' or node.value == 'false' :\n return self.construct_yaml_bool(node)\n return self.construct_scalar(node)","def __bool__(self):\n return bool(self.obj)","def get_bool(self, sect, opt):\r\n return self.get_safe(sect, opt) == \"True\"","def __bool__(self):\n return bool(self._items)","def __bool__(self):\n return bool(self._items)","def __bool__(self):\n return _uhd_swig.device_addr_vector_t___bool__(self)","def test_setitem_bool(self):\n random.seed(12345)\n nside_coverage = 32\n nside_map = 128\n pxnums = np.arange(0, 2000)\n pxvalues = np.ones(pxnums.size, dtype=bool)\n full_map = np.zeros(hpg.nside_to_npixel(nside_map), dtype=bool)\n full_map[pxnums] = pxvalues\n\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage=nside_coverage,\n nside_sparse=nside_map, dtype=pxvalues.dtype)\n\n sparse_map[pxnums[0]] = pxvalues[0]\n testing.assert_equal(sparse_map[pxnums[0]], full_map[pxnums[0]])\n\n sparse_map[int(pxnums[1])] = bool(pxvalues[1])\n testing.assert_equal(sparse_map[pxnums[1]], full_map[pxnums[1]])\n\n sparse_map[pxnums] = pxvalues\n testing.assert_array_almost_equal(sparse_map[pxnums], full_map[pxnums])","def CTrue():\n return Cond(CT.TRUE, None, None, z3=BoolSort().cast(True), cleaned=True, checked=True )","def IsChecked(self):\r\n\r\n return self.GetValue()","def get_boolean_attribute_value(attrs, attr_name):\n return 1 if attrs.get(attr_name, 0) in [\"True\", \"1\"] else 0","def gt(self, other):\n\n return self._get(\"gt\", other, Bool)","def __bool__(self):\n\t\treturn not self.empty()","def __bool__(self):\n return self.balance > 0","def readBoolean(self) -> bool:\n return self.readByte() == 1","def getBoolValue(self):\n return _libsbml.ConversionOption_getBoolValue(self)","def __bool__(self):\n return bool(self.exp)","def is_boolean_type(self):\n raise exceptions.NotImplementedError()","def is_bool(space, w_obj):\n return space.wrap(w_obj.tp == space.tp_bool)","def f_boolean(node, pos, size, context, v):\n if xpath.tools.nodesetp(v):\n return len(v) > 0\n elif xpath.tools.numberp(v):\n if v == 0 or v != v:\n return False\n return True\n elif xpath.tools.stringp(v):\n return v != ''\n\n return v","def __bool__(self):\r\n return self.valid","def _readBool(self, rawData, offset=0):\n val, = unpack(\n self.boolFormat, rawData[\n offset:offset + self.boolFormatLen])\n \n return val","def variable_boolean(self, value):\n\n text_value = to_text(value)\n text_value = text_value.lower()\n\n if text_value == 'true' or text_value == 'false':\n return True\n\n return False","def isDefault (self):\n val = self.__getattribute__('StoredValue')\n dft = self.__class__.StoredValue\n return val==dft","def test_evaluate_boolean_literal_expression(self):\n value = self.evaluate_common(\"true\")\n self.assertTrue(\n value.type_code == edm.SimpleType.Boolean, \"Expected Boolean\")\n self.assertTrue(value.value is True, \"Expected True\")\n value = self.evaluate_common(\"false\")\n self.assertTrue(\n value.type_code == edm.SimpleType.Boolean, \"Expected Boolean\")\n self.assertTrue(value.value is False, \"Expected False\")","def Get(self):\n value=False\n return value","def is_true(value):\n \n return (value is True)","def test_is_primary_data(self):\n\n self.validator.adata.obs[\"is_primary_data\"] = \"FALSE\"\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\n \"ERROR: Column 'is_primary_data' in dataframe 'obs' \"\n \"must be boolean, not 'object'.\"\n ],\n )","def is_simple(self):\n return self.upper_binary_tree() == self.lower_binary_tree()","def convert_bool(self, v, t):\n return relay.const(v, type_to_np_dtype(t))","def ReadBool(self):\n return self.unpack('?')","def __bool__(self):\n return _libsbml.string___bool__(self)","def to_bool(data, true_label, **kwargs):\n return Component(\n \"ToBool\",\n arguments={\n 'data': Component.of(data),\n 'true_label': Component.of(true_label)\n },\n options={\n \n },\n constraints=kwargs)","def has_data(self) -> bool:\n return bool(self.data)","def get_attr_bool(self, name, default=False):\n v = self.get_attr(name)\n if v is None:\n return default\n if v.lower() in [\"t\", \"true\", \"y\", \"yes\", \"1\"]:\n return True\n else:\n return False","def __ge__(self, other: t.Any) -> bool:\n return self._op_bool('__ge__', other)","def __nonzero__(self):\n return self.__nonzero","def __nonzero__(self):\n return self.__nonzero","def test_bool_variable(self, parse_input_mocked_metadata):\n bb = parse_input_mocked_metadata(\"bool b1 = True\\n bool b2 = False\")\n assert bb._var == {\"b1\": True, \"b2\": False}","def is_on(self) -> bool:\n val = bool(self._cluster_handler.cluster.get(self._zcl_attribute))\n return (not val) if self.inverted else val","def __bool__(self):\n raise ValueError(\"never bool enums\")","def is_simple(self) -> bool:\n return self.data in ('int', 'bool', 'float', 'str')","def _convert_bool(self) -> pd.Series:\n\n if self.requires_nan:\n dtype = \"float\"\n else:\n dtype = \"bool\"\n\n return self._convert(dtype=dtype)","def visit_true(self) -> T:","def read_bool(data):\n s_type = \"=%s\" % get_type(\"bool\")\n return struct.unpack(s_type, data.read(1))[0]","def default_numpy_bool_serializer(np_bool: np.bool_, **kwargs: Dict[str, Any]) -> bool:\n return np_bool.item()"],"string":"[\n \"def __bool__(self):\\n return bool(self.get_value())\",\n \"def __bool__(self):\\n raise RuntimeError(\\\"Cannot evaluate CrypTensors to boolean values\\\")\",\n \"def __bool__(self):\\n raise RuntimeError(\\\"Cannot evaluate BinarySharedTensors to boolean values\\\")\",\n \"def SetValue(self, *args):\\n return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_SetValue(self, *args)\",\n \"def get_boolean(self, df):\\n if not self.value:\\n return False\\n elif not self.par:\\n return ()\\n if self.variable_type == 'interval':\\n return self._interval_boolean(df)\\n elif self.variable_type == 'list':\\n return self._list_boolean(df)\",\n \"def __bool__(self):\\n # Do explicit cast to bool, as value can be a NumPy type, resulting in\\n # an np.bool_ type for the expression (not allowed for __bool__)\\n return bool(self.value != self.default_value)\",\n \"def __bool__(x):\\n if x.value == 1:\\n return True\\n elif x.value == -1:\\n return False\\n else:\\n raise ValueError('cannot determine boolean value of Unknown')\",\n \"def __bool__(self):\\n return bool(self._value)\",\n \"def get_bool(self, x, y, name):\\r\\n\\r\\n value = self.get_tile(x, y).get(name)\\r\\n return value in (True, 1, 'true', 'yes', 'True', 'Yes', '1', 'on', 'On')\",\n \"def __nonzero__(self):\\n raise RuntimeError(\\\"Cannot evaluate CrypTensors to boolean values\\\")\",\n \"def __nonzero__(self):\\n raise RuntimeError(\\\"Cannot evaluate BinarySharedTensors to boolean values\\\")\",\n \"def get_bool2(self):\\n pass\",\n \"def to_bool(self):\\n return _uhd_swig.sensor_value_t_to_bool(self)\",\n \"def __bool__(self):\\n return self is TRUE\",\n \"def __bool__(self):\\n return self.__nonzero__()\",\n \"def value(self) -> bool:\",\n \"def bool(self) -> bool:\\n if isinstance(self, ps.DataFrame):\\n df = self\\n elif isinstance(self, ps.Series):\\n df = self.to_dataframe()\\n return df.head(2)._to_internal_pandas().bool()\",\n \"def getBool(self):\\n try:\\n data, n = self._buf.pop(_B_LEN)\\n \\n if n != _B_LEN:\\n raise SerializationError('There is not enough data left.')\\n \\n return bool(_B_STRUCT.unpack(data)[0])\\n except StructError as e:\\n raise SerializationError('Data is not a valid boolean: '\\n '{0}'.format(e))\",\n \"def is_flag(self):\\n return (self.__type & NODE_TAG) and isinstance(self.__value, bool)\",\n \"def get_state(rapid_data):\\n try:\\n if rapid_data.RapidType == 'bool':\\n if rapid_data.Value.ToString().lower() == 'true':\\n return True\\n elif rapid_data.Value.ToString().lower() == 'false':\\n return False\\n else:\\n err = 'DataType is ' + rapid_data.RapidType + ' and not bool.'\\n return err\\n except Exception, err:\\n return err\",\n \"def __bool__(self):\\n return self.fam.c_nonzero(self)\",\n \"def __bool__(self):\\n return self[0] != 0.0 or self[1] != 0.0\",\n \"def __nonzero__(self):\\n return self.__bool__()\",\n \"def __nonzero__(self):\\n return self.__bool__()\",\n \"def as_bool(self):\\n return self.as_type(bool)\",\n \"def __bool__(self):\\n return (self.value == POS)\",\n \"def __bool__(self) -> bool:\\n\\n nonzeroes = np.absolute(self.value) > _eps\\n\\n if nonzeroes.any():\\n return True\\n else:\\n return False\",\n \"def boolval(space, w_obj):\\n return space.newbool(space.is_true(w_obj))\",\n \"def is_data_true(data):\\n\\n if not data:\\n return False\\n\\n if not isinstance(data, dict):\\n if not util.get_value_from_health_internal_tuple(data):\\n return False\\n return True\\n\\n for _k in data:\\n if is_data_true(data[_k]):\\n return True\\n\\n return False\",\n \"def __bool__(self):\\n raise ValueError(\\\"bool() not permitted\\\")\",\n \"def read_bool(self):\\n return self.read_uint32() == 1\",\n \"def get_dict_of_bool2(self):\\n pass\",\n \"def __bool__(self):\\r\\n raise TypeError('cannot use secure type in Boolean expressions')\",\n \"def CONST_BOOL(self, t):\\n t.value = False if t.value == '#false' else True\\n return t\",\n \"def bool(a):\\n # Booleans need to be converted to integers for Theano\\n if cf.use_theano and isinstance(a, (builtins.bool, np.bool_)):\\n return np.int8(a)\\n elif cf.use_theano or is_theano_object(a):\\n return a\\n else:\\n return builtins.bool(a)\",\n \"def __nonzero__(self):\\n return True\",\n \"def pythonvalue(self, value):\\n return value in (\\\"true\\\", \\\"1\\\")\",\n \"def ISLOGICAL(value):\\n return isinstance(value, bool)\",\n \"def __nonzero__(self):\\n return self.value.__nonzero__()\",\n \"def bool_value(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"bool_value\\\")\",\n \"def test_get_value_bool(self):\\n val = self.setting_bool.get_value()\\n self.assertIsInstance(val, bool)\\n self.assertEqual(val, True)\",\n \"def test_get_value_bool(self):\\n val = self.setting_bool.get_value()\\n self.assertIsInstance(val, bool)\\n self.assertEqual(val, True)\",\n \"def is_bool(self):\\n return False\",\n \"def test_for_bool(self, parse_input_mocked_metadata):\\n bb = parse_input_mocked_metadata(\\n \\\"for bool b in [True, False]\\\\n\\\\tUnaryGate(b, 0) | 0\\\"\\n )\\n assert np.all(\\n bb._forvar[\\\"b\\\"] == np.array([True, False])\\n )\",\n \"def getBoolean(self, int: int, int2: int) -> bool:\\n ...\",\n \"def __bool__(self):\\n return _uhd_swig.range_vector_t___bool__(self)\",\n \"def bool(self):\\n return bool(self.int(2))\",\n \"def as_bool(self):\\n return InvenTree.helpers.str2bool(self.value)\",\n \"def _has_numeric_or_bool(self) -> bool:\\n dtypes: Set[str] = set(self._data.keys())\\n return 'i' in dtypes or 'f' in dtypes or 'b' in dtypes\",\n \"def get_bool(self, key, default):\\n value = self.get(key, default)\\n if isinstance(value, bool):\\n return value\\n return value.lower() in (\\\"true\\\", \\\"t\\\", \\\"yes\\\", \\\"y\\\")\",\n \"def read_bool(self):\\n return bool(self.read_and_unpack('l')[0])\",\n \"def __gt__(self, other: t.Any) -> bool:\\n return self._op_bool('__gt__', other)\",\n \"def bool_attr(attr):\\n if attr.lower() == \\\"true\\\":\\n val = True\\n elif attr.lower() == \\\"false\\\":\\n val = False\\n else:\\n raise EzXMLError(\\\"Must be \\\"\\\\\\n \\\"'true' or 'false'. Not %s\\\" % (attr))\\n return val\",\n \"def __bool__(self):\\n return _uhd_swig.uhd_size_vector_t___bool__(self)\",\n \"def _getBoolFeature(self):\\n\\n # create args\\n valueToGet = c_bool()\\n\\n errorCode = VimbaDLL.featureBoolGet(self._handle,\\n self._name,\\n byref(valueToGet))\\n if errorCode != 0:\\n raise VimbaException(errorCode)\\n\\n return valueToGet.value\",\n \"def add_bool_as_scalar(self, node):\\n if node.value == 'true' or node.value == 'false' :\\n return self.construct_yaml_bool(node)\\n return self.construct_scalar(node)\",\n \"def __bool__(self):\\n return bool(self.obj)\",\n \"def get_bool(self, sect, opt):\\r\\n return self.get_safe(sect, opt) == \\\"True\\\"\",\n \"def __bool__(self):\\n return bool(self._items)\",\n \"def __bool__(self):\\n return bool(self._items)\",\n \"def __bool__(self):\\n return _uhd_swig.device_addr_vector_t___bool__(self)\",\n \"def test_setitem_bool(self):\\n random.seed(12345)\\n nside_coverage = 32\\n nside_map = 128\\n pxnums = np.arange(0, 2000)\\n pxvalues = np.ones(pxnums.size, dtype=bool)\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map), dtype=bool)\\n full_map[pxnums] = pxvalues\\n\\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage=nside_coverage,\\n nside_sparse=nside_map, dtype=pxvalues.dtype)\\n\\n sparse_map[pxnums[0]] = pxvalues[0]\\n testing.assert_equal(sparse_map[pxnums[0]], full_map[pxnums[0]])\\n\\n sparse_map[int(pxnums[1])] = bool(pxvalues[1])\\n testing.assert_equal(sparse_map[pxnums[1]], full_map[pxnums[1]])\\n\\n sparse_map[pxnums] = pxvalues\\n testing.assert_array_almost_equal(sparse_map[pxnums], full_map[pxnums])\",\n \"def CTrue():\\n return Cond(CT.TRUE, None, None, z3=BoolSort().cast(True), cleaned=True, checked=True )\",\n \"def IsChecked(self):\\r\\n\\r\\n return self.GetValue()\",\n \"def get_boolean_attribute_value(attrs, attr_name):\\n return 1 if attrs.get(attr_name, 0) in [\\\"True\\\", \\\"1\\\"] else 0\",\n \"def gt(self, other):\\n\\n return self._get(\\\"gt\\\", other, Bool)\",\n \"def __bool__(self):\\n\\t\\treturn not self.empty()\",\n \"def __bool__(self):\\n return self.balance > 0\",\n \"def readBoolean(self) -> bool:\\n return self.readByte() == 1\",\n \"def getBoolValue(self):\\n return _libsbml.ConversionOption_getBoolValue(self)\",\n \"def __bool__(self):\\n return bool(self.exp)\",\n \"def is_boolean_type(self):\\n raise exceptions.NotImplementedError()\",\n \"def is_bool(space, w_obj):\\n return space.wrap(w_obj.tp == space.tp_bool)\",\n \"def f_boolean(node, pos, size, context, v):\\n if xpath.tools.nodesetp(v):\\n return len(v) > 0\\n elif xpath.tools.numberp(v):\\n if v == 0 or v != v:\\n return False\\n return True\\n elif xpath.tools.stringp(v):\\n return v != ''\\n\\n return v\",\n \"def __bool__(self):\\r\\n return self.valid\",\n \"def _readBool(self, rawData, offset=0):\\n val, = unpack(\\n self.boolFormat, rawData[\\n offset:offset + self.boolFormatLen])\\n \\n return val\",\n \"def variable_boolean(self, value):\\n\\n text_value = to_text(value)\\n text_value = text_value.lower()\\n\\n if text_value == 'true' or text_value == 'false':\\n return True\\n\\n return False\",\n \"def isDefault (self):\\n val = self.__getattribute__('StoredValue')\\n dft = self.__class__.StoredValue\\n return val==dft\",\n \"def test_evaluate_boolean_literal_expression(self):\\n value = self.evaluate_common(\\\"true\\\")\\n self.assertTrue(\\n value.type_code == edm.SimpleType.Boolean, \\\"Expected Boolean\\\")\\n self.assertTrue(value.value is True, \\\"Expected True\\\")\\n value = self.evaluate_common(\\\"false\\\")\\n self.assertTrue(\\n value.type_code == edm.SimpleType.Boolean, \\\"Expected Boolean\\\")\\n self.assertTrue(value.value is False, \\\"Expected False\\\")\",\n \"def Get(self):\\n value=False\\n return value\",\n \"def is_true(value):\\n \\n return (value is True)\",\n \"def test_is_primary_data(self):\\n\\n self.validator.adata.obs[\\\"is_primary_data\\\"] = \\\"FALSE\\\"\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors,\\n [\\n \\\"ERROR: Column 'is_primary_data' in dataframe 'obs' \\\"\\n \\\"must be boolean, not 'object'.\\\"\\n ],\\n )\",\n \"def is_simple(self):\\n return self.upper_binary_tree() == self.lower_binary_tree()\",\n \"def convert_bool(self, v, t):\\n return relay.const(v, type_to_np_dtype(t))\",\n \"def ReadBool(self):\\n return self.unpack('?')\",\n \"def __bool__(self):\\n return _libsbml.string___bool__(self)\",\n \"def to_bool(data, true_label, **kwargs):\\n return Component(\\n \\\"ToBool\\\",\\n arguments={\\n 'data': Component.of(data),\\n 'true_label': Component.of(true_label)\\n },\\n options={\\n \\n },\\n constraints=kwargs)\",\n \"def has_data(self) -> bool:\\n return bool(self.data)\",\n \"def get_attr_bool(self, name, default=False):\\n v = self.get_attr(name)\\n if v is None:\\n return default\\n if v.lower() in [\\\"t\\\", \\\"true\\\", \\\"y\\\", \\\"yes\\\", \\\"1\\\"]:\\n return True\\n else:\\n return False\",\n \"def __ge__(self, other: t.Any) -> bool:\\n return self._op_bool('__ge__', other)\",\n \"def __nonzero__(self):\\n return self.__nonzero\",\n \"def __nonzero__(self):\\n return self.__nonzero\",\n \"def test_bool_variable(self, parse_input_mocked_metadata):\\n bb = parse_input_mocked_metadata(\\\"bool b1 = True\\\\n bool b2 = False\\\")\\n assert bb._var == {\\\"b1\\\": True, \\\"b2\\\": False}\",\n \"def is_on(self) -> bool:\\n val = bool(self._cluster_handler.cluster.get(self._zcl_attribute))\\n return (not val) if self.inverted else val\",\n \"def __bool__(self):\\n raise ValueError(\\\"never bool enums\\\")\",\n \"def is_simple(self) -> bool:\\n return self.data in ('int', 'bool', 'float', 'str')\",\n \"def _convert_bool(self) -> pd.Series:\\n\\n if self.requires_nan:\\n dtype = \\\"float\\\"\\n else:\\n dtype = \\\"bool\\\"\\n\\n return self._convert(dtype=dtype)\",\n \"def visit_true(self) -> T:\",\n \"def read_bool(data):\\n s_type = \\\"=%s\\\" % get_type(\\\"bool\\\")\\n return struct.unpack(s_type, data.read(1))[0]\",\n \"def default_numpy_bool_serializer(np_bool: np.bool_, **kwargs: Dict[str, Any]) -> bool:\\n return np_bool.item()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6632537","0.65650076","0.6527329","0.64361316","0.6419467","0.6400087","0.6373707","0.637024","0.6366055","0.63470244","0.6285019","0.62832886","0.62286204","0.62076914","0.62011594","0.6153996","0.6111137","0.6075253","0.60686135","0.60634077","0.6022753","0.5950054","0.594322","0.594322","0.59133273","0.58960325","0.58778507","0.5807958","0.58005416","0.57978266","0.5789283","0.57733166","0.57681596","0.57502395","0.5744106","0.5742617","0.5737703","0.5736092","0.5721471","0.5715676","0.5701224","0.5701224","0.56999874","0.5681008","0.56732285","0.56653374","0.56627274","0.5658593","0.5650951","0.5631371","0.56292564","0.5598749","0.55977046","0.5596972","0.55698067","0.5561468","0.55612063","0.55415696","0.5538496","0.5538496","0.55348915","0.5527977","0.5524901","0.5516237","0.5514766","0.5504338","0.549292","0.549088","0.54840106","0.5474455","0.54716736","0.54695845","0.54631156","0.546282","0.5460126","0.54403234","0.5433456","0.54187375","0.54119307","0.53996944","0.5396738","0.5394638","0.53887576","0.53862756","0.5385348","0.5385056","0.5379231","0.53792244","0.5379157","0.5378265","0.5377318","0.5377318","0.53735054","0.5371418","0.53598976","0.53590727","0.53588957","0.5347235","0.5339937","0.53349346"],"string":"[\n \"0.6632537\",\n \"0.65650076\",\n \"0.6527329\",\n \"0.64361316\",\n \"0.6419467\",\n \"0.6400087\",\n \"0.6373707\",\n \"0.637024\",\n \"0.6366055\",\n \"0.63470244\",\n \"0.6285019\",\n \"0.62832886\",\n \"0.62286204\",\n \"0.62076914\",\n \"0.62011594\",\n \"0.6153996\",\n \"0.6111137\",\n \"0.6075253\",\n \"0.60686135\",\n \"0.60634077\",\n \"0.6022753\",\n \"0.5950054\",\n \"0.594322\",\n \"0.594322\",\n \"0.59133273\",\n \"0.58960325\",\n \"0.58778507\",\n \"0.5807958\",\n \"0.58005416\",\n \"0.57978266\",\n \"0.5789283\",\n \"0.57733166\",\n \"0.57681596\",\n \"0.57502395\",\n \"0.5744106\",\n \"0.5742617\",\n \"0.5737703\",\n \"0.5736092\",\n \"0.5721471\",\n \"0.5715676\",\n \"0.5701224\",\n \"0.5701224\",\n \"0.56999874\",\n \"0.5681008\",\n \"0.56732285\",\n \"0.56653374\",\n \"0.56627274\",\n \"0.5658593\",\n \"0.5650951\",\n \"0.5631371\",\n \"0.56292564\",\n \"0.5598749\",\n \"0.55977046\",\n \"0.5596972\",\n \"0.55698067\",\n \"0.5561468\",\n \"0.55612063\",\n \"0.55415696\",\n \"0.5538496\",\n \"0.5538496\",\n \"0.55348915\",\n \"0.5527977\",\n \"0.5524901\",\n \"0.5516237\",\n \"0.5514766\",\n \"0.5504338\",\n \"0.549292\",\n \"0.549088\",\n \"0.54840106\",\n \"0.5474455\",\n \"0.54716736\",\n \"0.54695845\",\n \"0.54631156\",\n \"0.546282\",\n \"0.5460126\",\n \"0.54403234\",\n \"0.5433456\",\n \"0.54187375\",\n \"0.54119307\",\n \"0.53996944\",\n \"0.5396738\",\n \"0.5394638\",\n \"0.53887576\",\n \"0.53862756\",\n \"0.5385348\",\n \"0.5385056\",\n \"0.5379231\",\n \"0.53792244\",\n \"0.5379157\",\n \"0.5378265\",\n \"0.5377318\",\n \"0.5377318\",\n \"0.53735054\",\n \"0.5371418\",\n \"0.53598976\",\n \"0.53590727\",\n \"0.53588957\",\n \"0.5347235\",\n \"0.5339937\",\n \"0.53349346\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7905299"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78790,"cells":{"query":{"kind":"string","value":"SetValue(BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean self, Standard_Boolean value)"},"document":{"kind":"string","value":"def SetValue(self, *args):\n return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_SetValue(self, *args)"},"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 GetValue(self):\n return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_GetValue(self)","def test_setitem_bool(self):\n random.seed(12345)\n nside_coverage = 32\n nside_map = 128\n pxnums = np.arange(0, 2000)\n pxvalues = np.ones(pxnums.size, dtype=bool)\n full_map = np.zeros(hpg.nside_to_npixel(nside_map), dtype=bool)\n full_map[pxnums] = pxvalues\n\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage=nside_coverage,\n nside_sparse=nside_map, dtype=pxvalues.dtype)\n\n sparse_map[pxnums[0]] = pxvalues[0]\n testing.assert_equal(sparse_map[pxnums[0]], full_map[pxnums[0]])\n\n sparse_map[int(pxnums[1])] = bool(pxvalues[1])\n testing.assert_equal(sparse_map[pxnums[1]], full_map[pxnums[1]])\n\n sparse_map[pxnums] = pxvalues\n testing.assert_array_almost_equal(sparse_map[pxnums], full_map[pxnums])","def set(self, attr, value=True):\n if type(value) == bool:\n self.__dict__['_'+attr] = value\n print attr, \"set to\", value\n else:\n print 'Value must be a bool, either \"True\" or \"False\" (no quotes)!'","def set_bool_value(self, event):\n\n self.undo_add()\n\n key_list = list(self.patch.engine.misc_data.keys())\n key = key_list[self.selected_index]\n data = self.patch.engine.misc_data[key]\n\n if self.ValueEnabled.GetValue():\n self.patch.misc[key] = data['on']\n else:\n self.patch.misc[key] = data['off']\n\n self.is_modified(True)\n self.misclist_update_row(self.selected_index)","def _setBoolFeature(self, valueToSet):\n\n errorCode = VimbaDLL.featureBoolSet(self._handle,\n self._name,\n valueToSet)\n if errorCode != 0:\n raise VimbaException(errorCode)","def setBoolean(self, key, value):\n self.__config.setValue(key, QtCore.QVariant(value))\n self.__saved = False","def _setForDocument (self, value):\n if not isinstance(value, bool):\n raise TypeError(value)\n self.__forDocument = value\n return value","def writeBoolean(self, value: bool):\n self.writeByte(1 if value else 0)","def CONST_BOOL(self, t):\n t.value = False if t.value == '#false' else True\n return t","def edit_and_write_rapid_data(rapid_data, new_value):\n try:\n if rapid_data.RapidType == 'bool':\n rapid_data.Value = ctrlrs.RapidDomain.Bool(new_value)\n msg = 'Changed the value'\n return msg\n else:\n msg = 'DataType is ' + rapid_data.RapidType + ' and not bool.'\n return msg\n except Exception, err:\n return err","def set_data(self, data):\n assert data.shape == self.shape, \"data should be an array of the same shape as Mask\"\n assert data.dtype == bool, \"data should be an array of data type bool\"\n\n self.data = data","def setbool(self, strcommand, value):\n command = ct.c_wchar_p(strcommand)\n value = ct.c_bool(value)\n self.lib.AT_SetBool(self.AT_H, command, value)","def sparse_arrays(self, value):\n if not isinstance(value, bool):\n raise TypeError('sparse_arrays attribute must be a logical type.')\n self._sparse_arrays = value","def __bool__(self):\n raise RuntimeError(\"Cannot evaluate BinarySharedTensors to boolean values\")","def set_value(self, item, value):\n super(t_8_Bit_Options, self).set_value(item, value)\n\n if(item == t_8_Bit_Options.BOOLEAN_CONFIG_1):\n self.set_bools(value, self.bools, t_8_Bit_Options.BIT_MAX)","def set(self, boolean):\n self._val = boolean","def set_bool_attribute(self, id: str, b: Optional[bool]):\n self.set_attribute(id, None if not b else ConstInt(1))","def set(self,Data):\n if len(Data.shape)==2:\n assert type(Data[0,0])!=bool,'Polygonize Data ( SetRasterData(Data) ) Must be bool Ndarray,But now in '+str(type(Data[0,0]))\n self.RasterSet=True\n self.imageoutput=Data","def __bool__(self):\n raise RuntimeError(\"Cannot evaluate CrypTensors to boolean values\")","def _setForBinding (self, value):\n if not isinstance(value, bool):\n raise TypeError(value)\n self.__forBinding = value\n return value","def setBit(self,i,boolval):\n self.boolVals[i]=boolval","def set_boolean(dict, name, elem):\n node = elem.find(name)\n if node is not None:\n if node.text.lower() == 'yes':\n dict[name] = True\n elif node.text.lower() == 'no':\n dict[name] = False","def setBoolValue(self, *args):\n return _libsbml.ConversionProperties_setBoolValue(self, *args)","def __nonzero__(self):\n raise RuntimeError(\"Cannot evaluate BinarySharedTensors to boolean values\")","def test_bool(self):\n mute_map = MutableMap()\n\n assert not mute_map\n\n mute_map['str_val'] = 'test'\n\n assert mute_map","def set_default(self, default):\n\n\t\tif default is not None and not isinstance(default, bool):\n\t\t\traise SDKException(Constants.DATA_TYPE_ERROR, 'KEY: default EXPECTED TYPE: bool', None, None)\n\t\t\n\t\tself.__default = default\n\t\tself.__key_modified['default'] = 1","def add_bool_as_scalar(self, node):\n if node.value == 'true' or node.value == 'false' :\n return self.construct_yaml_bool(node)\n return self.construct_scalar(node)","def testBoolValue(self):\n objectID = uuid4()\n user = createUser(u'username', u'password', u'User',\n u'user@example.com')\n namespace = createNamespace(user, u'name')\n tag = createTag(user, namespace, u'tag')\n self.store.add(TagValue(user.id, tag.id, objectID, True))","def set_bools(self, value, bools, limit):\n for x in range(limit):\n if value & 1 << x:\n bools[x]['value'] = True\n else:\n bools[x]['value'] = False\n pass","def _writeBool(self, val):\n self.__writeValue(self.boolFormat, val)","def val(self, new_val: bool) -> None:\n if type(new_val) != bool:\n raise TypeError(f\"Invalid literal {new_val} with type '{new_val.__class__.__name__}' for parameter 'new_val'\")\n self._val: bool = new_val\n return","def __setitem__(self, pos, is_on):\n row, column = pos\n self.bits[row][column] = is_on","def __setattr__(self, key, value):\n\n # Set internal fields\n if key[0:1] == \"_\":\n self.__dict__[key] = value\n return\n\n # Values should either be boolean or type of self\n if isinstance(value, bool) and key in self.__dict__ and \\\n isinstance(self.__dict__[key], self.__class__):\n self.__dict__[key].set_all_attribute_values(value)\n return\n elif isinstance(value, (bool, self.__class__)):\n self.__dict__[key] = value\n return\n\n raise TypeError(\"%s name in %s must be of type Boolean or AttributeFilter, given %s\" %\n (key, self.__class__.__name__, value.__class__.__name__))","def __nonzero__(self):\n raise RuntimeError(\"Cannot evaluate CrypTensors to boolean values\")","def isSetValue(self):\n return _libsbml.SpeciesFeatureValue_isSetValue(self)","def set_boolean(x):\n\n if x:\n return \"True\"\n else:\n return \"False\"","def setTrue(self):\n self.cond = CT.TRUE\n self.left = self.right = None\n self.z3 = BoolSort().cast(True)\n self.cleaned = self.Z3Simplified = self.customSimplified = self.checked = True\n self.customSimplifiedValue = CE.TRUE","def __init__(\n self, name: str, index: Optional[int] = 0, label: Optional[str] = None,\n help: Optional[str] = None, default: Optional[bool] = None,\n required: Optional[bool] = False, group: Optional[str] = None\n ):\n super(Bool, self).__init__(\n dtype=PARA_BOOL,\n name=name,\n index=index,\n label=label,\n help=help,\n default=default,\n required=required,\n group=group\n )","def setSinglePush(self, bool_value):\n self.data_struct['__singlePush'] = bool_value","def set_value(self, value: ScalarType) -> None:\n if isinstance(value, bool):\n value_str = 'true' if value else 'false'\n else:\n value_str = str(value)\n start_mark = self.yaml_node.start_mark\n end_mark = self.yaml_node.end_mark\n # If we're of a class type, then we want to keep that tag so that the\n # correct Constructor is called. If we're a built-in type, set the tag\n # to the appropriate YAML tag.\n tag = self.yaml_node.tag\n if tag.startswith('tag:yaml.org,2002:'):\n tag = scalar_type_to_tag[type(value)]\n new_node = yaml.ScalarNode(tag, value_str, start_mark, end_mark)\n self.yaml_node = new_node","def _set_bool(name, value, context):\n if name in os.environ:\n envval = os.environ.get(name).lower()\n if envval in [\"1\", \"true\", \"y\", \"yes\"]:\n context[name] = True\n elif envval in [\"0\", \"false\", \"n\", \"no\"]:\n context[name] = False\n else:\n raise ValueError(f\"{name} is a boolean, cannot match '{os.environ[name]}'\")\n\n _set_default(name, value, context)","def cast(self, value: Any) -> Any:\n if value is None:\n return False\n if isinstance(value, bool):\n return value\n strvalue = str(value).lower()\n if strvalue in ['1', 't', 'true']:\n return True\n elif strvalue in ['', '0', 'f', 'false']:\n return False\n raise err.InvalidArgumentError(\"not a Boolean '{}'\".format(value))","def test_is_primary_data(self):\n\n self.validator.adata.obs[\"is_primary_data\"] = \"FALSE\"\n self.validator.validate_adata()\n self.assertEqual(\n self.validator.errors,\n [\n \"ERROR: Column 'is_primary_data' in dataframe 'obs' \"\n \"must be boolean, not 'object'.\"\n ],\n )","def setAllowInsert(self, value, **kwa):\n\n if type(value) == BooleanType:\n self.fgField.allow_insert = value\n else:\n self.fgField.allow_insert = value == '1'","def map(self, datasetType, dataId, write=False):\n copyId = dataId.copy()\n copyId.pop(\"flags\", None)\n location = super(SuperBITMapper, self).map(datasetType, copyId, write=write)\n\n if 'flags' in dataId:\n location.getAdditionalData().set('flags', dataId['flags'])\n\n return location","def getSetBoolean(self, key: str, default: bool | None = None) -> bool:\n value = self.parsedConfig.getboolean(key, default)\n self.parsedConfig[key] = str(value)\n return value","def _replace_boolean(data):\n output_data = deepcopy(data)\n for row in output_data:\n for i, element in enumerate(row):\n if element is True:\n element = 'P'\n elif element is False:\n element = 'N'\n row[i] = element\n return output_data","def virtual_flag(self, value):\n if not isinstance(value, bool):\n raise TypeError(\"virtual_flag must be bool.\")\n self._virtual_flag = value","def __init__(self, boolean_name, boolean_value):\n self._boolean_name = process_for_latex(boolean_name)\n self._boolean_value = boolean_value","def setBoolValue(self, *args):\n return _libsbml.ConversionOption_setBoolValue(self, *args)","def fake_opgepakt(self, value: bool) -> None:\n self._fake_opgepakt = value","def device_set_property_bool(pnd, property, bEnable):\n return _nfc.device_set_property_bool(pnd, property, bEnable)","def test_boolean_default(self):\r\n default = True\r\n prop = Boolean(default=default, required=True)\r\n self.assertEqual(prop.to_database(None), prop.to_database(default))","def __init__(self, shape, threshold=0.0, newval=1.0):\n self.bool_array = np.full(shape, True, dtype=bool)\n self.threshold = threshold\n self.newval = newval","def set_value(self, setting_id, value):\n if setting_id not in self.values:\n raise KeyError\n\n if self.types[setting_id] == \"bool\":\n self.values[setting_id] = (value.lower() == 'true')\n else:\n self.defaults[setting_id] = value\n return","def pythonvalue(self, value):\n return value in (\"true\", \"1\")","def convert_boolean(cls, param, value):\r\n return True","def populate_obj(self, obj, name):\n if self.data.lower() == 'true':\n data = True\n else:\n data = False\n setattr(obj, name, data)","def boolval(space, w_obj):\n return space.newbool(space.is_true(w_obj))","def write(writer: BitStreamWriter, value: bool) -> None:\n\n writer.writeBool(value)","def __init__(self, value, extra=None):\n if not isinstance(value, bool):\n raise TypeError(\n 'Passed value must be a bool. %s found instead.' % type(value))\n\n self._value = value\n self._extra = extra","def test_set_boolean(self):\n setting_name = 'project_bool_setting'\n url = reverse(\n 'projectroles:api_project_setting_set',\n kwargs={'project': self.project.sodar_uuid},\n )\n post_data = {\n 'app_name': EX_APP_NAME,\n 'setting_name': setting_name,\n 'value': True,\n }\n response = self.request_knox(url, method='POST', data=post_data)\n self.assertEqual(response.status_code, 200, msg=response.content)\n obj = AppSetting.objects.get(name=setting_name, project=self.project)\n self.assertEqual(obj.get_value(), True)","def set(self, key, value):\n try:\n if value.lower() in ['true', 'false']:\n value = value.lower() == 'true'\n except:\n pass\n\n try:\n if \".\" in key:\n keys = key.split(\".\")\n #\n # create parents\n #\n parents = keys[:-1]\n location = self.data\n for parent in parents:\n if parent not in location:\n location[parent] = {}\n location = location[parent]\n #\n # create entry\n #\n location[keys[-1]] = value\n else:\n self.data[key] = value\n\n except KeyError:\n raise ValueError(f\"The key '{key}' could not be found in the yaml file '{self.filename}'\")\n except Exception as e:\n print(e)\n raise ValueError(\"unkown error\")\n\n self.flush()","def write_boolean(self, boolean: bool) -> None:\n self.write(bytearray([bool(boolean)]))","def bool_attr(attr):\n if attr.lower() == \"true\":\n val = True\n elif attr.lower() == \"false\":\n val = False\n else:\n raise EzXMLError(\"Must be \"\\\n \"'true' or 'false'. Not %s\" % (attr))\n return val","def new_value(self, value=False):\n return data_value_factory(self.type, value)","def bool_to_python(self, value):\r\n if value == 'true':\r\n return True\r\n elif value == 'false':\r\n return False","def set_flag(self, new):\n self.flag = new","def test_get_value_bool(self):\n val = self.setting_bool.get_value()\n self.assertIsInstance(val, bool)\n self.assertEqual(val, True)","def test_get_value_bool(self):\n val = self.setting_bool.get_value()\n self.assertIsInstance(val, bool)\n self.assertEqual(val, True)","def _registerBoolPropertyInPEM27(name, is_visible, defval):\n import uSysDB\n con = uSysDB.connect()\n cur = con.cursor()\n cur.execute(\n \"INSERT INTO confman_parameters (name, type, is_visible, user_id) VALUES (%s, %s, %s, %s)\",\n (name, 0, int(is_visible), 1))\n prop_id = uSysDB.get_last_inserted_value(con, \"confman_parameters\")\n cur.execute(\n \"INSERT INTO confman_bool_parameters (parameter_id, value, vlimit) VALUES (%s, %s, %s)\",\n (prop_id, int(defval), -1))","def convert_bool(self, v, t):\n return relay.const(v, type_to_np_dtype(t))","def init_flag(self, value):\n if not isinstance(value, bool):\n raise TypeError(\"init_flag must be bool.\")\n self.set_init_flag(value)\n self._init_flag = value","def strict_logical(self, value):\n if value is not None:\n if not isinstance(value, bool):\n raise TypeError(\n 'f90nml: error: strict_logical must be a logical value.')\n else:\n self._strict_logical = value","def _bool_encode(self, d):\n for k, v in d.items():\n if isinstance(v, bool):\n d[k] = str(v).lower()\n \n return d","def __bool__(self):\n return bool(self.get_value())","def set_is_watering(valve: Valve, value: bool) -> None:\n valve.is_watering = value","def __init__(__self__, *,\n bool_value: Optional[pulumi.Input[bool]] = None,\n double_value: Optional[pulumi.Input[float]] = None,\n int64_value: Optional[pulumi.Input[str]] = None,\n proto_value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\n string_value: Optional[pulumi.Input[str]] = None):\n if bool_value is not None:\n pulumi.set(__self__, \"bool_value\", bool_value)\n if double_value is not None:\n pulumi.set(__self__, \"double_value\", double_value)\n if int64_value is not None:\n pulumi.set(__self__, \"int64_value\", int64_value)\n if proto_value is not None:\n pulumi.set(__self__, \"proto_value\", proto_value)\n if string_value is not None:\n pulumi.set(__self__, \"string_value\", string_value)","def test_boolean_custom_values(self):\n true_values = ['YES', 'yes', 'Yes']\n false_values = ['NO', 'no', 'No']\n wrong_values = ['true', 'false', 'True', 'False', 'y', 'n', 'Y', 'N', 't', '1', 1, '0', 0]\n descriptor = self.base_field_descriptor\n descriptor['type'] = 'boolean'\n # only 'default' format\n descriptor['format'] = 'default'\n descriptor['trueValues'] = true_values\n descriptor['falseValues'] = false_values\n\n f = SchemaField(descriptor)\n for v in true_values:\n self.assertTrue(f.cast(v))\n for v in false_values:\n self.assertFalse(f.cast(v))\n for v in wrong_values:\n with self.assertRaises(Exception):\n f.cast(v)","def test_for_bool(self, parse_input_mocked_metadata):\n bb = parse_input_mocked_metadata(\n \"for bool b in [True, False]\\n\\tUnaryGate(b, 0) | 0\"\n )\n assert np.all(\n bb._forvar[\"b\"] == np.array([True, False])\n )","def bool_on_off(value):\n return 'on' if value else 'off'","def default_numpy_bool_serializer(np_bool: np.bool_, **kwargs: Dict[str, Any]) -> bool:\n return np_bool.item()","def __bool__(self):\r\n raise TypeError('cannot use secure type in Boolean expressions')","def XPLMSetDataf(inDataRef, inValue):","def setStructureTrueOrFalse(a):\n inputIma = np.copy(a)\n inputImb = np.copy(a)\n ndims = np.ndim(a)\n if ndims == 2:\n inputImb[1][1] = 1\n inputIma[1][1] = 0\n deletableTemp = countObjects(inputImb, inputIma)\n else:\n inputImb[1][1][1] = 1\n inputIma[1][1][1] = 0\n deletableTemp = countObjects(inputImb, inputIma)\n return deletableTemp","def test_boolean_in_serializer() -> None:\n assert cv.custom_serializer(cv.boolean) == {\n \"type\": \"boolean\",\n }","def __setitem__(self, range: ngcore::T_Range<unsigned __int64>, value: bool) -> None:","def setData(key, value):\n #only string keys are accepted\n if ( type(key) != str ): return None\n \n Co8PersistentData.__dataDict[key] = value","def to_python(self, value):\n return force_bool(value)","def to_bool(data, true_label, **kwargs):\n return Component(\n \"ToBool\",\n arguments={\n 'data': Component.of(data),\n 'true_label': Component.of(true_label)\n },\n options={\n \n },\n constraints=kwargs)","def compressed(self, value: bool):\n if type(value) is not bool:\n raise TypeError(\"Value must be of type 'bool' ('{}' given)\".format(type(value)))\n\n self._compressed = value","def convert_bool(self, v, t):\n return relay_from_scalar(v, type_to_np_dtype(t))","def test_bool_field():","def is_flag(self):\n return (self.__type & NODE_TAG) and isinstance(self.__value, bool)","def __bool__(x):\n if x.value == 1:\n return True\n elif x.value == -1:\n return False\n else:\n raise ValueError('cannot determine boolean value of Unknown')","def _boolean_callback(self, *args):\n\t\tnew_value = args[1].get_boolean()\n\n\t\targs[0].set_state(GLib.Variant.new_boolean(new_value))\n\t\tself.window.set_picture_title()\n\t\tself.get_active_pane().hide_options_menu()","def setFlag(self, flag, value) -> None:\n ...","def setData(self,data):\n self.data=data\n self.leaf=True","def get_bool2(self):\n pass","def __nonzero__(self):\n raise TypeError(\"PObject is a distributed object, bool(PObject) is not allowed.\")"],"string":"[\n \"def GetValue(self):\\n return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_GetValue(self)\",\n \"def test_setitem_bool(self):\\n random.seed(12345)\\n nside_coverage = 32\\n nside_map = 128\\n pxnums = np.arange(0, 2000)\\n pxvalues = np.ones(pxnums.size, dtype=bool)\\n full_map = np.zeros(hpg.nside_to_npixel(nside_map), dtype=bool)\\n full_map[pxnums] = pxvalues\\n\\n sparse_map = healsparse.HealSparseMap.make_empty(nside_coverage=nside_coverage,\\n nside_sparse=nside_map, dtype=pxvalues.dtype)\\n\\n sparse_map[pxnums[0]] = pxvalues[0]\\n testing.assert_equal(sparse_map[pxnums[0]], full_map[pxnums[0]])\\n\\n sparse_map[int(pxnums[1])] = bool(pxvalues[1])\\n testing.assert_equal(sparse_map[pxnums[1]], full_map[pxnums[1]])\\n\\n sparse_map[pxnums] = pxvalues\\n testing.assert_array_almost_equal(sparse_map[pxnums], full_map[pxnums])\",\n \"def set(self, attr, value=True):\\n if type(value) == bool:\\n self.__dict__['_'+attr] = value\\n print attr, \\\"set to\\\", value\\n else:\\n print 'Value must be a bool, either \\\"True\\\" or \\\"False\\\" (no quotes)!'\",\n \"def set_bool_value(self, event):\\n\\n self.undo_add()\\n\\n key_list = list(self.patch.engine.misc_data.keys())\\n key = key_list[self.selected_index]\\n data = self.patch.engine.misc_data[key]\\n\\n if self.ValueEnabled.GetValue():\\n self.patch.misc[key] = data['on']\\n else:\\n self.patch.misc[key] = data['off']\\n\\n self.is_modified(True)\\n self.misclist_update_row(self.selected_index)\",\n \"def _setBoolFeature(self, valueToSet):\\n\\n errorCode = VimbaDLL.featureBoolSet(self._handle,\\n self._name,\\n valueToSet)\\n if errorCode != 0:\\n raise VimbaException(errorCode)\",\n \"def setBoolean(self, key, value):\\n self.__config.setValue(key, QtCore.QVariant(value))\\n self.__saved = False\",\n \"def _setForDocument (self, value):\\n if not isinstance(value, bool):\\n raise TypeError(value)\\n self.__forDocument = value\\n return value\",\n \"def writeBoolean(self, value: bool):\\n self.writeByte(1 if value else 0)\",\n \"def CONST_BOOL(self, t):\\n t.value = False if t.value == '#false' else True\\n return t\",\n \"def edit_and_write_rapid_data(rapid_data, new_value):\\n try:\\n if rapid_data.RapidType == 'bool':\\n rapid_data.Value = ctrlrs.RapidDomain.Bool(new_value)\\n msg = 'Changed the value'\\n return msg\\n else:\\n msg = 'DataType is ' + rapid_data.RapidType + ' and not bool.'\\n return msg\\n except Exception, err:\\n return err\",\n \"def set_data(self, data):\\n assert data.shape == self.shape, \\\"data should be an array of the same shape as Mask\\\"\\n assert data.dtype == bool, \\\"data should be an array of data type bool\\\"\\n\\n self.data = data\",\n \"def setbool(self, strcommand, value):\\n command = ct.c_wchar_p(strcommand)\\n value = ct.c_bool(value)\\n self.lib.AT_SetBool(self.AT_H, command, value)\",\n \"def sparse_arrays(self, value):\\n if not isinstance(value, bool):\\n raise TypeError('sparse_arrays attribute must be a logical type.')\\n self._sparse_arrays = value\",\n \"def __bool__(self):\\n raise RuntimeError(\\\"Cannot evaluate BinarySharedTensors to boolean values\\\")\",\n \"def set_value(self, item, value):\\n super(t_8_Bit_Options, self).set_value(item, value)\\n\\n if(item == t_8_Bit_Options.BOOLEAN_CONFIG_1):\\n self.set_bools(value, self.bools, t_8_Bit_Options.BIT_MAX)\",\n \"def set(self, boolean):\\n self._val = boolean\",\n \"def set_bool_attribute(self, id: str, b: Optional[bool]):\\n self.set_attribute(id, None if not b else ConstInt(1))\",\n \"def set(self,Data):\\n if len(Data.shape)==2:\\n assert type(Data[0,0])!=bool,'Polygonize Data ( SetRasterData(Data) ) Must be bool Ndarray,But now in '+str(type(Data[0,0]))\\n self.RasterSet=True\\n self.imageoutput=Data\",\n \"def __bool__(self):\\n raise RuntimeError(\\\"Cannot evaluate CrypTensors to boolean values\\\")\",\n \"def _setForBinding (self, value):\\n if not isinstance(value, bool):\\n raise TypeError(value)\\n self.__forBinding = value\\n return value\",\n \"def setBit(self,i,boolval):\\n self.boolVals[i]=boolval\",\n \"def set_boolean(dict, name, elem):\\n node = elem.find(name)\\n if node is not None:\\n if node.text.lower() == 'yes':\\n dict[name] = True\\n elif node.text.lower() == 'no':\\n dict[name] = False\",\n \"def setBoolValue(self, *args):\\n return _libsbml.ConversionProperties_setBoolValue(self, *args)\",\n \"def __nonzero__(self):\\n raise RuntimeError(\\\"Cannot evaluate BinarySharedTensors to boolean values\\\")\",\n \"def test_bool(self):\\n mute_map = MutableMap()\\n\\n assert not mute_map\\n\\n mute_map['str_val'] = 'test'\\n\\n assert mute_map\",\n \"def set_default(self, default):\\n\\n\\t\\tif default is not None and not isinstance(default, bool):\\n\\t\\t\\traise SDKException(Constants.DATA_TYPE_ERROR, 'KEY: default EXPECTED TYPE: bool', None, None)\\n\\t\\t\\n\\t\\tself.__default = default\\n\\t\\tself.__key_modified['default'] = 1\",\n \"def add_bool_as_scalar(self, node):\\n if node.value == 'true' or node.value == 'false' :\\n return self.construct_yaml_bool(node)\\n return self.construct_scalar(node)\",\n \"def testBoolValue(self):\\n objectID = uuid4()\\n user = createUser(u'username', u'password', u'User',\\n u'user@example.com')\\n namespace = createNamespace(user, u'name')\\n tag = createTag(user, namespace, u'tag')\\n self.store.add(TagValue(user.id, tag.id, objectID, True))\",\n \"def set_bools(self, value, bools, limit):\\n for x in range(limit):\\n if value & 1 << x:\\n bools[x]['value'] = True\\n else:\\n bools[x]['value'] = False\\n pass\",\n \"def _writeBool(self, val):\\n self.__writeValue(self.boolFormat, val)\",\n \"def val(self, new_val: bool) -> None:\\n if type(new_val) != bool:\\n raise TypeError(f\\\"Invalid literal {new_val} with type '{new_val.__class__.__name__}' for parameter 'new_val'\\\")\\n self._val: bool = new_val\\n return\",\n \"def __setitem__(self, pos, is_on):\\n row, column = pos\\n self.bits[row][column] = is_on\",\n \"def __setattr__(self, key, value):\\n\\n # Set internal fields\\n if key[0:1] == \\\"_\\\":\\n self.__dict__[key] = value\\n return\\n\\n # Values should either be boolean or type of self\\n if isinstance(value, bool) and key in self.__dict__ and \\\\\\n isinstance(self.__dict__[key], self.__class__):\\n self.__dict__[key].set_all_attribute_values(value)\\n return\\n elif isinstance(value, (bool, self.__class__)):\\n self.__dict__[key] = value\\n return\\n\\n raise TypeError(\\\"%s name in %s must be of type Boolean or AttributeFilter, given %s\\\" %\\n (key, self.__class__.__name__, value.__class__.__name__))\",\n \"def __nonzero__(self):\\n raise RuntimeError(\\\"Cannot evaluate CrypTensors to boolean values\\\")\",\n \"def isSetValue(self):\\n return _libsbml.SpeciesFeatureValue_isSetValue(self)\",\n \"def set_boolean(x):\\n\\n if x:\\n return \\\"True\\\"\\n else:\\n return \\\"False\\\"\",\n \"def setTrue(self):\\n self.cond = CT.TRUE\\n self.left = self.right = None\\n self.z3 = BoolSort().cast(True)\\n self.cleaned = self.Z3Simplified = self.customSimplified = self.checked = True\\n self.customSimplifiedValue = CE.TRUE\",\n \"def __init__(\\n self, name: str, index: Optional[int] = 0, label: Optional[str] = None,\\n help: Optional[str] = None, default: Optional[bool] = None,\\n required: Optional[bool] = False, group: Optional[str] = None\\n ):\\n super(Bool, self).__init__(\\n dtype=PARA_BOOL,\\n name=name,\\n index=index,\\n label=label,\\n help=help,\\n default=default,\\n required=required,\\n group=group\\n )\",\n \"def setSinglePush(self, bool_value):\\n self.data_struct['__singlePush'] = bool_value\",\n \"def set_value(self, value: ScalarType) -> None:\\n if isinstance(value, bool):\\n value_str = 'true' if value else 'false'\\n else:\\n value_str = str(value)\\n start_mark = self.yaml_node.start_mark\\n end_mark = self.yaml_node.end_mark\\n # If we're of a class type, then we want to keep that tag so that the\\n # correct Constructor is called. If we're a built-in type, set the tag\\n # to the appropriate YAML tag.\\n tag = self.yaml_node.tag\\n if tag.startswith('tag:yaml.org,2002:'):\\n tag = scalar_type_to_tag[type(value)]\\n new_node = yaml.ScalarNode(tag, value_str, start_mark, end_mark)\\n self.yaml_node = new_node\",\n \"def _set_bool(name, value, context):\\n if name in os.environ:\\n envval = os.environ.get(name).lower()\\n if envval in [\\\"1\\\", \\\"true\\\", \\\"y\\\", \\\"yes\\\"]:\\n context[name] = True\\n elif envval in [\\\"0\\\", \\\"false\\\", \\\"n\\\", \\\"no\\\"]:\\n context[name] = False\\n else:\\n raise ValueError(f\\\"{name} is a boolean, cannot match '{os.environ[name]}'\\\")\\n\\n _set_default(name, value, context)\",\n \"def cast(self, value: Any) -> Any:\\n if value is None:\\n return False\\n if isinstance(value, bool):\\n return value\\n strvalue = str(value).lower()\\n if strvalue in ['1', 't', 'true']:\\n return True\\n elif strvalue in ['', '0', 'f', 'false']:\\n return False\\n raise err.InvalidArgumentError(\\\"not a Boolean '{}'\\\".format(value))\",\n \"def test_is_primary_data(self):\\n\\n self.validator.adata.obs[\\\"is_primary_data\\\"] = \\\"FALSE\\\"\\n self.validator.validate_adata()\\n self.assertEqual(\\n self.validator.errors,\\n [\\n \\\"ERROR: Column 'is_primary_data' in dataframe 'obs' \\\"\\n \\\"must be boolean, not 'object'.\\\"\\n ],\\n )\",\n \"def setAllowInsert(self, value, **kwa):\\n\\n if type(value) == BooleanType:\\n self.fgField.allow_insert = value\\n else:\\n self.fgField.allow_insert = value == '1'\",\n \"def map(self, datasetType, dataId, write=False):\\n copyId = dataId.copy()\\n copyId.pop(\\\"flags\\\", None)\\n location = super(SuperBITMapper, self).map(datasetType, copyId, write=write)\\n\\n if 'flags' in dataId:\\n location.getAdditionalData().set('flags', dataId['flags'])\\n\\n return location\",\n \"def getSetBoolean(self, key: str, default: bool | None = None) -> bool:\\n value = self.parsedConfig.getboolean(key, default)\\n self.parsedConfig[key] = str(value)\\n return value\",\n \"def _replace_boolean(data):\\n output_data = deepcopy(data)\\n for row in output_data:\\n for i, element in enumerate(row):\\n if element is True:\\n element = 'P'\\n elif element is False:\\n element = 'N'\\n row[i] = element\\n return output_data\",\n \"def virtual_flag(self, value):\\n if not isinstance(value, bool):\\n raise TypeError(\\\"virtual_flag must be bool.\\\")\\n self._virtual_flag = value\",\n \"def __init__(self, boolean_name, boolean_value):\\n self._boolean_name = process_for_latex(boolean_name)\\n self._boolean_value = boolean_value\",\n \"def setBoolValue(self, *args):\\n return _libsbml.ConversionOption_setBoolValue(self, *args)\",\n \"def fake_opgepakt(self, value: bool) -> None:\\n self._fake_opgepakt = value\",\n \"def device_set_property_bool(pnd, property, bEnable):\\n return _nfc.device_set_property_bool(pnd, property, bEnable)\",\n \"def test_boolean_default(self):\\r\\n default = True\\r\\n prop = Boolean(default=default, required=True)\\r\\n self.assertEqual(prop.to_database(None), prop.to_database(default))\",\n \"def __init__(self, shape, threshold=0.0, newval=1.0):\\n self.bool_array = np.full(shape, True, dtype=bool)\\n self.threshold = threshold\\n self.newval = newval\",\n \"def set_value(self, setting_id, value):\\n if setting_id not in self.values:\\n raise KeyError\\n\\n if self.types[setting_id] == \\\"bool\\\":\\n self.values[setting_id] = (value.lower() == 'true')\\n else:\\n self.defaults[setting_id] = value\\n return\",\n \"def pythonvalue(self, value):\\n return value in (\\\"true\\\", \\\"1\\\")\",\n \"def convert_boolean(cls, param, value):\\r\\n return True\",\n \"def populate_obj(self, obj, name):\\n if self.data.lower() == 'true':\\n data = True\\n else:\\n data = False\\n setattr(obj, name, data)\",\n \"def boolval(space, w_obj):\\n return space.newbool(space.is_true(w_obj))\",\n \"def write(writer: BitStreamWriter, value: bool) -> None:\\n\\n writer.writeBool(value)\",\n \"def __init__(self, value, extra=None):\\n if not isinstance(value, bool):\\n raise TypeError(\\n 'Passed value must be a bool. %s found instead.' % type(value))\\n\\n self._value = value\\n self._extra = extra\",\n \"def test_set_boolean(self):\\n setting_name = 'project_bool_setting'\\n url = reverse(\\n 'projectroles:api_project_setting_set',\\n kwargs={'project': self.project.sodar_uuid},\\n )\\n post_data = {\\n 'app_name': EX_APP_NAME,\\n 'setting_name': setting_name,\\n 'value': True,\\n }\\n response = self.request_knox(url, method='POST', data=post_data)\\n self.assertEqual(response.status_code, 200, msg=response.content)\\n obj = AppSetting.objects.get(name=setting_name, project=self.project)\\n self.assertEqual(obj.get_value(), True)\",\n \"def set(self, key, value):\\n try:\\n if value.lower() in ['true', 'false']:\\n value = value.lower() == 'true'\\n except:\\n pass\\n\\n try:\\n if \\\".\\\" in key:\\n keys = key.split(\\\".\\\")\\n #\\n # create parents\\n #\\n parents = keys[:-1]\\n location = self.data\\n for parent in parents:\\n if parent not in location:\\n location[parent] = {}\\n location = location[parent]\\n #\\n # create entry\\n #\\n location[keys[-1]] = value\\n else:\\n self.data[key] = value\\n\\n except KeyError:\\n raise ValueError(f\\\"The key '{key}' could not be found in the yaml file '{self.filename}'\\\")\\n except Exception as e:\\n print(e)\\n raise ValueError(\\\"unkown error\\\")\\n\\n self.flush()\",\n \"def write_boolean(self, boolean: bool) -> None:\\n self.write(bytearray([bool(boolean)]))\",\n \"def bool_attr(attr):\\n if attr.lower() == \\\"true\\\":\\n val = True\\n elif attr.lower() == \\\"false\\\":\\n val = False\\n else:\\n raise EzXMLError(\\\"Must be \\\"\\\\\\n \\\"'true' or 'false'. Not %s\\\" % (attr))\\n return val\",\n \"def new_value(self, value=False):\\n return data_value_factory(self.type, value)\",\n \"def bool_to_python(self, value):\\r\\n if value == 'true':\\r\\n return True\\r\\n elif value == 'false':\\r\\n return False\",\n \"def set_flag(self, new):\\n self.flag = new\",\n \"def test_get_value_bool(self):\\n val = self.setting_bool.get_value()\\n self.assertIsInstance(val, bool)\\n self.assertEqual(val, True)\",\n \"def test_get_value_bool(self):\\n val = self.setting_bool.get_value()\\n self.assertIsInstance(val, bool)\\n self.assertEqual(val, True)\",\n \"def _registerBoolPropertyInPEM27(name, is_visible, defval):\\n import uSysDB\\n con = uSysDB.connect()\\n cur = con.cursor()\\n cur.execute(\\n \\\"INSERT INTO confman_parameters (name, type, is_visible, user_id) VALUES (%s, %s, %s, %s)\\\",\\n (name, 0, int(is_visible), 1))\\n prop_id = uSysDB.get_last_inserted_value(con, \\\"confman_parameters\\\")\\n cur.execute(\\n \\\"INSERT INTO confman_bool_parameters (parameter_id, value, vlimit) VALUES (%s, %s, %s)\\\",\\n (prop_id, int(defval), -1))\",\n \"def convert_bool(self, v, t):\\n return relay.const(v, type_to_np_dtype(t))\",\n \"def init_flag(self, value):\\n if not isinstance(value, bool):\\n raise TypeError(\\\"init_flag must be bool.\\\")\\n self.set_init_flag(value)\\n self._init_flag = value\",\n \"def strict_logical(self, value):\\n if value is not None:\\n if not isinstance(value, bool):\\n raise TypeError(\\n 'f90nml: error: strict_logical must be a logical value.')\\n else:\\n self._strict_logical = value\",\n \"def _bool_encode(self, d):\\n for k, v in d.items():\\n if isinstance(v, bool):\\n d[k] = str(v).lower()\\n \\n return d\",\n \"def __bool__(self):\\n return bool(self.get_value())\",\n \"def set_is_watering(valve: Valve, value: bool) -> None:\\n valve.is_watering = value\",\n \"def __init__(__self__, *,\\n bool_value: Optional[pulumi.Input[bool]] = None,\\n double_value: Optional[pulumi.Input[float]] = None,\\n int64_value: Optional[pulumi.Input[str]] = None,\\n proto_value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\\n string_value: Optional[pulumi.Input[str]] = None):\\n if bool_value is not None:\\n pulumi.set(__self__, \\\"bool_value\\\", bool_value)\\n if double_value is not None:\\n pulumi.set(__self__, \\\"double_value\\\", double_value)\\n if int64_value is not None:\\n pulumi.set(__self__, \\\"int64_value\\\", int64_value)\\n if proto_value is not None:\\n pulumi.set(__self__, \\\"proto_value\\\", proto_value)\\n if string_value is not None:\\n pulumi.set(__self__, \\\"string_value\\\", string_value)\",\n \"def test_boolean_custom_values(self):\\n true_values = ['YES', 'yes', 'Yes']\\n false_values = ['NO', 'no', 'No']\\n wrong_values = ['true', 'false', 'True', 'False', 'y', 'n', 'Y', 'N', 't', '1', 1, '0', 0]\\n descriptor = self.base_field_descriptor\\n descriptor['type'] = 'boolean'\\n # only 'default' format\\n descriptor['format'] = 'default'\\n descriptor['trueValues'] = true_values\\n descriptor['falseValues'] = false_values\\n\\n f = SchemaField(descriptor)\\n for v in true_values:\\n self.assertTrue(f.cast(v))\\n for v in false_values:\\n self.assertFalse(f.cast(v))\\n for v in wrong_values:\\n with self.assertRaises(Exception):\\n f.cast(v)\",\n \"def test_for_bool(self, parse_input_mocked_metadata):\\n bb = parse_input_mocked_metadata(\\n \\\"for bool b in [True, False]\\\\n\\\\tUnaryGate(b, 0) | 0\\\"\\n )\\n assert np.all(\\n bb._forvar[\\\"b\\\"] == np.array([True, False])\\n )\",\n \"def bool_on_off(value):\\n return 'on' if value else 'off'\",\n \"def default_numpy_bool_serializer(np_bool: np.bool_, **kwargs: Dict[str, Any]) -> bool:\\n return np_bool.item()\",\n \"def __bool__(self):\\r\\n raise TypeError('cannot use secure type in Boolean expressions')\",\n \"def XPLMSetDataf(inDataRef, inValue):\",\n \"def setStructureTrueOrFalse(a):\\n inputIma = np.copy(a)\\n inputImb = np.copy(a)\\n ndims = np.ndim(a)\\n if ndims == 2:\\n inputImb[1][1] = 1\\n inputIma[1][1] = 0\\n deletableTemp = countObjects(inputImb, inputIma)\\n else:\\n inputImb[1][1][1] = 1\\n inputIma[1][1][1] = 0\\n deletableTemp = countObjects(inputImb, inputIma)\\n return deletableTemp\",\n \"def test_boolean_in_serializer() -> None:\\n assert cv.custom_serializer(cv.boolean) == {\\n \\\"type\\\": \\\"boolean\\\",\\n }\",\n \"def __setitem__(self, range: ngcore::T_Range<unsigned __int64>, value: bool) -> None:\",\n \"def setData(key, value):\\n #only string keys are accepted\\n if ( type(key) != str ): return None\\n \\n Co8PersistentData.__dataDict[key] = value\",\n \"def to_python(self, value):\\n return force_bool(value)\",\n \"def to_bool(data, true_label, **kwargs):\\n return Component(\\n \\\"ToBool\\\",\\n arguments={\\n 'data': Component.of(data),\\n 'true_label': Component.of(true_label)\\n },\\n options={\\n \\n },\\n constraints=kwargs)\",\n \"def compressed(self, value: bool):\\n if type(value) is not bool:\\n raise TypeError(\\\"Value must be of type 'bool' ('{}' given)\\\".format(type(value)))\\n\\n self._compressed = value\",\n \"def convert_bool(self, v, t):\\n return relay_from_scalar(v, type_to_np_dtype(t))\",\n \"def test_bool_field():\",\n \"def is_flag(self):\\n return (self.__type & NODE_TAG) and isinstance(self.__value, bool)\",\n \"def __bool__(x):\\n if x.value == 1:\\n return True\\n elif x.value == -1:\\n return False\\n else:\\n raise ValueError('cannot determine boolean value of Unknown')\",\n \"def _boolean_callback(self, *args):\\n\\t\\tnew_value = args[1].get_boolean()\\n\\n\\t\\targs[0].set_state(GLib.Variant.new_boolean(new_value))\\n\\t\\tself.window.set_picture_title()\\n\\t\\tself.get_active_pane().hide_options_menu()\",\n \"def setFlag(self, flag, value) -> None:\\n ...\",\n \"def setData(self,data):\\n self.data=data\\n self.leaf=True\",\n \"def get_bool2(self):\\n pass\",\n \"def __nonzero__(self):\\n raise TypeError(\\\"PObject is a distributed object, bool(PObject) is not allowed.\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74341255","0.67324233","0.668604","0.63878953","0.63041806","0.63035727","0.62389475","0.62142","0.619102","0.61905813","0.6144637","0.60952264","0.6080537","0.6070081","0.60686034","0.59739524","0.59568506","0.59503865","0.59209836","0.5920271","0.5913511","0.5912031","0.5876294","0.5859997","0.5833736","0.5815865","0.5813722","0.58095735","0.57896703","0.57370436","0.57347","0.5718337","0.5715155","0.5706389","0.5702576","0.56891114","0.5678204","0.5668623","0.56317925","0.56248325","0.5618238","0.56172127","0.5615245","0.55755025","0.5574515","0.5563806","0.5548717","0.55444485","0.5543341","0.5533654","0.55303437","0.5527965","0.55267006","0.55216557","0.55028397","0.5495474","0.5474074","0.54533327","0.5452556","0.54478776","0.54377717","0.543399","0.5432678","0.5423485","0.5404263","0.53891677","0.5388378","0.5368133","0.5367793","0.5367793","0.53527266","0.5349206","0.53377724","0.53302103","0.53276414","0.5326498","0.53190345","0.5316731","0.5310199","0.5304819","0.52973","0.52885085","0.5286745","0.5285542","0.52835643","0.528096","0.5256394","0.52558774","0.52550954","0.5249688","0.5245256","0.52396244","0.52392346","0.5233217","0.52302766","0.5214533","0.5213782","0.52119285","0.51957315","0.51945865"],"string":"[\n \"0.74341255\",\n \"0.67324233\",\n \"0.668604\",\n \"0.63878953\",\n \"0.63041806\",\n \"0.63035727\",\n \"0.62389475\",\n \"0.62142\",\n \"0.619102\",\n \"0.61905813\",\n \"0.6144637\",\n \"0.60952264\",\n \"0.6080537\",\n \"0.6070081\",\n \"0.60686034\",\n \"0.59739524\",\n \"0.59568506\",\n \"0.59503865\",\n \"0.59209836\",\n \"0.5920271\",\n \"0.5913511\",\n \"0.5912031\",\n \"0.5876294\",\n \"0.5859997\",\n \"0.5833736\",\n \"0.5815865\",\n \"0.5813722\",\n \"0.58095735\",\n \"0.57896703\",\n \"0.57370436\",\n \"0.57347\",\n \"0.5718337\",\n \"0.5715155\",\n \"0.5706389\",\n \"0.5702576\",\n \"0.56891114\",\n \"0.5678204\",\n \"0.5668623\",\n \"0.56317925\",\n \"0.56248325\",\n \"0.5618238\",\n \"0.56172127\",\n \"0.5615245\",\n \"0.55755025\",\n \"0.5574515\",\n \"0.5563806\",\n \"0.5548717\",\n \"0.55444485\",\n \"0.5543341\",\n \"0.5533654\",\n \"0.55303437\",\n \"0.5527965\",\n \"0.55267006\",\n \"0.55216557\",\n \"0.55028397\",\n \"0.5495474\",\n \"0.5474074\",\n \"0.54533327\",\n \"0.5452556\",\n \"0.54478776\",\n \"0.54377717\",\n \"0.543399\",\n \"0.5432678\",\n \"0.5423485\",\n \"0.5404263\",\n \"0.53891677\",\n \"0.5388378\",\n \"0.5368133\",\n \"0.5367793\",\n \"0.5367793\",\n \"0.53527266\",\n \"0.5349206\",\n \"0.53377724\",\n \"0.53302103\",\n \"0.53276414\",\n \"0.5326498\",\n \"0.53190345\",\n \"0.5316731\",\n \"0.5310199\",\n \"0.5304819\",\n \"0.52973\",\n \"0.52885085\",\n \"0.5286745\",\n \"0.5285542\",\n \"0.52835643\",\n \"0.528096\",\n \"0.5256394\",\n \"0.52558774\",\n \"0.52550954\",\n \"0.5249688\",\n \"0.5245256\",\n \"0.52396244\",\n \"0.52392346\",\n \"0.5233217\",\n \"0.52302766\",\n \"0.5214533\",\n \"0.5213782\",\n \"0.52119285\",\n \"0.51957315\",\n \"0.51945865\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8526055"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78791,"cells":{"query":{"kind":"string","value":"returns a list of wire non standard"},"document":{"kind":"string","value":"def MakeBlock(self, *args):\n return _BRepAlgo.BRepAlgo_EdgeConnector_MakeBlock(self, *args)"},"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 non_zero_components(self) :\n return list(self.parent().characters())","def test_show_all_wires_false(self):\n\n ops = [qml.PauliX(\"a\"), qml.PauliY(\"c\")]\n wire_order = [\"a\", \"b\", \"c\", \"d\"]\n\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=False)\n assert wire_map == {\"a\": 0, \"c\": 1}","def get_naughty_string_list():\n return naughty_string_list","def wires(self):\n return [o.wires for o in self.obs]","def wires(self) -> Iterator[TopoDS_Wire]:\n return map(Wire, self._top_exp.wires())","def listNonDegenerate(self):\n return arange(self.nelems())[~self.testDegenerate()]","def get_light_sensors(self):\n x=self.send_packet_check_response('\\x50')\n LS=[]\n for i in range(8):\n a=bytearray(x[i*3:(i+1)*3])\n LS.append(a[0]|(a[1]&0xf)<<8)\n LS.append(a[1]>>4|a[2]<<4)\n return LS","def getnegates(self):\n from beliefSys import beliefSys as bs\n return bs.negatelist","def get_non_terminals(self):\r\n return {non_terminal for non_terminal, symbols in self.productions}","def wires(self):\n top_exp = TopologyUtils.TopologyExplorer(self.topods_shape(), ignore_orientation=False)\n return map(Wire, top_exp.wires())","def excluded(cls):\n return []","def getExcludedDumpRegisterNames(self):\n pass","def diffignoreattrib(cls, instcls):\n if instcls == effective_configuration:\n return [\"checksum\"]\n if instcls == fibrechannel:\n return [\"neighbor_wwn\"]\n if instcls == port_group:\n return [\"port_group_f_ports_f_port\"]\n if instcls == fibrechannel_switch:\n return [\"enabled_state\", \"domain_id\"]\n if instcls == fibrechannel_logical_switch:\n return [\"ge_port_member_list_port_member\"]\n return None","def get_symbol(self):\n return []","def getNoShortName(self):\n return [x for x in self.xeps if not x.shortname]","def test_no_wire_order(self):\n\n ops = [qml.PauliX(0), qml.PauliX(2), qml.PauliX(1)]\n\n wire_map = convert_wire_order(ops)\n\n assert wire_map == {0: 0, 2: 1, 1: 2}","def network_bytes(self) -> List[bytes]:","def __get_scanning_range(self):\n if self.__network is not None:\n return [self.__network]\n networks = []\n interfaces = netifaces.interfaces()\n for data in interfaces:\n ips = netifaces.ifaddresses(data)\n for key, interface_data in ips.items():\n for item in interface_data:\n if item.get(\"netmask\", None) is not None and \\\n item.get(\"addr\", None) is not None and \\\n self.is_legal_ip(item[\"netmask\"]):\n if item.get(\"addr\") not in [\"127.0.0.1\", \"0.0.0.0\"]:\n network = \"{ip}/{cird}\".format(ip=item[\"addr\"],\n cird=IPAddress(item[\"netmask\"]).netmask_bits())\n if network not in networks:\n networks.append(network)\n return networks","def getSpectralTypes():\n return ['B','A','F','G','K','M']","def get_standard_xml(self):\n return [s for (i, s) in list(self._I2EMAP.items())\n if (i != self._CUSTOM) and s.strip()]","def test_missing_wire(self):\r\n\r\n dev = qml.device(\"default.qubit\", wires=[\"a\", -1, \"q2\"])\r\n\r\n @qml.beta.qnode(dev)\r\n def circuit():\r\n qml.Hadamard(wires=-1)\r\n qml.CNOT(wires=[\"a\", \"q2\"])\r\n qml.RX(0.2, wires=\"a\")\r\n return qml.expval(qml.PauliX(wires=\"q2\"))\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", \"a\"])()\r\n expected = [\r\n \" q2: ──╭X───────────┤ ⟨X⟩ \",\r\n \" a: ──╰C──RX(0.2)──┤ \",\r\n \" -1: ───H───────────┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", -1])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test multiple missing wires\r\n res = qml.draw(circuit, wire_order=[\"q2\"])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)","def test_get_unregistered_networks(self):\n pass","def hex_list(self):\r\n return [''.join(['{:02X}'.format(b) for b in data]) for data in self.buffers()]","def list_bed_types():\n\n list = [\"ctrl\", \"cresis\", \"cresisp\", \"minus\", \"plus\", \"ba01_bed\", \"970mW_hs\", \"jak_1985\", \"no_bath\", \"wc\"]\n\n return list","def exclude_list(self):\n pass","def get_party_blocks_list():\n return get_pro_independence_parties(), [\"C's\", 'PSC', 'CatSíqueesPot', 'PP']","def get_list_of_nets(self):\n return self.mfp.get_list_of_nets()","def ignored_lists(self) -> List[str]:\n return self.__lists_to_ignore","def test_string_wires(self):\n\n ops = [qml.PauliY(\"a\"), qml.CNOT(wires=(\"b\", \"c\"))]\n\n wire_map = default_wire_map(ops)\n assert wire_map == {\"a\": 0, \"b\": 1, \"c\": 2}","def get_list_of_bytes2(self):\n pass","def list():\n return [Cliff.CLIFF_L,\n Cliff.CLIFF_FL,\n Cliff.CLIFF_R,\n Cliff.CLIFF_FR,\n Cliff.VIRTUAL_WALL]","def getBondsNoH(self):\n try:\n return self._bondListNoH\n except AttributeError:\n pass\n bondPointers=self._raw_data[\"BONDS_WITHOUT_HYDROGEN\"]\n self._bondListNoH = self._getBonds(bondPointers)\n return self._bondListNoH","def not_matching_list(self):\n\n pre_result = comp(self.regex)\n\n return list(\n filter(lambda element: not pre_result.search(element), self.data)\n )","def getMaskVariableNames(self, product):\r\n return []","def getNoeuds(self) -> list:\n return self._noeuds","def ntypes(self): # -> list[str]:\n ...","def _useful_network(self):\n\n networks = self._compile_networks()\n\n network = []\n for n in networks:\n if len(n) >= self.min_network_size:\n network += list(n)\n\n return network","def to_deprecated_list_repr(self):\r\n return ['c4x', self.org, self.course, self.block_type, self.name, None]","def test_missing_wire():\r\n\r\n dev = qml.device(\"default.qubit\", wires=[\"a\", -1, \"q2\"])\r\n\r\n @qml.beta.qnode(dev)\r\n def circuit():\r\n qml.Hadamard(wires=-1)\r\n qml.CNOT(wires=[\"a\", \"q2\"])\r\n qml.RX(0.2, wires=\"a\")\r\n return qml.expval(qml.PauliX(wires=\"q2\"))\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", \"a\"])()\r\n expected = [\r\n \" q2: ──╭X───────────┤ ⟨X⟩ \",\r\n \" a: ──╰C──RX(0.2)──┤ \",\r\n \" -1: ───H───────────┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", -1])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test multiple missing wires\r\n res = qml.draw(circuit, wire_order=[\"q2\"])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)","def genes():\n return [\"b2935\", \"b0723\", \"b0451\"]","def list():\n return [Drive.ENCODER_L,\n Drive.ENCODER_R]","def test_should_return_a_list(self):\n\n tcp_flags = TCPControlBits(['SYN', 'ACK'])\n assert_is_instance(tcp_flags.to_list(), list)","def warn(self) -> list:\n return self.__wrn","def getweigths():\n ls = []\n for i_lay in range(1, len(layers)):\n ls.append(layers[i_lay][\"weigths\"])\n return ls","def unpack(self):\n return []","def getBanterList(self, num):\r\n return [self.__banterAssembler.assembleString() for a in range(num)]","def list_networks():\n return __sets.keys()","def non_special_tokens(self) -> List[Hashable]:\n return self._non_special_tokens","def symbols_zero_spin(self) -> List[str]:\n return self._symbols_zero_spin","def to_list(self):\n return [bits.value for bits in self.data]","def get_non_ovf_disks():\n return [\n d.get_id() for d in get_all_disks() if (\n d.get_alias() != ENUMS['ovf_disk_alias']\n )\n ]","def get_leds_used(self)->List[str]:\n leds = list()\n for group in self.LedGroups:\n leds.extend(group.Leds)\n return [str(led) for led in leds]","def _minimal() -> list:\n\n return ['r2', 'mape', 'nrmse', 'corr_coeff', 'rmse', 'mae', 'mse', 'mpe', \n 'mase', 'r2_score']","def generate_list(self):\n\n array = [False] * 25\n bits = self.generate_bits()\n\n for column in range(2, -1, -1):\n for row in range(0, 5):\n bit = next(bits)\n\n array[column + (row * 5)] = bit\n array[(4 - column) + (row * 5)] = bit\n\n return array","def vendor_list():\n return ['nxos', 'eos', 'cumulus']","def _get_lsp_config_exclude_interfaces(self):\n return self.__lsp_config_exclude_interfaces","def get_unnamed_outputs(self):\n return []","def protocol_names(self):\n l = self.protocols()\n retval = [str(k.name) for k in l]\n return retval","def get_bfsl(self):\n return array(self.LIST1,int)","def power_list():","def listDegenerate(self):\n return arange(self.nelems())[self.testDegenerate()]","def getNoWells(self):\n #code begins here \n return self.__nwells","def ntypes(self): # -> list[None]:\n ...","def network_excludes(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"network_excludes\")","def non_zero_components(self) :\n return self.__coefficients.keys()","def raw_fields(self):\n list_fields = ['BAROR', None, None] + self.x.tolist() + [self.offt]\n return list_fields","def get_all_wifi(self):\n return list(self.collection.find({\"sensor_type\": \"wifi\"}, {\"_id\": False})) # Return a list","def test_show_all_wires_true(self):\n\n ops = [qml.PauliX(\"a\"), qml.PauliY(\"c\")]\n wire_order = [\"a\", \"b\", \"c\", \"d\"]\n\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=True)\n assert wire_map == {\"a\": 0, \"b\": 1, \"c\": 2, \"d\": 3}","def getPeripheralNames(self):\n pass","def nontrainable_weights(self):\n return list(filter(lambda x: not x.requires_grad, self.get_parameters(expand=True)))","def bits(self):\n return list(range(self.lsb, self.msb + 1))","def wells_list(self, wtype='all'):\n list_names = []\n for well_data in self.wells:\n if wtype == 'all':\n list_names.append(well_data.drawdown.name)\n elif wtype == well_data._type - 2:\n list_names.append(well_data.drawdown.name)\n return(list_names)","def dump_raw(self):\n return [ [ ( m.coeff, m.k1, m.k2 )\n for m in O.monomials if m.coeff ] for O in self.states ]","def get_not_read(self):\n result = self.not_read\n self.not_read = []\n return result","def netlist(self):\n return self._netlist","def get_quirks(self, labware_id: str) -> List[str]:\n definition = self.get_definition(labware_id)\n return definition.parameters.quirks or []","def get_without(list, char=\"#\"):\n s = []\n for line in list:\n if char not in line:\n s.append(line)\n return s","def raw_fields(self):\n (x1, x2, x3) = self.get_x_g0_defaults()\n\n # offt doesn't exist in NX nastran\n offt = set_blank_if_default(self.offt, 'GGG')\n\n list_fields = ['CBAR', self.eid, self.Pid(), self.Ga(), self.Gb(), x1, x2,\n x3, offt, self.pa, self.pb] + list(self.wa) + list(self.wb)\n return list_fields","def getNetIfaceList(path):\n except_list = [\"bonding_masters\"]\n\n if os.path.exists(path):\n iface_list = [i for i in os.listdir(path) if i not in except_list]\n return iface_list\n\n else:\n return False","def notreturnedbanks(self):\n notreturned = []\n for bank in self.signedin():\n if not bank.returned():\n notreturned.append(bank)\n return notreturned","def notreturnedbanks(self):\n notreturned = []\n for bank in self.signedin():\n if not bank.returned():\n notreturned.append(bank)\n return notreturned","def notreturnedbanks(self):\n notreturned = []\n for bank in self.signedin():\n if not bank.returned():\n notreturned.append(bank)\n return notreturned","def notreturnedbanks(self):\n notreturned = []\n for bank in self.signedin():\n if not bank.returned():\n notreturned.append(bank)\n return notreturned","def notreturnedbanks(self):\n notreturned = []\n for bank in self.signedin():\n if not bank.returned():\n notreturned.append(bank)\n return notreturned","def notreturnedbanks(self):\n notreturned = []\n for bank in self.signedin():\n if not bank.returned():\n notreturned.append(bank)\n return notreturned","def notreturnedbanks(self):\n notreturned = []\n for bank in self.signedin():\n if not bank.returned():\n notreturned.append(bank)\n return notreturned","def Read2000256List(self):\n items = []\n for i in range(0, 2000):\n data = self.ReadBytes(64)\n ba = bytearray(binascii.unhexlify(data))\n ba.reverse()\n items.append(ba.hex().encode('utf-8'))\n return items","def get_warning(self) -> List[str]:\n return []","def get_warning(self) -> List[str]:\n return []","def control_bus_tokens(self):\n if self.lliagraph:\n return self.lliagraph.control_bus_tokens.items()\n else:\n return []","def get_obstList(self,X,Y,Z):\n return []","def get_obstList(self,X,Y,Z):\n return []","def gettypes(self):\n return [str(self.sd.xlate(t[0])) for t in self.sd.types]","def circuit_list(self):\r\n return self.circuits.itervalues()","def getNonShapeUncertainties(self, pars = []):\n\t\tif not self.chi2init:\n\t\t\traise RuntimeError(\"Chi2 not initialized, cannot evaluate\")\n\t\tif len(pars) > 0:\n\t\t\tself.setShapeParameters(pars)\n\t\tA,B,C = self.getOwnTheoryABC()\n\t\tunc = []\n\t\tfor i in range(len(A)):\n\t\t\tunc.append(A[i,i]**-.5)\n\t\treturn unc","def unisolvent_nodes(self):\r\n return self.grid.unisolvent_nodes","def bits(data):\n\treturn [format(ord(c),'08b') for c in data]","def getConnectedInterfacesOnly(self):\n return self.connectedInterfaces","def get_list_powers(self):\r\n _debug('simq03b_api.get_list_powers')\r\n \r\n s = self.query('SOUR:LIST:POW?')\r\n if s == None: return None\r\n a = []\r\n n = 0\r\n for x in s.split(','):\r\n try:\r\n a.append(float(x.strip()))\r\n except:\r\n print('ERROR get_list_powers(): non-float in list ', n, x)\r\n n += 1\r\n return a","def test_wire_order_str(self):\n\n ops = [qml.CNOT(wires=(\"a\", \"b\")), qml.PauliX(\"c\")]\n wire_order = (\"c\", \"b\", \"a\")\n\n wire_map = convert_wire_order(ops, wire_order)\n assert wire_map == {\"c\": 0, \"b\": 1, \"a\": 2}","def yield_ties_to_wire(wire):\n if wire not in WIRE_TIE_OPTIONS:\n return\n\n for constant in WIRE_TIE_OPTIONS[wire]:\n yield constant"],"string":"[\n \"def non_zero_components(self) :\\n return list(self.parent().characters())\",\n \"def test_show_all_wires_false(self):\\n\\n ops = [qml.PauliX(\\\"a\\\"), qml.PauliY(\\\"c\\\")]\\n wire_order = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\"]\\n\\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=False)\\n assert wire_map == {\\\"a\\\": 0, \\\"c\\\": 1}\",\n \"def get_naughty_string_list():\\n return naughty_string_list\",\n \"def wires(self):\\n return [o.wires for o in self.obs]\",\n \"def wires(self) -> Iterator[TopoDS_Wire]:\\n return map(Wire, self._top_exp.wires())\",\n \"def listNonDegenerate(self):\\n return arange(self.nelems())[~self.testDegenerate()]\",\n \"def get_light_sensors(self):\\n x=self.send_packet_check_response('\\\\x50')\\n LS=[]\\n for i in range(8):\\n a=bytearray(x[i*3:(i+1)*3])\\n LS.append(a[0]|(a[1]&0xf)<<8)\\n LS.append(a[1]>>4|a[2]<<4)\\n return LS\",\n \"def getnegates(self):\\n from beliefSys import beliefSys as bs\\n return bs.negatelist\",\n \"def get_non_terminals(self):\\r\\n return {non_terminal for non_terminal, symbols in self.productions}\",\n \"def wires(self):\\n top_exp = TopologyUtils.TopologyExplorer(self.topods_shape(), ignore_orientation=False)\\n return map(Wire, top_exp.wires())\",\n \"def excluded(cls):\\n return []\",\n \"def getExcludedDumpRegisterNames(self):\\n pass\",\n \"def diffignoreattrib(cls, instcls):\\n if instcls == effective_configuration:\\n return [\\\"checksum\\\"]\\n if instcls == fibrechannel:\\n return [\\\"neighbor_wwn\\\"]\\n if instcls == port_group:\\n return [\\\"port_group_f_ports_f_port\\\"]\\n if instcls == fibrechannel_switch:\\n return [\\\"enabled_state\\\", \\\"domain_id\\\"]\\n if instcls == fibrechannel_logical_switch:\\n return [\\\"ge_port_member_list_port_member\\\"]\\n return None\",\n \"def get_symbol(self):\\n return []\",\n \"def getNoShortName(self):\\n return [x for x in self.xeps if not x.shortname]\",\n \"def test_no_wire_order(self):\\n\\n ops = [qml.PauliX(0), qml.PauliX(2), qml.PauliX(1)]\\n\\n wire_map = convert_wire_order(ops)\\n\\n assert wire_map == {0: 0, 2: 1, 1: 2}\",\n \"def network_bytes(self) -> List[bytes]:\",\n \"def __get_scanning_range(self):\\n if self.__network is not None:\\n return [self.__network]\\n networks = []\\n interfaces = netifaces.interfaces()\\n for data in interfaces:\\n ips = netifaces.ifaddresses(data)\\n for key, interface_data in ips.items():\\n for item in interface_data:\\n if item.get(\\\"netmask\\\", None) is not None and \\\\\\n item.get(\\\"addr\\\", None) is not None and \\\\\\n self.is_legal_ip(item[\\\"netmask\\\"]):\\n if item.get(\\\"addr\\\") not in [\\\"127.0.0.1\\\", \\\"0.0.0.0\\\"]:\\n network = \\\"{ip}/{cird}\\\".format(ip=item[\\\"addr\\\"],\\n cird=IPAddress(item[\\\"netmask\\\"]).netmask_bits())\\n if network not in networks:\\n networks.append(network)\\n return networks\",\n \"def getSpectralTypes():\\n return ['B','A','F','G','K','M']\",\n \"def get_standard_xml(self):\\n return [s for (i, s) in list(self._I2EMAP.items())\\n if (i != self._CUSTOM) and s.strip()]\",\n \"def test_missing_wire(self):\\r\\n\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=[\\\"a\\\", -1, \\\"q2\\\"])\\r\\n\\r\\n @qml.beta.qnode(dev)\\r\\n def circuit():\\r\\n qml.Hadamard(wires=-1)\\r\\n qml.CNOT(wires=[\\\"a\\\", \\\"q2\\\"])\\r\\n qml.RX(0.2, wires=\\\"a\\\")\\r\\n return qml.expval(qml.PauliX(wires=\\\"q2\\\"))\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", \\\"a\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ──╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" a: ──╰C──RX(0.2)──┤ \\\",\\r\\n \\\" -1: ───H───────────┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", -1])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test multiple missing wires\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\",\n \"def test_get_unregistered_networks(self):\\n pass\",\n \"def hex_list(self):\\r\\n return [''.join(['{:02X}'.format(b) for b in data]) for data in self.buffers()]\",\n \"def list_bed_types():\\n\\n list = [\\\"ctrl\\\", \\\"cresis\\\", \\\"cresisp\\\", \\\"minus\\\", \\\"plus\\\", \\\"ba01_bed\\\", \\\"970mW_hs\\\", \\\"jak_1985\\\", \\\"no_bath\\\", \\\"wc\\\"]\\n\\n return list\",\n \"def exclude_list(self):\\n pass\",\n \"def get_party_blocks_list():\\n return get_pro_independence_parties(), [\\\"C's\\\", 'PSC', 'CatSíqueesPot', 'PP']\",\n \"def get_list_of_nets(self):\\n return self.mfp.get_list_of_nets()\",\n \"def ignored_lists(self) -> List[str]:\\n return self.__lists_to_ignore\",\n \"def test_string_wires(self):\\n\\n ops = [qml.PauliY(\\\"a\\\"), qml.CNOT(wires=(\\\"b\\\", \\\"c\\\"))]\\n\\n wire_map = default_wire_map(ops)\\n assert wire_map == {\\\"a\\\": 0, \\\"b\\\": 1, \\\"c\\\": 2}\",\n \"def get_list_of_bytes2(self):\\n pass\",\n \"def list():\\n return [Cliff.CLIFF_L,\\n Cliff.CLIFF_FL,\\n Cliff.CLIFF_R,\\n Cliff.CLIFF_FR,\\n Cliff.VIRTUAL_WALL]\",\n \"def getBondsNoH(self):\\n try:\\n return self._bondListNoH\\n except AttributeError:\\n pass\\n bondPointers=self._raw_data[\\\"BONDS_WITHOUT_HYDROGEN\\\"]\\n self._bondListNoH = self._getBonds(bondPointers)\\n return self._bondListNoH\",\n \"def not_matching_list(self):\\n\\n pre_result = comp(self.regex)\\n\\n return list(\\n filter(lambda element: not pre_result.search(element), self.data)\\n )\",\n \"def getMaskVariableNames(self, product):\\r\\n return []\",\n \"def getNoeuds(self) -> list:\\n return self._noeuds\",\n \"def ntypes(self): # -> list[str]:\\n ...\",\n \"def _useful_network(self):\\n\\n networks = self._compile_networks()\\n\\n network = []\\n for n in networks:\\n if len(n) >= self.min_network_size:\\n network += list(n)\\n\\n return network\",\n \"def to_deprecated_list_repr(self):\\r\\n return ['c4x', self.org, self.course, self.block_type, self.name, None]\",\n \"def test_missing_wire():\\r\\n\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=[\\\"a\\\", -1, \\\"q2\\\"])\\r\\n\\r\\n @qml.beta.qnode(dev)\\r\\n def circuit():\\r\\n qml.Hadamard(wires=-1)\\r\\n qml.CNOT(wires=[\\\"a\\\", \\\"q2\\\"])\\r\\n qml.RX(0.2, wires=\\\"a\\\")\\r\\n return qml.expval(qml.PauliX(wires=\\\"q2\\\"))\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", \\\"a\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ──╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" a: ──╰C──RX(0.2)──┤ \\\",\\r\\n \\\" -1: ───H───────────┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", -1])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test multiple missing wires\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\",\n \"def genes():\\n return [\\\"b2935\\\", \\\"b0723\\\", \\\"b0451\\\"]\",\n \"def list():\\n return [Drive.ENCODER_L,\\n Drive.ENCODER_R]\",\n \"def test_should_return_a_list(self):\\n\\n tcp_flags = TCPControlBits(['SYN', 'ACK'])\\n assert_is_instance(tcp_flags.to_list(), list)\",\n \"def warn(self) -> list:\\n return self.__wrn\",\n \"def getweigths():\\n ls = []\\n for i_lay in range(1, len(layers)):\\n ls.append(layers[i_lay][\\\"weigths\\\"])\\n return ls\",\n \"def unpack(self):\\n return []\",\n \"def getBanterList(self, num):\\r\\n return [self.__banterAssembler.assembleString() for a in range(num)]\",\n \"def list_networks():\\n return __sets.keys()\",\n \"def non_special_tokens(self) -> List[Hashable]:\\n return self._non_special_tokens\",\n \"def symbols_zero_spin(self) -> List[str]:\\n return self._symbols_zero_spin\",\n \"def to_list(self):\\n return [bits.value for bits in self.data]\",\n \"def get_non_ovf_disks():\\n return [\\n d.get_id() for d in get_all_disks() if (\\n d.get_alias() != ENUMS['ovf_disk_alias']\\n )\\n ]\",\n \"def get_leds_used(self)->List[str]:\\n leds = list()\\n for group in self.LedGroups:\\n leds.extend(group.Leds)\\n return [str(led) for led in leds]\",\n \"def _minimal() -> list:\\n\\n return ['r2', 'mape', 'nrmse', 'corr_coeff', 'rmse', 'mae', 'mse', 'mpe', \\n 'mase', 'r2_score']\",\n \"def generate_list(self):\\n\\n array = [False] * 25\\n bits = self.generate_bits()\\n\\n for column in range(2, -1, -1):\\n for row in range(0, 5):\\n bit = next(bits)\\n\\n array[column + (row * 5)] = bit\\n array[(4 - column) + (row * 5)] = bit\\n\\n return array\",\n \"def vendor_list():\\n return ['nxos', 'eos', 'cumulus']\",\n \"def _get_lsp_config_exclude_interfaces(self):\\n return self.__lsp_config_exclude_interfaces\",\n \"def get_unnamed_outputs(self):\\n return []\",\n \"def protocol_names(self):\\n l = self.protocols()\\n retval = [str(k.name) for k in l]\\n return retval\",\n \"def get_bfsl(self):\\n return array(self.LIST1,int)\",\n \"def power_list():\",\n \"def listDegenerate(self):\\n return arange(self.nelems())[self.testDegenerate()]\",\n \"def getNoWells(self):\\n #code begins here \\n return self.__nwells\",\n \"def ntypes(self): # -> list[None]:\\n ...\",\n \"def network_excludes(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"network_excludes\\\")\",\n \"def non_zero_components(self) :\\n return self.__coefficients.keys()\",\n \"def raw_fields(self):\\n list_fields = ['BAROR', None, None] + self.x.tolist() + [self.offt]\\n return list_fields\",\n \"def get_all_wifi(self):\\n return list(self.collection.find({\\\"sensor_type\\\": \\\"wifi\\\"}, {\\\"_id\\\": False})) # Return a list\",\n \"def test_show_all_wires_true(self):\\n\\n ops = [qml.PauliX(\\\"a\\\"), qml.PauliY(\\\"c\\\")]\\n wire_order = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\"]\\n\\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=True)\\n assert wire_map == {\\\"a\\\": 0, \\\"b\\\": 1, \\\"c\\\": 2, \\\"d\\\": 3}\",\n \"def getPeripheralNames(self):\\n pass\",\n \"def nontrainable_weights(self):\\n return list(filter(lambda x: not x.requires_grad, self.get_parameters(expand=True)))\",\n \"def bits(self):\\n return list(range(self.lsb, self.msb + 1))\",\n \"def wells_list(self, wtype='all'):\\n list_names = []\\n for well_data in self.wells:\\n if wtype == 'all':\\n list_names.append(well_data.drawdown.name)\\n elif wtype == well_data._type - 2:\\n list_names.append(well_data.drawdown.name)\\n return(list_names)\",\n \"def dump_raw(self):\\n return [ [ ( m.coeff, m.k1, m.k2 )\\n for m in O.monomials if m.coeff ] for O in self.states ]\",\n \"def get_not_read(self):\\n result = self.not_read\\n self.not_read = []\\n return result\",\n \"def netlist(self):\\n return self._netlist\",\n \"def get_quirks(self, labware_id: str) -> List[str]:\\n definition = self.get_definition(labware_id)\\n return definition.parameters.quirks or []\",\n \"def get_without(list, char=\\\"#\\\"):\\n s = []\\n for line in list:\\n if char not in line:\\n s.append(line)\\n return s\",\n \"def raw_fields(self):\\n (x1, x2, x3) = self.get_x_g0_defaults()\\n\\n # offt doesn't exist in NX nastran\\n offt = set_blank_if_default(self.offt, 'GGG')\\n\\n list_fields = ['CBAR', self.eid, self.Pid(), self.Ga(), self.Gb(), x1, x2,\\n x3, offt, self.pa, self.pb] + list(self.wa) + list(self.wb)\\n return list_fields\",\n \"def getNetIfaceList(path):\\n except_list = [\\\"bonding_masters\\\"]\\n\\n if os.path.exists(path):\\n iface_list = [i for i in os.listdir(path) if i not in except_list]\\n return iface_list\\n\\n else:\\n return False\",\n \"def notreturnedbanks(self):\\n notreturned = []\\n for bank in self.signedin():\\n if not bank.returned():\\n notreturned.append(bank)\\n return notreturned\",\n \"def notreturnedbanks(self):\\n notreturned = []\\n for bank in self.signedin():\\n if not bank.returned():\\n notreturned.append(bank)\\n return notreturned\",\n \"def notreturnedbanks(self):\\n notreturned = []\\n for bank in self.signedin():\\n if not bank.returned():\\n notreturned.append(bank)\\n return notreturned\",\n \"def notreturnedbanks(self):\\n notreturned = []\\n for bank in self.signedin():\\n if not bank.returned():\\n notreturned.append(bank)\\n return notreturned\",\n \"def notreturnedbanks(self):\\n notreturned = []\\n for bank in self.signedin():\\n if not bank.returned():\\n notreturned.append(bank)\\n return notreturned\",\n \"def notreturnedbanks(self):\\n notreturned = []\\n for bank in self.signedin():\\n if not bank.returned():\\n notreturned.append(bank)\\n return notreturned\",\n \"def notreturnedbanks(self):\\n notreturned = []\\n for bank in self.signedin():\\n if not bank.returned():\\n notreturned.append(bank)\\n return notreturned\",\n \"def Read2000256List(self):\\n items = []\\n for i in range(0, 2000):\\n data = self.ReadBytes(64)\\n ba = bytearray(binascii.unhexlify(data))\\n ba.reverse()\\n items.append(ba.hex().encode('utf-8'))\\n return items\",\n \"def get_warning(self) -> List[str]:\\n return []\",\n \"def get_warning(self) -> List[str]:\\n return []\",\n \"def control_bus_tokens(self):\\n if self.lliagraph:\\n return self.lliagraph.control_bus_tokens.items()\\n else:\\n return []\",\n \"def get_obstList(self,X,Y,Z):\\n return []\",\n \"def get_obstList(self,X,Y,Z):\\n return []\",\n \"def gettypes(self):\\n return [str(self.sd.xlate(t[0])) for t in self.sd.types]\",\n \"def circuit_list(self):\\r\\n return self.circuits.itervalues()\",\n \"def getNonShapeUncertainties(self, pars = []):\\n\\t\\tif not self.chi2init:\\n\\t\\t\\traise RuntimeError(\\\"Chi2 not initialized, cannot evaluate\\\")\\n\\t\\tif len(pars) > 0:\\n\\t\\t\\tself.setShapeParameters(pars)\\n\\t\\tA,B,C = self.getOwnTheoryABC()\\n\\t\\tunc = []\\n\\t\\tfor i in range(len(A)):\\n\\t\\t\\tunc.append(A[i,i]**-.5)\\n\\t\\treturn unc\",\n \"def unisolvent_nodes(self):\\r\\n return self.grid.unisolvent_nodes\",\n \"def bits(data):\\n\\treturn [format(ord(c),'08b') for c in data]\",\n \"def getConnectedInterfacesOnly(self):\\n return self.connectedInterfaces\",\n \"def get_list_powers(self):\\r\\n _debug('simq03b_api.get_list_powers')\\r\\n \\r\\n s = self.query('SOUR:LIST:POW?')\\r\\n if s == None: return None\\r\\n a = []\\r\\n n = 0\\r\\n for x in s.split(','):\\r\\n try:\\r\\n a.append(float(x.strip()))\\r\\n except:\\r\\n print('ERROR get_list_powers(): non-float in list ', n, x)\\r\\n n += 1\\r\\n return a\",\n \"def test_wire_order_str(self):\\n\\n ops = [qml.CNOT(wires=(\\\"a\\\", \\\"b\\\")), qml.PauliX(\\\"c\\\")]\\n wire_order = (\\\"c\\\", \\\"b\\\", \\\"a\\\")\\n\\n wire_map = convert_wire_order(ops, wire_order)\\n assert wire_map == {\\\"c\\\": 0, \\\"b\\\": 1, \\\"a\\\": 2}\",\n \"def yield_ties_to_wire(wire):\\n if wire not in WIRE_TIE_OPTIONS:\\n return\\n\\n for constant in WIRE_TIE_OPTIONS[wire]:\\n yield constant\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6052848","0.5989274","0.5908896","0.59033775","0.58206475","0.5755208","0.5742159","0.5671657","0.56207526","0.5596734","0.5553147","0.5512436","0.5506076","0.5496295","0.54956263","0.54736805","0.54546434","0.5410878","0.5403076","0.5399878","0.53901386","0.53832865","0.53730404","0.5359125","0.53222746","0.531708","0.53116024","0.53098834","0.53090614","0.53064436","0.5298905","0.529136","0.5291165","0.5290614","0.528916","0.5277881","0.52757233","0.52719945","0.52698874","0.5264622","0.5261887","0.5261556","0.52505857","0.5221098","0.52147245","0.5196666","0.518273","0.517676","0.5174863","0.5170073","0.5152736","0.5147104","0.5146782","0.5143593","0.5132359","0.51311034","0.5123507","0.5118081","0.51119334","0.5109078","0.51067317","0.5101378","0.5099611","0.5098477","0.50977546","0.50965357","0.50891155","0.50820893","0.5079802","0.50772166","0.50758374","0.5074011","0.50727123","0.5072649","0.50706077","0.5061254","0.5055181","0.5053351","0.50516504","0.50515383","0.50515383","0.50515383","0.50515383","0.50515383","0.50515383","0.50515383","0.5051278","0.5050104","0.5050104","0.5047867","0.5038776","0.5038776","0.50328887","0.5032526","0.5030652","0.5029442","0.5027443","0.5019268","0.5015487","0.50138444","0.50137436"],"string":"[\n \"0.6052848\",\n \"0.5989274\",\n \"0.5908896\",\n \"0.59033775\",\n \"0.58206475\",\n \"0.5755208\",\n \"0.5742159\",\n \"0.5671657\",\n \"0.56207526\",\n \"0.5596734\",\n \"0.5553147\",\n \"0.5512436\",\n \"0.5506076\",\n \"0.5496295\",\n \"0.54956263\",\n \"0.54736805\",\n \"0.54546434\",\n \"0.5410878\",\n \"0.5403076\",\n \"0.5399878\",\n \"0.53901386\",\n \"0.53832865\",\n \"0.53730404\",\n \"0.5359125\",\n \"0.53222746\",\n \"0.531708\",\n \"0.53116024\",\n \"0.53098834\",\n \"0.53090614\",\n \"0.53064436\",\n \"0.5298905\",\n \"0.529136\",\n \"0.5291165\",\n \"0.5290614\",\n \"0.528916\",\n \"0.5277881\",\n \"0.52757233\",\n \"0.52719945\",\n \"0.52698874\",\n \"0.5264622\",\n \"0.5261887\",\n \"0.5261556\",\n \"0.52505857\",\n \"0.5221098\",\n \"0.52147245\",\n \"0.5196666\",\n \"0.518273\",\n \"0.517676\",\n \"0.5174863\",\n \"0.5170073\",\n \"0.5152736\",\n \"0.5147104\",\n \"0.5146782\",\n \"0.5143593\",\n \"0.5132359\",\n \"0.51311034\",\n \"0.5123507\",\n \"0.5118081\",\n \"0.51119334\",\n \"0.5109078\",\n \"0.51067317\",\n \"0.5101378\",\n \"0.5099611\",\n \"0.5098477\",\n \"0.50977546\",\n \"0.50965357\",\n \"0.50891155\",\n \"0.50820893\",\n \"0.5079802\",\n \"0.50772166\",\n \"0.50758374\",\n \"0.5074011\",\n \"0.50727123\",\n \"0.5072649\",\n \"0.50706077\",\n \"0.5061254\",\n \"0.5055181\",\n \"0.5053351\",\n \"0.50516504\",\n \"0.50515383\",\n \"0.50515383\",\n \"0.50515383\",\n \"0.50515383\",\n \"0.50515383\",\n \"0.50515383\",\n \"0.50515383\",\n \"0.5051278\",\n \"0.5050104\",\n \"0.5050104\",\n \"0.5047867\",\n \"0.5038776\",\n \"0.5038776\",\n \"0.50328887\",\n \"0.5032526\",\n \"0.5030652\",\n \"0.5029442\",\n \"0.5027443\",\n \"0.5019268\",\n \"0.5015487\",\n \"0.50138444\",\n \"0.50137436\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78792,"cells":{"query":{"kind":"string","value":"NYI returns true if proceeded to MakeBlock()"},"document":{"kind":"string","value":"def IsDone(self, *args):\n return _BRepAlgo.BRepAlgo_EdgeConnector_IsDone(self, *args)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_block(self, block):\n pass","def test_34(self):\n assert 'False' == Api.requestBlock('test-34')","def test_13(self):\n assert 'False' == Api.requestBlock('test-13')","def test_03(self):\n assert 'False' == Api.requestBlock('test-03')","def test_33(self):\n assert 'False' == Api.requestBlock('test-33')","def test_35(self):\n assert 'False' == Api.requestBlock('test-35')","def test_28(self):\n assert 'False' == Api.requestBlock('test-28')","def test_41(self):\n assert 'False' == Api.requestBlock('test-41')","def test_43(self):\n assert 'False' == Api.requestBlock('test-43')","def test_02(self):\n assert 'False' == Api.requestBlock('test-02')","def test_37(self):\n assert 'False' == Api.requestBlock('test-37')","def test_44(self):\n assert 'False' == Api.requestBlock('test-44')","def test_23(self):\n assert 'False' == Api.requestBlock('test-23')","def test_11(self):\n assert 'False' == Api.requestBlock('test-11')","def test_46(self):\n assert 'False' == Api.requestBlock('test-46')","def test_29(self):\n assert 'True' == Api.requestBlock('test-29')","def test_27(self):\n assert 'False' == Api.requestBlock('test-27')","def test_52(self):\n assert 'False' == Api.requestBlock('test-52')","def test_14(self):\n assert 'False' == Api.requestBlock('test-14')","def test_12(self):\n assert 'False' == Api.requestBlock('test-12')","def test_21(self):\n assert 'False' == Api.requestBlock('test-21')","def test_26(self):\n assert 'False' == Api.requestBlock('test-26')","def test_32(self):\n assert 'False' == Api.requestBlock('test-32')","def test_15(self):\n assert 'False' == Api.requestBlock('test-15')","def test_16(self):\n assert 'False' == Api.requestBlock('test-16')","def test_36(self):\n assert 'False' == Api.requestBlock('test-36')","def test_40(self):\n assert 'False' == Api.requestBlock('test-40')","def test_30(self):\n assert 'False' == Api.requestBlock('test-30')","def test_31(self):\n assert 'True' == Api.requestBlock('test-31')","def test_20(self):\n assert 'False' == Api.requestBlock('test-20')","def test_09(self):\n assert 'False' == Api.requestBlock('test-09')","def test_39(self):\n assert 'True' == Api.requestBlock('test-39')","def test_24(self):\n assert 'False' == Api.requestBlock('test-24')","def test_19(self):\n assert 'True' == Api.requestBlock('test-19')","def test_45(self):\n assert 'True' == Api.requestBlock('test-45')","def is_block(self) -> bool:\n return self.answer == \".\"","def test_22(self):\n assert 'True' == Api.requestBlock('test-22')","def test_01(self):\n assert 'True' == Api.requestBlock('test-01')","def is_block(self):\n return self.v & 1 == 0","def test_returns_block() -> None:\n gr = BlobGoal(REAL_RED)\n gp = PerimeterGoal(MELON_MAMBO)\n board = one_block_four_children_(1)\n rp = RandomPlayer(0, gr)\n sp = SmartPlayer(1, gp, 10)\n rp._proceed = True\n sp._proceed = True\n move_block_rp = rp.generate_move(board)[2]\n move_block_sp = sp.generate_move(board)[2]\n assert move_block_rp == board or move_block_rp in board.children\n assert move_block_sp == board or move_block_sp in board.children","def test_25(self):\n assert 'False' == Api.requestBlock('test-25')","def test_38(self):\n assert 'True' == Api.requestBlock('test-38')","def test_10(self):\n assert 'False' == Api.requestBlock('test-10')","def test_04(self):\n assert 'False' == Api.requestBlock('test-04', charOrder='')","def test_block_bad_state(self):\n pass","def test_fork_simple(self):\n bvh = self.BlockValidationHandler()\n new_block = self.btm.generate_block(previous_block=self.btm.chain_head,\n add_to_store=True)\n\n bv = self.create_block_validator(new_block, bvh.on_block_validated)\n bv.run()\n\n self.assertTrue(bvh.has_result())\n self.assertTrue(new_block.status == BlockStatus.Valid)\n self.assertTrue(bvh.result[\"commit_new_block\"])","def test_42(self):\n assert 'True' == Api.requestBlock('test-42')","def test_06(self):\n assert 'False' == Api.requestBlock('test-06', charOrder=51)","def test_block_bad_consensus(self):\n pass","def is_block_complete(self, n):\n\n return self._complete(self._block(n))","def handleBlock(self, block_str):\n\n new_block = Block()\n new_block.parseJson(block_str)\n if not self.checkBlock(new_block):\n return False\n\n if new_block.confirmed:# if confirmed by someone, check and add block\n if valid_proof_of_work(new_block):\n print(\"Someone done before me, I'm going to stop\")\n self.threadjob = False\n self.BlockChain.addBlock(new_block) \n else:\n raise Exception(\"Hey this Block's Hash is not valid\")\n return False\n\n elif self.miner_indicator:\n if self.threadjob:\n print(\"This is miner, I should mine, but I'm already doing \")\n return True\n print(\"Hey this is miner, I'm going to mine\")\n self.threadjob = True\n t = Thread(target=self.mine, args = (new_block,))\n t.start()\n else:\n print(\"Hey this is unconfirmed block , but I am not miner, so I gonna miss it\")\n return True","def is_block(self):\n\t\treturn self.name in get_elements_collection(self.__res, 'block_level')","def blocks(self):\n pass","def block(self):\n pass","def test_block_bad_batch(self):\n pass","def block_one(self):","def test_block_missing_batch(self):\n pass","def is_block(modules):\n if isinstance(modules, (BasicBlock, Bottleneck)):\n return True\n return False","def test_05(self):\n assert 'True' == Api.requestBlock('test-05', charOrder=50)","def test_49(self):\n assert 'False' == Api.requestBlock('test-49', CustomFields=True)","def test_genesis_block(self):\n genesis_block = self.blockchain.last_block[\"index\"]\n self.assertEqual(genesis_block, 1)","def _check_for_new_block() -> None:\n logging.debug(\"Checking for new block\")\n CAPACITY = block.get_capacity()\n\n r = util.get_db()\n with r.lock(\"blockchain:last_block:lock\"), \\\n r.lock(\"blockchain:miner_pid:lock\"), \\\n r.lock(\"blockchain:tx_pool:lock\"), \\\n r.lock(\"blockchain:utxo-block:lock\"):\n # NOTE: If a miner is running, we expect it to add a new block, so we\n # abort. If mining succeeds, this function will be called again by\n # new_recv_block(). If it fails (another valid block is received) this\n # will again be called by new_recv_block()\n miner_pidb = r.get(\"blockchain:miner_pid\")\n if miner_pidb is not None:\n logging.debug(\"Miner already running with PID %d\", util.btoui(miner_pidb))\n return\n\n tx_pool = {Transaction.loadb(tb) for tb in r.hvals(\"blockchain:tx_pool\")}\n if len(tx_pool) < CAPACITY:\n logging.debug(\"Cannot create new block yet (not enough transactions)\")\n return\n\n last_block = get_block()\n utxo_block = {TransactionInput.loadb(i): TransactionOutput.loadb(o) for i, o \\\n in r.hgetall(\"blockchain:utxo-block:\".encode() + last_block.current_hash).items()}\n new_block_tx: List[Transaction] = []\n # NOTE: Since there are >= CAPACITY transactions in the pool, and we\n # don't mind transaction inter-dependence in the same block, a new\n # block can be created, so this loop will terminate\n while True:\n for t in tx_pool:\n # Search for t.inputs in UTXO-block[last_block] as well as in new_block_tx\n if all(i in utxo_block or \\\n any(nt.id == i.transaction_id for nt in new_block_tx) for i in t.inputs):\n new_block_tx.append(t)\n if len(new_block_tx) == CAPACITY:\n new_block = Block(index=last_block.index + 1,\n previous_hash=last_block.current_hash,\n transactions=new_block_tx)\n # NOTE: We don't delete the new block_tx from the pool, because\n # mining might fail. They will be deleted eventually when they\n # enter the main branch.\n miner_pid = new_block.finalize()\n r.set(\"blockchain:miner_pid\", util.uitob(miner_pid))\n logging.debug(\"Miner started with PID %d\", miner_pid)\n return\n tx_pool.difference_update(new_block_tx)","def test_51(self):\n assert 'False' == Api.requestBlock('test-51', CustomFields=True)","def test(self, parent, block):\r\n pass","def test_block_full_context(self):\n # old model file == beam block full context false\n pp = ParlaiParser(True, True)\n opt = pp.parse_args(\n ['--model-file', 'zoo:unittest/transformer_generator2/model']\n )\n agent = create_agent(opt, True)\n self.assertEqual(agent.opt['beam_block_full_context'], False)\n self.assertEqual(agent.beam_block_full_context, False)\n\n # brand new model == beam block full context true\n pp = ParlaiParser(True, True)\n opt = pp.parse_args(['--model', 'transformer/generator'])\n agent = create_agent(opt, True)\n self.assertEqual(agent.opt['beam_block_full_context'], True)\n self.assertEqual(agent.beam_block_full_context, True)","def test_block_extra_batch(self):\n pass","def chainIsValid(self):\n for i in range(1, len(self.blocks)):\n prev_block = self.blocks[i-1]\n cur_block = self.blocks[i]\n if cur_block.header['prevBlockH'] != getHashBlock(prev_block):\n return False\n return True","def IsExitBlock(self, node) -> bool:\n return self.nodes[node].get(\"exit\", False)","def test_50(self):\n assert 'False' == Api.requestBlock('test-50', CustomFields=True)","def test_good_fork_lower(self):\n bvh = self.BlockValidationHandler()\n\n root = self.btm.chain_head\n\n # create a new valid chain 5 long from the current root\n new_head = self.btm.generate_chain(root, 5,\n {'add_to_store': True})\n self.btm.set_chain_head(new_head[-1])\n # generate candidate chain 3 long from the same root\n new_block = self.btm.generate_chain(root, 3,\n {'add_to_cache': True})\n\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\n bv.run()\n\n self.assertTrue(bvh.has_result())\n self.assertTrue(new_block[-1].status == BlockStatus.Valid)\n self.assertFalse(bvh.result[\"commit_new_block\"])","def find_block_to_run(blk):\n _top = find_top_block(blk)\n if blk == _top and blk.name[0:3] is not 'def':\n return True\n else:\n return False","def test_block_bad_signature(self):\n pass","def verify_chain():\n for (index, block) in enumerate(blockchain):\n if index == 0:\n continue\n if block['previous_hash'] != hash_block(blockchain[index - 1]):\n return False\n # Here [:-1] excludes the reward from being a part of validation\n if not valid_proof(block['transactions'][:-1], block['previous_hash'], block['proof']):\n print('Proof of work is invalid.')\n return False\n return True","def test_08(self):\n assert 'False' == Api.requestBlock('test-08', differentOrderId=True)","def valid_chain(self, block, prev_block):\n self.stop_mine()\n\n print('\\n //// MINING STOPPED\\n')\n\n print('\\n //// block entering valid_chain')\n pprint(block)\n\n if block is not None and block['message'] != 'mining stopped':\n if block['previous_hash'] == self.hash(prev_block):\n \n # Check that the Proof of Work is correct\n if self.valid_proof(prev_block['proof'], block['proof']):\n if block['index'] == self.last_block['index']:\n if self.last_block['timestamp'] > block['timestamp']:\n del self.chain[-1]\n self.chain.append(block)\n print('\\n //// true from equal index but older timestamp')\n return True\n\n elif self.last_block['timestamp'] == block['timestamp']:\n print('\\n //// true from timestamps are equal block isnt added')\n return True\n else:\n print('\\n //// true timestamp is newer not added but sending false')\n return False\n\n elif block['index'] > self.last_block['index']:\n print('\\n //// true from index is greater and block is added')\n self.chain.append(block)\n return True\n else:\n print('\\n //// false from adding block had index less than block already there')\n else:\n print('\\n //// false from not a valid proof')\n\n else:\n print('\\n //// false from hashes arent equal')\n if (block['timestamp'] < self.last_block['timestamp']):\n if (block['index'] == self.last_block['index']):\n print('\\n //// hashes arent equal but block is older, subtracting and adding')\n del self.chain[-1]\n self.chain.append(block)\n return True\n\n elif (block['timestamp'] > self.last_block['timestamp']):\n if(block['index'] > self.last_block['index']):\n self.chain.append(block)\n return True\n else:\n return True\n\n return False\n\n else:\n return 'reject'","def begin():\n return BeginBlock()","def is_valid_proof(self, block, block_hash): \n return (block_hash.startswith('0' * Blockchain.difficulty) and block_hash == compute_hash())","def test_47(self):\n assert 'False' == Api.requestBlock('test-47', CustomFields=True)","def test_good_fork_higher(self):\n bvh = self.BlockValidationHandler()\n\n root = self.btm.chain_head\n\n # create a new valid chain 5 long from the current root\n new_head = self.btm.generate_chain(root, 5,\n {'add_to_store': True})\n self.btm.set_chain_head(new_head[-1])\n # generate candidate chain 8 long from the same root\n new_block = self.btm.generate_chain(root, 8,\n {'add_to_cache': True})\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\n bv.run()\n\n self.assertTrue(bvh.has_result())\n self.assertTrue(new_block[-1].status == BlockStatus.Valid)\n self.assertTrue(bvh.result[\"commit_new_block\"])","def test_single_chain(self):\n self.assertEqual(len(self.genesis_blocks), 1)\n manager = self.create_peer('testnet', tx_storage=self.tx_storage)\n\n # The initial score is the sum of the genesis\n score = self.genesis_blocks[0].weight\n for tx in self.genesis_txs:\n score = sum_weights(score, tx.weight)\n\n # Mine 100 blocks in a row with no transaction but the genesis\n blocks = add_new_blocks(manager, 100, advance_clock=15)\n for i, block in enumerate(blocks):\n meta = block.get_metadata(force_reload=True)\n score = sum_weights(score, block.weight)\n self.assertAlmostEqual(score, meta.score)\n\n # Add some transactions between blocks\n txs = add_new_transactions(manager, 30, advance_clock=15)\n for tx in txs:\n score = sum_weights(score, tx.weight)\n\n # Mine 50 more blocks in a row with no transactions between them\n blocks = add_new_blocks(manager, 50)\n for i, block in enumerate(blocks):\n meta = block.get_metadata()\n score = sum_weights(score, block.weight)\n self.assertAlmostEqual(score, meta.score)\n consensus_context = manager.consensus_algorithm.create_context()\n self.assertAlmostEqual(consensus_context.block_algorithm.calculate_score(block), meta.score)\n\n # Mine 15 more blocks with 10 transactions between each block\n for _ in range(15):\n txs = add_new_transactions(manager, 10, advance_clock=15)\n for tx in txs:\n score = sum_weights(score, tx.weight)\n\n blocks = add_new_blocks(manager, 1)\n for i, block in enumerate(blocks):\n meta = block.get_metadata()\n score = sum_weights(score, block.weight)\n self.assertAlmostEqual(score, meta.score)\n consensus_context = manager.consensus_algorithm.create_context()\n self.assertAlmostEqual(consensus_context.block_algorithm.calculate_score(block), meta.score)\n\n self.assertConsensusValid(manager)","def valid_chain(self, chain):\n\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n print(f'{last_block}')\n print(f'{block}')\n print(\"\\n-----------\\n\")\n # Check that the hash of the block is correct\n last_block_hash = self.hash(last_block)\n if block['previous_hash'] != last_block_hash:\n return False\n\n # Check that the Proof of Work is correct\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\n return False\n\n last_block = block\n current_index += 1\n\n return True","def test_07(self):\n assert 'False' == Api.requestBlock('test-07', charOrder='~!@#$%%^&*()=_+<>?/')","def mine_block(self):\n\n last_block = self.__chain[-1]\n hashed_block = hash_util.hash_block(last_block)\n\n proof = self.proof_of_work()\n\n # we are using OrderedDict to get an ordered dictionary so that the hash doesn't change due to the order changing\n reward_transaction = Transaction('MINING', self.hosting_node, MINING_REWARD)\n copied_transactions = self.__open_transactions[:] # copies open_transactions by value (: signifies range, if nothing is\n # specified, then the whole list is copied\n copied_transactions.append(reward_transaction) # reward for miners\n\n block = Block(len(self.__chain), hashed_block, copied_transactions, proof)\n self.__chain.append(block)\n self.__open_transactions = []\n return True","def valid_proof(block):\n return Blockchain.hash(block) [:4] == \"0000\"","def update_one_block(self):\n trial_result_list = self.do_trial_on_circuits_by_cost_gradient()\n if len(trial_result_list) != 0:\n self.update_circuit_by_trial_result(trial_result_list)\n print(\"Block added and shown below, cost now is:\",\n self.current_cost)\n print(\"********New Circuit********\")\n print(self.circuit)\n if not self.no_global_optimization:\n print(\"Doing global optimization on the new circuit\")\n self.do_global_optimization()\n print(\"Global Optimized Cost:\", self.current_cost)\n \n self.cost_list.append(self.current_cost)\n\n if not self.not_save:\n save_construction(self, self.save_name)\n\n print(\"Distance to target cost:\",\n self.current_cost - self.terminate_cost)\n print(\"Gate Usage:\", self.circuit.get_gate_used())\n print(\"Cost list:\", self.cost_list)\n if self.current_cost <= self.terminate_cost:\n self.when_terminate_cost_achieved = len(\n self.circuit.block_list)\n print(\"Target cost achieved by\",\n self.when_terminate_cost_achieved, \" blocks!\")\n print(\"Construction process ends!\")\n return True\n else:\n print(\"No trial circuit in the list provides a lower cost\")\n return False","def test_48(self):\n assert 'False' == Api.requestBlock('test-48', CustomFields=True)","def valid_chain(self, chain):\n last_block = chain[0]\n current_index = 1\n\n while current_index < len(chain):\n block = chain[current_index]\n # print(f'{last_block}')\n # print(f'{block}')\n # print(\"\\n-----------\\n\")\n # Check that the hash of the block is correct\n last_block_hash = self.hash(last_block)\n if block['previous_hash'] != self.hash(last_block):\n return False\n\n # Check that the Proof of Work is correct\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\n return False\n\n last_block = block\n current_index += 1\n\n return True","def verify_chain():\n\n block_index = 0\n is_unchanged = True\n\n if namoto_length < 1:\n print('Blockchain is empty!')\n return None\n\n for block in namoto_blockchain:\n\n if block[0] == namoto_blockchain[block_index -1]:\n is_unchanged = True\n block_index += 1\n\n else:\n is_unchanged = False\n break\n\n return is_unchanged","def scenario():\n LOCAL_HOST = \"http://127.0.0.1\"\n\n # import functions\n from . import genesis_block\n from . import create_block\n from . import connect_peer\n from . import stop_server\n from . import block_crosscheck\n\n total_cnt = 0\n pass_cnt = 0\n\n # 1. Check each peer's genesis block\n try:\n assert genesis_block.check(LOCAL_HOST, 3001)\n assert genesis_block.check(LOCAL_HOST, 3002)\n assert genesis_block.check(LOCAL_HOST, 3003)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/genesis_block\")\n total_cnt += 1\n\n # 2. Generate new blocks\n # 2.1. 2 blocks on peer #1\n # 2.2. 4 blocks on peer #2\n # 2.3. 2 blocks on peer #3\n try:\n assert create_block.addBlocks(LOCAL_HOST, 3001, num=2)\n assert create_block.check(LOCAL_HOST, 3001, num=2)\n\n assert create_block.addBlocks(LOCAL_HOST, 3002, num=4)\n assert create_block.check(LOCAL_HOST, 3002, num=4)\n\n assert create_block.addBlocks(LOCAL_HOST, 3003, num=2)\n assert create_block.check(LOCAL_HOST, 3003, num=2)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/create_block\")\n total_cnt += 1\n\n # 3. Connect peers\n # 3.1. peer #1 with #2 (1->2)\n # 3.2. peer #1 with #3 (1->(2 and 3))\n try:\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \"ws://127.0.0.1:6002\")\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \"ws://127.0.0.1:6003\")\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/connect_peer\")\n total_cnt += 1\n\n # 4. Generate new blocks\n # 4.1. 3 blocks on peer #1\n # 4.2. 5 blocks on peer #3\n try:\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3001, num=3)\n assert isPass\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=3)\n assert block_crosscheck.check(LOCAL_HOST, 3003, newBlocks, num=3)\n\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3003, num=5)\n assert isPass\n assert block_crosscheck.check(LOCAL_HOST, 3001, newBlocks, num=5)\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=5)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/block_crosscheck\")\n total_cnt += 1\n\n # 5. Stop all peers\n try:\n assert stop_server.stopServer(LOCAL_HOST, 3001)\n assert stop_server.stopServer(LOCAL_HOST, 3002)\n assert stop_server.stopServer(LOCAL_HOST, 3003)\n\n print(\"pass\", end=' ')\n pass_cnt += 1\n\n except:\n print(\"FAIL\", end=' ')\n\n finally:\n print(\"test1/stop_server\")\n total_cnt += 1\n\n # return pass_cnt_per_test and total_cnt_per_test\n return pass_cnt, total_cnt","def block(self):\n return self._block","def test_simple_block(self):\n if config.SUMLEV_BLOCK not in config.SUMLEVS:\n pass\n\n blocks = self.geographies.find({ 'geoid': '150010210053029' })\n\n self.assertEqual(blocks.count(), 1)\n\n block = blocks[0]\n\n self.assertEqual(block['sumlev'], config.SUMLEV_BLOCK)\n self.assertEqual(block['metadata']['NAME'], 'Block 3029')\n self.assertEqual(block['metadata']['STATE'], '15')\n self.assertEqual(block['metadata']['COUNTY'], '001')\n self.assertEqual(block['metadata']['TRACT'], '021005')\n\n pop_2000 = 33 \n pop_2010 = 93 \n self._test_totalpop(block, pop_2000, pop_2010)","def Blocking(self) -> bool:","def test_mine_empty_transaction_block(self):\n miner_address = 'miner_address'\n\n blockchain = Blockchain()\n block = blockchain.mine(miner_address)\n\n # First we look that a new block could be mined\n self.assertIsNotNone(block)\n\n # Let's see if the block was added to the chain\n self.assertEqual(blockchain.last_block.hash, block.hash)\n\n # We need to check that the block contains only the reward transaction\n self.assertEqual(len(block.transactions), 1)\n\n reward_transaction = block.transactions[0]\n\n # We make sure the reward function has no sender, and gives away exactly 1 coin\n self.assertEqual(reward_transaction.sender, '0')\n self.assertEqual(reward_transaction.recipient, miner_address)\n self.assertEqual(reward_transaction.amount, 1)","def verify_chain():\n for (index,block) in enumerate(blockchain):\n if index ==0:\n continue\n if block['previous_hash'] != hash_block(blockchain[index-1]):\n return False\n if not valid_proof(block['transactions'][:-1],block['previous_hash'],block['proof']):\n print('Proof of Work is Invalid')\n return False\n return True","def test_new_block_return_type(self):\n block = self.blockchain.new_block(self.proof, self.previous_hash)\n self.assertIsInstance(block, dict)","def mine(self):\n if self.mining_right ==True:\n if not self.unconfirmed_transactions:\n return False\n\n last_block = self.last_block\n\n new_block = Block(index=last_block.index + 1,\n transactions=self.unconfirmed_transactions,\n timestamp=time.time(),\n previous_hash=last_block.hash)\n\n proof = self.proof_of_work(new_block)\n self.add_block(new_block, proof)\n\n self.unconfirmed_transactions = {}\n\n return True","def mine(self):\n new_block = Block(self.block['timestamp'], self.block['car'],\n self.block['id'])\n # link the block to the previous block\n new_block.previous_hash = self._get_previous_hash()\n while True:\n # get a hash\n new_hash = new_block.get_hash()\n # check hash rules, in our case check if the hash starts with\n # self.difficulty number of zeroes\n if new_hash[0] != self.difficulty * \"0\":\n if self.new_block[\"block\"] is None:\n # the hash hasn't been found yet by any other process,\n # therefore increase the nonce and continue\n # miners will use a different mining mechanism in order\n # to increase the probability of finding a hash by\n # a different miner\n new_block.increment_nonce(self.id + 1)\n continue\n break\n break\n\n # NOTE: May happen that two processes find the hash at the same time,\n # because there is not a big difficulty, however, it's not a problem,\n # for sake of the demo it's fine\n\n if self.new_block[\"block\"] is None:\n # this process has found the hash first\n print(self.id, \" - the winner hash\", new_hash)\n new_block.hash = new_hash\n self.new_block[\"block\"] = new_block\n print(self.id, \" - mined the block\")\n else:\n # validate the block found by other process (miner)\n if self.new_block[\"validated\"] is not False:\n print(self.id, \" - validating\")\n # check block's validity\n valid = False\n if self.new_block[\"block\"].is_block_valid():\n # check blockchain's validity when we apply the newly\n # mined block\n if self.is_blockchain_valid(self.new_block[\"block\"]):\n valid = True\n self.new_block[\"validated\"] = valid\n else:\n # NOTE: this demo doesn't take into account the number of\n # miners who approved the block, the block will be rejected\n # if any of them rejected it\n # but usually just more than 50% of miners must approve\n print(self.id, \" - the block has been rejected by other miner\")","def test_mine_simple_transaction_block(self):\n miner_address = 'miner_address'\n\n blockchain = Blockchain()\n blockchain.create_transaction('sender', 'recipient', 1)\n blockchain.create_transaction('sender2', 'recipient2', 1.5)\n self.assertEqual(len(blockchain.pending_transactions), 2)\n\n block = blockchain.mine(miner_address)\n\n # First we look that a new block could be mined\n self.assertIsNotNone(block)\n\n # Let's see if the block was added to the chain\n self.assertEqual(blockchain.last_block.hash, block.hash)\n\n # We need to check that the transaction list is empty\n self.assertEqual(0, len(blockchain.pending_transactions))\n\n # We need to check that the block contains all of the transactions\n self.assertEqual(3, len(block.transactions))\n\n reward_transaction = block.transactions[-1]\n\n # We make sure the reward function has no sender, and gives away exactly 1 coin\n self.assertEqual('0', reward_transaction.sender)\n self.assertEqual(miner_address, reward_transaction.recipient)\n self.assertEqual(1, reward_transaction.amount)","def verify_stored_block(leading_zeros: int) -> bool:\n try:\n with open(\"block.json\", \"r\") as file:\n block_json = json.load(file)\n block = Block(block_json[\"data\"], block_json[\"nonce\"], block_json[\"hash\"])\n hash_to_verify = block.hash\n recalculated_hash = block.get_hash()\n\n binary_hash_to_verify = get_binary_sha256_hash(hash_to_verify)\n binary_recalculated_hash = get_binary_sha256_hash(recalculated_hash)\n\n return (\n binary_hash_to_verify == binary_recalculated_hash\n and binary_recalculated_hash[:leading_zeros] == \"0\" * leading_zeros\n )\n except FileNotFoundError:\n print(\"No stored block found. Create one first\")\n return False","def isValid(self):\n currBlock = self.getBlock(self.tailBlockHash)\n while currBlock != self.genesisBlock:\n if not self.isValidBlock(currBlock):\n return False\n currBlock = self.getBlock(currBlock.prevHash)\n return True","def _rpc_loaded(self):\n try:\n self.server.eth.getBlock(self.server.eth.blockNumber)\n return True\n except (web3.utils.threads.Timeout, ConnectionRefusedError, FileNotFoundError):\n return False"],"string":"[\n \"def check_block(self, block):\\n pass\",\n \"def test_34(self):\\n assert 'False' == Api.requestBlock('test-34')\",\n \"def test_13(self):\\n assert 'False' == Api.requestBlock('test-13')\",\n \"def test_03(self):\\n assert 'False' == Api.requestBlock('test-03')\",\n \"def test_33(self):\\n assert 'False' == Api.requestBlock('test-33')\",\n \"def test_35(self):\\n assert 'False' == Api.requestBlock('test-35')\",\n \"def test_28(self):\\n assert 'False' == Api.requestBlock('test-28')\",\n \"def test_41(self):\\n assert 'False' == Api.requestBlock('test-41')\",\n \"def test_43(self):\\n assert 'False' == Api.requestBlock('test-43')\",\n \"def test_02(self):\\n assert 'False' == Api.requestBlock('test-02')\",\n \"def test_37(self):\\n assert 'False' == Api.requestBlock('test-37')\",\n \"def test_44(self):\\n assert 'False' == Api.requestBlock('test-44')\",\n \"def test_23(self):\\n assert 'False' == Api.requestBlock('test-23')\",\n \"def test_11(self):\\n assert 'False' == Api.requestBlock('test-11')\",\n \"def test_46(self):\\n assert 'False' == Api.requestBlock('test-46')\",\n \"def test_29(self):\\n assert 'True' == Api.requestBlock('test-29')\",\n \"def test_27(self):\\n assert 'False' == Api.requestBlock('test-27')\",\n \"def test_52(self):\\n assert 'False' == Api.requestBlock('test-52')\",\n \"def test_14(self):\\n assert 'False' == Api.requestBlock('test-14')\",\n \"def test_12(self):\\n assert 'False' == Api.requestBlock('test-12')\",\n \"def test_21(self):\\n assert 'False' == Api.requestBlock('test-21')\",\n \"def test_26(self):\\n assert 'False' == Api.requestBlock('test-26')\",\n \"def test_32(self):\\n assert 'False' == Api.requestBlock('test-32')\",\n \"def test_15(self):\\n assert 'False' == Api.requestBlock('test-15')\",\n \"def test_16(self):\\n assert 'False' == Api.requestBlock('test-16')\",\n \"def test_36(self):\\n assert 'False' == Api.requestBlock('test-36')\",\n \"def test_40(self):\\n assert 'False' == Api.requestBlock('test-40')\",\n \"def test_30(self):\\n assert 'False' == Api.requestBlock('test-30')\",\n \"def test_31(self):\\n assert 'True' == Api.requestBlock('test-31')\",\n \"def test_20(self):\\n assert 'False' == Api.requestBlock('test-20')\",\n \"def test_09(self):\\n assert 'False' == Api.requestBlock('test-09')\",\n \"def test_39(self):\\n assert 'True' == Api.requestBlock('test-39')\",\n \"def test_24(self):\\n assert 'False' == Api.requestBlock('test-24')\",\n \"def test_19(self):\\n assert 'True' == Api.requestBlock('test-19')\",\n \"def test_45(self):\\n assert 'True' == Api.requestBlock('test-45')\",\n \"def is_block(self) -> bool:\\n return self.answer == \\\".\\\"\",\n \"def test_22(self):\\n assert 'True' == Api.requestBlock('test-22')\",\n \"def test_01(self):\\n assert 'True' == Api.requestBlock('test-01')\",\n \"def is_block(self):\\n return self.v & 1 == 0\",\n \"def test_returns_block() -> None:\\n gr = BlobGoal(REAL_RED)\\n gp = PerimeterGoal(MELON_MAMBO)\\n board = one_block_four_children_(1)\\n rp = RandomPlayer(0, gr)\\n sp = SmartPlayer(1, gp, 10)\\n rp._proceed = True\\n sp._proceed = True\\n move_block_rp = rp.generate_move(board)[2]\\n move_block_sp = sp.generate_move(board)[2]\\n assert move_block_rp == board or move_block_rp in board.children\\n assert move_block_sp == board or move_block_sp in board.children\",\n \"def test_25(self):\\n assert 'False' == Api.requestBlock('test-25')\",\n \"def test_38(self):\\n assert 'True' == Api.requestBlock('test-38')\",\n \"def test_10(self):\\n assert 'False' == Api.requestBlock('test-10')\",\n \"def test_04(self):\\n assert 'False' == Api.requestBlock('test-04', charOrder='')\",\n \"def test_block_bad_state(self):\\n pass\",\n \"def test_fork_simple(self):\\n bvh = self.BlockValidationHandler()\\n new_block = self.btm.generate_block(previous_block=self.btm.chain_head,\\n add_to_store=True)\\n\\n bv = self.create_block_validator(new_block, bvh.on_block_validated)\\n bv.run()\\n\\n self.assertTrue(bvh.has_result())\\n self.assertTrue(new_block.status == BlockStatus.Valid)\\n self.assertTrue(bvh.result[\\\"commit_new_block\\\"])\",\n \"def test_42(self):\\n assert 'True' == Api.requestBlock('test-42')\",\n \"def test_06(self):\\n assert 'False' == Api.requestBlock('test-06', charOrder=51)\",\n \"def test_block_bad_consensus(self):\\n pass\",\n \"def is_block_complete(self, n):\\n\\n return self._complete(self._block(n))\",\n \"def handleBlock(self, block_str):\\n\\n new_block = Block()\\n new_block.parseJson(block_str)\\n if not self.checkBlock(new_block):\\n return False\\n\\n if new_block.confirmed:# if confirmed by someone, check and add block\\n if valid_proof_of_work(new_block):\\n print(\\\"Someone done before me, I'm going to stop\\\")\\n self.threadjob = False\\n self.BlockChain.addBlock(new_block) \\n else:\\n raise Exception(\\\"Hey this Block's Hash is not valid\\\")\\n return False\\n\\n elif self.miner_indicator:\\n if self.threadjob:\\n print(\\\"This is miner, I should mine, but I'm already doing \\\")\\n return True\\n print(\\\"Hey this is miner, I'm going to mine\\\")\\n self.threadjob = True\\n t = Thread(target=self.mine, args = (new_block,))\\n t.start()\\n else:\\n print(\\\"Hey this is unconfirmed block , but I am not miner, so I gonna miss it\\\")\\n return True\",\n \"def is_block(self):\\n\\t\\treturn self.name in get_elements_collection(self.__res, 'block_level')\",\n \"def blocks(self):\\n pass\",\n \"def block(self):\\n pass\",\n \"def test_block_bad_batch(self):\\n pass\",\n \"def block_one(self):\",\n \"def test_block_missing_batch(self):\\n pass\",\n \"def is_block(modules):\\n if isinstance(modules, (BasicBlock, Bottleneck)):\\n return True\\n return False\",\n \"def test_05(self):\\n assert 'True' == Api.requestBlock('test-05', charOrder=50)\",\n \"def test_49(self):\\n assert 'False' == Api.requestBlock('test-49', CustomFields=True)\",\n \"def test_genesis_block(self):\\n genesis_block = self.blockchain.last_block[\\\"index\\\"]\\n self.assertEqual(genesis_block, 1)\",\n \"def _check_for_new_block() -> None:\\n logging.debug(\\\"Checking for new block\\\")\\n CAPACITY = block.get_capacity()\\n\\n r = util.get_db()\\n with r.lock(\\\"blockchain:last_block:lock\\\"), \\\\\\n r.lock(\\\"blockchain:miner_pid:lock\\\"), \\\\\\n r.lock(\\\"blockchain:tx_pool:lock\\\"), \\\\\\n r.lock(\\\"blockchain:utxo-block:lock\\\"):\\n # NOTE: If a miner is running, we expect it to add a new block, so we\\n # abort. If mining succeeds, this function will be called again by\\n # new_recv_block(). If it fails (another valid block is received) this\\n # will again be called by new_recv_block()\\n miner_pidb = r.get(\\\"blockchain:miner_pid\\\")\\n if miner_pidb is not None:\\n logging.debug(\\\"Miner already running with PID %d\\\", util.btoui(miner_pidb))\\n return\\n\\n tx_pool = {Transaction.loadb(tb) for tb in r.hvals(\\\"blockchain:tx_pool\\\")}\\n if len(tx_pool) < CAPACITY:\\n logging.debug(\\\"Cannot create new block yet (not enough transactions)\\\")\\n return\\n\\n last_block = get_block()\\n utxo_block = {TransactionInput.loadb(i): TransactionOutput.loadb(o) for i, o \\\\\\n in r.hgetall(\\\"blockchain:utxo-block:\\\".encode() + last_block.current_hash).items()}\\n new_block_tx: List[Transaction] = []\\n # NOTE: Since there are >= CAPACITY transactions in the pool, and we\\n # don't mind transaction inter-dependence in the same block, a new\\n # block can be created, so this loop will terminate\\n while True:\\n for t in tx_pool:\\n # Search for t.inputs in UTXO-block[last_block] as well as in new_block_tx\\n if all(i in utxo_block or \\\\\\n any(nt.id == i.transaction_id for nt in new_block_tx) for i in t.inputs):\\n new_block_tx.append(t)\\n if len(new_block_tx) == CAPACITY:\\n new_block = Block(index=last_block.index + 1,\\n previous_hash=last_block.current_hash,\\n transactions=new_block_tx)\\n # NOTE: We don't delete the new block_tx from the pool, because\\n # mining might fail. They will be deleted eventually when they\\n # enter the main branch.\\n miner_pid = new_block.finalize()\\n r.set(\\\"blockchain:miner_pid\\\", util.uitob(miner_pid))\\n logging.debug(\\\"Miner started with PID %d\\\", miner_pid)\\n return\\n tx_pool.difference_update(new_block_tx)\",\n \"def test_51(self):\\n assert 'False' == Api.requestBlock('test-51', CustomFields=True)\",\n \"def test(self, parent, block):\\r\\n pass\",\n \"def test_block_full_context(self):\\n # old model file == beam block full context false\\n pp = ParlaiParser(True, True)\\n opt = pp.parse_args(\\n ['--model-file', 'zoo:unittest/transformer_generator2/model']\\n )\\n agent = create_agent(opt, True)\\n self.assertEqual(agent.opt['beam_block_full_context'], False)\\n self.assertEqual(agent.beam_block_full_context, False)\\n\\n # brand new model == beam block full context true\\n pp = ParlaiParser(True, True)\\n opt = pp.parse_args(['--model', 'transformer/generator'])\\n agent = create_agent(opt, True)\\n self.assertEqual(agent.opt['beam_block_full_context'], True)\\n self.assertEqual(agent.beam_block_full_context, True)\",\n \"def test_block_extra_batch(self):\\n pass\",\n \"def chainIsValid(self):\\n for i in range(1, len(self.blocks)):\\n prev_block = self.blocks[i-1]\\n cur_block = self.blocks[i]\\n if cur_block.header['prevBlockH'] != getHashBlock(prev_block):\\n return False\\n return True\",\n \"def IsExitBlock(self, node) -> bool:\\n return self.nodes[node].get(\\\"exit\\\", False)\",\n \"def test_50(self):\\n assert 'False' == Api.requestBlock('test-50', CustomFields=True)\",\n \"def test_good_fork_lower(self):\\n bvh = self.BlockValidationHandler()\\n\\n root = self.btm.chain_head\\n\\n # create a new valid chain 5 long from the current root\\n new_head = self.btm.generate_chain(root, 5,\\n {'add_to_store': True})\\n self.btm.set_chain_head(new_head[-1])\\n # generate candidate chain 3 long from the same root\\n new_block = self.btm.generate_chain(root, 3,\\n {'add_to_cache': True})\\n\\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\\n bv.run()\\n\\n self.assertTrue(bvh.has_result())\\n self.assertTrue(new_block[-1].status == BlockStatus.Valid)\\n self.assertFalse(bvh.result[\\\"commit_new_block\\\"])\",\n \"def find_block_to_run(blk):\\n _top = find_top_block(blk)\\n if blk == _top and blk.name[0:3] is not 'def':\\n return True\\n else:\\n return False\",\n \"def test_block_bad_signature(self):\\n pass\",\n \"def verify_chain():\\n for (index, block) in enumerate(blockchain):\\n if index == 0:\\n continue\\n if block['previous_hash'] != hash_block(blockchain[index - 1]):\\n return False\\n # Here [:-1] excludes the reward from being a part of validation\\n if not valid_proof(block['transactions'][:-1], block['previous_hash'], block['proof']):\\n print('Proof of work is invalid.')\\n return False\\n return True\",\n \"def test_08(self):\\n assert 'False' == Api.requestBlock('test-08', differentOrderId=True)\",\n \"def valid_chain(self, block, prev_block):\\n self.stop_mine()\\n\\n print('\\\\n //// MINING STOPPED\\\\n')\\n\\n print('\\\\n //// block entering valid_chain')\\n pprint(block)\\n\\n if block is not None and block['message'] != 'mining stopped':\\n if block['previous_hash'] == self.hash(prev_block):\\n \\n # Check that the Proof of Work is correct\\n if self.valid_proof(prev_block['proof'], block['proof']):\\n if block['index'] == self.last_block['index']:\\n if self.last_block['timestamp'] > block['timestamp']:\\n del self.chain[-1]\\n self.chain.append(block)\\n print('\\\\n //// true from equal index but older timestamp')\\n return True\\n\\n elif self.last_block['timestamp'] == block['timestamp']:\\n print('\\\\n //// true from timestamps are equal block isnt added')\\n return True\\n else:\\n print('\\\\n //// true timestamp is newer not added but sending false')\\n return False\\n\\n elif block['index'] > self.last_block['index']:\\n print('\\\\n //// true from index is greater and block is added')\\n self.chain.append(block)\\n return True\\n else:\\n print('\\\\n //// false from adding block had index less than block already there')\\n else:\\n print('\\\\n //// false from not a valid proof')\\n\\n else:\\n print('\\\\n //// false from hashes arent equal')\\n if (block['timestamp'] < self.last_block['timestamp']):\\n if (block['index'] == self.last_block['index']):\\n print('\\\\n //// hashes arent equal but block is older, subtracting and adding')\\n del self.chain[-1]\\n self.chain.append(block)\\n return True\\n\\n elif (block['timestamp'] > self.last_block['timestamp']):\\n if(block['index'] > self.last_block['index']):\\n self.chain.append(block)\\n return True\\n else:\\n return True\\n\\n return False\\n\\n else:\\n return 'reject'\",\n \"def begin():\\n return BeginBlock()\",\n \"def is_valid_proof(self, block, block_hash): \\n return (block_hash.startswith('0' * Blockchain.difficulty) and block_hash == compute_hash())\",\n \"def test_47(self):\\n assert 'False' == Api.requestBlock('test-47', CustomFields=True)\",\n \"def test_good_fork_higher(self):\\n bvh = self.BlockValidationHandler()\\n\\n root = self.btm.chain_head\\n\\n # create a new valid chain 5 long from the current root\\n new_head = self.btm.generate_chain(root, 5,\\n {'add_to_store': True})\\n self.btm.set_chain_head(new_head[-1])\\n # generate candidate chain 8 long from the same root\\n new_block = self.btm.generate_chain(root, 8,\\n {'add_to_cache': True})\\n bv = self.create_block_validator(new_block[-1], bvh.on_block_validated)\\n bv.run()\\n\\n self.assertTrue(bvh.has_result())\\n self.assertTrue(new_block[-1].status == BlockStatus.Valid)\\n self.assertTrue(bvh.result[\\\"commit_new_block\\\"])\",\n \"def test_single_chain(self):\\n self.assertEqual(len(self.genesis_blocks), 1)\\n manager = self.create_peer('testnet', tx_storage=self.tx_storage)\\n\\n # The initial score is the sum of the genesis\\n score = self.genesis_blocks[0].weight\\n for tx in self.genesis_txs:\\n score = sum_weights(score, tx.weight)\\n\\n # Mine 100 blocks in a row with no transaction but the genesis\\n blocks = add_new_blocks(manager, 100, advance_clock=15)\\n for i, block in enumerate(blocks):\\n meta = block.get_metadata(force_reload=True)\\n score = sum_weights(score, block.weight)\\n self.assertAlmostEqual(score, meta.score)\\n\\n # Add some transactions between blocks\\n txs = add_new_transactions(manager, 30, advance_clock=15)\\n for tx in txs:\\n score = sum_weights(score, tx.weight)\\n\\n # Mine 50 more blocks in a row with no transactions between them\\n blocks = add_new_blocks(manager, 50)\\n for i, block in enumerate(blocks):\\n meta = block.get_metadata()\\n score = sum_weights(score, block.weight)\\n self.assertAlmostEqual(score, meta.score)\\n consensus_context = manager.consensus_algorithm.create_context()\\n self.assertAlmostEqual(consensus_context.block_algorithm.calculate_score(block), meta.score)\\n\\n # Mine 15 more blocks with 10 transactions between each block\\n for _ in range(15):\\n txs = add_new_transactions(manager, 10, advance_clock=15)\\n for tx in txs:\\n score = sum_weights(score, tx.weight)\\n\\n blocks = add_new_blocks(manager, 1)\\n for i, block in enumerate(blocks):\\n meta = block.get_metadata()\\n score = sum_weights(score, block.weight)\\n self.assertAlmostEqual(score, meta.score)\\n consensus_context = manager.consensus_algorithm.create_context()\\n self.assertAlmostEqual(consensus_context.block_algorithm.calculate_score(block), meta.score)\\n\\n self.assertConsensusValid(manager)\",\n \"def valid_chain(self, chain):\\n\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n print(f'{last_block}')\\n print(f'{block}')\\n print(\\\"\\\\n-----------\\\\n\\\")\\n # Check that the hash of the block is correct\\n last_block_hash = self.hash(last_block)\\n if block['previous_hash'] != last_block_hash:\\n return False\\n\\n # Check that the Proof of Work is correct\\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def test_07(self):\\n assert 'False' == Api.requestBlock('test-07', charOrder='~!@#$%%^&*()=_+<>?/')\",\n \"def mine_block(self):\\n\\n last_block = self.__chain[-1]\\n hashed_block = hash_util.hash_block(last_block)\\n\\n proof = self.proof_of_work()\\n\\n # we are using OrderedDict to get an ordered dictionary so that the hash doesn't change due to the order changing\\n reward_transaction = Transaction('MINING', self.hosting_node, MINING_REWARD)\\n copied_transactions = self.__open_transactions[:] # copies open_transactions by value (: signifies range, if nothing is\\n # specified, then the whole list is copied\\n copied_transactions.append(reward_transaction) # reward for miners\\n\\n block = Block(len(self.__chain), hashed_block, copied_transactions, proof)\\n self.__chain.append(block)\\n self.__open_transactions = []\\n return True\",\n \"def valid_proof(block):\\n return Blockchain.hash(block) [:4] == \\\"0000\\\"\",\n \"def update_one_block(self):\\n trial_result_list = self.do_trial_on_circuits_by_cost_gradient()\\n if len(trial_result_list) != 0:\\n self.update_circuit_by_trial_result(trial_result_list)\\n print(\\\"Block added and shown below, cost now is:\\\",\\n self.current_cost)\\n print(\\\"********New Circuit********\\\")\\n print(self.circuit)\\n if not self.no_global_optimization:\\n print(\\\"Doing global optimization on the new circuit\\\")\\n self.do_global_optimization()\\n print(\\\"Global Optimized Cost:\\\", self.current_cost)\\n \\n self.cost_list.append(self.current_cost)\\n\\n if not self.not_save:\\n save_construction(self, self.save_name)\\n\\n print(\\\"Distance to target cost:\\\",\\n self.current_cost - self.terminate_cost)\\n print(\\\"Gate Usage:\\\", self.circuit.get_gate_used())\\n print(\\\"Cost list:\\\", self.cost_list)\\n if self.current_cost <= self.terminate_cost:\\n self.when_terminate_cost_achieved = len(\\n self.circuit.block_list)\\n print(\\\"Target cost achieved by\\\",\\n self.when_terminate_cost_achieved, \\\" blocks!\\\")\\n print(\\\"Construction process ends!\\\")\\n return True\\n else:\\n print(\\\"No trial circuit in the list provides a lower cost\\\")\\n return False\",\n \"def test_48(self):\\n assert 'False' == Api.requestBlock('test-48', CustomFields=True)\",\n \"def valid_chain(self, chain):\\n last_block = chain[0]\\n current_index = 1\\n\\n while current_index < len(chain):\\n block = chain[current_index]\\n # print(f'{last_block}')\\n # print(f'{block}')\\n # print(\\\"\\\\n-----------\\\\n\\\")\\n # Check that the hash of the block is correct\\n last_block_hash = self.hash(last_block)\\n if block['previous_hash'] != self.hash(last_block):\\n return False\\n\\n # Check that the Proof of Work is correct\\n if not self.valid_proof(last_block['proof'], block['proof'], last_block_hash):\\n return False\\n\\n last_block = block\\n current_index += 1\\n\\n return True\",\n \"def verify_chain():\\n\\n block_index = 0\\n is_unchanged = True\\n\\n if namoto_length < 1:\\n print('Blockchain is empty!')\\n return None\\n\\n for block in namoto_blockchain:\\n\\n if block[0] == namoto_blockchain[block_index -1]:\\n is_unchanged = True\\n block_index += 1\\n\\n else:\\n is_unchanged = False\\n break\\n\\n return is_unchanged\",\n \"def scenario():\\n LOCAL_HOST = \\\"http://127.0.0.1\\\"\\n\\n # import functions\\n from . import genesis_block\\n from . import create_block\\n from . import connect_peer\\n from . import stop_server\\n from . import block_crosscheck\\n\\n total_cnt = 0\\n pass_cnt = 0\\n\\n # 1. Check each peer's genesis block\\n try:\\n assert genesis_block.check(LOCAL_HOST, 3001)\\n assert genesis_block.check(LOCAL_HOST, 3002)\\n assert genesis_block.check(LOCAL_HOST, 3003)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/genesis_block\\\")\\n total_cnt += 1\\n\\n # 2. Generate new blocks\\n # 2.1. 2 blocks on peer #1\\n # 2.2. 4 blocks on peer #2\\n # 2.3. 2 blocks on peer #3\\n try:\\n assert create_block.addBlocks(LOCAL_HOST, 3001, num=2)\\n assert create_block.check(LOCAL_HOST, 3001, num=2)\\n\\n assert create_block.addBlocks(LOCAL_HOST, 3002, num=4)\\n assert create_block.check(LOCAL_HOST, 3002, num=4)\\n\\n assert create_block.addBlocks(LOCAL_HOST, 3003, num=2)\\n assert create_block.check(LOCAL_HOST, 3003, num=2)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/create_block\\\")\\n total_cnt += 1\\n\\n # 3. Connect peers\\n # 3.1. peer #1 with #2 (1->2)\\n # 3.2. peer #1 with #3 (1->(2 and 3))\\n try:\\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \\\"ws://127.0.0.1:6002\\\")\\n assert connect_peer.connectPeer(LOCAL_HOST, 3001, \\\"ws://127.0.0.1:6003\\\")\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/connect_peer\\\")\\n total_cnt += 1\\n\\n # 4. Generate new blocks\\n # 4.1. 3 blocks on peer #1\\n # 4.2. 5 blocks on peer #3\\n try:\\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3001, num=3)\\n assert isPass\\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=3)\\n assert block_crosscheck.check(LOCAL_HOST, 3003, newBlocks, num=3)\\n\\n isPass, newBlocks = block_crosscheck.addBlocks(LOCAL_HOST, 3003, num=5)\\n assert isPass\\n assert block_crosscheck.check(LOCAL_HOST, 3001, newBlocks, num=5)\\n assert block_crosscheck.check(LOCAL_HOST, 3002, newBlocks, num=5)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/block_crosscheck\\\")\\n total_cnt += 1\\n\\n # 5. Stop all peers\\n try:\\n assert stop_server.stopServer(LOCAL_HOST, 3001)\\n assert stop_server.stopServer(LOCAL_HOST, 3002)\\n assert stop_server.stopServer(LOCAL_HOST, 3003)\\n\\n print(\\\"pass\\\", end=' ')\\n pass_cnt += 1\\n\\n except:\\n print(\\\"FAIL\\\", end=' ')\\n\\n finally:\\n print(\\\"test1/stop_server\\\")\\n total_cnt += 1\\n\\n # return pass_cnt_per_test and total_cnt_per_test\\n return pass_cnt, total_cnt\",\n \"def block(self):\\n return self._block\",\n \"def test_simple_block(self):\\n if config.SUMLEV_BLOCK not in config.SUMLEVS:\\n pass\\n\\n blocks = self.geographies.find({ 'geoid': '150010210053029' })\\n\\n self.assertEqual(blocks.count(), 1)\\n\\n block = blocks[0]\\n\\n self.assertEqual(block['sumlev'], config.SUMLEV_BLOCK)\\n self.assertEqual(block['metadata']['NAME'], 'Block 3029')\\n self.assertEqual(block['metadata']['STATE'], '15')\\n self.assertEqual(block['metadata']['COUNTY'], '001')\\n self.assertEqual(block['metadata']['TRACT'], '021005')\\n\\n pop_2000 = 33 \\n pop_2010 = 93 \\n self._test_totalpop(block, pop_2000, pop_2010)\",\n \"def Blocking(self) -> bool:\",\n \"def test_mine_empty_transaction_block(self):\\n miner_address = 'miner_address'\\n\\n blockchain = Blockchain()\\n block = blockchain.mine(miner_address)\\n\\n # First we look that a new block could be mined\\n self.assertIsNotNone(block)\\n\\n # Let's see if the block was added to the chain\\n self.assertEqual(blockchain.last_block.hash, block.hash)\\n\\n # We need to check that the block contains only the reward transaction\\n self.assertEqual(len(block.transactions), 1)\\n\\n reward_transaction = block.transactions[0]\\n\\n # We make sure the reward function has no sender, and gives away exactly 1 coin\\n self.assertEqual(reward_transaction.sender, '0')\\n self.assertEqual(reward_transaction.recipient, miner_address)\\n self.assertEqual(reward_transaction.amount, 1)\",\n \"def verify_chain():\\n for (index,block) in enumerate(blockchain):\\n if index ==0:\\n continue\\n if block['previous_hash'] != hash_block(blockchain[index-1]):\\n return False\\n if not valid_proof(block['transactions'][:-1],block['previous_hash'],block['proof']):\\n print('Proof of Work is Invalid')\\n return False\\n return True\",\n \"def test_new_block_return_type(self):\\n block = self.blockchain.new_block(self.proof, self.previous_hash)\\n self.assertIsInstance(block, dict)\",\n \"def mine(self):\\n if self.mining_right ==True:\\n if not self.unconfirmed_transactions:\\n return False\\n\\n last_block = self.last_block\\n\\n new_block = Block(index=last_block.index + 1,\\n transactions=self.unconfirmed_transactions,\\n timestamp=time.time(),\\n previous_hash=last_block.hash)\\n\\n proof = self.proof_of_work(new_block)\\n self.add_block(new_block, proof)\\n\\n self.unconfirmed_transactions = {}\\n\\n return True\",\n \"def mine(self):\\n new_block = Block(self.block['timestamp'], self.block['car'],\\n self.block['id'])\\n # link the block to the previous block\\n new_block.previous_hash = self._get_previous_hash()\\n while True:\\n # get a hash\\n new_hash = new_block.get_hash()\\n # check hash rules, in our case check if the hash starts with\\n # self.difficulty number of zeroes\\n if new_hash[0] != self.difficulty * \\\"0\\\":\\n if self.new_block[\\\"block\\\"] is None:\\n # the hash hasn't been found yet by any other process,\\n # therefore increase the nonce and continue\\n # miners will use a different mining mechanism in order\\n # to increase the probability of finding a hash by\\n # a different miner\\n new_block.increment_nonce(self.id + 1)\\n continue\\n break\\n break\\n\\n # NOTE: May happen that two processes find the hash at the same time,\\n # because there is not a big difficulty, however, it's not a problem,\\n # for sake of the demo it's fine\\n\\n if self.new_block[\\\"block\\\"] is None:\\n # this process has found the hash first\\n print(self.id, \\\" - the winner hash\\\", new_hash)\\n new_block.hash = new_hash\\n self.new_block[\\\"block\\\"] = new_block\\n print(self.id, \\\" - mined the block\\\")\\n else:\\n # validate the block found by other process (miner)\\n if self.new_block[\\\"validated\\\"] is not False:\\n print(self.id, \\\" - validating\\\")\\n # check block's validity\\n valid = False\\n if self.new_block[\\\"block\\\"].is_block_valid():\\n # check blockchain's validity when we apply the newly\\n # mined block\\n if self.is_blockchain_valid(self.new_block[\\\"block\\\"]):\\n valid = True\\n self.new_block[\\\"validated\\\"] = valid\\n else:\\n # NOTE: this demo doesn't take into account the number of\\n # miners who approved the block, the block will be rejected\\n # if any of them rejected it\\n # but usually just more than 50% of miners must approve\\n print(self.id, \\\" - the block has been rejected by other miner\\\")\",\n \"def test_mine_simple_transaction_block(self):\\n miner_address = 'miner_address'\\n\\n blockchain = Blockchain()\\n blockchain.create_transaction('sender', 'recipient', 1)\\n blockchain.create_transaction('sender2', 'recipient2', 1.5)\\n self.assertEqual(len(blockchain.pending_transactions), 2)\\n\\n block = blockchain.mine(miner_address)\\n\\n # First we look that a new block could be mined\\n self.assertIsNotNone(block)\\n\\n # Let's see if the block was added to the chain\\n self.assertEqual(blockchain.last_block.hash, block.hash)\\n\\n # We need to check that the transaction list is empty\\n self.assertEqual(0, len(blockchain.pending_transactions))\\n\\n # We need to check that the block contains all of the transactions\\n self.assertEqual(3, len(block.transactions))\\n\\n reward_transaction = block.transactions[-1]\\n\\n # We make sure the reward function has no sender, and gives away exactly 1 coin\\n self.assertEqual('0', reward_transaction.sender)\\n self.assertEqual(miner_address, reward_transaction.recipient)\\n self.assertEqual(1, reward_transaction.amount)\",\n \"def verify_stored_block(leading_zeros: int) -> bool:\\n try:\\n with open(\\\"block.json\\\", \\\"r\\\") as file:\\n block_json = json.load(file)\\n block = Block(block_json[\\\"data\\\"], block_json[\\\"nonce\\\"], block_json[\\\"hash\\\"])\\n hash_to_verify = block.hash\\n recalculated_hash = block.get_hash()\\n\\n binary_hash_to_verify = get_binary_sha256_hash(hash_to_verify)\\n binary_recalculated_hash = get_binary_sha256_hash(recalculated_hash)\\n\\n return (\\n binary_hash_to_verify == binary_recalculated_hash\\n and binary_recalculated_hash[:leading_zeros] == \\\"0\\\" * leading_zeros\\n )\\n except FileNotFoundError:\\n print(\\\"No stored block found. Create one first\\\")\\n return False\",\n \"def isValid(self):\\n currBlock = self.getBlock(self.tailBlockHash)\\n while currBlock != self.genesisBlock:\\n if not self.isValidBlock(currBlock):\\n return False\\n currBlock = self.getBlock(currBlock.prevHash)\\n return True\",\n \"def _rpc_loaded(self):\\n try:\\n self.server.eth.getBlock(self.server.eth.blockNumber)\\n return True\\n except (web3.utils.threads.Timeout, ConnectionRefusedError, FileNotFoundError):\\n return False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7251698","0.7021523","0.70073795","0.6960257","0.6946966","0.69168705","0.6913372","0.6911039","0.69050634","0.69032633","0.68848264","0.68548423","0.6844301","0.6840599","0.68374604","0.6833395","0.68182987","0.6814433","0.6800926","0.67845434","0.6770566","0.6770326","0.676215","0.67614156","0.6755451","0.6747383","0.6742426","0.6729119","0.6717196","0.67067754","0.66924506","0.6691482","0.6675012","0.66730255","0.6648397","0.66464245","0.66392094","0.6639032","0.6632742","0.6616792","0.6602575","0.65480673","0.64943004","0.6470728","0.6461451","0.64563155","0.6443609","0.64097804","0.64001316","0.6391349","0.63553846","0.6350572","0.63393974","0.6263802","0.62550443","0.62509006","0.6231362","0.6154171","0.6149276","0.6140872","0.61285603","0.6082955","0.607187","0.6069392","0.6065315","0.60633284","0.6060566","0.60589707","0.60474914","0.6041955","0.6017133","0.60124314","0.5989907","0.5971049","0.59695023","0.5964181","0.5911516","0.59066474","0.5904579","0.59034884","0.58910227","0.58859295","0.58748674","0.5873779","0.5864723","0.58368754","0.58350253","0.5832045","0.5812952","0.58104193","0.57937616","0.579033","0.5780108","0.57767725","0.57600445","0.57519764","0.5747363","0.5741","0.57403034","0.57313186","0.57291716"],"string":"[\n \"0.7251698\",\n \"0.7021523\",\n \"0.70073795\",\n \"0.6960257\",\n \"0.6946966\",\n \"0.69168705\",\n \"0.6913372\",\n \"0.6911039\",\n \"0.69050634\",\n \"0.69032633\",\n \"0.68848264\",\n \"0.68548423\",\n \"0.6844301\",\n \"0.6840599\",\n \"0.68374604\",\n \"0.6833395\",\n \"0.68182987\",\n \"0.6814433\",\n \"0.6800926\",\n \"0.67845434\",\n \"0.6770566\",\n \"0.6770326\",\n \"0.676215\",\n \"0.67614156\",\n \"0.6755451\",\n \"0.6747383\",\n \"0.6742426\",\n \"0.6729119\",\n \"0.6717196\",\n \"0.67067754\",\n \"0.66924506\",\n \"0.6691482\",\n \"0.6675012\",\n \"0.66730255\",\n \"0.6648397\",\n \"0.66464245\",\n \"0.66392094\",\n \"0.6639032\",\n \"0.6632742\",\n \"0.6616792\",\n \"0.6602575\",\n \"0.65480673\",\n \"0.64943004\",\n \"0.6470728\",\n \"0.6461451\",\n \"0.64563155\",\n \"0.6443609\",\n \"0.64097804\",\n \"0.64001316\",\n \"0.6391349\",\n \"0.63553846\",\n \"0.6350572\",\n \"0.63393974\",\n \"0.6263802\",\n \"0.62550443\",\n \"0.62509006\",\n \"0.6231362\",\n \"0.6154171\",\n \"0.6149276\",\n \"0.6140872\",\n \"0.61285603\",\n \"0.6082955\",\n \"0.607187\",\n \"0.6069392\",\n \"0.6065315\",\n \"0.60633284\",\n \"0.6060566\",\n \"0.60589707\",\n \"0.60474914\",\n \"0.6041955\",\n \"0.6017133\",\n \"0.60124314\",\n \"0.5989907\",\n \"0.5971049\",\n \"0.59695023\",\n \"0.5964181\",\n \"0.5911516\",\n \"0.59066474\",\n \"0.5904579\",\n \"0.59034884\",\n \"0.58910227\",\n \"0.58859295\",\n \"0.58748674\",\n \"0.5873779\",\n \"0.5864723\",\n \"0.58368754\",\n \"0.58350253\",\n \"0.5832045\",\n \"0.5812952\",\n \"0.58104193\",\n \"0.57937616\",\n \"0.579033\",\n \"0.5780108\",\n \"0.57767725\",\n \"0.57600445\",\n \"0.57519764\",\n \"0.5747363\",\n \"0.5741\",\n \"0.57403034\",\n \"0.57313186\",\n \"0.57291716\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78793,"cells":{"query":{"kind":"string","value":"NYI returns true if W is a Wire standard. W must belong to the list returned by MakeBlock."},"document":{"kind":"string","value":"def IsWire(self, *args):\n return _BRepAlgo.BRepAlgo_EdgeConnector_IsWire(self, *args)"},"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 isWatt(self):\n return _libsbml.Unit_isWatt(self)","def test_wireable_object(self):\n result = attributeAsLDIF(\"dn\", WireableObject())\n self.assertEqual(result, b\"dn: wire\\n\")","def wwn(self) -> SmartSsdWwn:\n return self._wwn","def CanBalanceWithWater(self):\n try:\n extra_waters = self._ExtraWaters()\n except ReactantFormulaMissingError:\n return True\n \n return extra_waters is not None","def isWeber(self):\n return _libsbml.Unit_isWeber(self)","def has_waters(self):\n for frag in self.iter_waters():\n return True\n return False","def test_ww_layer_attributes(self):\n\t\t\n\t\tww_layer = self._get_resnet_fc_layer()\n\t\t\t\t\t\n\t\texpected_type = \"<class 'weightwatcher.weightwatcher.WWLayer'>\"\n\t\tactual_type = str(type(ww_layer))\n\t\tself.assertEqual(expected_type, actual_type)\n\t\t\n\t\t# RESET FOR WW_FLATFILES vs PYSTATEDICT vs ...\n\t\texpected_name = self.fc_layer_name \n\t\tactual_name = ww_layer.name\n\t\tself.assertEqual(expected_name, actual_name)\n\t\t\n\t\tframework_layer = ww_layer.framework_layer\n\t\tself.assertTrue(framework_layer is not None)\n\t\t\n\t\t# RESET FOR WW_FLATFILES vs PYSTATEDICT vs ...\n\t\texpected_type = self.fc_layer_type \n\t\tactual_type = str(type(framework_layer))\n\t\tself.assertEqual(expected_type, actual_type)\n\t\n\t\tself.assertEqual(ww_layer.name, framework_layer.name)\n\t\t\n\t\t\n\t\thas_weights, weights, has_biases, biases = ww_layer.get_weights_and_biases()\n\t\tself.assertTrue(has_weights)\n\t\tself.assertTrue(has_biases)\n\t\tself.assertTrue(weights is not None)\n\t\tself.assertTrue(biases is not None)\n\t\t\n\t\texpected_W_shape = (1000, 512)\n\t\texpected_B_shape = (1000,)\n\t\tactual_W_shape = weights.shape\n\t\tactual_B_shape = biases.shape\n\t\t\n\t\tself.assertEqual(expected_W_shape, actual_W_shape)\n\t\tself.assertEqual(expected_B_shape, actual_B_shape)\n\t\t\n\t\treturn","def wire_type(self):\n if hasattr(self, '_m_wire_type'):\n return self._m_wire_type if hasattr(self, '_m_wire_type') else None\n\n self._m_wire_type = self._root.Pair.WireTypes((self.key.value & 7))\n return self._m_wire_type if hasattr(self, '_m_wire_type') else None","def test_wireable_object(self):\n attributes = [\n (b\"key\", [WireableObject()]),\n ]\n result = asLDIF(WireableObject(), attributes)\n self.assertEqual(result, b\"dn: wire\\nkey: wire\\n\\n\")","def testWireConnectivity(self):\n\n wire_copied = self.board.get((4, 0))\n wire_adjacent = self.board.get((5, 0))\n\n self.assertIs(wire_adjacent, wire_copied)","def test_twwt_wire(self) -> None:\n # Generate multiple stackups, but we'll only use the largest for this test\n stackup = StackupTestHelper.create_test_stackup_list()[-1]\n for m in stackup.metals:\n # Try with 1 track (this should return a minimum width wire)\n w, s, o = m.get_width_spacing_start_twwt(1, logger=None)\n self.assertEqual(w, m.min_width)\n self.assertEqual(s, m.pitch - w)\n\n # e.g. 2 tracks:\n # | | | | | |\n # T W W T\n # e.g. 4 tracks:\n # | | | | | | | | | |\n # T --W-- --W-- T\n for num_tracks in range(2,40):\n w, s, o = m.get_width_spacing_start_twwt(num_tracks, logger=None)\n # Check that the resulting spacing is the min spacing\n self.assertGreaterEqual(s, m.get_spacing_for_width(w))\n # Check that there is no DRC\n self.assertGreaterEqual(m.pitch * (2 * num_tracks + 1), m.min_width + s*3 + w*2)\n # Check that if we increase the width slightly we get a DRC violation\n w = w + (m.grid_unit*2)\n s = m.get_spacing_for_width(w)\n self.assertLess(m.pitch * (2 * num_tracks + 1), m.min_width + s*3 + w*2)","def has_wcs(self):\n return self.wcs is not None","def TryBalanceWithWater(self): \n extra_waters = self._ExtraWaters()\n if extra_waters is None:\n # cannot balance the reaction with H2O only\n return False\n if extra_waters != 0:\n self._AddCompound('C00001', extra_waters)\n self._Dedup()\n return True","def is_owif(self):\n return self._is_owif","def is_sw_9000(self) -> bool:\n return self.sw1 == 0x90 and self.sw2 == 0x00","def test_twt_wire(self) -> None:\n # Generate multiple stackups, but we'll only use the largest for this test\n stackup = StackupTestHelper.create_test_stackup_list()[-1]\n for m in stackup.metals:\n # Try with 1 track (this should return a minimum width wire)\n w, s, o = m.get_width_spacing_start_twt(1, logger=None)\n self.assertEqual(w, m.min_width)\n self.assertEqual(s, m.pitch - w)\n\n # e.g. 2 tracks:\n # | | | |\n # T W T\n # e.g. 4 tracks:\n # | | | | | |\n # T --W-- T\n for num_tracks in range(2,40):\n w, s, o = m.get_width_spacing_start_twt(num_tracks, logger=None)\n # Check that the resulting spacing is the min spacing\n self.assertTrue(s >= m.get_spacing_for_width(w))\n # Check that there is no DRC\n self.assertGreaterEqual(m.pitch * (num_tracks + 1), m.min_width + s*2 + w)\n # Check that if we increase the width slightly we get a DRC violation\n w = w + (m.grid_unit * 2)\n s = m.get_spacing_for_width(w)\n self.assertLess(m.pitch * (num_tracks + 1), m.min_width + s*2 + w)","def _want_sym(sym):\n if sym is None or len(sym) < 2:\n return False\n if sym['name'] in extract_ignore_names:\n return False\n bad_types = ['t', 'b', 'r', 'd', 'w']\n return (sym['type'] not in bad_types\n and sym['name'] not in ['__bss_start', '_end', '_edata'])","def is_raw(self):\n return not self.has_structure","def isWave(self, wave):\n if wave is None or isinstance(wave, Wave):\n return True\n return False","def is_structure(self) -> bool:\n return ATTRIBUTE.Structure.value in self.type_data.attributes","def is_structure(self) -> bool:\n return ATTRIBUTE.Structure.value in self.type_data.attributes","def _is_network_type(self, name):\n nt = self.config[\"networks\"].get(name)\n return bool(nt)","def IsWirelessUp(self):\n return self.wifi.IsUp()","def wire_format(self) -> BaseWireFormat:\n return self._wire_format","def producer(w):\n assert isinstance(w, WireVector)\n for net in block.logic:\n for dest in net.dests:\n if dest is w:\n return net\n add_node(w, '???')\n return w","def isStation(self) -> bool:\n return self.station","def is_water(self):\n return False","def is_water(self):\n return False","def _recordIsWGS(recordStr) :\n lines = recordStr.split(\"\\n\")\n WGS_lines = [x for x in lines if x.startswith(\"WGS \")]\n if len(WGS_lines) == 1 :\n return WGS_lines[0]\n elif len(WGS_lines) == 0 :\n return False\n else :\n raise Exception(\"Several lines starting with \\\"WGS \\\" in a GenBank record\")","def is_block(self):\n\t\treturn self.name in get_elements_collection(self.__res, 'block_level')","def is_worthless(self):\n self.normalize()\n return self.all_details['normalized'] in WORTHLESS_UA_TYPES","def has_weights(obj):\n # TODO(b/110718070): Replace with isinstance(obj, base_layer.Layer).\n has_weight = (hasattr(type(obj), \"trainable_weights\")\n and hasattr(type(obj), \"non_trainable_weights\"))\n\n return has_weight and not isinstance(obj, type)","def RequireWitness(witness):\n Require(CheckWitness(witness))\n return True","def is_wif_valid(wif, allowable_netcodes=DEFAULT_NETCODES):\n return _check_against(wif, [\"wif\"], allowable_netcodes)","def is_bone(self, niBlock):\n if not niBlock :\n return False\n for bones in self.nif_import.dict_armatures.values():\n if niBlock in bones:\n return True\n return False","def is_coding(self):\n return self.wt.is_coding()","def test_wires():\n\n wires = [\"A\", 0, \"B\", -1]\n dev = _aws_device(wires=wires, device_type=AwsDeviceType.SIMULATOR, shots=0)\n\n ops = [qml.RX(0.1, wires=\"A\"), qml.CNOT(wires=[0, \"B\"]), qml.RY(0.3, wires=-1)]\n target_wires = [[0], [1, 2], [3]]\n circ = dev.apply(ops)\n\n for op, targets in zip(circ.instructions, target_wires):\n wires = op.target\n for w, t in zip(wires, targets):\n assert w == t","def regular(self):\n return all(numpy.allclose(w, w[0]) for w in self.binwidths)","def test_missing_wire(self):\r\n\r\n dev = qml.device(\"default.qubit\", wires=[\"a\", -1, \"q2\"])\r\n\r\n @qml.beta.qnode(dev)\r\n def circuit():\r\n qml.Hadamard(wires=-1)\r\n qml.CNOT(wires=[\"a\", \"q2\"])\r\n qml.RX(0.2, wires=\"a\")\r\n return qml.expval(qml.PauliX(wires=\"q2\"))\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", \"a\"])()\r\n expected = [\r\n \" q2: ──╭X───────────┤ ⟨X⟩ \",\r\n \" a: ──╰C──RX(0.2)──┤ \",\r\n \" -1: ───H───────────┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", -1])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test multiple missing wires\r\n res = qml.draw(circuit, wire_order=[\"q2\"])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)","def CheckIfWirelessConnecting(self):\n if self.wifi.connecting_thread:\n return self.wifi.connecting_thread.is_connecting\n else:\n return False","def is_wdl(schema_obj):\n\n if isinstance(schema_obj, schema.Field):\n if schema_obj.data_type == schema.Field.DataType.ENUM:\n return is_wdl(schema_obj.enum_type)\n elif schema_obj.data_type == schema.Field.DataType.STRUCT:\n return is_wdl(schema_obj.struct_type)\n else:\n wdl_prefixes = (\n 'wdl.',\n 'weave.common.',\n )\n return schema_obj.full_name.startswith(wdl_prefixes)","def test_ww_layer_iterator(self):\n\t\t\n\t\texpected_num_layers = 16\n\t\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\n\t\tself.assertTrue(layer_iterator is not None)\n\t\tnum_layers = 0\n\t\tfor ww_layer in layer_iterator:\n\t\t\tnum_layers += 1\n\t\t\tprint(ww_layer)\n\t\tself.assertEqual(expected_num_layers, num_layers)\n\t\t\n\t\t\n\t\texpected_type = \"<class 'weightwatcher.weightwatcher.WWLayer'>\"\n\t\tactual_type = str(type(ww_layer))\n\t\tself.assertEqual(expected_type, actual_type)","def is_route_throu(self):\n\n # VPR stores route-through LUTs as \"open\" blocks with mode set to\n # \"wire\".\n return self.is_leaf and self.name == \"open\" and self.mode == \"wire\"","def unknown(self, w):\n return True","def test_ww_layer_iterator(self):\n\t\t\n\t\texpected_num_layers = 21 # I think 16 is the flattened layer\n\t\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\n\t\t\n\t\tself.assertTrue(layer_iterator is not None)\n\t\tnum_layers = 0\n\t\tfor ww_layer in layer_iterator:\n\t\t\tnum_layers += 1\n\t\tself.assertEqual(expected_num_layers, num_layers)\n\t\t\n\t\t\n\t\texpected_type = \"<class 'weightwatcher.weightwatcher.WWLayer'>\"\n\t\tactual_type = str(type(ww_layer))\n\t\tself.assertEqual(expected_type, actual_type)","def _iswritemode(self, mode):\n\n # Currently only used to test the bz2 files.\n _writemodes = (\"w\", \"+\")\n for c in mode:\n if c in _writemodes:\n return True\n return False","def consumer(w):\n assert isinstance(w, WireVector)\n for net in block.logic:\n for arg in net.args:\n if arg is w:\n return net\n add_node(w, '???')\n return w","def test_ww_layer_iterator(self):\n\n\t\texpected_num_layers = 21 # I think 16 is the flattened layer\n\t\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\n\t\tself.assertTrue(layer_iterator is not None)\n\t\tnum_layers = 0\n\t\tfor ww_layer in layer_iterator:\n\t\t\tnum_layers += 1\n\t\tself.assertEqual(expected_num_layers, num_layers)\n\t\t\n\t\t\n\t\texpected_type = \"<class 'weightwatcher.weightwatcher.WWLayer'>\"\n\t\tactual_type = str(type(ww_layer))\n\t\tself.assertEqual(expected_type, actual_type)","def wireframe_only(self):\n return self._wireframe_only","def my_frame(self):\n first_byte_as_bits = bin(int(self.packet_body[self.reader], base=16))[2:].zfill(8)\n return first_byte_as_bits[0:3] == \"001\"","def is_light(self) -> bool:\n return ATTRIBUTE.Light.value in self.type_data.attributes","def is_light(self) -> bool:\n return ATTRIBUTE.Light.value in self.type_data.attributes","def testWiresAreDifferent(self):\n\n wire_original = self.board.get((0, 0))\n wire_copied = self.board.get((4, 0))\n\n self.assertIsNot(wire_original, wire_copied)","def is_part_valid(wtype, bodypart, rank):\n\n if wtype != mgc.BITE:\n return True\n\n if rank != 1:\n return True\n\n return bodypart not in INVALIDS","def IsTestNet(self) -> bool:\n return self.m_is_testnet","def proto():\n # Make a few wires and connect them to each other\n # Typically this will not be possible\n nodes = [Wire(), Nand(), Wire(), Wire(), Wire()]\n for i in range(len(nodes) - 1):\n nodes[i+1].inputs = [nodes[i]]\n\n wireWorld = World(nodes)\n print(textwrap.dedent(\"\"\"\n Wire World\n\n Standard wires propagate signal one per tick\n \"\"\"))\n for x in range(4):\n wireWorld.print()\n wireWorld.sim()\n print('----')\n\n # Make a Nand gate, connect it to itself via a wire\n nodes = [Wire(), Nand()]\n nodes[0].inputs = [nodes[1]]\n nodes[1].inputs = [nodes[0]]\n\n clockWorld = World(nodes)\n print(textwrap.dedent(\"\"\"\n Clock World\n\n Two-tick clock due to wire caching state.\n \"\"\"))\n for x in range(6):\n clockWorld.print()\n clockWorld.sim()\n print('----')\n\n # Make a Nand gate, connect it to itself via a instawire\n nodes = [InstaWire(), Nand()]\n nodes[0].inputs = [nodes[1]]\n nodes[1].inputs = [nodes[0]]\n\n instaclockWorld = World(nodes)\n print(textwrap.dedent(\"\"\"\n Instaclock World\n\n The instantaneous wire allows us to produce a one-tick clock.\n \"\"\"))\n for x in range(6):\n instaclockWorld.print()\n instaclockWorld.sim()\n print('----')","def is_Slew_allowed(self):\n handler = self.get_command_object(\"Slew\")\n return handler.check_allowed()","def wires(self):\n top_exp = TopologyUtils.TopologyExplorer(self.topods_shape(), ignore_orientation=False)\n return map(Wire, top_exp.wires())","def is_weight(self):\n return self.id in (1, 2)","def is_win(self, stone_num: int, coord: tuple) -> bool:\n\n def is_chain(stone_num: int, coord: tuple, step: tuple):\n \"\"\"\n Check whether there is an unbreakable chain of 5 stones at coord such as\n the coordinates of the adjacent stone is the coordinate of the stone +/- step\n :return: true if there is a chain of 5 stones, else false\n \"\"\"\n total = 0\n row, col = coord\n\n for i in range(5):\n if total >= 5:\n return True\n try:\n if self.board.get(row, col) == stone_num:\n total += 1\n else:\n break\n except IndexError:\n break\n row += step[0]\n col += step[1]\n\n row, col = coord\n row -= step[0]\n col -= step[1]\n\n for i in range(5):\n if total >= 5:\n return True\n try:\n if self.board.get(row, col) == stone_num:\n total += 1\n else:\n break\n except IndexError:\n break\n row -= step[0]\n col -= step[1]\n\n return False\n\n # row col diagonal\n steps = [(0, 1), (1, 0), (1, -1), (1, 1)]\n for step in steps:\n if is_chain(stone_num, coord, step):\n return True","def is_stationary(self):\n\n # in datafold there is no handling of this attribute, if required this has to\n # be implemented\n raise NotImplementedError(\"base class\")","def has_physical_io(part_w):\n try:\n io_slots = part_w.io_config.io_slots\n except AttributeError:\n # If the wrapper has no io_slots, it has no physical I/O\n return False\n\n # Doesn't count as physical I/O if description contains any of these\n non_ios = (\"USB\", \"Universal Serial Bus\", \"Graphics\", \"Empty slot\",\n \"3D Controller\")\n for io_slot in io_slots:\n try:\n # If the description *isn't* one of the non-I/O ones, it's a hit.\n if not any([non_io in io_slot.description for non_io in non_ios]):\n return True\n except AttributeError:\n # The slot didn't have a description. That shouldn't happen. But\n # we have to assume it's physical I/O in that case.\n LOG.warning(\n _(\"Assuming description-less slot is physical I/O: %s\"),\n io_slot.toxmlstring())\n return True\n # We got through all the I/O slots without finding a physical I/O adapter\n return False","def test_validate_fake_wire(self, circuit):\n with pytest.raises(ValueError, match=r\"Wire ID 4 falls outside the range \\[0, 4\\).\"):\n circuit._validate_wire_ids(wire_ids=[4])","def test_custom_wire_labels(self, tol):\n shapes = expected_shapes(1, 3)\n weights = [np.random.random(shape) for shape in shapes]\n\n dev = DummyDevice(wires=3)\n dev2 = DummyDevice(wires=[\"z\", \"a\", \"k\"])\n\n @qml.qnode(dev)\n def circuit():\n qml.CVNeuralNetLayers(*weights, wires=range(3))\n return qml.expval(qml.Identity(0))\n\n @qml.qnode(dev2)\n def circuit2():\n qml.CVNeuralNetLayers(*weights, wires=[\"z\", \"a\", \"k\"])\n return qml.expval(qml.Identity(\"z\"))\n\n circuit()\n circuit2()\n\n assert np.allclose(dev._state[0], dev2._state[0], atol=tol, rtol=0)\n assert np.allclose(dev._state[1], dev2._state[1], atol=tol, rtol=0)","def win_condition(self):\n return self.wave == 8","def Wire(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_WireDivide_Wire(self, *args)","def can_send_eth(ir):\n return isinstance(ir, Call) and ir.can_send_eth()","def write_acceptable(self):\n return self.outstanding_wcount == 0","def canSend(self):\n return self._lte.isconnected()","def wifi_connectivity_verify(self):\n self.sendline(\"iw %s link\" % self.iface_wifi)\n matched = self.expect([\"Connected\", \"Not connected\", pexpect.TIMEOUT])\n if matched == 0:\n return True\n else:\n return False","def wires(self) -> Iterator[TopoDS_Wire]:\n return map(Wire, self._top_exp.wires())","def _consistentWithWA_(self, span, lan):\n\t\tif lan == 'src':\n\t\t\twordAlign = self.waMatrix\n\t\telse:\n\t\t\twordAlign = [[self.waMatrix[i][j] for i in xrange(len(self.waMatrix))] for j in xrange(len(self.waMatrix[0]))] \n\n\t\tpos1 = [j for i in xrange(span[0], span[1]) for j in xrange(len(wordAlign[i])) if wordAlign[i][j] == 1]\n\t\tif pos1 == []: return True\n\n\t\tfor i in xrange(span[0], span[1]):\n\t\t\tfor j in xrange(min(pos1), max(pos1) + 1):\n\t\t\t\tif sum([wordAlign[row][j] for row in xrange(len(wordAlign[:span[0]]))]) == 0 and \\\n\t\t\t\t\t\tsum([wordAlign[row][j] for row in xrange(span[1], len(wordAlign))]) == 0:\n\t\t\t\t\tcontinue\n\t\t\t\telse:\n\t\t\t\t\treturn False\n\t\t#print >> debug_log, 'consistent:', span\n\t\treturn True","def is_zwj(self) -> bool:\n\n return _ZWJ in self.emoji","def set_802_11_wireless(self, pardus_profile):\n if pardus_profile.connection_type == \"802-11-wireless\":\n return _802_11_Wireless(pardus_profile)\n else:\n return \"none\"","def is_spow_enabled() -> bool:\n\n return _SPOW_ENABLED","def looks_like_a_smiles(self):\n regexp = r\"^([^J][0-9BCOHNSOPIFKcons@+\\-\\[\\]\\(\\)\\\\\\/%=#$,.~&!|Si|Se|Br|Mg|Na|Cl|Al]{3,})$\"\n return re.search(regexp, self.dirty) is not None","def is_wall_marker(self):\n return self.id in WALL","def standardize_water(mol_traj):\n if mol_traj.topology.n_atoms != 3 or mol_traj.topology.n_residues != 1:\n # This is not a water molecule.\n return False\n\n # Count oxygen and hydrogens in molecule and save their indices.\n atom_element_ids = {'O': [], 'H': []}\n for atom_index, atom in enumerate(mol_traj.topology.atoms):\n try:\n atom_element_ids[atom.element.symbol].append(atom_index)\n except KeyError:\n # There's an element different than oxygen or hydrogen.\n return False\n\n # This is water if there are two hydrogens and an oxygen.\n if not (len(atom_element_ids['O']) == 1 and len(atom_element_ids['H']) == 2):\n return False\n\n # Rename residue and atoms.\n mol_traj.topology.residue(0).name = 'HOH'\n [o_index], [h1_index, h2_index] = atom_element_ids['O'], atom_element_ids['H']\n for index, std_name in zip([o_index, h1_index, h2_index], ['O', 'H1', 'H2']):\n mol_traj.topology.atom(index).name = std_name\n\n # Update bonds now that water residue is standard.\n mol_traj.topology.create_standard_bonds()\n return True","def is_pure(self) -> bool:\n return self.w==0.0","def _network_trunk_supported(self):\n if 'trunk' in self.network_extensions:\n return True\n return False","def yield_ties_to_wire(wire):\n if wire not in WIRE_TIE_OPTIONS:\n return\n\n for constant in WIRE_TIE_OPTIONS[wire]:\n yield constant","def is_strobe(self):\n if self._driver is None and not self._strobers:\n raise ValueError(\n 'internal %s is not driven by anything' % self._name)\n return bool(self._strobers)","def is_tx(self):\n return self._pin_name in TX_CHANNELS","def is_block(modules):\n if isinstance(modules, (BasicBlock, Bottleneck)):\n return True\n return False","def is_on(self):\n return self.wink.state()","def check_topology(self, ninputs, noutputs):\n return _spacegrant_swig.general_burster_2_sptr_check_topology(self, ninputs, noutputs)","def has_wcs(self):\n if self.header is None:\n return False\n\n required = 'CRPIX,CRVAL,CTYPE'.split(',')\n keywords = np.concatenate(\n [(lambda i: [r+str(i+1) for r in required])(i) \n for i in range(self.header['NAXIS'])])\n\n return all([k in self.header for k in keywords])","def is_connected(self):\n return self._ws is not None","def HasWiredDriver(self):\n if self.wired.driver:\n return True\n else:\n return False","def is_mine(self) -> bool:\n return self.proto.alliance == ALLIANCE.Self.value","def test_show_all_wires_true(self):\n\n ops = [qml.PauliX(\"a\"), qml.PauliY(\"c\")]\n wire_order = [\"a\", \"b\", \"c\", \"d\"]\n\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=True)\n assert wire_map == {\"a\": 0, \"b\": 1, \"c\": 2, \"d\": 3}","def is_logical(self):\n\t\treturn bool(call_sdk_function('PrlSrvCfgHddPart_IsLogical', self.handle))","def is_work(self):\n from .works import Work\n return isinstance(self, Work)","def is_bossa_nova(self, strict = False):\n strings_binary = []\n for i in self.notes:\n if i.name in ['MUTE','NULL']:\n strings_binary += [0]\n else:\n strings_binary += [1]\n result = True if sum(strings_binary) == 4 else False\n if strict and result:\n valid_patterns = [\n [1,1,1,1,0,0],\n [1,0,1,1,1,0],\n [1,0,0,1,1,1],\n [0,1,1,1,1,0],\n [0,1,0,1,1,1],\n [0,0,1,1,1,1]\n ]\n result = True if strings_binary in valid_patterns else False\n self.bossa_nova = result\n return self.bossa_nova","def is_stationary(self):\n return self.kernel.is_stationary()","def test_ww_layer_iterator(self):\n\t\t\n\t\t# this wont work for Resnet models because we dont support lazy loading of Conv2D yet\n\t\t\t\t\n\t\tlogger = logging.getLogger(ww.__name__)\n\t\tlogger.setLevel(logging.DEBUG)\n\t\t\n\t\texpected_num_layers = 21 # I think 16 is the flattened layer\n\n\t\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\n\t\t\n\t\tself.assertTrue(layer_iterator is not None)\n\t\tnum_layers = 0\n\t\tfor ww_layer in layer_iterator:\n\t\t\tnum_layers += 1\n\t\tself.assertEqual(expected_num_layers, num_layers)\n\t\tprint(num_layers)\n\t\t\n\t\t\n\t\texpected_type = \"<class 'weightwatcher.weightwatcher.WWLayer'>\"\n\t\tactual_type = str(type(ww_layer))\n\t\tself.assertEqual(expected_type, actual_type)\n\n\t\t\n\t\treturn","def test_missing_wire():\r\n\r\n dev = qml.device(\"default.qubit\", wires=[\"a\", -1, \"q2\"])\r\n\r\n @qml.beta.qnode(dev)\r\n def circuit():\r\n qml.Hadamard(wires=-1)\r\n qml.CNOT(wires=[\"a\", \"q2\"])\r\n qml.RX(0.2, wires=\"a\")\r\n return qml.expval(qml.PauliX(wires=\"q2\"))\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", \"a\"])()\r\n expected = [\r\n \" q2: ──╭X───────────┤ ⟨X⟩ \",\r\n \" a: ──╰C──RX(0.2)──┤ \",\r\n \" -1: ───H───────────┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test one missing wire\r\n res = qml.draw(circuit, wire_order=[\"q2\", -1])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)\r\n\r\n # test multiple missing wires\r\n res = qml.draw(circuit, wire_order=[\"q2\"])()\r\n expected = [\r\n \" q2: ─────╭X───────────┤ ⟨X⟩ \",\r\n \" -1: ──H──│────────────┤ \",\r\n \" a: ─────╰C──RX(0.2)──┤ \\n\",\r\n ]\r\n\r\n assert res == \"\\n\".join(expected)","def _is_wiz(agent: Agent):\n return agent.agent_id == 'Wizard'","def test_show_all_wires_false(self):\n\n ops = [qml.PauliX(\"a\"), qml.PauliY(\"c\")]\n wire_order = [\"a\", \"b\", \"c\", \"d\"]\n\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=False)\n assert wire_map == {\"a\": 0, \"c\": 1}","def wwn(self, wwn: SmartSsdWwn):\n\n self._wwn = wwn"],"string":"[\n \"def isWatt(self):\\n return _libsbml.Unit_isWatt(self)\",\n \"def test_wireable_object(self):\\n result = attributeAsLDIF(\\\"dn\\\", WireableObject())\\n self.assertEqual(result, b\\\"dn: wire\\\\n\\\")\",\n \"def wwn(self) -> SmartSsdWwn:\\n return self._wwn\",\n \"def CanBalanceWithWater(self):\\n try:\\n extra_waters = self._ExtraWaters()\\n except ReactantFormulaMissingError:\\n return True\\n \\n return extra_waters is not None\",\n \"def isWeber(self):\\n return _libsbml.Unit_isWeber(self)\",\n \"def has_waters(self):\\n for frag in self.iter_waters():\\n return True\\n return False\",\n \"def test_ww_layer_attributes(self):\\n\\t\\t\\n\\t\\tww_layer = self._get_resnet_fc_layer()\\n\\t\\t\\t\\t\\t\\n\\t\\texpected_type = \\\"<class 'weightwatcher.weightwatcher.WWLayer'>\\\"\\n\\t\\tactual_type = str(type(ww_layer))\\n\\t\\tself.assertEqual(expected_type, actual_type)\\n\\t\\t\\n\\t\\t# RESET FOR WW_FLATFILES vs PYSTATEDICT vs ...\\n\\t\\texpected_name = self.fc_layer_name \\n\\t\\tactual_name = ww_layer.name\\n\\t\\tself.assertEqual(expected_name, actual_name)\\n\\t\\t\\n\\t\\tframework_layer = ww_layer.framework_layer\\n\\t\\tself.assertTrue(framework_layer is not None)\\n\\t\\t\\n\\t\\t# RESET FOR WW_FLATFILES vs PYSTATEDICT vs ...\\n\\t\\texpected_type = self.fc_layer_type \\n\\t\\tactual_type = str(type(framework_layer))\\n\\t\\tself.assertEqual(expected_type, actual_type)\\n\\t\\n\\t\\tself.assertEqual(ww_layer.name, framework_layer.name)\\n\\t\\t\\n\\t\\t\\n\\t\\thas_weights, weights, has_biases, biases = ww_layer.get_weights_and_biases()\\n\\t\\tself.assertTrue(has_weights)\\n\\t\\tself.assertTrue(has_biases)\\n\\t\\tself.assertTrue(weights is not None)\\n\\t\\tself.assertTrue(biases is not None)\\n\\t\\t\\n\\t\\texpected_W_shape = (1000, 512)\\n\\t\\texpected_B_shape = (1000,)\\n\\t\\tactual_W_shape = weights.shape\\n\\t\\tactual_B_shape = biases.shape\\n\\t\\t\\n\\t\\tself.assertEqual(expected_W_shape, actual_W_shape)\\n\\t\\tself.assertEqual(expected_B_shape, actual_B_shape)\\n\\t\\t\\n\\t\\treturn\",\n \"def wire_type(self):\\n if hasattr(self, '_m_wire_type'):\\n return self._m_wire_type if hasattr(self, '_m_wire_type') else None\\n\\n self._m_wire_type = self._root.Pair.WireTypes((self.key.value & 7))\\n return self._m_wire_type if hasattr(self, '_m_wire_type') else None\",\n \"def test_wireable_object(self):\\n attributes = [\\n (b\\\"key\\\", [WireableObject()]),\\n ]\\n result = asLDIF(WireableObject(), attributes)\\n self.assertEqual(result, b\\\"dn: wire\\\\nkey: wire\\\\n\\\\n\\\")\",\n \"def testWireConnectivity(self):\\n\\n wire_copied = self.board.get((4, 0))\\n wire_adjacent = self.board.get((5, 0))\\n\\n self.assertIs(wire_adjacent, wire_copied)\",\n \"def test_twwt_wire(self) -> None:\\n # Generate multiple stackups, but we'll only use the largest for this test\\n stackup = StackupTestHelper.create_test_stackup_list()[-1]\\n for m in stackup.metals:\\n # Try with 1 track (this should return a minimum width wire)\\n w, s, o = m.get_width_spacing_start_twwt(1, logger=None)\\n self.assertEqual(w, m.min_width)\\n self.assertEqual(s, m.pitch - w)\\n\\n # e.g. 2 tracks:\\n # | | | | | |\\n # T W W T\\n # e.g. 4 tracks:\\n # | | | | | | | | | |\\n # T --W-- --W-- T\\n for num_tracks in range(2,40):\\n w, s, o = m.get_width_spacing_start_twwt(num_tracks, logger=None)\\n # Check that the resulting spacing is the min spacing\\n self.assertGreaterEqual(s, m.get_spacing_for_width(w))\\n # Check that there is no DRC\\n self.assertGreaterEqual(m.pitch * (2 * num_tracks + 1), m.min_width + s*3 + w*2)\\n # Check that if we increase the width slightly we get a DRC violation\\n w = w + (m.grid_unit*2)\\n s = m.get_spacing_for_width(w)\\n self.assertLess(m.pitch * (2 * num_tracks + 1), m.min_width + s*3 + w*2)\",\n \"def has_wcs(self):\\n return self.wcs is not None\",\n \"def TryBalanceWithWater(self): \\n extra_waters = self._ExtraWaters()\\n if extra_waters is None:\\n # cannot balance the reaction with H2O only\\n return False\\n if extra_waters != 0:\\n self._AddCompound('C00001', extra_waters)\\n self._Dedup()\\n return True\",\n \"def is_owif(self):\\n return self._is_owif\",\n \"def is_sw_9000(self) -> bool:\\n return self.sw1 == 0x90 and self.sw2 == 0x00\",\n \"def test_twt_wire(self) -> None:\\n # Generate multiple stackups, but we'll only use the largest for this test\\n stackup = StackupTestHelper.create_test_stackup_list()[-1]\\n for m in stackup.metals:\\n # Try with 1 track (this should return a minimum width wire)\\n w, s, o = m.get_width_spacing_start_twt(1, logger=None)\\n self.assertEqual(w, m.min_width)\\n self.assertEqual(s, m.pitch - w)\\n\\n # e.g. 2 tracks:\\n # | | | |\\n # T W T\\n # e.g. 4 tracks:\\n # | | | | | |\\n # T --W-- T\\n for num_tracks in range(2,40):\\n w, s, o = m.get_width_spacing_start_twt(num_tracks, logger=None)\\n # Check that the resulting spacing is the min spacing\\n self.assertTrue(s >= m.get_spacing_for_width(w))\\n # Check that there is no DRC\\n self.assertGreaterEqual(m.pitch * (num_tracks + 1), m.min_width + s*2 + w)\\n # Check that if we increase the width slightly we get a DRC violation\\n w = w + (m.grid_unit * 2)\\n s = m.get_spacing_for_width(w)\\n self.assertLess(m.pitch * (num_tracks + 1), m.min_width + s*2 + w)\",\n \"def _want_sym(sym):\\n if sym is None or len(sym) < 2:\\n return False\\n if sym['name'] in extract_ignore_names:\\n return False\\n bad_types = ['t', 'b', 'r', 'd', 'w']\\n return (sym['type'] not in bad_types\\n and sym['name'] not in ['__bss_start', '_end', '_edata'])\",\n \"def is_raw(self):\\n return not self.has_structure\",\n \"def isWave(self, wave):\\n if wave is None or isinstance(wave, Wave):\\n return True\\n return False\",\n \"def is_structure(self) -> bool:\\n return ATTRIBUTE.Structure.value in self.type_data.attributes\",\n \"def is_structure(self) -> bool:\\n return ATTRIBUTE.Structure.value in self.type_data.attributes\",\n \"def _is_network_type(self, name):\\n nt = self.config[\\\"networks\\\"].get(name)\\n return bool(nt)\",\n \"def IsWirelessUp(self):\\n return self.wifi.IsUp()\",\n \"def wire_format(self) -> BaseWireFormat:\\n return self._wire_format\",\n \"def producer(w):\\n assert isinstance(w, WireVector)\\n for net in block.logic:\\n for dest in net.dests:\\n if dest is w:\\n return net\\n add_node(w, '???')\\n return w\",\n \"def isStation(self) -> bool:\\n return self.station\",\n \"def is_water(self):\\n return False\",\n \"def is_water(self):\\n return False\",\n \"def _recordIsWGS(recordStr) :\\n lines = recordStr.split(\\\"\\\\n\\\")\\n WGS_lines = [x for x in lines if x.startswith(\\\"WGS \\\")]\\n if len(WGS_lines) == 1 :\\n return WGS_lines[0]\\n elif len(WGS_lines) == 0 :\\n return False\\n else :\\n raise Exception(\\\"Several lines starting with \\\\\\\"WGS \\\\\\\" in a GenBank record\\\")\",\n \"def is_block(self):\\n\\t\\treturn self.name in get_elements_collection(self.__res, 'block_level')\",\n \"def is_worthless(self):\\n self.normalize()\\n return self.all_details['normalized'] in WORTHLESS_UA_TYPES\",\n \"def has_weights(obj):\\n # TODO(b/110718070): Replace with isinstance(obj, base_layer.Layer).\\n has_weight = (hasattr(type(obj), \\\"trainable_weights\\\")\\n and hasattr(type(obj), \\\"non_trainable_weights\\\"))\\n\\n return has_weight and not isinstance(obj, type)\",\n \"def RequireWitness(witness):\\n Require(CheckWitness(witness))\\n return True\",\n \"def is_wif_valid(wif, allowable_netcodes=DEFAULT_NETCODES):\\n return _check_against(wif, [\\\"wif\\\"], allowable_netcodes)\",\n \"def is_bone(self, niBlock):\\n if not niBlock :\\n return False\\n for bones in self.nif_import.dict_armatures.values():\\n if niBlock in bones:\\n return True\\n return False\",\n \"def is_coding(self):\\n return self.wt.is_coding()\",\n \"def test_wires():\\n\\n wires = [\\\"A\\\", 0, \\\"B\\\", -1]\\n dev = _aws_device(wires=wires, device_type=AwsDeviceType.SIMULATOR, shots=0)\\n\\n ops = [qml.RX(0.1, wires=\\\"A\\\"), qml.CNOT(wires=[0, \\\"B\\\"]), qml.RY(0.3, wires=-1)]\\n target_wires = [[0], [1, 2], [3]]\\n circ = dev.apply(ops)\\n\\n for op, targets in zip(circ.instructions, target_wires):\\n wires = op.target\\n for w, t in zip(wires, targets):\\n assert w == t\",\n \"def regular(self):\\n return all(numpy.allclose(w, w[0]) for w in self.binwidths)\",\n \"def test_missing_wire(self):\\r\\n\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=[\\\"a\\\", -1, \\\"q2\\\"])\\r\\n\\r\\n @qml.beta.qnode(dev)\\r\\n def circuit():\\r\\n qml.Hadamard(wires=-1)\\r\\n qml.CNOT(wires=[\\\"a\\\", \\\"q2\\\"])\\r\\n qml.RX(0.2, wires=\\\"a\\\")\\r\\n return qml.expval(qml.PauliX(wires=\\\"q2\\\"))\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", \\\"a\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ──╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" a: ──╰C──RX(0.2)──┤ \\\",\\r\\n \\\" -1: ───H───────────┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", -1])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test multiple missing wires\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\",\n \"def CheckIfWirelessConnecting(self):\\n if self.wifi.connecting_thread:\\n return self.wifi.connecting_thread.is_connecting\\n else:\\n return False\",\n \"def is_wdl(schema_obj):\\n\\n if isinstance(schema_obj, schema.Field):\\n if schema_obj.data_type == schema.Field.DataType.ENUM:\\n return is_wdl(schema_obj.enum_type)\\n elif schema_obj.data_type == schema.Field.DataType.STRUCT:\\n return is_wdl(schema_obj.struct_type)\\n else:\\n wdl_prefixes = (\\n 'wdl.',\\n 'weave.common.',\\n )\\n return schema_obj.full_name.startswith(wdl_prefixes)\",\n \"def test_ww_layer_iterator(self):\\n\\t\\t\\n\\t\\texpected_num_layers = 16\\n\\t\\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\\n\\t\\tself.assertTrue(layer_iterator is not None)\\n\\t\\tnum_layers = 0\\n\\t\\tfor ww_layer in layer_iterator:\\n\\t\\t\\tnum_layers += 1\\n\\t\\t\\tprint(ww_layer)\\n\\t\\tself.assertEqual(expected_num_layers, num_layers)\\n\\t\\t\\n\\t\\t\\n\\t\\texpected_type = \\\"<class 'weightwatcher.weightwatcher.WWLayer'>\\\"\\n\\t\\tactual_type = str(type(ww_layer))\\n\\t\\tself.assertEqual(expected_type, actual_type)\",\n \"def is_route_throu(self):\\n\\n # VPR stores route-through LUTs as \\\"open\\\" blocks with mode set to\\n # \\\"wire\\\".\\n return self.is_leaf and self.name == \\\"open\\\" and self.mode == \\\"wire\\\"\",\n \"def unknown(self, w):\\n return True\",\n \"def test_ww_layer_iterator(self):\\n\\t\\t\\n\\t\\texpected_num_layers = 21 # I think 16 is the flattened layer\\n\\t\\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\\n\\t\\t\\n\\t\\tself.assertTrue(layer_iterator is not None)\\n\\t\\tnum_layers = 0\\n\\t\\tfor ww_layer in layer_iterator:\\n\\t\\t\\tnum_layers += 1\\n\\t\\tself.assertEqual(expected_num_layers, num_layers)\\n\\t\\t\\n\\t\\t\\n\\t\\texpected_type = \\\"<class 'weightwatcher.weightwatcher.WWLayer'>\\\"\\n\\t\\tactual_type = str(type(ww_layer))\\n\\t\\tself.assertEqual(expected_type, actual_type)\",\n \"def _iswritemode(self, mode):\\n\\n # Currently only used to test the bz2 files.\\n _writemodes = (\\\"w\\\", \\\"+\\\")\\n for c in mode:\\n if c in _writemodes:\\n return True\\n return False\",\n \"def consumer(w):\\n assert isinstance(w, WireVector)\\n for net in block.logic:\\n for arg in net.args:\\n if arg is w:\\n return net\\n add_node(w, '???')\\n return w\",\n \"def test_ww_layer_iterator(self):\\n\\n\\t\\texpected_num_layers = 21 # I think 16 is the flattened layer\\n\\t\\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\\n\\t\\tself.assertTrue(layer_iterator is not None)\\n\\t\\tnum_layers = 0\\n\\t\\tfor ww_layer in layer_iterator:\\n\\t\\t\\tnum_layers += 1\\n\\t\\tself.assertEqual(expected_num_layers, num_layers)\\n\\t\\t\\n\\t\\t\\n\\t\\texpected_type = \\\"<class 'weightwatcher.weightwatcher.WWLayer'>\\\"\\n\\t\\tactual_type = str(type(ww_layer))\\n\\t\\tself.assertEqual(expected_type, actual_type)\",\n \"def wireframe_only(self):\\n return self._wireframe_only\",\n \"def my_frame(self):\\n first_byte_as_bits = bin(int(self.packet_body[self.reader], base=16))[2:].zfill(8)\\n return first_byte_as_bits[0:3] == \\\"001\\\"\",\n \"def is_light(self) -> bool:\\n return ATTRIBUTE.Light.value in self.type_data.attributes\",\n \"def is_light(self) -> bool:\\n return ATTRIBUTE.Light.value in self.type_data.attributes\",\n \"def testWiresAreDifferent(self):\\n\\n wire_original = self.board.get((0, 0))\\n wire_copied = self.board.get((4, 0))\\n\\n self.assertIsNot(wire_original, wire_copied)\",\n \"def is_part_valid(wtype, bodypart, rank):\\n\\n if wtype != mgc.BITE:\\n return True\\n\\n if rank != 1:\\n return True\\n\\n return bodypart not in INVALIDS\",\n \"def IsTestNet(self) -> bool:\\n return self.m_is_testnet\",\n \"def proto():\\n # Make a few wires and connect them to each other\\n # Typically this will not be possible\\n nodes = [Wire(), Nand(), Wire(), Wire(), Wire()]\\n for i in range(len(nodes) - 1):\\n nodes[i+1].inputs = [nodes[i]]\\n\\n wireWorld = World(nodes)\\n print(textwrap.dedent(\\\"\\\"\\\"\\n Wire World\\n\\n Standard wires propagate signal one per tick\\n \\\"\\\"\\\"))\\n for x in range(4):\\n wireWorld.print()\\n wireWorld.sim()\\n print('----')\\n\\n # Make a Nand gate, connect it to itself via a wire\\n nodes = [Wire(), Nand()]\\n nodes[0].inputs = [nodes[1]]\\n nodes[1].inputs = [nodes[0]]\\n\\n clockWorld = World(nodes)\\n print(textwrap.dedent(\\\"\\\"\\\"\\n Clock World\\n\\n Two-tick clock due to wire caching state.\\n \\\"\\\"\\\"))\\n for x in range(6):\\n clockWorld.print()\\n clockWorld.sim()\\n print('----')\\n\\n # Make a Nand gate, connect it to itself via a instawire\\n nodes = [InstaWire(), Nand()]\\n nodes[0].inputs = [nodes[1]]\\n nodes[1].inputs = [nodes[0]]\\n\\n instaclockWorld = World(nodes)\\n print(textwrap.dedent(\\\"\\\"\\\"\\n Instaclock World\\n\\n The instantaneous wire allows us to produce a one-tick clock.\\n \\\"\\\"\\\"))\\n for x in range(6):\\n instaclockWorld.print()\\n instaclockWorld.sim()\\n print('----')\",\n \"def is_Slew_allowed(self):\\n handler = self.get_command_object(\\\"Slew\\\")\\n return handler.check_allowed()\",\n \"def wires(self):\\n top_exp = TopologyUtils.TopologyExplorer(self.topods_shape(), ignore_orientation=False)\\n return map(Wire, top_exp.wires())\",\n \"def is_weight(self):\\n return self.id in (1, 2)\",\n \"def is_win(self, stone_num: int, coord: tuple) -> bool:\\n\\n def is_chain(stone_num: int, coord: tuple, step: tuple):\\n \\\"\\\"\\\"\\n Check whether there is an unbreakable chain of 5 stones at coord such as\\n the coordinates of the adjacent stone is the coordinate of the stone +/- step\\n :return: true if there is a chain of 5 stones, else false\\n \\\"\\\"\\\"\\n total = 0\\n row, col = coord\\n\\n for i in range(5):\\n if total >= 5:\\n return True\\n try:\\n if self.board.get(row, col) == stone_num:\\n total += 1\\n else:\\n break\\n except IndexError:\\n break\\n row += step[0]\\n col += step[1]\\n\\n row, col = coord\\n row -= step[0]\\n col -= step[1]\\n\\n for i in range(5):\\n if total >= 5:\\n return True\\n try:\\n if self.board.get(row, col) == stone_num:\\n total += 1\\n else:\\n break\\n except IndexError:\\n break\\n row -= step[0]\\n col -= step[1]\\n\\n return False\\n\\n # row col diagonal\\n steps = [(0, 1), (1, 0), (1, -1), (1, 1)]\\n for step in steps:\\n if is_chain(stone_num, coord, step):\\n return True\",\n \"def is_stationary(self):\\n\\n # in datafold there is no handling of this attribute, if required this has to\\n # be implemented\\n raise NotImplementedError(\\\"base class\\\")\",\n \"def has_physical_io(part_w):\\n try:\\n io_slots = part_w.io_config.io_slots\\n except AttributeError:\\n # If the wrapper has no io_slots, it has no physical I/O\\n return False\\n\\n # Doesn't count as physical I/O if description contains any of these\\n non_ios = (\\\"USB\\\", \\\"Universal Serial Bus\\\", \\\"Graphics\\\", \\\"Empty slot\\\",\\n \\\"3D Controller\\\")\\n for io_slot in io_slots:\\n try:\\n # If the description *isn't* one of the non-I/O ones, it's a hit.\\n if not any([non_io in io_slot.description for non_io in non_ios]):\\n return True\\n except AttributeError:\\n # The slot didn't have a description. That shouldn't happen. But\\n # we have to assume it's physical I/O in that case.\\n LOG.warning(\\n _(\\\"Assuming description-less slot is physical I/O: %s\\\"),\\n io_slot.toxmlstring())\\n return True\\n # We got through all the I/O slots without finding a physical I/O adapter\\n return False\",\n \"def test_validate_fake_wire(self, circuit):\\n with pytest.raises(ValueError, match=r\\\"Wire ID 4 falls outside the range \\\\[0, 4\\\\).\\\"):\\n circuit._validate_wire_ids(wire_ids=[4])\",\n \"def test_custom_wire_labels(self, tol):\\n shapes = expected_shapes(1, 3)\\n weights = [np.random.random(shape) for shape in shapes]\\n\\n dev = DummyDevice(wires=3)\\n dev2 = DummyDevice(wires=[\\\"z\\\", \\\"a\\\", \\\"k\\\"])\\n\\n @qml.qnode(dev)\\n def circuit():\\n qml.CVNeuralNetLayers(*weights, wires=range(3))\\n return qml.expval(qml.Identity(0))\\n\\n @qml.qnode(dev2)\\n def circuit2():\\n qml.CVNeuralNetLayers(*weights, wires=[\\\"z\\\", \\\"a\\\", \\\"k\\\"])\\n return qml.expval(qml.Identity(\\\"z\\\"))\\n\\n circuit()\\n circuit2()\\n\\n assert np.allclose(dev._state[0], dev2._state[0], atol=tol, rtol=0)\\n assert np.allclose(dev._state[1], dev2._state[1], atol=tol, rtol=0)\",\n \"def win_condition(self):\\n return self.wave == 8\",\n \"def Wire(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_WireDivide_Wire(self, *args)\",\n \"def can_send_eth(ir):\\n return isinstance(ir, Call) and ir.can_send_eth()\",\n \"def write_acceptable(self):\\n return self.outstanding_wcount == 0\",\n \"def canSend(self):\\n return self._lte.isconnected()\",\n \"def wifi_connectivity_verify(self):\\n self.sendline(\\\"iw %s link\\\" % self.iface_wifi)\\n matched = self.expect([\\\"Connected\\\", \\\"Not connected\\\", pexpect.TIMEOUT])\\n if matched == 0:\\n return True\\n else:\\n return False\",\n \"def wires(self) -> Iterator[TopoDS_Wire]:\\n return map(Wire, self._top_exp.wires())\",\n \"def _consistentWithWA_(self, span, lan):\\n\\t\\tif lan == 'src':\\n\\t\\t\\twordAlign = self.waMatrix\\n\\t\\telse:\\n\\t\\t\\twordAlign = [[self.waMatrix[i][j] for i in xrange(len(self.waMatrix))] for j in xrange(len(self.waMatrix[0]))] \\n\\n\\t\\tpos1 = [j for i in xrange(span[0], span[1]) for j in xrange(len(wordAlign[i])) if wordAlign[i][j] == 1]\\n\\t\\tif pos1 == []: return True\\n\\n\\t\\tfor i in xrange(span[0], span[1]):\\n\\t\\t\\tfor j in xrange(min(pos1), max(pos1) + 1):\\n\\t\\t\\t\\tif sum([wordAlign[row][j] for row in xrange(len(wordAlign[:span[0]]))]) == 0 and \\\\\\n\\t\\t\\t\\t\\t\\tsum([wordAlign[row][j] for row in xrange(span[1], len(wordAlign))]) == 0:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t#print >> debug_log, 'consistent:', span\\n\\t\\treturn True\",\n \"def is_zwj(self) -> bool:\\n\\n return _ZWJ in self.emoji\",\n \"def set_802_11_wireless(self, pardus_profile):\\n if pardus_profile.connection_type == \\\"802-11-wireless\\\":\\n return _802_11_Wireless(pardus_profile)\\n else:\\n return \\\"none\\\"\",\n \"def is_spow_enabled() -> bool:\\n\\n return _SPOW_ENABLED\",\n \"def looks_like_a_smiles(self):\\n regexp = r\\\"^([^J][0-9BCOHNSOPIFKcons@+\\\\-\\\\[\\\\]\\\\(\\\\)\\\\\\\\\\\\/%=#$,.~&!|Si|Se|Br|Mg|Na|Cl|Al]{3,})$\\\"\\n return re.search(regexp, self.dirty) is not None\",\n \"def is_wall_marker(self):\\n return self.id in WALL\",\n \"def standardize_water(mol_traj):\\n if mol_traj.topology.n_atoms != 3 or mol_traj.topology.n_residues != 1:\\n # This is not a water molecule.\\n return False\\n\\n # Count oxygen and hydrogens in molecule and save their indices.\\n atom_element_ids = {'O': [], 'H': []}\\n for atom_index, atom in enumerate(mol_traj.topology.atoms):\\n try:\\n atom_element_ids[atom.element.symbol].append(atom_index)\\n except KeyError:\\n # There's an element different than oxygen or hydrogen.\\n return False\\n\\n # This is water if there are two hydrogens and an oxygen.\\n if not (len(atom_element_ids['O']) == 1 and len(atom_element_ids['H']) == 2):\\n return False\\n\\n # Rename residue and atoms.\\n mol_traj.topology.residue(0).name = 'HOH'\\n [o_index], [h1_index, h2_index] = atom_element_ids['O'], atom_element_ids['H']\\n for index, std_name in zip([o_index, h1_index, h2_index], ['O', 'H1', 'H2']):\\n mol_traj.topology.atom(index).name = std_name\\n\\n # Update bonds now that water residue is standard.\\n mol_traj.topology.create_standard_bonds()\\n return True\",\n \"def is_pure(self) -> bool:\\n return self.w==0.0\",\n \"def _network_trunk_supported(self):\\n if 'trunk' in self.network_extensions:\\n return True\\n return False\",\n \"def yield_ties_to_wire(wire):\\n if wire not in WIRE_TIE_OPTIONS:\\n return\\n\\n for constant in WIRE_TIE_OPTIONS[wire]:\\n yield constant\",\n \"def is_strobe(self):\\n if self._driver is None and not self._strobers:\\n raise ValueError(\\n 'internal %s is not driven by anything' % self._name)\\n return bool(self._strobers)\",\n \"def is_tx(self):\\n return self._pin_name in TX_CHANNELS\",\n \"def is_block(modules):\\n if isinstance(modules, (BasicBlock, Bottleneck)):\\n return True\\n return False\",\n \"def is_on(self):\\n return self.wink.state()\",\n \"def check_topology(self, ninputs, noutputs):\\n return _spacegrant_swig.general_burster_2_sptr_check_topology(self, ninputs, noutputs)\",\n \"def has_wcs(self):\\n if self.header is None:\\n return False\\n\\n required = 'CRPIX,CRVAL,CTYPE'.split(',')\\n keywords = np.concatenate(\\n [(lambda i: [r+str(i+1) for r in required])(i) \\n for i in range(self.header['NAXIS'])])\\n\\n return all([k in self.header for k in keywords])\",\n \"def is_connected(self):\\n return self._ws is not None\",\n \"def HasWiredDriver(self):\\n if self.wired.driver:\\n return True\\n else:\\n return False\",\n \"def is_mine(self) -> bool:\\n return self.proto.alliance == ALLIANCE.Self.value\",\n \"def test_show_all_wires_true(self):\\n\\n ops = [qml.PauliX(\\\"a\\\"), qml.PauliY(\\\"c\\\")]\\n wire_order = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\"]\\n\\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=True)\\n assert wire_map == {\\\"a\\\": 0, \\\"b\\\": 1, \\\"c\\\": 2, \\\"d\\\": 3}\",\n \"def is_logical(self):\\n\\t\\treturn bool(call_sdk_function('PrlSrvCfgHddPart_IsLogical', self.handle))\",\n \"def is_work(self):\\n from .works import Work\\n return isinstance(self, Work)\",\n \"def is_bossa_nova(self, strict = False):\\n strings_binary = []\\n for i in self.notes:\\n if i.name in ['MUTE','NULL']:\\n strings_binary += [0]\\n else:\\n strings_binary += [1]\\n result = True if sum(strings_binary) == 4 else False\\n if strict and result:\\n valid_patterns = [\\n [1,1,1,1,0,0],\\n [1,0,1,1,1,0],\\n [1,0,0,1,1,1],\\n [0,1,1,1,1,0],\\n [0,1,0,1,1,1],\\n [0,0,1,1,1,1]\\n ]\\n result = True if strings_binary in valid_patterns else False\\n self.bossa_nova = result\\n return self.bossa_nova\",\n \"def is_stationary(self):\\n return self.kernel.is_stationary()\",\n \"def test_ww_layer_iterator(self):\\n\\t\\t\\n\\t\\t# this wont work for Resnet models because we dont support lazy loading of Conv2D yet\\n\\t\\t\\t\\t\\n\\t\\tlogger = logging.getLogger(ww.__name__)\\n\\t\\tlogger.setLevel(logging.DEBUG)\\n\\t\\t\\n\\t\\texpected_num_layers = 21 # I think 16 is the flattened layer\\n\\n\\t\\tlayer_iterator = ww.WeightWatcher().make_layer_iterator(self.model)\\n\\t\\t\\n\\t\\tself.assertTrue(layer_iterator is not None)\\n\\t\\tnum_layers = 0\\n\\t\\tfor ww_layer in layer_iterator:\\n\\t\\t\\tnum_layers += 1\\n\\t\\tself.assertEqual(expected_num_layers, num_layers)\\n\\t\\tprint(num_layers)\\n\\t\\t\\n\\t\\t\\n\\t\\texpected_type = \\\"<class 'weightwatcher.weightwatcher.WWLayer'>\\\"\\n\\t\\tactual_type = str(type(ww_layer))\\n\\t\\tself.assertEqual(expected_type, actual_type)\\n\\n\\t\\t\\n\\t\\treturn\",\n \"def test_missing_wire():\\r\\n\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=[\\\"a\\\", -1, \\\"q2\\\"])\\r\\n\\r\\n @qml.beta.qnode(dev)\\r\\n def circuit():\\r\\n qml.Hadamard(wires=-1)\\r\\n qml.CNOT(wires=[\\\"a\\\", \\\"q2\\\"])\\r\\n qml.RX(0.2, wires=\\\"a\\\")\\r\\n return qml.expval(qml.PauliX(wires=\\\"q2\\\"))\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", \\\"a\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ──╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" a: ──╰C──RX(0.2)──┤ \\\",\\r\\n \\\" -1: ───H───────────┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test one missing wire\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\", -1])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\\r\\n\\r\\n # test multiple missing wires\\r\\n res = qml.draw(circuit, wire_order=[\\\"q2\\\"])()\\r\\n expected = [\\r\\n \\\" q2: ─────╭X───────────┤ ⟨X⟩ \\\",\\r\\n \\\" -1: ──H──│────────────┤ \\\",\\r\\n \\\" a: ─────╰C──RX(0.2)──┤ \\\\n\\\",\\r\\n ]\\r\\n\\r\\n assert res == \\\"\\\\n\\\".join(expected)\",\n \"def _is_wiz(agent: Agent):\\n return agent.agent_id == 'Wizard'\",\n \"def test_show_all_wires_false(self):\\n\\n ops = [qml.PauliX(\\\"a\\\"), qml.PauliY(\\\"c\\\")]\\n wire_order = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\"]\\n\\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=False)\\n assert wire_map == {\\\"a\\\": 0, \\\"c\\\": 1}\",\n \"def wwn(self, wwn: SmartSsdWwn):\\n\\n self._wwn = wwn\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5597362","0.55873543","0.5548783","0.55013156","0.54576916","0.53746676","0.5354919","0.5347618","0.52789843","0.5266089","0.51734984","0.51449096","0.513721","0.50930214","0.50891733","0.5074785","0.5068847","0.50615853","0.5049344","0.50426847","0.50426847","0.5037756","0.50273675","0.50262064","0.50252867","0.50222564","0.5019379","0.5019379","0.5014733","0.49773365","0.49670792","0.4950526","0.4936992","0.493603","0.48957846","0.48854384","0.48848608","0.48256803","0.4816713","0.4811598","0.48025364","0.47997645","0.47987306","0.47954977","0.4786536","0.47842017","0.47797328","0.47753155","0.47663262","0.47644505","0.47432616","0.47432616","0.47384703","0.47283244","0.47195145","0.47149327","0.47053784","0.47024894","0.47012994","0.47006026","0.46902752","0.46784344","0.46763766","0.46740428","0.4669501","0.46641913","0.46562842","0.46507078","0.46491426","0.46466738","0.4629351","0.4627588","0.4615063","0.46117464","0.46081603","0.4607315","0.46059972","0.45931482","0.45900184","0.45796576","0.45682654","0.45663455","0.4564708","0.4563724","0.45552942","0.45542014","0.45516396","0.45396477","0.45392722","0.4529194","0.45250055","0.4524519","0.45225352","0.4521436","0.4520469","0.4516858","0.45149314","0.45129895","0.45095688","0.4507006"],"string":"[\n \"0.5597362\",\n \"0.55873543\",\n \"0.5548783\",\n \"0.55013156\",\n \"0.54576916\",\n \"0.53746676\",\n \"0.5354919\",\n \"0.5347618\",\n \"0.52789843\",\n \"0.5266089\",\n \"0.51734984\",\n \"0.51449096\",\n \"0.513721\",\n \"0.50930214\",\n \"0.50891733\",\n \"0.5074785\",\n \"0.5068847\",\n \"0.50615853\",\n \"0.5049344\",\n \"0.50426847\",\n \"0.50426847\",\n \"0.5037756\",\n \"0.50273675\",\n \"0.50262064\",\n \"0.50252867\",\n \"0.50222564\",\n \"0.5019379\",\n \"0.5019379\",\n \"0.5014733\",\n \"0.49773365\",\n \"0.49670792\",\n \"0.4950526\",\n \"0.4936992\",\n \"0.493603\",\n \"0.48957846\",\n \"0.48854384\",\n \"0.48848608\",\n \"0.48256803\",\n \"0.4816713\",\n \"0.4811598\",\n \"0.48025364\",\n \"0.47997645\",\n \"0.47987306\",\n \"0.47954977\",\n \"0.4786536\",\n \"0.47842017\",\n \"0.47797328\",\n \"0.47753155\",\n \"0.47663262\",\n \"0.47644505\",\n \"0.47432616\",\n \"0.47432616\",\n \"0.47384703\",\n \"0.47283244\",\n \"0.47195145\",\n \"0.47149327\",\n \"0.47053784\",\n \"0.47024894\",\n \"0.47012994\",\n \"0.47006026\",\n \"0.46902752\",\n \"0.46784344\",\n \"0.46763766\",\n \"0.46740428\",\n \"0.4669501\",\n \"0.46641913\",\n \"0.46562842\",\n \"0.46507078\",\n \"0.46491426\",\n \"0.46466738\",\n \"0.4629351\",\n \"0.4627588\",\n \"0.4615063\",\n \"0.46117464\",\n \"0.46081603\",\n \"0.4607315\",\n \"0.46059972\",\n \"0.45931482\",\n \"0.45900184\",\n \"0.45796576\",\n \"0.45682654\",\n \"0.45663455\",\n \"0.4564708\",\n \"0.4563724\",\n \"0.45552942\",\n \"0.45542014\",\n \"0.45516396\",\n \"0.45396477\",\n \"0.45392722\",\n \"0.4529194\",\n \"0.45250055\",\n \"0.4524519\",\n \"0.45225352\",\n \"0.4521436\",\n \"0.4520469\",\n \"0.4516858\",\n \"0.45149314\",\n \"0.45129895\",\n \"0.45095688\",\n \"0.4507006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6148025"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":78794,"cells":{"query":{"kind":"string","value":"the surface of will be the the surface of each new faces built. is used to update pcurves on edges if necessary. See Add()."},"document":{"kind":"string","value":"def Init(self, *args):\n return _BRepAlgo.BRepAlgo_FaceRestrictor_Init(self, *args)"},"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 __init__(self, initial_surfaces):\n\n nsurf = len(initial_surfaces)\n nvert, nedge, ngroup, \\\n surf_ptrs, edge_ptrs, \\\n surf_group, edge_group \\\n = self._compute_topology(initial_surfaces)\n\n self._num = {\n 'surf': len(initial_surfaces),\n 'vert': nvert,\n 'edge': nedge,\n 'group': ngroup,\n }\n\n self._topo = {\n 'surf_ptrs': surf_ptrs,\n 'edge_ptrs': edge_ptrs,\n 'surf_group': surf_group,\n 'edge_group': edge_group,\n }\n\n self._mult = {\n 'vert': numpy.zeros(nvert, int),\n 'edge': numpy.zeros(nedge, int),\n 'diff_vert': numpy.zeros(nvert, int),\n 'diff_edge': numpy.zeros(nedge, int),\n }\n\n self._bspline = {\n 'order': 4 * numpy.ones(ngroup, int),\n 'num_cp': 4 * numpy.ones(ngroup, int),\n 'num_pt': 10 * numpy.ones(ngroup, int),\n }\n\n self._surf_indices = {\n 'df': numpy.zeros((nsurf, 2), int, 'F'),\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\n }\n\n self._edge_indices = {\n 'df': numpy.zeros((nedge, 2), int, 'F'),\n 'cp': numpy.zeros((nedge, 2), int, 'F'),\n 'pt': numpy.zeros((nedge, 2), int, 'F'),\n }\n\n self._str_indices = {\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\n }\n\n self._vert_indices = numpy.zeros(nvert, int)\n\n self._size = {\n 'df_str': 0,\n 'df': 0,\n 'cp': 0,\n 'cp_str': 0,\n 'pt_str': 0,\n 'pt': 0,\n }\n\n self.diff = {\n 'surf': numpy.zeros((nsurf, 3, 3), bool, 'F'),\n 'edge': numpy.zeros((nedge, 2), bool, 'F'),\n }\n\n self.hidden = numpy.zeros(nsurf, bool)\n\n self.jac = {\n 'd(df)/d(df_str)': None,\n 'd(cp)/d(df)': None,\n 'd(cp_str)/d(cp)': None,\n 'd(pt_str)/d(cp_str)': None,\n 'd(pt)/d(pt_str)': None,\n }\n\n self.vec = {\n 'df_str': None,\n 'df': None,\n 'cp': None,\n 'cp_str': None,\n 'pt_str': None,\n 'pt': None,\n }","def add_surface(self,s):\n self.surfaces.append(s)\n s.system=self.surfaces","def map_face(self):\n #Array Order: U0,D1,R2,L3,F4,B5,\n \n cube_list = []\n cube_list = self.cube.definition()\n \n for index, cubit in enumerate(self.faces['Up']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\n for index, cubit in enumerate(self.faces['Ri']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\n for index, cubit in enumerate(self.faces['Ft']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\n for index, cubit in enumerate(self.faces['Dn']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\n for index, cubit in enumerate(self.faces['Le']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\n for index, cubit in enumerate(self.faces['Bk']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])","def Spherical_aberrations_surface_addup(self):\n bf=beam_field()\n bf.U=np.array([[[0,0,1],[0,0,1],[0,0,1]]])\n pp=self.entrance_pupil\n bf.Q_p=np.array([[[0,0,0],[0,pp/10.,0],[0,pp,0]]]) \n bf.propagate(self.surfaces)\n i,x=bf.calculate_intersections(bf.U[:,[0]],bf.Q_p[:,[0]],bf.U[:,[1]],bf.Q_p[:,[1]])\n \n i2,x2=bf.calculate_intersections(bf.U[:,[0]],bf.Q_p[:,[0]],bf.U[:,[2]],bf.Q_p[:,[2]])\n \n #print(i[:,:,2]-i2[:,:,2])","def cfdProcessGeometry(self):\r\n \r\n # self.faceCentroids']= [[] for i in range(self.numberOfFaces'])]\r\n # self.faceSf']= [[] for i in range(self.numberOfFaces'])]\r\n # self.faceAreas']= [[] for i in range(self.numberOfFaces'])]\r\n \r\n ## Linear weight of distance from cell center to face\r\n self.faceWeights= [[0] for i in range(self.numberOfFaces)]\r\n\r\n ## Not\r\n self.faceCF= [[0, 0, 0] for i in range(self.numberOfFaces)]\r\n \r\n self.faceCf= [[0,0,0] for i in range(self.numberOfFaces)]\r\n \r\n self.faceFf= [[0,0,0] for i in range(self.numberOfFaces)]\r\n \r\n self.wallDist= [[] for i in range(self.numberOfFaces)]\r\n \r\n self.wallDistLimited= [[] for i in range(self.numberOfFaces)]\r\n \r\n self.elementCentroids= [[] for i in range(self.numberOfElements)]\r\n self.elementVolumes= [[] for i in range(self.numberOfElements)]\r\n \r\n \"\"\"\r\n Calculate:\r\n -face centroids (faceCentroids)\r\n -face normal (Sf)\r\n -face areas (faceAreas)\r\n \"\"\"\r\n \r\n #find cell with largest number of points\r\n maxPoints=len(max(self.faceNodes, key=len))\r\n forCross1 = [[] for i in range(maxPoints)]\r\n forCross2 = [[] for i in range(maxPoints)]\r\n local_faceCentroid=[[] for i in range(maxPoints)]\r\n \r\n for iFace in range(self.numberOfFaces):\r\n theNodeIndices = self.faceNodes[iFace]\r\n theNumberOfFaceNodes = len(theNodeIndices)\r\n \r\n #compute a rough centre of the face\r\n local_centre = [0,0,0]\r\n \r\n for iNode in theNodeIndices:\r\n local_centre = local_centre + self.nodeCentroids[int(iNode)]\r\n \r\n local_centre = local_centre/theNumberOfFaceNodes\r\n \r\n for iTriangle in range(theNumberOfFaceNodes):\r\n \r\n point1 = local_centre\r\n point2 = self.nodeCentroids[int(theNodeIndices[iTriangle])]\r\n \r\n if iTriangle < theNumberOfFaceNodes-1:\r\n point3 = self.nodeCentroids[int(theNodeIndices[iTriangle+1])]\r\n else:\r\n point3 = self.nodeCentroids[int(theNodeIndices[0])]\r\n \r\n local_faceCentroid[iTriangle].append((point1+point2+point3)/3)\r\n \r\n left=point2-point1\r\n right=point3-point1\r\n \r\n forCross1[iTriangle].append(left)\r\n forCross2[iTriangle].append(right)\r\n \r\n \r\n local_Sf=[np.zeros([self.numberOfFaces,3]) for i in range(maxPoints)]\r\n local_area=[np.zeros([self.numberOfFaces,3]) for i in range(maxPoints)]\r\n \r\n centroid=np.zeros([self.numberOfFaces,3])\r\n area=np.zeros([self.numberOfFaces])\r\n Sf=np.zeros([self.numberOfFaces,3])\r\n \r\n #cells with fewer faces than others are full of zeros\r\n for i in range(maxPoints):\r\n \r\n forCrossLeft=np.vstack(np.array(forCross1[i]))\r\n forCrossRight=np.vstack(np.array(forCross2[i]))\r\n \r\n local_Sf[i]=0.5*np.cross(forCrossLeft,forCrossRight)\r\n local_area[i]=np.linalg.norm(local_Sf[i],axis=1)\r\n \r\n centroid = centroid + np.array(local_faceCentroid[i])*local_area[i][:,None]\r\n Sf=Sf+local_Sf[i]\r\n area=area+local_area[i]\r\n \r\n self.faceCentroids=centroid/area[:,None]\r\n self.faceSf=Sf\r\n self.faceAreas=area \r\n \r\n \r\n \"\"\"\r\n Pure python version - causes slowness due to iterative np.cross()\r\n \"\"\"\r\n \r\n # for iFace in range(self.numberOfFaces):\r\n # theNodeIndices = self.faceNodes[iFace]\r\n # theNumberOfFaceNodes = len(theNodeIndices)\r\n # \r\n # #compute a rough centre of the face\r\n # local_centre = [0,0,0]\r\n # \r\n # for iNode in theNodeIndices:\r\n # \r\n # local_centre = local_centre + self.nodeCentroids[int(iNode)]\r\n # \r\n # local_centre = local_centre/theNumberOfFaceNodes\r\n # centroid = [0, 0, 0]\r\n # Sf = [0,0,0]\r\n # area = 0\r\n # \r\n # #finds area of virtual triangles and adds them to the find to find face area\r\n # #and direction (Sf)\r\n # \r\n # \r\n # \r\n # for iTriangle in range(theNumberOfFaceNodes):\r\n # point1 = local_centre\r\n # point2 = self.nodeCentroids[int(theNodeIndices[iTriangle])]\r\n # \r\n # if iTriangle < theNumberOfFaceNodes-1:\r\n # point3 = self.nodeCentroids[int(theNodeIndices[iTriangle+1])]\r\n # else:\r\n # point3 = self.nodeCentroids[int(theNodeIndices[0])]\r\n # \r\n # local_centroid = (point1 + point2 + point3)/3\r\n # \r\n # left=point2-point1\r\n # right=point3-point1\r\n # x = 0.5*((left[1] * right[2]) - (left[2] * right[1]))\r\n # y = 0.5*((left[2] * right[0]) - (left[0] * right[2]))\r\n # z = 0.5*((left[0] * right[1]) - (left[1] * right[0]))\r\n # local_Sf=np.array([x,y,z])\r\n # \r\n # local_area = np.linalg.norm(local_Sf)\r\n # \r\n # centroid = centroid + local_area*local_centroid\r\n # Sf = Sf + local_Sf\r\n # area = area + local_area\r\n # centroid = centroid/area\r\n # self.faceCentroids[iFace]=centroid\r\n # self.faceSf[iFace]=Sf\r\n # self.faceAreas[iFace]=area\r\n \r\n \r\n \"\"\"\r\n Calculate:\r\n -element centroids (elementCentroids)\r\n -element volumes (elementVolumes)\r\n \"\"\"\r\n for iElement in range(self.numberOfElements):\r\n \r\n theElementFaces = self.elementFaces[iElement]\r\n \r\n #compute a rough centre of the element\r\n local_centre = [0,0,0]\r\n \r\n for iFace in range(len(theElementFaces)):\r\n faceIndex = theElementFaces[iFace]\r\n local_centre = local_centre + self.faceCentroids[faceIndex]\r\n \r\n local_centre = local_centre/len(theElementFaces)\r\n \r\n localVolumeCentroidSum = [0,0,0]\r\n localVolumeSum = 0\r\n \r\n for iFace in range(len(theElementFaces)):\r\n faceIndex = theElementFaces[iFace]\r\n \r\n Cf = self.faceCentroids[faceIndex]-local_centre\r\n \r\n faceSign = -1\r\n if iElement == self.owners[faceIndex]:\r\n faceSign = 1\r\n \r\n local_Sf = faceSign*self.faceSf[faceIndex]\r\n \r\n localVolume = np.dot(local_Sf,Cf)/3\r\n \r\n localCentroid = 0.75*self.faceCentroids[faceIndex]+0.25*local_centre\r\n \r\n localVolumeCentroidSum = localVolumeCentroidSum + localCentroid*localVolume\r\n \r\n localVolumeSum = localVolumeSum + localVolume\r\n \r\n self.elementCentroids[iElement]=localVolumeCentroidSum/localVolumeSum\r\n self.elementVolumes[iElement]=localVolumeSum\r\n \r\n \r\n for iFace in range(self.numberOfInteriorFaces):\r\n \r\n n=self.faceSf[iFace]/np.linalg.norm(self.faceSf[iFace])\r\n own=self.owners[iFace]\r\n nei = self.neighbours[iFace]\r\n \r\n self.faceCF[iFace]=self.elementCentroids[nei]-self.elementCentroids[own]\r\n self.faceCf[iFace]=self.faceCentroids[iFace]-self.elementCentroids[own]\r\n self.faceFf[iFace]=self.faceCentroids[iFace]-self.elementCentroids[nei]\r\n self.faceWeights[iFace]=(-np.dot(self.faceFf[iFace],n))/(-np.dot(self.faceFf[iFace],n)+np.dot(self.faceCf[iFace],n))\r\n \r\n for iBFace in range(self.numberOfInteriorFaces, self.numberOfFaces):\r\n \r\n \r\n n=self.faceSf[iBFace]/np.linalg.norm(self.faceSf[iBFace])\r\n own=self.owners[iBFace]\r\n \r\n self.faceCF[iBFace]=self.faceCentroids[iBFace]-self.elementCentroids[own]\r\n self.faceCf[iBFace]=self.faceCentroids[iBFace]-self.elementCentroids[own] \r\n self.faceWeights[iBFace]=1\r\n self.wallDist[iBFace]= max(np.dot(self.faceCf[iBFace], n), 1e-24)\r\n self.wallDistLimited[iBFace]= max(self.wallDist[iBFace], 0.05*np.linalg.norm(self.faceCf[iBFace]))","def __init__(self, vertices, edges, surfaces):\n #self.target = target\n #self.support = support\n self.vertices = vertices\n self.edges = edges\n self.surfaces = surfaces","def draw(self, surface):\n for molecule in self.molecules:\n molecule.draw(surface)","def new_mesh_set(self, all_meshes):\n if isinstance(all_meshes, Mesh):\n mesh_tp = []\n mesh_tp.append(all_meshes)\n all_meshes = mesh_tp\n\n if not isinstance(all_meshes, list):\n raise TypeError(\"Please send a list of mesh to update_mesh\")\n self.all_meshes = all_meshes\n\n # Remove previous actors from the scene\n for actor in self.mesh_actors:\n self.parent_window.ren.RemoveActor(actor)\n self.mesh_actors = list()\n\n # Create the geometry of a point (the coordinate) points = vtkPoints()\n for i, mesh in enumerate(self.all_meshes):\n if mesh.time.size != 1:\n raise IndexError(\"Mesh should be from one frame only\")\n\n points = vtkPoints()\n for j in range(mesh.channel.size):\n # points.InsertNextPoint([0, 0, 0])\n points.InsertNextPoint(mesh.data[:3, j, 0].tolist())\n\n # Create an array for each triangle\n draw_patch = not mesh.automatic_triangles and not self.force_wireframe\n if draw_patch:\n poly_type = vtkPolygon\n n_ids = 3\n color = self.patch_color[i]\n else:\n poly_type = vtkPolyLine\n n_ids = 4\n color = self.mesh_color\n cells = vtkCellArray()\n\n # Create the polygons\n for j in range(mesh.triangles.shape[1]):\n poly = poly_type()\n poly.GetPointIds().SetNumberOfIds(n_ids) # make a tri\n for k in range(len(mesh.triangles[:, j])):\n poly.GetPointIds().SetId(k, mesh.triangles[k, j])\n if not draw_patch:\n poly.GetPointIds().SetId(3, mesh.triangles[0, j]) # Close the triangle\n cells.InsertNextCell(poly)\n\n poly_data = vtkPolyData()\n poly_data.SetPoints(points)\n if draw_patch:\n poly_data.SetPolys(cells)\n else:\n poly_data.SetLines(cells)\n\n mapper = vtkPolyDataMapper()\n mapper.SetInputData(poly_data)\n\n # Create an actor\n self.mesh_actors.append(vtkActor())\n self.mesh_actors[i].SetMapper(mapper)\n self.mesh_actors[i].GetProperty().SetColor(color)\n self.mesh_actors[i].GetProperty().SetOpacity(self.mesh_opacity)\n\n self.parent_window.ren.AddActor(self.mesh_actors[i])\n\n # Update marker position\n self.update_mesh(self.all_meshes)","def createSurfaceGeo(self):\n self.surfGeo = dict()\n r = self.geoParam['CylinderLightGuideRadius']\n self.surfGeo[r] = 'LightGuide'\n #self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\n while(r + self.geoParam['DetectorThickness'] < self.geoParam['CylinderRadius']):\n r += self.geoParam['DetectorThickness']\n self.surfGeo[r] = 'Detector'\n r += self.geoParam['DetectorSpacing']\n if (r < self.geoParam['CylinderRadius']):\n self.surfGeo[r] = 'LightGuide'\n return self.surfGeo","def add_face(self, vertices: Iterable[\"Vertex\"]) -> None:\n self.faces.append(self.add_vertices(vertices))","def draw(self, surface):\n #\n # Set the positions of all the items\n y = 0\n self.my_surface.fill((0, 0, 0, 0))\n for idx, item in enumerate(self):\n y += self.item_heights\n item.pos = (item.width / 2, y - self.initial_offset)\n #\n # Now draw item\n item.draw(self.my_surface)\n # #\n # # And the scrollbar\n # self.scroll_grab.pos = (self.my_surface.get_size()[0] - S['scrolled-scroll-width'], 0)\n # self.scroll_grab.draw(self.my_surface)\n #\n # Draw main surface\n if self.background:\n self.background.pos = self.pos\n self.background.draw(surface)\n self.region.pos = self.pos\n self.region.draw(surface)","def surface():\n \"\"\"\n Get surface for plotting.\n\n :return fsaverage: surface locations as in nilearn\n :return surf: surface for plotting\n \"\"\"\n\n fsaverage = fetch_surf_fsaverage('fsaverage')\n surf = {}\n\n for key in [t + '_' + h for t in ['pial', 'infl'] for h in ['left', 'right']]:\n\n surf = load_surf_mesh(fsaverage[key])\n x, y, z = np.asarray(surf[0].T, dtype='<f4')\n i, j, k = np.asarray(surf[1].T, dtype='<i4')\n\n surf[key] = dict(x=x, y=y, z=z, i=i, j=j, k=k)\n\n return fsaverage, surf","def set_und_surface(self):\n if (self.dimension == '3D'):\n self.part_RVE.Set(\n cells=self.part_RVE.cells.getSequenceFromMask(mask=('[#1 ]', ), ),\n name='Set_RVE')\n elif (self.dimension == '2D'):\n self.part_RVE.Set(\n faces=self.part_RVE.faces.getSequenceFromMask(mask=('[#1 ]', ), ),\n name='Set_RVE')\n else:\n print('dimension Error!')","def faces(self, f):\n self._faces = f","def _getFacesAndMaterials_bpy(self):\r\n obj = self.obj\r\n mesh = obj.data\r\n polygonDict = {} # a dict that holds faces (dict), their vertices (dict: positions and materials)\r\n # self._checkForUndoMess()\r\n\r\n for n in range (0, len(mesh.polygons)):\r\n f = mesh.polygons[n] # current face\r\n\r\n # create local dict\r\n d = {}\r\n\r\n # get face material\r\n slot = obj.material_slots[f.material_index]\r\n mat = slot.material\r\n d['material'] = mat.name\r\n\r\n # get face vertices\r\n v_list = []\r\n for v in f.vertices: # browse through vertice index\r\n vect = obj.matrix_world * mesh.vertices[v].co\r\n v_list.append(vect)\r\n \r\n # add third twice for triangle face (expected by evertims raytracing client)\r\n if( len(f.vertices) == 3 ): \r\n vect = obj.matrix_world * mesh.vertices[ f.vertices[2] ].co\r\n v_list.append(vect)\r\n\r\n d['vertices'] = v_list\r\n\r\n # store local dict\r\n polygonDict[n] = d\r\n return polygonDict","def __init__(self, surface, rect):\n self.surface = surface\n self.rect = rect","def __init__(self, surface, rect):\n self.surface = surface\n self.rect = rect","def get_faces(self):\n for i, j in combinations(self.gens, 2):\n c0 = self.triangle_verts[self.vertex_at_mirrors(i, j)]\n f0 = []\n m = self.cox_mat[i][j]\n H = (i, j)\n type = 0\n if self.active[i] and self.active[j]:\n type = 1\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\n f0.append(self.G.move(self.vtable, 0, (i, j) * k + (i,)))\n elif self.active[i] and m > 2:\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (j, i) * k))\n elif self.active[j] and m > 2:\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\n else:\n continue\n\n reps = set(self.word_generator(parabolic=H))\n reps = self.G.sort_words(reps)\n flist = []\n for word in reps:\n f = tuple(self.G.move(self.vtable, v, word) for v in f0)\n if None not in f and not helpers.check_duplicate_face(f, flist):\n center = self.transform(word, c0)\n coords = [self.vertices_coords[k] for k in f]\n face = DihedralFace(word, f, center, coords, type)\n flist.append(face)\n\n self.face_indices[(i, j)] = flist\n\n self.num_faces = sum(len(L) for L in self.face_indices.values())","def __init__(self, geometries, surfaceRefinement, case):\n\n self.geometries = geometries\n self.surfaceRefinement = surfaceRefinement\n self.case = case\n #we set up the default settings for snappy\n self.castellate = True\n self.snap = True\n self.addLayers = True\n self.maxLocalCells = 1000000\n self.maxGlobalCells = 200000\n self.minRefinementCells = 200\n self.maxLoadUnbalance = 0.1\n self.nCellsBetweenLevels = 3\n self.edgeRefinementLevel = 6\n self.refinementSurfaceMin = 5\n self.refinementSurfaceMax = 6\n self.resolveFeatureAngle = 5\n self.distanceRefinements = [0.1, 0.2]\n self.distanceLevels = [4, 3]\n self.locationToKeep = [0.001, 0.001, 0.0015]\n self.allowFreeStandingFaces = True\n self.nSmoothPatch = 3\n self.snapTolerance = 2\n self.nSolveIter = 30\n self.nRelaxIter = 5\n self.nFeatureSnapIter = 10\n self.implicitFeatureSnap = False\n self.explicitFeatureSnap = True\n self.multiRegionFeatureSnap = False\n self.relativeSizes = True\n self.nSurfaceLayers = 1\n self.expansionRatio = 1\n self.finalLayerThickness = 0.1\n self.minThickness = 0.03\n self.nGrow = 0\n self.featureAngle = 60\n self.slipFeatureAngle = 30\n self.nRelaxIter = 3\n self.nSmoothSurfaceNormals = 1\n self.nSmoothNormals = 1\n self.nSmoothThickness = 10\n self.maxFaceThicknessratio = 0.5\n self.maxThicknessToMedialRatio = 0.3\n self.minMedianAxisAngle = 90\n self.nBufferCellsNoExtrude = 0\n self.nLayerIter = 50\n self.mergeTolerance = 1e-6","def Surface(self, *args):\n return _Adaptor3d.Adaptor3d_HSurface_Surface(self, *args)","def update(self) -> pygame.Surface:\n return self.surface","def buildFaces(self):\n for fi in range(len(self.poly1.faces)):\n f = self.poly1.faces[fi]\n for vi in range(len(f.vertices)):\n v = f.vertices[vi]\n if self.getIntersector(v) is not None and not v.isMarkedFor(f):\n self.faceTrace(1, fi, vi)\n v = f.vertices[0]\n if v.isInterior() and not v.isMarkedFor(f):\n interiorFaceTrace(f)\n for fi in range(len(self.poly2.faces)):\n f = self.poly2.faces[fi]\n for vi in range(len(f.vertices)):\n v = f.vertices[vi]\n if self.getIntersector(v) is not None and not v.isMarkedFor(f) :\n self.faceTrace(2, fi, vi)\n v = f.vertices[0]\n if v.isInterior() and not v.isMarkedFor(f):\n interiorFaceTrace(f)","def update(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 if xyz.size:\n self.mesh.visible = True\n self.mesh.set_data(xyz, edge_color=self.edgecolor, size=sData,\n face_color=sColor, scaling=self.scaling,\n edge_width=self.edgewidth, symbol=self.symbol)\n # self.mesh.transform = self.transform\n self.mesh.update()\n else:\n self.mesh.visible = False","def __init__(self, Region):\r\n \r\n self.Region=Region\r\n \r\n ## Path to points files\r\n self.pointsFile = r\"%s/constant/polyMesh/points\" % self.Region.caseDirectoryPath\r\n\r\n ## Path to faces file\r\n self.facesFile = r\"%s/constant/polyMesh/faces\" % self.Region.caseDirectoryPath\r\n\r\n ## Path to owner file\r\n self.ownerFile = r\"%s/constant/polyMesh/owner\" % self.Region.caseDirectoryPath\r\n\r\n ## Path to neighbour file\r\n self.neighbourFile = r\"%s/constant/polyMesh/neighbour\" % self.Region.caseDirectoryPath\r\n\r\n ## Path to boundary file\r\n self.boundaryFile = r\"%s/constant/polyMesh/boundary\" % self.Region.caseDirectoryPath \r\n \r\n print('\\n')\r\n print('Reading contents of ./constant/polyMesh folder ...')\r\n \r\n self.cfdReadPointsFile()\r\n self.cfdReadFacesFile()\r\n self.cfdReadOwnerFile()\r\n self.cfdReadNeighbourFile()\r\n\r\n #maybe these should go in a function?\r\n self.numberOfBFaces=self.numberOfFaces-self.numberOfInteriorFaces\r\n self.numberOfElements = max(self.neighbours)+1 #because of zero indexing in Python\r\n self.numberOfBElements=self.numberOfFaces-self.numberOfInteriorFaces #seems strange that subtracting faces gives elements ...\r\n\r\n self.cfdReadBoundaryFile() \r\n self.cfdCheckIfCavity()\r\n \r\n print('Processing mesh ... please wait ....')\r\n \r\n self.cfdProcessElementTopology()\r\n self.cfdProcessNodeTopology()\r\n self.cfdProcessGeometry()\r\n \r\n self.cfdGetBoundaryElementsSubArrayForBoundaryPatch()\r\n self.cfdGetOwnersSubArrayForBoundaryPatch()\r\n self.cfdGetFaceSfSubArrayForBoundaryPatch()\r\n self.cfdGetFaceCentroidsSubArrayForBoundaryPatch()\r\n \r\n ## (list) 1D, indices refer to an interior face, list value is the face's owner\r\n self.interiorFaceOwners = self.owners[0:self.numberOfInteriorFaces]\r\n\r\n ## (list) 1D, indices refer to an interior face, list value is the face's neighbor cell\r\n self.interiorFaceNeighbours = self.neighbours[0:self.numberOfInteriorFaces]\r\n\r\n ## (list) 1D, face weighting factors. Values near 0.5 mean the face's centroid is approximately halfway between the center of the owner and neighbour cell centers, values less than 0.5 mean the face centroid is closer to the owner and those greater than 0.5 are closer to the neighbour cell).\r\n self.interiorFaceWeights = self.faceWeights[0:self.numberOfInteriorFaces]\r\n\r\n ## (array) 2D, normal vectors (Sf) of the interior faces (indices refer to face index)\r\n self.interiorFaceSf = self.faceSf[0:self.numberOfInteriorFaces]\r\n \r\n ## (array) 2D, CF vectors of the interior faces (indices refer to face index)\r\n self.interiorFaceCF = self.faceCF[0:self.numberOfInteriorFaces]\r\n \r\n ## (list) 1D, indices refer to an boundary face, list value refers to the face's owner\r\n self.owners_b = self.owners[self.numberOfInteriorFaces:self.numberOfFaces]\r\n\r\n ## (list) 1D, normal vectors (Sf) of the boundary faces (indices refer to face index). Boundary face normals always point out of the domain. \r\n self.Sf_b=self.faceSf[self.numberOfInteriorFaces:self.numberOfFaces]","def update(self,image):\r\n \r\n self._faces=[]\r\n \r\n if util.isgray(image):\r\n image=cv2.equalizeHist(image)\r\n \r\n else:\r\n \r\n image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\r\n cv2.equalizeHist(image,image)\r\n \r\n minsize=util.widthheightdividedby(image,8)\r\n\r\n \r\n\r\n \r\n facerect=self._faceclassifier.detectMultiScale(image,\r\n self.scalefactor,\r\n self.minneighbors,\r\n self.flags,\r\n minsize)\r\n \r\n \"\"\"if facerects is not None:\r\n \r\n for facerect in facerects:\r\n face=face()\r\n \r\n face.facerect=facerect\r\n \r\n \r\n x,y,w,h=facerect\r\n \r\n # Seek an eye in the upper-left part of the face. \r\n searchRect = (x+w/7, y, w*2/7, h/2) \r\n face.leftEyeRect = self._detectOneObject( \r\n self._eyeClassifier, image, searchRect, 64) \r\n \r\n \r\n \r\n # Seek an eye in the upper-right part of the face. \r\n searchRect = (x+w*4/7, y, w*2/7, h/2) \r\n face.rightEyeRect = self._detectOneObject( \r\n self._eyeClassifier, image, searchRect, 64) \r\n \r\n \r\n \r\n # Seek a nose in the middle part of the face. \r\n searchRect = (x+w/4, y+h/4, w/2, h/2) \r\n face.noseRect = self._detectOneObject( \r\n self._noseClassifier, image, searchRect, 32) \r\n \r\n # Seek a mouth in the lower-middle part of the face. \r\n searchRect = (x+w/6, y+h*2/3, w*2/3, h/3) \r\n face.mouthRect = self._detectOneObject( \r\n self._mouthClassifier, image, searchRect, 16) \r\n \r\n \r\n \r\n self._faces.append(face)\r\n\r\n \r\n \r\n def _detectoneobject(self,\r\n classifier,\r\n image,\r\n rect,\r\n imagesizetominsizeratio):\r\n \r\n x ,y ,w ,h=rect\r\n \r\n minsize=util.widthheightdividedby(image,\r\n imagesizetominsizeratio)\r\n \r\n subimage=image[y:y+h,x:x+w]\r\n \r\n subrect=classifier.dectectMultiScale(subimage,\r\n self.scalefactor,\r\n self.minneighbors,\r\n self.flags,\r\n minsize)\r\n \r\n if len(subrect)==0:\r\n return None\r\n \r\n subx,suby,subw,subh=subrects[0]\r\n \r\n return (x+subx,y+suby,w+subw,h+subh)\r\n \r\n \"\"\"","def compute_mixing_coefficients_surf(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n\n # SET UP NEW MIXING COEFFICIENT ARRAYS\n self.Kv_surf = np.zeros([Ly,N+1])\n self.Kt_surf = np.zeros([Ly,N+1])\n \n self.ghat = np.zeros([Ly,N+1])\n \n\n #################################\n # \tSURFACE KPP\n ################################\n #---> j-loop\n \n self.wm2 = []\n self.ws2 = []\n self.sigma_y = []\n for j in range(Ly):\n #--> k-loop (top to kbl[j])\n # in fortran k=N-1,kbl(j),-1\n for k in range(N-1,self.kbl[j]-1,-1):\n k_w = k\n k_r = k-1\n\n Bfsfc = self.Bfsfc_bl[j]\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\n \n # CALCULATE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm2.append(wm)\n self.ws2.append(ws)\n # COMPUTE VERTICAL MIXING COEFFICIENTS\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\n self.sigma1 = sigma #for debugging\n if j == 25: \n self.sigma_y.append(sigma)\n a1 = sigma - 2.\n a2 = 3.-2.*sigma\n a3 = sigma - 1.\n\n if sigma < 0.07:\n cff = 0.5 * (sigma-0.07)**2/0.07\n else:\n cff = 0\n \n \n if k == N-1: \n self.wm_debug = wm\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\n\n if k == N-1:\n self.ws_debug = ws\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n \n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\n #---> end k-loop \n if self.LMD_NONLOCAL:\n if Bfsfc < 0:\n self.ghat[j,k_w] = 0\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\n else:\n self.ghat[j,k_w] = 0.\n\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \n if self.LMD_CONVEC and self.MLCONVEC: \n for k in range(N-1,int(self.kbl[j]-1),-1):\n k_w = k\n k_r = k -1\n\n if self.bvf[j,k_w] < 0:\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\n\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\n # IF BKPP IS SWITCHED OFF!!\n for k in range(int(self.kbl[j]-1),-1,-1):\n k_w = k\n k_r = k -1\n if self.LMD_NONLOCAL:\n self.ghat[j,k_w] = 0\n if self.LMD_CONVEC and self.LMD_BKPP == False:\n if self.bvf[j,k_w] < 0:\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\n \n\n #---> end j-loop","def update_surface(frame):\n \n #fig.suptitle(time[frame])\n im.set_array(surf[frame])\n im.set_extent([np.nanmin(xx[frame]), np.nanmax(xx[frame]), np.nanmin(yy[frame]), np.nanmax(yy[frame])])\n \n line.set_data([(times[:-1] + utc_to_east).plot_date[frame]]*2, ylim)","def __init__(self, renderSurf):\n self.surf = renderSurf","def drawFace():\r\n\tglPushMatrix()\r\n\tglTranslatef(-0.5,-0.5,0)\r\n\tglBegin(GL_LINE_LOOP)\r\n\t\r\n\tglVertex3f(0,VALUE,0)\r\n\tglVertex3f(VALUE,0,0)\r\n\t\r\n\tglVertex3f(LENGTH-VALUE,0,0)\r\n\tglVertex3f(LENGTH,VALUE,0)\r\n\t\r\n\tglVertex3f(LENGTH,LENGTH-VALUE,0)\r\n\tglVertex3f(LENGTH-VALUE,LENGTH,0)\r\n\t\r\n\tglVertex3f(VALUE,LENGTH,0)\r\n\tglVertex3f(0,LENGTH-VALUE,0)\r\n\t\r\n\tglEnd()\r\n\tglPopMatrix()","def surfaces(self):\n return self._surfaces","def __init__(self):\n self.delCurves = []\n return","def surface(self):\n # return sum(np.outer(basis_function, control_point) for basis_function, control_point in zip(self.basis_1, self.basis)).T\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) + np.outer(basis_function_2, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\n\n # x = np.zeros_like(self.xi_1_mesh)\n # y = np.zeros_like(self.xi_1_mesh)\n # z = np.zeros_like(self.xi_1_mesh)\n xyz = np.zeros((*self.xi_1_mesh.shape, 3))\n for (i, basis_function_i), (j, basis_function_j) in itertools.product(enumerate(self.basis_1), enumerate(self.basis_2)):\n print(i, basis_function_i)\n print(j, basis_function_j)\n print(self.control_net[i, j])\n # b1, b2 = np.meshgrid(basis_function_i, basis_function_j, indexing = 'ij')\n control_x, control_y, control_z = self.control_net[i, j]\n # print(b1.shape, b2.shape, np.array(self.control_net[i, j]).shape)\n # print((b1 * b2).shape)\n # z += np.outer(b1 * b2, self.control_net[i, j])\n # print(np.shape(z))\n print(np.outer(basis_function_i, basis_function_j))\n # x += np.outer(basis_function_i, basis_function_j) * control_x\n # y += np.outer(basis_function_i, basis_function_j) * control_y\n # z += np.outer(basis_function_i, basis_function_j) * control_z\n print(np.outer(basis_function_i, basis_function_j).shape)\n print(np.outer(np.outer(basis_function_i, basis_function_j), self.control_net[i, j]).shape)\n print(np.outer(np.outer(basis_function_i, basis_function_j), np.array(self.control_net[i, j])).shape)\n r = np.einsum('i,j,k->ijk', basis_function_i, basis_function_j, np.array(self.control_net[i, j]))\n print(r.shape)\n xyz += r\n\n # print(x, y, z)\n\n # return x, y, z\n return xyz","def append(self, solf):\n exist_map = {'vertex_index': len(self.get('vertices', [])),\n 'texcoord_index': len(self.get('texcoords', [])),\n 'normal_index': len(self.get('normals', [])),\n 'param_index': len(self.get('params', []))}\n exist_map.update(points=exist_map['vertex_index'],\n curve2Ds=exist_map['param_index'])\n # Vertex fields\n for k in ['vertices', 'texcoords', 'normals', 'params']:\n if k in solf:\n if k not in self:\n self[k] = []\n self[k] += solf[k]\n # Points/2D curves\n for k in ['points', 'curve2Ds']:\n if k in solf:\n if k not in self:\n self[k] = []\n for x in solf[k]:\n self[k].append([v + exist_map[k] for v in x])\n # Face/line fields\n for k in ['lines', 'faces']:\n if k in solf:\n if k not in self:\n self[k] = []\n for x in solf[k]:\n iele = [{ik: v[ik] + exist_map[ik] for ik in v.keys()} for v in x]\n self[k].append(iele)\n # Curves\n k = 'curves'\n if k in solf:\n if k not in self:\n self[k] = []\n for x in solf[k]:\n iele = copy.deepcopy(x)\n iele['vertex_indices'] = [v + exist_map['vertex_index']\n for v in x['vertex_indices']]\n # Surfaces\n k = 'surfaces'\n if k in solf:\n if k not in self:\n self[k] = []\n for x in solf[k]:\n iele = copy.deepcopy(x)\n iele['vertex_indices'] = [{ik: v[ik] + exist_map[ik] for ik in v.keys()}\n for v in x['vertex_indices']]\n # Merge material using first in list\n material = None\n for x in [self, solf]:\n if x.get('material', None) is not None:\n material = x['material']\n break\n if material is not None:\n self['material'] = material\n return self","def updateGeometryInfo(self,*args):\r\n self.wf.dataGridView.Rows.Clear()\r\n sceneRoot = Application.ActiveSceneRoot\r\n children = sceneRoot.FindChildren2( \"\", constants.siPolyMeshType, constants.siMeshFamily, True )\r\n for child in children:\r\n vTrans = child.Kinematics.Local.GetTransform2(None).Translation\r\n self.wf.AddRow( child.FullName, vTrans.X, vTrans.Y, vTrans.Z )","def draw_on(self, surface):\n for x, y in self.alive_cells():\n #size = (self.box_size, self.box_size)\n #position = (x * self.box_size, y * self.box_size)\n #thickness = 1\n pygame.draw.rect(surface, DARK_RED, (x * self.box_size, y * self.box_size,self.box_size, self.box_size ))","def show(self):\n # if a blender object already exists then the mesh_grower must have been finalized;\n # in this case make a new mesh_grower and object\n viz.add_box(self.lower_vertex, self.upper_vertex)","def subdivision(mesh):\n\t\n\t\n\t# 1. generate new nodes in the centre of quad\n\t# 1/4 o-------o 1/4 o: existing vertices\n\t# | | *: newly-generated vertices\n\t# | * |\n\t# | |\n\t# 1/4 o-------o 1/4\n\n\tnew_coor = mesh.give_nodes().give_coor()\n\t\n\tfor face_index in range(mesh.give_model_inf()[2]): \n\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\tfor vertex_index in range(4):\n\t\t\tmesh.give_faces()\n\t\t\tnode_index = mesh.give_faces().give_node_list(face_index)[vertex_index]\n\n\t\t\tnew_x += 0.25*mesh.give_nodes().give_coor(node_index)[0]\n\t\t\tnew_y += 0.25*mesh.give_nodes().give_coor(node_index)[1]\n\t\t\tnew_z += 0.25*mesh.give_nodes().give_coor(node_index)[2]\n\t\t\t\n\t\tnew_coor.append((new_x, new_y, new_z))\n\t\t\n\t# generating new nodes on the edge\n\t# figure out one edge is shared by how many surfaces\n\tedge_shared_by_faces_list = helper.find_edge_shared_by_which_faces(mesh.give_edges(), mesh.give_faces())\n\t\n\tfor edge_index in range(mesh.give_model_inf()[1]):\n\n\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\n\t# 2. generate new node on boundary edge\n\t# o: existing vertices\n\t# 1/2 o---*---o 1/2 *: newly-generated vertices\n\t# \n\n\t\tnew_coor = mesh.give_nodes().give_coor()\n\t\tif len(edge_shared_by_faces_list[edge_index]) == 1:\t\n\t\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\tfor vertex_index in range(2):\n\t\t\t\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\n\t\t\t\tnew_x += 0.5*mesh.give_nodes().give_coor()[this_node][0]\n\t\t\t\tnew_y += 0.5*mesh.give_nodes().give_coor()[this_node][1]\n\t\t\t\tnew_z += 0.5*mesh.give_nodes().give_coor()[this_node][2]\n\t\t\t\t\n\t\t\tnew_coor.append((new_x, new_y, new_z))\n\t\t\t\t\n\t# 3. generate new node on interior edge\n\t# 1/16 o-------o 1/16 o: existing vertices\n\t# | | *: newly-generated vertices\n\t# 3/8 o---*---o 3/8\n\t# | |\n\t# 1/16 o-------o 1/16\n\n\t\telse:\n\t\t\tnew_x, new_y, new_z = (0., 0., 0.)\n\t\t\tconsidered_node = []\n\t\t\tfor vertex_index in range(2):\n\t\t\t\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\n\t\t\t\tconsidered_node.append(this_node)\n\t\t\t\tnew_x += 3./8.*mesh.give_nodes().give_coor()[this_node][0]\n\t\t\t\tnew_y += 3./8.*mesh.give_nodes().give_coor()[this_node][1]\n\t\t\t\tnew_z += 3./8.*mesh.give_nodes().give_coor()[this_node][2]\n\t\t\t\n\t\t\t# faces contain this node\n\t\t\tpotential_node = []\n\t\t\tfor face_index in edge_shared_by_faces_list[edge_index]:\t\t\n\t\t\t\tfor vertex_index in range(4):\n\t\t\t\t\t\tpotential_node.append(mesh.give_faces().give_node_list(face_index)[vertex_index])\n\t\t\t\n\t\t\touter_node = []\n\t\t\tfor node in potential_node:\n\t\t\t\tif (node not in considered_node) & (node not in outer_node):\n\t\t\t\t\touter_node.append(node)\n\t\t\t\t\t\n\t\t\tfor vertex_index in outer_node:\n\t\t\t\tnew_x += 1./16.*mesh.give_nodes().give_coor()[vertex_index][0]\n\t\t\t\tnew_y += 1./16.*mesh.give_nodes().give_coor()[vertex_index][1]\n\t\t\t\tnew_z += 1./16.*mesh.give_nodes().give_coor()[vertex_index][2]\n\t\t\t\n\t\t\tnew_coor.append((new_x, new_y, new_z))\n\n\t# update the links of edges and surfaces\n\tnew_edge_list = []\n\tnew_face_list = []\n\tfor face_index in range(mesh.give_model_inf()[2]):\n\t\told_node0 = mesh.give_faces().give_node_list(face_index)[0]\n\t\told_node1 = mesh.give_faces().give_node_list(face_index)[1]\n\t\told_node2 = mesh.give_faces().give_node_list(face_index)[2]\n\t\told_node3 = mesh.give_faces().give_node_list(face_index)[3]\n\t\t\n\t\told_edge0 = mesh.give_faces().give_edge_list(face_index)[0]\n\t\told_edge1 = mesh.give_faces().give_edge_list(face_index)[1]\n\t\told_edge2 = mesh.give_faces().give_edge_list(face_index)[2]\n\t\told_edge3 = mesh.give_faces().give_edge_list(face_index)[3]\n\t\t\n\t\tnew_node4 = old_edge0 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2] \n\t\tnew_node5 = old_edge1 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\n\t\tnew_node6 = old_edge2 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\n\t\tnew_node7 = old_edge3 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\t\n\t\tnew_node8 = mesh.give_model_inf()[0] + face_index\n\t\t\n\t\tif helper.in_list((old_node0, new_node4), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node0, new_node4))\n\t\tif helper.in_list((new_node4, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node4, new_node8))\n\t\tif helper.in_list((new_node8, new_node7), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node8, new_node7))\n\t\tif helper.in_list((new_node7, old_node0), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node7, old_node0))\n\t\tif helper.in_list((new_node4, old_node1), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node4, old_node1))\n\t\tif helper.in_list((old_node1, new_node5), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node1, new_node5))\n\t\tif helper.in_list((new_node5, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node5, new_node8))\n\t\tif helper.in_list((new_node7, old_node3), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node7, old_node3))\n\t\tif helper.in_list((old_node3, new_node6), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node3, new_node6))\n\t\tif helper.in_list((new_node6, new_node8), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node6, new_node8))\n\t\tif helper.in_list((new_node6, old_node2), new_edge_list) == False: \n\t\t\tnew_edge_list.append((new_node6, old_node2))\n\t\tif helper.in_list((old_node2, new_node5), new_edge_list) == False: \n\t\t\tnew_edge_list.append((old_node2, new_node5))\n\t\n\t\tnew_face_list.append((old_node0, new_node4, new_node8, new_node7))\n\t\tnew_face_list.append((new_node4, old_node1, new_node5, new_node8))\n\t\tnew_face_list.append((new_node7, new_node8, new_node6, old_node3))\n\t\tnew_face_list.append((new_node8, new_node5, old_node2, new_node6))\n\t\t\n\tnew_edges = geo.Edge(new_edge_list)\n\t\n\tnew_faces = geo.Face(new_face_list, new_edges)\n\t\t\n\t# update existing nodes\t\n\tfor node_index in range(mesh.give_model_inf()[0]):\n\t\t\n\t\tring1, ring2 = helper.find_neighbour_node(new_edges, new_faces, node_index)\n\t\tvalence = helper.find_valence(node_index, new_faces) \n\t\t#: valence: the number of faces sharing on specific edge\n\n\t# 4. update existing corner vertex\n\t# 2/4 @---* 1/4 *: newly-generated vertices\n\t# | | @: existing vertices to be updated\n\t# 1/4 *---* 0 The higher mask values on neighbouring vertices, \n\t# the more likely a square mesh will be refined into a sphere.\n\t \n\t\tif valence == 1:\n\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tprint\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tnew_x += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\tnew_y += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\tnew_z += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\n\t\t\tfor node_in_ring2 in ring2:\n\t\t\t\tnew_x += 0.*mesh.give_nodes().give_coor()[node_in_ring2][0]\n\t\t\t\tnew_y += 0.*mesh.give_nodes().give_coor()[node_in_ring2][1]\n\t\t\t\tnew_z += 0.*mesh.give_nodes().give_coor()[node_in_ring2][2]\n\t\t\t\t\n\t\t\tnew_x += 2./4.*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += 2./4.*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += 2./4.*mesh.give_nodes().give_coor()[node_index][2]\n\n\t# 5. update existing boundary joint vertex\n\t# 3/4\n\t# 1/8 *---*---* 1/8 *: newly-generated vertices\n\t# | | | @: existing vertices to be updated\n\t# 0 *---*---* 0\n\n\t\telif valence == 2:\n\t\t\t\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tif helper.find_valence(node_in_ring1, new_faces) <= 2: \n\t\t\t\t\tnew_x += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\t\tnew_y += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\t\tnew_z += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\t\t\t\t\t\n\t\t\tnew_x += 3./4.*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += 3./4.*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += 3./4.*mesh.give_nodes().give_coor()[node_index][2]\n\t\n\t# 6. update new node on interior edge\n\t# * r/k\n\t# /\\ b/k*\n\t# *__/ \\___ r/k\n\t# \\ \\ /¬¬/ *: newly-generated vertices: \n\t# \\ \\/ / b = 3/2/valence, r = 1/4/valence\n\t# *--@--* b/k\t @: existing vertices to be updated: 1-b-r\t\t\n\t# / /\\ \\\n\t# /__/ \\__\\\n\t# * \\ / * r/k\n\t# \\/\n\t\t\n\t\telse:\n\t\t\tnew_x, new_y, new_z = (0, 0, 0)\n\t\t\tbeta = 3./2./valence\n\t\t\tgamma = 1./4./valence\n\t\t\tfor node_in_ring1 in ring1:\n\t\t\t\tnew_x += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][0]\n\t\t\t\tnew_y += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][1]\n\t\t\t\tnew_z += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][2]\n\t\t\t\n\t\t\tfor node_in_ring2 in ring2:\n\t\t\t\tnew_x += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][0]\n\t\t\t\tnew_y += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][1]\n\t\t\t\tnew_z += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][2]\n\t\t\t\n\t\t\tnew_x += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][0]\n\t\t\tnew_y += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][1]\n\t\t\tnew_z += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][2]\n\t\t\n\t\tnew_coor[node_index] = (new_x, new_y, new_z)\n\t\n\tnew_nodes = geo.Node(new_coor)\n\t\n\tmesh.update(new_nodes, new_edges, new_faces)\n\t\n\t# return new_mesh\n\treturn mesh","def surface(self):\n return self._surface","def plot_surface(self):\n X, Y = np.meshgrid(self.x, self.y)\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n ax.plot_surface(X=X, Y=Y, Z=self.z)\n plt.show()","def draw_layers(self):\n\t\tfor z in xrange(0,16):\n\t\t\t#create surface for this layer\n\t\t\tsrf = pygame.Surface((16,128))\n\t\t\tfor x in xrange(0,16):\n\t\t\t\tfor y in xrange(0,128):\n\t\t\t\t\tv = self.data[ self.xyz_to_offset( x,y,z) ]\n\t\t\t\t\tif v != 0:\n\t\t\t\t\t\tsrf.fill( BLOCKS.get(v, [0,0])[1], \t(x, 127 -y, 1, 1 ))\n\t\t\t#save layer to dict for this chunk\n\t\t\tself.layers[z] = srf","def _prepare_plane(self):\n verticies = [\n # main plane - note that the mainplane is scaled so the mat_plane\n # matrix will it transform to the correct coordinates\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n\n # coord plane\n 0, 0,\n 0, -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], 0,\n 0, 0,\n\n # axes\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\n 0, 0, 0, -self.o_wh[1], #y\n ]\n\n colors = [\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n .9, .9, .9, 9.0, # plot box\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n 0.0, 0.0, 0.0, 1.0, #lines\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n ]\n\n self._fonts = []\n for u in range(1, self._unit_count[0]+1):\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]+0.02)\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]-0.02)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\n (-self.o_wh[1]+(self.i_border[3])*0.5)\n ])\n for u in range(0, self._unit_count[1]):\n verticies.append(0.02)\n verticies.append(-self._unit_w[1]*u)\n verticies.append(-0.02)\n verticies.append(-self._unit_w[1]*u)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\n (0.025)*self._scaling[0],\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\n ])\n\n self._draw_plane_indicies = (0, 12)\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\n\n # convert data into valid data format\n verticies = numpy.array(verticies, dtype=numpy.float32)\n colors = numpy.array(colors, dtype=numpy.float32)\n\n self._plane_vao = util.VAO()\n self._plane_vbo = util.VBO(2)\n\n with self._plane_vao:\n # plane verticies\n with self._plane_vbo.get(0):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(0)\n\n # place vertex colors\n with self._plane_vbo.get(1):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(1)","def halfedgeConstruction(self,facetList):\n\t\tedges = []\n\t\t# the temporary map of the halfedges\n\t\tedgeMap = {}\n\t\tcount = 0\n\t\tfor i in range(0,len(facetList)):\n\t\t\t# \n\t\t\tfor j in range(0,len(facetList[i])):\n\t\t\t\t# j is the index of the current vertex\n\t\t\t\tkey = (facetList[i][j-1],facetList[i][j])\n\t\t\t\tedges.append(key)\n\t\t\t\tedgeMap[key] = count\n\t\t\t\tcount += 1\n\t\t\t\t# initialze the current halfedge\n\t\t\t\the = Halfedge()\n\t\t\t\t# assume that the mesh has been well oriented\n\t\t\t\the.setVertex(self._mesh._vertices[facetList[i][j]])\n\t\t\t\tself._mesh._halfedges.append(he)\n\t\t# construct the opposite halfedge\n\t\tfor key in edgeMap:\n\t\t\ti = edgeMap[key]\n\t\t\tif self._mesh._halfedges[i].opposite() is None:\n\t\t\t\t# the opposite has not been set\n\t\t\t\toppo = key[1],key[0]\n\t\t\t\tif oppo in edgeMap:\n\t\t\t\t\t# interior edge\n\t\t\t\t\tj = edgeMap[oppo]\n\t\t\t\t\tself._mesh._halfedges[i].setOpposite(self._mesh._halfedges[j])\n\t\t\t\t\tself._mesh._halfedges[j].setOpposite(self._mesh._halfedges[i])\n\t\t\t\telse:\n\t\t\t\t\t# border edge\n\t\t\t\t\t# construct a border halfedge\n\t\t\t\t\the = Halfedge()\n\t\t\t\t\t# the edge is border edge\n\t\t\t\t\the._isBorder = True\n\t\t\t\t\tself._mesh._halfedges[i].setOpposite(he)\n\t\t\t\t\the.setOpposite(self._mesh._halfedges[i])\n\t\t\t\t\t# append the halfedge\n\t\t\t\t\tself._mesh._halfedges.append(he)\n\t\t\t\t\tcount += 1\n\t\t# set next and prev halfedge\n\t\t# the interior edges\n\t\tcount = 0\n\t\tfor i in range(0,len(facetList)):\n\t\t\tfor j in range(0,len(facetList[i])):\n\t\t\t\tif j == len(facetList[i])-1:\n\t\t\t\t\t# the last edge: the next edge is the beggining edge\n\t\t\t\t\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count])\n\t\t\t\t\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\n\t\t\t\telif j == 0:\n\t\t\t\t\t# the beginning edge: the prev edge is the last one\n\t\t\t\t\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\n\t\t\t\t\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+len(facetList[i])-1])\n\t\t\t\telse:\n\t\t\t\t\t# the interior edge\n\t\t\t\t\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\n\t\t\t\t\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\n\t\t\t# the count\n\t\t\tcount += len(facetList[i])\n\t\t# the border edges\n\t\tfor i in range(count,len(self._mesh._halfedges)):\n\t\t\the = self._mesh._halfedges[i]\n\t\t\t# first set the vertex\n\t\t\the.setVertex(he.opposite().prev().vertex())\n\t\t\t# two kinds of situation\n\t\t\tif he.opposite().prev().opposite().isBorder():\n\t\t\t\the.setNext(he.opposite().prev().opposite())\n\t\t\telse:\n\t\t\t\the.setNext(he.opposite().prev().opposite().prev().opposite())\n\t\t\tif he.opposite().next().opposite().isBorder():\n\t\t\t\the.setPrev(he.opposite().next().opposite())\n\t\t\telse:\n\t\t\t\the.setPrev(he.opposite().next().opposite().next().opposite())","def draw(self, surface):\n for box in self.checkboxes:\n box.draw(surface)","def face_lattice(self):\n try:\n return self._face_lattice\n except AttributeError:\n pass\n \n coatom_to_Hindex = [ h.index() for h in self.inequality_generator() ]\n Hindex_to_coatom = [None] * self.n_Hrepresentation() \n for i in range(0,len(coatom_to_Hindex)):\n Hindex_to_coatom[ coatom_to_Hindex[i] ] = i\n \n atom_to_Vindex = [ v.index() for v in self.Vrep_generator() if not v.is_line() ]\n Vindex_to_atom = [None] * self.n_Vrepresentation() \n for i in range(0,len(atom_to_Vindex)):\n Vindex_to_atom[ atom_to_Vindex[i] ] = i\n \n atoms_incidences = [ tuple([ Hindex_to_coatom[h.index()] \n for h in v.incident() if h.is_inequality() ]) \n for v in self.Vrepresentation() if not v.is_line() ]\n \n coatoms_incidences = [ tuple([ Vindex_to_atom[v.index()] \n for v in h.incident() if not v.is_line() ])\n for h in self.Hrepresentation() if h.is_inequality() ]\n \n atoms_vertices = [ Vindex_to_atom[v.index()] for v in self.vertex_generator() ]\n equations = [ e.index() for e in self.equation_generator() ]\n lines = [ l.index() for l in self.line_generator() ]\n\n def face_constructor(atoms,coatoms):\n if len(atoms)==0:\n Vindices = ()\n else:\n Vindices = tuple(sorted([ atom_to_Vindex[i] for i in atoms ]+lines))\n Hindices = tuple(sorted([ coatom_to_Hindex[i] for i in coatoms ]+equations))\n return PolyhedronFace(self, Vindices, Hindices)\n\n self._face_lattice = Hasse_diagram_from_incidences\\\n (atoms_incidences, coatoms_incidences, face_constructor=face_constructor, required_atoms=atoms_vertices)\n return self._face_lattice","def update_mesh(self, all_meshes):\n if isinstance(all_meshes, Mesh):\n mesh_tp = []\n mesh_tp.append(all_meshes)\n all_meshes = mesh_tp\n\n for i, mesh in enumerate(all_meshes):\n if mesh.time.size != 1:\n raise IndexError(\"Mesh should be from one frame only\")\n\n if len(self.all_meshes) <= i or mesh.channel.size != self.all_meshes[i].channel.size:\n self.new_mesh_set(all_meshes)\n return # Prevent calling update_markers recursively\n\n if not isinstance(all_meshes, list):\n raise TypeError(\"Please send a list of mesh to update_mesh\")\n\n self.all_meshes = all_meshes\n\n for i, mesh in enumerate(self.all_meshes):\n points = vtkPoints()\n n_vertex = mesh.channel.size\n mesh = np.array(mesh)\n for j in range(n_vertex):\n points.InsertNextPoint(mesh[0:3, j])\n\n poly_line = self.mesh_actors[i].GetMapper().GetInput()\n poly_line.SetPoints(points)\n self.mesh_actors[i].GetProperty().SetLineWidth(self.mesh_linewidth)","def faces(self) -> Polygon:\n return Polygon(self.array, copy=False)","def buildSurface(self, idx = 0, surface = 1, z = 1, verbose = 1,\\\n strained = False, vacuum = 0, ab = False):\n\n \"\"\"Basis for the selected surface, and the cell repetitions\"\"\"\n rep = np.zeros((3, 4))\n new_base = np.zeros((3, 3))\n\n altBase1 = np.zeros((3, 3))\n altBase2 = np.zeros((3, 3))\n if ab:\n B1, B2 = self.getAB()\n\n if surface == 1:\n old_base = self.base_1\n spec = self.spec_1\n mass = self.mass_1\n pos = self.pos_1\n\n new_base[2, 2] = self.base_1[2, 2] * z\n new_base[0:2, 0:2] = self.cell_1[idx, :, :]\n \n if ab:\n altBase1[:2, :2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\n altBase1[2, 2] = B1[2, 2] * z\n \n rep[0:2, 0:2] = self.rep_1[idx, :, :]\n rep[:, 2] = np.sum(rep, axis = 1)\n elif surface == 2:\n old_base = self.base_2\n spec = self.spec_2\n mass = self.mass_2\n pos = self.pos_2\n\n new_base[2, 2] = self.base_2[2, 2] * z\n new_base[0:2, 0:2] = self.cell_2[idx, :, :]\n \n if ab:\n altBase2[:2, :2] = np.matmul(B2[:2, :2], self.rep_2[idx, :, :])\n altBase2[2, 2] = B2[2, 2] * z\n\n rep[0:2, 0:2] = self.rep_2[idx, :, :]\n rep[:, 2] = np.sum(rep, axis = 1)\n\n \"\"\"Set all hi-lo limits for the cell repetitions\"\"\"\n h = 2\n rep = [rep[0, :].min() - h, rep[0, :].max() + h,\\\n rep[1, :].min() - h, rep[1, :].max() + h,\\\n 0, z - 1]\n\n \"\"\"Extend the cell as spcefied\"\"\"\n pos_ext, spec_ext, mass_ext = ut.extendCell(base = old_base, rep = rep,\\\n pos = pos.T, spec = spec,\\\n mass = mass)\n\n if surface == 1:\n \"\"\"Change to alternative base_1 if specified\"\"\"\n if ab:\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n new_base = altBase1\n pos_ext = np.matmul(new_base, pos_d)\n if verbose > 0:\n string = \"Surface 1 constructed with alternative base\"\n ut.infoPrint(string)\n\n elif surface == 2:\n \"\"\"Initial rotation\"\"\"\n initRot = np.deg2rad(self.ang[idx])\n\n \"\"\"Rotate the positions pos_rot = R*pos\"\"\"\n pos_ext = ut.rotate(pos_ext, initRot, verbose = verbose - 1)\n\n \"\"\"Construct it in the alternative base_2 if specified\"\"\"\n if ab:\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n new_base = altBase2\n pos_ext = np.matmul(new_base, pos_d)\n if verbose > 0:\n string = \"Surface 2 constructed with alternative base\"\n ut.infoPrint(string)\n\n \"\"\"Strain the cell if specified\"\"\"\n if strained:\n\n \"\"\"If the cell is to be strained then convert to direct coordinates\"\"\"\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n\n \"\"\"Convert back to cartesian coordinates.\"\"\"\n if ab:\n \"\"\"Strain it to the alternative base_1\"\"\"\n new_base[0:2, 0:2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\n string = \"Surface 2 strained to match surface 1 with an alternative base\"\n \n else:\n \"\"\"Strain it to the bottom surface\"\"\"\n new_base[0:2, 0:2] = self.cell_1[idx, :, :].copy()\n string = \"Surface 2 strained to match surface 1\"\n\n pos_ext = np.matmul(new_base, pos_d)\n\n if verbose > 0:\n ut.infoPrint(string)\n\n \"\"\"Convert the entire new cell to direct coordinates\"\"\"\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\n\n \"\"\"Remove all positions outside [0, 1)\"\"\"\n pos_d = np.round(pos_d, 8)\n new_base = np.round(new_base, 8)\n\n keep = np.all(pos_d < 1, axis = 0) * np.all(pos_d >= 0, axis = 0)\n pos_d = pos_d[:, keep]\n species = spec_ext[keep]\n mass = mass_ext[keep]\n\n \"\"\"Return to cartesian coordinates and change shape to (...,3)\"\"\"\n pos = np.matmul(new_base, pos_d).T\n\n \"\"\"Add vacuum if specified\"\"\"\n new_base[2, 2] = new_base[2, 2] + vacuum\n if verbose: \n string = \"Vacuum added: %.2f\"\\\n % (vacuum)\n ut.infoPrint(string)\n\n return new_base, pos, species, mass","def update_points(self, *args):\n points = [Window.width / 2, Window.height / 2, .5, .5]\n i = 0\n while i < 2 * pi:\n i += 0.01 * pi\n points.extend([\n Window.width / 2 + cos(i) * (self.radius + self.sin_wobble *\n sin(i * self.sin_wobble_speed)),\n Window.height / 2 + sin(i) * (self.radius + self.sin_wobble *\n sin(i * self.sin_wobble_speed)),\n self.offset_x + sin(i),\n self.offset_y + cos(i)])\n\n self.mesh_points = points","def _draw(self):\r\n \r\n if self.active:\r\n self.surface = self.activeSurface # Set active surface to be displayed.\r\n else:\r\n self.surface = self.passiveSurface # Set passive surface to be displayed.\r","def test_face_in_face(self):\n w = mt.createCube(marker=1, boundaryMarker=1)\n b = w.boundary(2)\n\n pad = mt.createFacet(mt.createCircle(radius=0.2, segments=12,\n isHole=True))\n b2 = pad.boundary(0)\n\n # rotate to match target norm and pos\n rot = pg.core.getRotation(b2.norm(), b.norm())\n pad.transform(rot)\n pad.translate(b.center())\n\n # create a boundary with new marker match the hole\n w.copyBoundary(b2)\n\n w.createBoundary(w.nodes([w.createNode(n.pos()).id() for n in b2.nodes()]),\n marker=2)\n\n #print(w.boundaryMarkers())\n\n mesh = mt.createMesh(w)\n\n #pg.show(mesh)\n # w.exportPLC('pad.poly')\n # mesh.exportBoundaryVTU('b.vtu')\n np.testing.assert_array_equal(pg.unique(pg.sort(mesh.boundaryMarkers())),\n [0, 1, 2])\n\n # print(mesh)\n # mesh.exportBoundaryVTU('b.vtu')\n pg.show(mesh)","def create_reference_array(self):\r\n self.active = True\r\n self.pxarray = pygame.surfarray.pixels3d(self.surface)\r\n pygame.display.flip()\r\n return","def __init__(self):\n self.lattices = []\n self.meshfns = []","def new_mesh_set(self, all_meshes):\n if isinstance(all_meshes, Mesh):\n mesh_tp = MeshCollection()\n mesh_tp.append(all_meshes)\n all_meshes = mesh_tp\n\n if all_meshes.get_num_frames() is not 1:\n raise IndexError(\"Mesh should be from one frame only\")\n\n if not isinstance(all_meshes, MeshCollection):\n raise TypeError(\"Please send a list of mesh to update_mesh\")\n self.all_meshes = all_meshes\n\n # Remove previous actors from the scene\n for actor in self.mesh_actors:\n self.parent_window.ren.RemoveActor(actor)\n self.mesh_actors = list()\n\n # Create the geometry of a point (the coordinate) points = vtkPoints()\n for (i, mesh) in enumerate(self.all_meshes):\n points = vtkPoints()\n for j in range(mesh.get_num_vertex()):\n points.InsertNextPoint([0, 0, 0])\n\n # Create an array for each triangle\n cell = vtkCellArray()\n for j in range(mesh.get_num_triangles()): # For each triangle\n line = vtkPolyLine()\n line.GetPointIds().SetNumberOfIds(4)\n for k in range(len(mesh.triangles[j])): # For each index\n line.GetPointIds().SetId(k, mesh.triangles[j, k])\n line.GetPointIds().SetId(3, mesh.triangles[j, 0]) # Close the triangle\n cell.InsertNextCell(line)\n poly_line = vtkPolyData()\n poly_line.SetPoints(points)\n poly_line.SetLines(cell)\n\n # Create a mapper\n mapper = vtkPolyDataMapper()\n mapper.SetInputData(poly_line)\n\n # Create an actor\n self.mesh_actors.append(vtkActor())\n self.mesh_actors[i].SetMapper(mapper)\n\n self.parent_window.ren.AddActor(self.mesh_actors[i])\n self.parent_window.ren.ResetCamera()\n\n # Update marker position\n self.update_mesh(self.all_meshes)","def change_face(self, face):\n if self.face is not None:\n self.face.remove_point(self)\n\n self.face = face\n self.face.add_point(self)","def update_mesh(self, all_meshes):\n if isinstance(all_meshes, Mesh):\n mesh_tp = MeshCollection()\n mesh_tp.append(all_meshes)\n all_meshes = mesh_tp\n\n if all_meshes.get_num_frames() is not 1:\n raise IndexError(\"Mesh should be from one frame only\")\n\n for i in range(len(all_meshes)):\n if all_meshes.get_mesh(i).get_num_vertex() is not self.all_meshes.get_mesh(i).get_num_vertex():\n self.new_mesh_set(all_meshes)\n return # Prevent calling update_markers recursively\n\n if not isinstance(all_meshes, MeshCollection):\n raise TypeError(\"Please send a list of mesh to update_mesh\")\n\n self.all_meshes = all_meshes\n\n for (i, mesh) in enumerate(self.all_meshes):\n points = vtkPoints()\n for j in range(mesh.get_num_vertex()):\n points.InsertNextPoint(mesh[0:3, j])\n\n poly_line = self.mesh_actors[i].GetMapper().GetInput()\n poly_line.SetPoints(points)","def __init__(self, mesh):\n self._mesh = mesh\n # number of triangles in this patch\n self._nTris = 0\n # offset into mesh._indices where this patch starts\n self._startIndex = mesh.vertexCount()\n # indices into the parent mesh's vertex list\n self._indices = []\n # r, g, b, a\n self._color = [0.1, 0.1, 0.7, 1.0]\n # 'wire', 'flat', or 'smooth'\n self._surfaceMode = 'smooth'\n # DEBUG:\n self._showNormals = False","def SplitSurface(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_FaceDivide_SplitSurface(self, *args)","def faceTrace(self, pi, fi, vi):\n if pi == 1:\n face = self.poly1.faces[fi]\n elif pi == 2:\n face = self.poly2.faces[fi]\n else:\n raise ValueError('pi must be 1 or 2')\n n = len(face.vertices)\n initialV = face.vertices[vi]\n newFace = [initialV]\n initialI = self.getIntersector(initialV)\n assert initialI is not None # This checks that the vertex was actually an intersection\n # This part determines which side of the face is the way to go\n if self.getIntersector(face.vertices[(vi + 1) % n]) is not None or face.vertices[(vi + 1) % n].isInterior():\n step = 1\n elif self.getIntersector(face.vertices[(vi - 1) % n]) is not None or face.vertices[(vi - 1) % n].isInterior():\n step = -1\n else:\n raise ValueError('The vertex given has no adjacent interior or intersector vertex')\n i = (vi + step) % n\n force = True\n while force or i != (vi + step) % n:\n force = False\n # Tracing the interior\n while (face.vertices[i]).isInterior():\n newFace.append(self.newVertex(face.vertices[i]))\n face.vertices[i].markFTraced(face)\n # print('fTracing', i)\n i += step\n # Tracing the surface\n newFace.append(self.newVertex(face.vertices[i]))\n face.vertices[i].markFTraced(face)\n lastI = self.getIntersector(face.vertices[i])\n potentialInters = self.nextIntersectors(lastI)\n if abs((vector(potentialInters[0].v) - vector(lastI.v))\n .dotProduct(face.normalVect())) < COMPARISON_EPSILON:\n inter = potentialInters[0]\n elif abs((vector(potentialInters[1].v) - vector(lastI.v))\n .dotProduct(face.normalVect())) < COMPARISON_EPSILON:\n inter = potentialInters[1]\n else:\n raise Exception('The nextIntersectors are weird (1)')\n while inter.v not in face.vertices:\n nextInters = self.nextIntersectors(inter)\n if nextInters[0] != lastI:\n lastI = inter\n inter = nextInters[0]\n elif nextInters[1] != lastI:\n lastI = inter\n inter = nextInters[1]\n else:\n raise Exception('The nextIntersectors are weird (2)')\n newFace.append(lastI.v)\n inter.v.markFTraced(face)\n i = (face.vertices.index(inter.v) + step) % n\n if step == -1:\n newFace.reverse()\n self.result.addFace(newFace, True)","def draw(self, surface):\n\n\t\tsurface.blit(self.image, self.rect.topleft)","def traceSurface(self, inter):\n assert self.nonDoubleIntersectors()\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\n assert all(f.hasNoDoubleVertices() for f in self.poly1.faces)\n assert all(f.hasNoDoubleVertices() for f in self.poly2.faces)\n assert self.nonDoubleVertices()\n i = self.nextIntersectors(inter)[0]\n assert i.v != inter.v\n assert i.v.dist(inter.v) != 0\n lastI = inter\n self.result.addEdge(self.newVertex(lastI), self.newVertex(i))\n i.sTraced = True\n while i != inter:\n nextInts = self.nextIntersectors(i)\n if nextInts[0] != lastI:\n lastI = i\n i = nextInts[0]\n else:\n lastI = i\n i = nextInts[1]\n self.result.addEdge(self.newVertex(lastI), self.newVertex(i))\n i.sTraced = True","def change_colour_surface(surface, r, g, b):\n arr = pg.surfarray.pixels3d(surface)\n arr[:, :, 0] = r\n arr[:, :, 1] = g\n arr[:, :, 2] = b","def subdivide(self, subdivision, new_point):\n\n\t\tassert(subdivision.ndim == 3)\n\n\t\t# Find the attached faces.\n\t\tface1, face2, face3, face4 = self.attached_faces\n\n\t\t# Find the attached lines, and be able to associate them with the\n\t\t# faces.\n\t\tline12, = face1.attached_lines & face2.attached_lines\n\t\tline13, = face1.attached_lines & face3.attached_lines\n\t\tline14, = face1.attached_lines & face4.attached_lines\n\t\tline23, = face2.attached_lines & face3.attached_lines\n\t\tline24, = face2.attached_lines & face4.attached_lines\n\t\tline34, = face3.attached_lines & face4.attached_lines\n\n\t\t# Find the attached points, and be able to associate them with the \n\t\t# faces.\n\t\tpoint123, = line12.attached_points & line13.attached_points\n\t\tpoint124, = line12.attached_points & line14.attached_points\n\t\tpoint134, = line13.attached_points & line14.attached_points\n\t\tpoint234, = line23.attached_points & line24.attached_points\n\n\t\t# Create the new lines.\n\t\tnew_line123 = matplot3dext.objects.line.Line(point123, new_point)\n\t\tnew_line124 = matplot3dext.objects.line.Line(point124, new_point)\n\t\tnew_line134 = matplot3dext.objects.line.Line(point134, new_point)\n\t\tnew_line234 = matplot3dext.objects.line.Line(point234, new_point)\n\n\t\t# Create the new faces.\n\t\tnew_face12 = matplot3dext.objects.face.Face(\n\t\t\t\tline12, new_line123, new_line124)\n\t\tnew_face13 = matplot3dext.objects.face.Face(\n\t\t\t\tline13, new_line123, new_line134)\n\t\tnew_face14 = matplot3dext.objects.face.Face(\n\t\t\t\tline14, new_line124, new_line134)\n\t\tnew_face23 = matplot3dext.objects.face.Face(\n\t\t\t\tline23, new_line123, new_line234)\n\t\tnew_face24 = matplot3dext.objects.face.Face(\n\t\t\t\tline24, new_line124, new_line234)\n\t\tnew_face34 = matplot3dext.objects.face.Face(\n\t\t\t\tline34, new_line134, new_line234)\n\n\t\t# Create the new tetrahedra.\n\t\t#\n\t\t# Make a sketch to understand what's going on now.\n\t\tnew_tetrahedron1 = Tetrahedron(\n\t\t\t\tface1, new_face12, new_face13, new_face14)\n\t\tnew_tetrahedron2 = Tetrahedron(\n\t\t\t\tface2, new_face12, new_face23, new_face24)\n\t\tnew_tetrahedron3 = Tetrahedron(\n\t\t\t\tface3, new_face13, new_face23, new_face34)\n\t\tnew_tetrahedron4 = TetrahedroN(\n\t\t\t\tface4, new_face14, new_face24, new_face34)\n\n\t\tself.replace_by([new_tetrahdron1, new_tetrahedron2, \n\t\t\t\tnew_tetrahedron3, new_tetrahedron4], subdivision.world)\n\n\t\treturn new_point","def Face_Cycle_R(self,event):\n t=event.widget.find_closest(event.x, event.y)[0]\n u=int(self.canvas.itemcget(t,\"tags\").split()[1])\n if u not in [4,13,22,31,40,49]:\n v=self.colours_face[self.ocol[self.canvas.itemcget(t,\"fill\")][1]][0][0]\n self.cubestring[u]=v\n self.cube.cube = self.cubestring#Cube.set(self.cubestring)\n self.map_face()\n else:\n print(\"Cant Change Center Cubit\")","def assemble_hyper_surface(self):\n def get_row_no(k0):\n hdf = pd.HDFStore(self.ewlibpath, 'r')\n hdf0 = hdf.get(k0)\n idx = np.where((np.abs(hdf0.th_wavelength-self.wavelength)<=0.025)\n & (np.abs(hdf0.th_EP - self.ep)<=0.02)\n & (hdf0.element == self.element))[0]\n if idx.size!=0:\n idx = idx[0]\n else:\n idx = -1\n hdf.close()\n return idx\n\n if self.interpolated:\n raise NotImplementedError(\"Interpolated model doesn't have such method!\")\n\n row_no = get_row_no(self._keys[0])\n if row_no == -1:\n warnings.warn(\"Data for interpolation is not enough!\")\n self._hyper_surface = None\n return self._hyper_surface\n else:\n f = h5py.File(self.ewlibpath, 'r')\n if self.cal == \"nlte\":\n ews = [np.array(f[k+\"/table\"])[row_no][1][3] for k in self._keys]\n else:\n ews = [np.array(f[k+\"/table\"])[row_no][1][2] for k in self._keys]\n f.close()\n\n\n datapoints = np.concatenate((np.array(self._atmos_pars), np.transpose([ews])), axis=1)\n datapoints = datapoints[~np.isnan(datapoints).any(axis=1)]\n\n if datapoints.shape[0] <= 3:\n warnings.warn(\"Data for interpolation is not enough!\")\n self._hyper_surface = None\n del datapoints\n return self._hyper_surface\n else:\n self._hyper_surface = datapoints\n print(\"Grid is prepared!\")\n del datapoints\n return self._hyper_surface","def __init__( self , l , w , h , pos = [ 0 , 0 , 0 ] ):\r\n # NOTE: Poses are stored as transforms , since that is what you need poses for anyway\r\n \r\n # FIXME : This object needs a transform to the parent frame\r\n \r\n self.vertices = ( # List of untransformed vertices\r\n 0 , 0 , 0 ,\t# vertex 0 3-------2 # NOTE: Z+ is UP\r\n l , 0 , 0 ,\t# vertex 1 !\\ !\\\r\n 0 , 0 , h ,\t# vertex 2 ! \\ Z \\\r\n l , 0 , h ,\t# vertex 3 ! 7=======6\r\n 0 , w , 0 ,\t# vertex 4 1--|X---0 |\r\n l , w , 0 ,\t# vertex 5 \\ | \\ |\r\n 0 , w , h ,\t# vertex 6 \\| Y|\r\n l , w , h ,\t# vertex 7 5=======4\r\n )\r\n \r\n self.vertX = list( self.vertices ) # List of transformed vertices\r\n \r\n self.indices = ( # NOTE: Vertices must have CCW order to point the normals towards exterior , \r\n 0 , 1 , 3 , 2 , # back face 3-----2 3-----2 right hand rule , otherwise dot products computed for backface-culling \r\n 4 , 6 , 7 , 5 , # front face !\\ up \\ !back !\\ will have the wrong sign! faces vanish!\r\n 0 , 2 , 6 , 4 , # left face right7=====6 ! ! 6\r\n 1 , 5 , 7 , 3 , # right face 1 |front| 1-----0l|eft \r\n 0 , 4 , 5 , 1 , # down face \\| | \\down \\|\r\n 2 , 3 , 7 , 6 , # up face 5=====4 5=====4 \r\n )\r\n \r\n self.linDices = (\r\n 3 , 2 ,\r\n 2 , 6 ,\r\n 6 , 7 ,\r\n 7 , 3 ,\r\n 3 , 1 ,\r\n 2 , 0 ,\r\n 6 , 4 ,\r\n 7 , 5 ,\r\n 0 , 4 ,\r\n 4 , 5 ,\r\n 5 , 1 ,\r\n 1 , 0\r\n )\r\n \r\n self.color = ( 88 , 181 , 74 ) # Body color\r\n self.colorLine = ( 0 , 0 , 255 ) # Line color\r\n \r\n self.pos3D = pos # 3D position in the parent frame\r\n \r\n self.thetaDeg = 0.0\r\n self.thetaRad = 0.0\r\n self.rotAxis = [ 0.0 , 0.0 , 1.0 ]\r\n \r\n self.rotnByOGL = False # Flag for whether to apply rotation by OpenGL: True - OpenGL , False - Matrix Algebra\r","def surfacePairs(self):\n return self._els","def __init__(self, vertices, edges, faces):\n self.vertices = vertices\n self.edges = edges\n self.faces = faces","def _get_surfaces(idf):\n surfaces = idf.getsurfaces() + idf.getshadingsurfaces() + idf.getsubsurfaces()\n return surfaces","def select_faces(maxAngle):\n date_1 = datetime.datetime.now()\n print(\"Start\")\n\n print(maxAngle, maxAngle*180/pi)\n\n # Get the active object\n obj = bpy.context.active_object\n\n # Add the vertices location in an array\n tabVertices = []\n for vertex in obj.data.vertices:\n tabVertices.append(obj.matrix_world @ vertex.co)\n\n # Find the downward vector in function of the angles of the mesh\n matrix_new = obj.matrix_world.to_3x3().inverted()\n no_world = matrix_new @ mathutils.Vector((0,0,-1))\n no_world.normalize() \n print(no_world)\n vecDir = no_world\n\n\n # Arrays for the function C parameters\n tabPoly = []\n tabNormalX = []\n tabNormalY = []\n tabNormalZ = []\n tabFaces = []\n\n tabPoint1X = []\n tabPoint1Y = []\n tabPoint2X = []\n tabPoint2Y = []\n tabPoint3X = []\n tabPoint3Y = []\n tabPoint1Z = []\n tabPoint2Z = []\n tabPoint3Z = []\n\n # Fill the arrays\n for poly in obj.data.polygons:\n tabPoly.append(poly.index)\n tabNormalX.append(poly.normal[0])\n tabNormalY.append(poly.normal[1])\n tabNormalZ.append(poly.normal[2])\n tabFaces.append(0)\n \n tabPoint1X.append(tabVertices[poly.vertices[0]].x)\n tabPoint1Y.append(tabVertices[poly.vertices[0]].y)\n tabPoint2X.append(tabVertices[poly.vertices[1]].x)\n tabPoint2Y.append(tabVertices[poly.vertices[1]].y)\n tabPoint3X.append(tabVertices[poly.vertices[2]].x)\n tabPoint3Y.append(tabVertices[poly.vertices[2]].y)\n tabPoint1Z.append(tabVertices[poly.vertices[0]].z)\n tabPoint2Z.append(tabVertices[poly.vertices[1]].z)\n tabPoint3Z.append(tabVertices[poly.vertices[2]].z)\n\n print(len(tabPoly)) \n\n print(os.path.dirname(__file__))\n # Get the filepath of the dll file\n functionC = ctypes.CDLL(os.path.dirname(__file__) + \"\\\\function.dll\")\n\n # Create array for C function\n seq = ctypes.c_int * len(tabPoly)\n arrIndex = seq(*tabPoly)\n\n seq = ctypes.c_float * len(tabNormalX)\n arrNormalX = seq(*tabNormalX)\n seq = ctypes.c_float * len(tabNormalY)\n arrNormalY = seq(*tabNormalY)\n seq = ctypes.c_float * len(tabNormalZ)\n arrNormalZ = seq(*tabNormalZ)\n\n seq = ctypes.c_int * len(tabFaces)\n arrFaces = seq(*tabFaces)\n\n seq = ctypes.c_float * len(tabPoint1X)\n arrPoint1X = seq(*tabPoint1X)\n seq = ctypes.c_float * len(tabPoint1Y)\n arrPoint1Y = seq(*tabPoint1Y)\n seq = ctypes.c_float * len(tabPoint2X)\n arrPoint2X = seq(*tabPoint2X)\n seq = ctypes.c_float * len(tabPoint2Y)\n arrPoint2Y = seq(*tabPoint2Y)\n seq = ctypes.c_float * len(tabPoint3X)\n arrPoint3X = seq(*tabPoint3X)\n seq = ctypes.c_float * len(tabPoint3Y)\n arrPoint3Y = seq(*tabPoint3Y)\n seq = ctypes.c_float * len(tabPoint1Z)\n arrPoint1Z = seq(*tabPoint1Z)\n seq = ctypes.c_float * len(tabPoint2Z)\n arrPoint2Z = seq(*tabPoint2Z)\n seq = ctypes.c_float * len(tabPoint3Z)\n arrPoint3Z = seq(*tabPoint3Z)\n\n date_3 = datetime.datetime.now()\n \n # Call the C function\n functionC.select_faces(arrIndex,len(tabPoly),arrNormalX,arrNormalY,arrNormalZ,ctypes.c_float(maxAngle),ctypes.c_float(vecDir.x),ctypes.c_float(vecDir.y),ctypes.c_float(vecDir.z),arrFaces,arrPoint1X,arrPoint1Y,arrPoint2X,arrPoint2Y,arrPoint3X,arrPoint3Y,arrPoint1Z,arrPoint2Z,arrPoint3Z)\n\n date_4 = datetime.datetime.now()\n\n # Switch in edit mode\n bpy.ops.object.mode_set(mode = 'EDIT')\n # Deselect all the faces\n bpy.ops.mesh.select_all(action = 'DESELECT')\n bpy.ops.mesh.select_mode(type=\"FACE\")\n # Switch in object mode\n bpy.ops.object.mode_set(mode = 'OBJECT')\n\n # Select all the faces needed support\n for i in range(len(arrFaces)):\n if arrFaces[i] == 1:\n obj.data.polygons[tabPoly[i]].select = True\n print(len(arrFaces))\n \n # Switch in edit mode\n bpy.ops.object.mode_set(mode = 'EDIT')\n print(\"End\")\n\n date_2 = datetime.datetime.now()\n time_delta = (date_2 - date_1)\n total_seconds = time_delta.total_seconds()\n print(total_seconds)\n \n time_delta = (date_4 - date_3)\n total_seconds = time_delta.total_seconds()\n print(\"C time : \", total_seconds)","def mesh_add_vertex_to_face_edge(mesh, key, fkey, v):\n vertices = mesh.face_vertices(fkey)\n i = vertices.index(v)\n u = vertices[i - 1]\n vertices.insert(key, i - 1)\n mesh.halfedge[u][key] = fkey\n mesh.halfedge[key][v] = fkey\n if u not in mesh.halfedge[key]:\n mesh.halfedge[key][u] = None\n if key not in mesh.halfedge[v]:\n mesh.halfedge[v][key] = None\n del mesh.halfedge[u][v]\n if u in mesh.halfedge[v]:\n del mesh.halfedge[v][u]\n if (u, v) in mesh.edgedata:\n del mesh.edgedata[u, v]\n if (v, u) in mesh.edgedata:\n del mesh.edgedata[v, u]","def _get_collection(surface_type, surfaces, opacity, facecolor, edgecolors=\"black\"):\n if surface_type == \"shading\":\n coords = [getcoords(s) for s in surfaces if not hasattr(s, \"Surface_Type\")]\n else:\n coords = [\n getcoords(s)\n for s in surfaces\n if hasattr(s, \"Surface_Type\")\n and s.Surface_Type.lower() == surface_type.lower()\n ]\n trimmed_coords = [c for c in coords if c] # dump any empty surfaces\n collection = Poly3DCollection(\n trimmed_coords, alpha=opacity, facecolor=facecolor, edgecolors=edgecolors\n )\n return collection","def refresh(self):\n\n # delete the existing plane first before recreating our plane by resetting the plane to an empty plane\n self.plane = []\n # calling our create_plane() to redraw our plane.\n self.create_plane()","def top(self, surface):\n #def target(self):\n \"\"\"Defines the target book\"\"\"\n #def adjacent(self, surface, surface, surface, surface, surface):\n \"\"\"Defines the adjacent surfaces for each surface\"\"\"\n #def touches(self, surface, surface):\n \"\"\"Defines surfaces touching other surfaces\"\"\"","def Init(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_SplitSurface_Init(self, *args)","def draw(self, surface):\r\n surface.blit(self.image, self.rect)","def __init__(self, width, height, color, main_surface):\n self.main_surface = main_surface\n self.width = width\n self.height = height\n self.color = color","def draw_f():\n fig = plt.figure()\n ax = fig.gca(projection='3d')\n x_matrix = np.arange(-10, 11, 0.1)\n y_matrix = np.arange(-10, 11, 0.1)\n x_matrix, y_matrix = np.meshgrid(x_matrix, y_matrix)\n # print(x_matrix)\n u_matrix = x_matrix.copy()\n for i in range(x_matrix.shape[0]):\n for j in range(x_matrix.shape[0]):\n u_matrix[i][j] = f(x_matrix[i][j], y_matrix[i][j])\n surf = ax.plot_surface(x_matrix, y_matrix, u_matrix)\n\n plt.show()\n return surf","def add_preview_surface(stage: Usd.Stage, prim: Usd.Prim,\n diffuse: Tuple[float, float, float],\n roughness: float,\n metallic: float):\n # Create material associated to the prim\n path = f\"{prim.GetPath()}/mat\"\n material = UsdShade.Material.Define(stage, path)\n # Create a shader associated with the material\n pbrShader = UsdShade.Shader.Define(stage, f\"{path}/shader\")\n pbrShader.CreateIdAttr(\"UsdPreviewSurface\")\n pbrShader.CreateInput(\"diffuseColor\", Sdf.ValueTypeNames.Float3).Set(diffuse)\n pbrShader.CreateInput(\"roughness\", Sdf.ValueTypeNames.Float).Set(roughness)\n pbrShader.CreateInput(\"metallic\", Sdf.ValueTypeNames.Float).Set(metallic)\n # Bind shader to the material surface\n material.CreateSurfaceOutput().ConnectToSource(pbrShader, \"surface\")\n # Bind material to the prim\n UsdShade.MaterialBindingAPI(prim).Bind(material)","def interiorFaceTrace(self, f):\n assert all(v.isInterior() for v in f.vertices)\n self.result.addFace([self.newVertex(v) for v in f.vertices])","def __init__(self, mesh: Mesh):\n self.mesh = mesh\n self.f = [0]*len(mesh.delaunay.simplices)","def Sphere_Bezier(refinements=0):\n \n S = np.array([0,0,0])\n T = np.array([0,0,1])\n V = np.array([0,0,0,0.5,0.5,1,1,1])\n q = 2\n m = 4\n Pj = np.array([[0,0,1],[1,0,1],[1,0,0],[1,0,-1],[0,0,-1]])\n wj = np.array([1,1/np.sqrt(2),1,1/np.sqrt(2),1])\n\n sphere = Bezier.MakeRevolvedSurface(S,T,2*np.pi,q,V,m,Pj,wj)\n \n # Make knot refinements before decomposing\n if refinements:\n uniqueU = np.unique(sphere.U)\n for i in xrange(uniqueU.size-1):\n XI = np.linspace(uniqueU[i],uniqueU[i+1],refinements+2)[1:-1]\n sphere.refineknotvector(XI,'U')\n uniqueV = np.unique(sphere.V)\n for i in xrange(uniqueV.size-1):\n XI = np.linspace(uniqueV[i],uniqueV[i+1],refinements+2)[1:-1]\n sphere.refineknotvector(XI,'V')\n \n sphere=sphere.decompose()\n\n element_list = [Bezier.BezierElement(sphere[i,:,:,:]) for i in xrange(sphere.shape[0])]\n \n \n sphere_domain = Bezier.Domain(element_list)\n mesh = Bezier.Mesh([sphere_domain])\n \n mesh.dList[0].edges = mesh.numElements * 2\n mesh.dList[0].corners = 8\n mesh.dList[0].extraordinary_points = 8\n\n \n return mesh","def add_surf(self, surf: Surface, pos: Tuple[int, int]):\n self.manual_surfaces.append((pos, surf))","def buildEdges(self):\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\n assert self.nonDoubleIntersectors()\n # print('2.1')\n for i in self.inter1:\n assert self.nonDoubleIntersectors()\n # print('test')\n assert all(all(v in self.poly1.vertices for v in f.vertices) for f in self.poly1.faces)\n if not i.isSTraced():\n self.traceSurface(i)\n # print('2.2')\n for i in self.inter2:\n if not i.isSTraced():\n self.traceSurface(i)\n for i in self.inter1:\n if not i.isITraced():\n self.traceInterior(i)\n for i in self.inter2:\n if not i.isITraced():\n self.traceInterior(i)","def __init__(self, face1, face2, face3, face4, world):\n\n\t\tself.attached_faces = set([face1, face2, face3, face4])\n\n\t\t# Attach to the faces ...\n\n\t\tfor face in self.attached_faces:\n\t\t\tface.attach_tetrahedron(self)\n\n\t\t# Attach to all points ...\n\n\t\tself.attached_points = set()\n\t\tfor face in self.attached_faces:\n\t\t\tself.attached_points |= face.attached_points\n\n\t\tfor point in self.attached_points:\n\t\t\tpoint.attach_tetrahedron(self)\n\n\t\t# Create the inverse coordinate matrix ...\n\n\t\tline1, line2, line3, line4, line5, line6 = \\\n\t\t\t\tface1.attached_lines | face2.attached_lines | \\\n\t\t\t\tface3.attached_lines | face4.attached_lines\n\n\t\tself.base_point, \\\n\t\t\t\tself.end_point1, self.end_point2, self.end_point3 = \\\n\t\t\t\tline1.attached_points | line2.attached_points | \\\n\t\t\t\tline3.attached_points | line4.attached_points | \\\n\t\t\t\tline5.attached_points | line6.attached_points\n\n\t\tself.end_points = [self.end_point1, self.end_point2, self.end_point3]\n\n\t\tself.base = self.base_point.position\n\t\tself.ends = numpy.asarray(\n\t\t\t\t[self.end_point1.position,\n\t\t\t\t self.end_point2.position,\n\t\t\t\t self.end_point3.position]) - self.base\n\t\tself.coordinate_matrix = numpy.linalg.inv(self.ends.T)\n\n\t\tworld.add_tetrahedron(self)","def on_draw( self ):\r\n self.clear()\r\n self.setup_3D()\r\n print \"DEBUG:\" , \"There are\" , len( self.renderlist ) , \"items in 'self.renderlist'\"\r\n for obj in self.renderlist:\r\n obj.draw()","def initialize_shade(self,shade_name,shade_color,alpha):\n\n self.shades[shade_name] = [0, pygame.Surface(self.image.get_size())]\n self.shades[shade_name][1].fill(shade_color)\n self.shades[shade_name][1].set_alpha(alpha)","def __drawCube(self):\n self.cubePos = [[[(160, 160), (200, 160), (240, 160)],\n [(160, 200), (200, 200), (240, 200)],\n [(160, 240), (200, 240), (240, 240)]],\n [[(400, 160), (440, 160), (480, 160)],\n [(400, 200), (440, 200), (480, 200)],\n [(400, 240), (440, 240), (480, 240)]],\n [[(280, 160), (320, 160), (360, 160)],\n [(280, 200), (320, 200), (360, 200)],\n [(280, 240), (320, 240), (360, 240)]],\n [[(40, 160), (80, 160), (120, 160)],\n [(40, 200), (80, 200), (120, 200)],\n [(40, 240), (80, 240), (120, 240)]],\n [[(160, 40), (200, 40), (240, 40)],\n [(160, 80), (200, 80), (240, 80)],\n [(160, 120), (200, 120), (240, 120)]],\n [[(160, 280), (200, 280), (240, 280)],\n [(160, 320), (200, 320), (240, 320)],\n [(160, 360), (200, 360), (240, 360)]]]\n self.cubeColor = {1: 'green', 2: 'blue', 3: 'red', 4: 'orange',\\\n 5: 'white', 6: 'yellow'}\n for x in range(6):\n for y in range(3):\n for z in range(3):\n pos = self.cubePos[x][y][z]\n color = self.cubeColor[self.cube.cube[x][y][z]]\n self.cv.create_rectangle(pos[0], pos[1], pos[0]+40, pos[1]+40,\n fill=color, width='2')","def save_surface_mesh(self, fname):\n triangulation = self.surf_mesh\n surf_indx = self.surface_indices\n points = self.cluster.get_positions()\n with open(fname, 'w') as out:\n # Write mandatory header\n out.write(\"$MeshFormat\\n\")\n out.write(\"2.2 0 8\\n\")\n out.write(\"$EndMeshFormat\\n\\n\")\n\n\n # Write points\n out.write(\"$Nodes\\n\")\n out.write(\"{}\\n\".format(points.shape[0]))\n for i in range(points.shape[0]):\n vec = points[i, :]\n out.write(\"{} {} {} {}\\n\".format(i+1, vec[0], vec[1], vec[2]))\n out.write(\"$EndNodes\\n\")\n\n # Write triangles\n out.write(\"$Elements\\n\")\n out.write(\"{}\\n\".format(len(triangulation)))\n for i, tri in enumerate(triangulation):\n out.write(\"{} 2 0 {} {} {}\\n\".format(i+1, tri[0]+1, tri[1]+1, tri[2]+1))\n out.write(\"$EndElements\\n\")\n\n if self._interface_energy:\n # Interface energy has been computed\n # We store the values as node data\n out.write(\"$NodeData\\n\")\n out.write(\"1\\n\")\n out.write(\"\\\"Gamma\\\"\\n\")\n out.write(\"1\\n0.0\\n\")\n out.write(\"4\\n0\\n1\\n{}\\n0\\n\".format(len(self._interface_energy)))\n for indx, interf in zip(surf_indx, self._interface_energy):\n out.write(\"{} {}\\n\".format(indx+1, interf[1]))\n out.write(\"$EndNodeData\\n\")\n print(\"Surface mesh saved to {}\".format(fname))","def copy(self):\n new = Face(np.array(self.norm[:]), self.colour[:])\n return new","def imshow_surface(self):\n plt.imshow(self.z)\n plt.colorbar()\n plt.show()","def draw(self, surface):\n surface.blit(self.image, self.rect)","def draw(self, surface):\n surface.blit(self.image, self.rect)","def create_surface(self):\n oval = graphics.Oval(graphics.Point(5,0), graphics.Point(300, -10))\n oval.setFill(\"gray\")\n return oval","def create_mesh(self):\n print(\"create_mesh\")\n faces = self.get_faces()\n print(\"num faces: {}\".format(len(faces)))\n\n # TODO: perform face filtering to remove long edges in Z direction\n # filtered_faces = self.get_filtered_faces(faces)\n # print(\"num filtered faces: {}\".format(len(filtered_faces)))\n\n vertices = self.xyz_points.T\n\n # handle texture mappings\n vertex_index_to_texture = []\n for j in range(0, self.height):\n for i in range(0, self.width):\n # vertex_index = (j * self.width) + ij\n w = i / self.width\n h = (self.height - j - 1) / self.height\n vertex_index_to_texture.append(\n (w, h)\n )\n\n # Create material.\n # TODO: make the string/filename randomly generated and unique\n file0 = open(os.path.join(self.args.path, \"triangle_mesh.obj.mtl\"), \"w\") # write mode\n file0.write(\"newmtl material_0\\n\")\n # Save image here.\n cv2.imwrite(os.path.join(self.args.path, \"triangle_mesh.png\"), self.bgr)\n file0.write(\"map_Kd triangle_mesh.png\\n\")\n file0.close()\n\n # https://en.wikipedia.org/wiki/Wavefront_.obj_file\n # https://github.com/mmatl/pyrender/blob/master/examples/models/fuze.obj\n obj_path = os.path.join(self.args.path, \"triangle_mesh.obj\")\n file1 = open(obj_path, \"w\") # write mode\n file1.write(\"mtllib ./triangle_mesh.obj.mtl\\n\")\n for vertex in vertices:\n x, y, z = vertex\n file1.write(\"v {} {} {}\\n\".format(x, y, z))\n file1.write(\"usemtl material_0\\n\")\n for w, h in vertex_index_to_texture:\n file1.write(\"vt {} {}\\n\".format(w, h))\n for face in faces:\n a, b, c = face\n a += 1\n b += 1\n c += 1\n file1.write(\"f {}/{} {}/{} {}/{}\\n\".format(\n a, a, b, b, c, c\n )\n )\n file1.close()\n\n # Load the trimesh from OBJ file.\n trimesh_mesh = trimesh.load(obj_path)\n # trimesh_mesh.show()\n\n mesh = pyrender.Mesh.from_trimesh(trimesh_mesh, smooth=False)\n self.scene = pyrender.Scene(ambient_light=[3.0, 3.0, 3.0])\n\n camera = pyrender.IntrinsicsCamera(\n self.focal_length, self.focal_length, self.width / 2, self.height / 2\n )\n self.camera_pose = np.array([\n [1.0, 0.0, 0.0, 0.0],\n [0.0, 1.0, 0.0, 0.0],\n [0.0, 0.0, 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ])\n # https://pyrender.readthedocs.io/en/latest/examples/cameras.html#creating-cameras\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html\n r = R.from_rotvec(np.array([0, np.pi, 0]))\n r = R.from_rotvec(np.array([0.0, 0, np.pi])) * r\n matrix = r.as_matrix()\n self.camera_pose[:3, :3] = matrix\n\n light = pyrender.PointLight(\n color=[1.0, 1.0, 1.0],\n intensity=0.0\n )\n\n self.nm = pyrender.Node(mesh=mesh, matrix=np.eye(4))\n self.nl = pyrender.Node(light=light, matrix=np.eye(4))\n self.nc = pyrender.Node(camera=camera, matrix=np.eye(4))\n self.scene.add_node(self.nm)\n self.scene.add_node(self.nl)\n self.scene.add_node(self.nc)\n\n # Set the pose and show the image.\n temppose = self.extrinsics @ self.camera_pose\n self.scene.set_pose(self.nl, pose=temppose)\n self.scene.set_pose(self.nc, pose=temppose)\n pyrender.Viewer(self.scene, use_raymond_lighting=True,\n viewport_size=(self.width, self.height))","def get_bforce_wm_ws_Gx_surf(self):\n\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w'] \n \n self.Gm1 = np.zeros([Ly])\n self.dGm1_dS = np.zeros([Ly]) \n self.Gt1 = np.zeros([Ly])\n self.dGt1_dS = np.zeros([Ly]) \n self.Bfsfc_bl = np.zeros([Ly])\n self.Av_bl = np.zeros([Ly])\n self.dAv_bl = np.zeros([Ly])\n \n #debugging\n self.wm_surf = np.zeros([Ly])\n self.ws_surf = np.zeros([Ly]) \n\n #---> j-loop\n for j in range(Ly): \n k_w = self.kbl[j] # KBL is \"new bl index after calling find_new_kbl()\n z_bl = z_u_w[j,N] - self.hbls[j]\n zscale = self.hbls[j] \n \n if self.swr_frac[j,k_w-1] > 0:\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\n \n else:\n Bfsfc = self.Bo[j] + self.Bosol[j]\n \n # CALCUALTE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm_surf[j] = wm\n self.ws_surf[j] = ws \n\n if self.LIMIT_UNSTABLE_ONLY:\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\n else:\n f1 = 0\n\n \n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n\n #MOMENTUM \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl[j] = Av_bl\n self.dAv_bl[j] = dAv_bl\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \n\n #TEMPERATURE(BUOYANCY)\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \n\n self.Bfsfc_bl[j] = Bfsfc","def _create_main_shape(self):\n\n a, b = gc( self.size/2,\n self._ZERO_DEGREES - self.angle,\n self._180_DEGREES + self.angle)\n self.wafer_points = zip(a,b)\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\n self.cell.add(self.wafer_polygon)","def unfold_object(current_surface,surface_dict,neighbors_dict):\n\n # Initialize a dictionary for the unfolded surfaces\n unfolded_surfaces = dict()\n\n # Generate a list of surface numbers\n surface_list = list(surface_dict.keys())\n\n # Add center surface to dictionary without modification\n unfolded_surfaces[current_surface] = surface_dict[current_surface]\n\n # Remove center surface from surface numbers list\n surface_list.remove(current_surface)\n\n # Generate an open list that contains the neighboring surface numbers to the center surface\n open_list = [(neighbor,[current_surface]) for neighbor in neighbors_dict[current_surface]]\n\n # Run until all surfaces are added to the unfolding\n while len(surface_list) > 0:\n\n # Next item in open list\n item = open_list[0]\n\n # Initialize a list of parents\n parents = list()\n\n # If neighbor is not already added\n if item[0] in surface_list:\n # Get folded version of the surface\n folded_surf = surface_dict[item[0]]\n child = item[0]\n\n # while there are still other parents of neighboring surface \n # (when more than one unfolding is required for a neighbor of the neighbor)\n while len(item[1])>0:\n # get parent surface no\n parent = item[1][-1]\n # unfold surface on the parent\n folded_surf = unfold_surface(surface_dict,neighbors_dict,item[1][-1],folded_surf,neighbors_dict[parent][child])\n # parent becomes the child\n child = item[1][-1]\n # remove parent and add to the parents list\n parents.append(item[1].pop())\n\n unfolded_surf = folded_surf\n\n else:\n open_list.pop(0)\n continue\n\n unfolded_surfaces[item[0]] = unfolded_surf\n \n surface_list.remove(item[0])\n\n parents.reverse()\n # for neighbors of the current neighbor\n for neighbor in neighbors_dict[item[0]]:\n # if not already added\n if neighbor in surface_list:\n # add to the open list with correct parenting order\n open_list.append((neighbor,parents+[item[0]]))\n else:\n continue\n open_list.pop(0)\n return unfolded_surfaces","def faces(self):\r\n return self._faces","def goify(self, layout=None):\n xx,yy,zz = self.getXYZ(layout)\n surf = dict(\n type='surface',\n x=xx,\n y=yy,\n z=zz\n )\n return surf","def recalc_verts(self):\n tongue_w = self.TEX.height\n\n along = self.fly_pos - self.mouth_pos\n across = along.normalized().rotated(90) * tongue_w * 0.5\n\n along *= self.length\n\n self.dl.vertices = [c for v in [\n self.mouth_pos - across,\n self.mouth_pos - across + along,\n self.mouth_pos + across + along,\n self.mouth_pos + across,\n ] for c in v]","def draw(self, surface):\n checked_color = (0, 196, 0) if self.checked else pg.Color(\"white\")\n surface.fill(pg.Color(\"black\"), self.rect)\n surface.fill(self.color, self.rect.inflate(-2,-2))\n surface.fill(pg.Color(\"white\"), self.rect.inflate(-6,-6))\n surface.fill((205,205,205), self.rect.inflate(-8,-8))\n surface.fill(checked_color, self.select_rect)"],"string":"[\n \"def __init__(self, initial_surfaces):\\n\\n nsurf = len(initial_surfaces)\\n nvert, nedge, ngroup, \\\\\\n surf_ptrs, edge_ptrs, \\\\\\n surf_group, edge_group \\\\\\n = self._compute_topology(initial_surfaces)\\n\\n self._num = {\\n 'surf': len(initial_surfaces),\\n 'vert': nvert,\\n 'edge': nedge,\\n 'group': ngroup,\\n }\\n\\n self._topo = {\\n 'surf_ptrs': surf_ptrs,\\n 'edge_ptrs': edge_ptrs,\\n 'surf_group': surf_group,\\n 'edge_group': edge_group,\\n }\\n\\n self._mult = {\\n 'vert': numpy.zeros(nvert, int),\\n 'edge': numpy.zeros(nedge, int),\\n 'diff_vert': numpy.zeros(nvert, int),\\n 'diff_edge': numpy.zeros(nedge, int),\\n }\\n\\n self._bspline = {\\n 'order': 4 * numpy.ones(ngroup, int),\\n 'num_cp': 4 * numpy.ones(ngroup, int),\\n 'num_pt': 10 * numpy.ones(ngroup, int),\\n }\\n\\n self._surf_indices = {\\n 'df': numpy.zeros((nsurf, 2), int, 'F'),\\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\\n }\\n\\n self._edge_indices = {\\n 'df': numpy.zeros((nedge, 2), int, 'F'),\\n 'cp': numpy.zeros((nedge, 2), int, 'F'),\\n 'pt': numpy.zeros((nedge, 2), int, 'F'),\\n }\\n\\n self._str_indices = {\\n 'cp': numpy.zeros((nsurf, 2), int, 'F'),\\n 'pt': numpy.zeros((nsurf, 2), int, 'F'),\\n }\\n\\n self._vert_indices = numpy.zeros(nvert, int)\\n\\n self._size = {\\n 'df_str': 0,\\n 'df': 0,\\n 'cp': 0,\\n 'cp_str': 0,\\n 'pt_str': 0,\\n 'pt': 0,\\n }\\n\\n self.diff = {\\n 'surf': numpy.zeros((nsurf, 3, 3), bool, 'F'),\\n 'edge': numpy.zeros((nedge, 2), bool, 'F'),\\n }\\n\\n self.hidden = numpy.zeros(nsurf, bool)\\n\\n self.jac = {\\n 'd(df)/d(df_str)': None,\\n 'd(cp)/d(df)': None,\\n 'd(cp_str)/d(cp)': None,\\n 'd(pt_str)/d(cp_str)': None,\\n 'd(pt)/d(pt_str)': None,\\n }\\n\\n self.vec = {\\n 'df_str': None,\\n 'df': None,\\n 'cp': None,\\n 'cp_str': None,\\n 'pt_str': None,\\n 'pt': None,\\n }\",\n \"def add_surface(self,s):\\n self.surfaces.append(s)\\n s.system=self.surfaces\",\n \"def map_face(self):\\n #Array Order: U0,D1,R2,L3,F4,B5,\\n \\n cube_list = []\\n cube_list = self.cube.definition()\\n \\n for index, cubit in enumerate(self.faces['Up']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\\n for index, cubit in enumerate(self.faces['Ri']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\\n for index, cubit in enumerate(self.faces['Ft']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\\n for index, cubit in enumerate(self.faces['Dn']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\\n for index, cubit in enumerate(self.faces['Le']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\\n for index, cubit in enumerate(self.faces['Bk']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])\",\n \"def Spherical_aberrations_surface_addup(self):\\n bf=beam_field()\\n bf.U=np.array([[[0,0,1],[0,0,1],[0,0,1]]])\\n pp=self.entrance_pupil\\n bf.Q_p=np.array([[[0,0,0],[0,pp/10.,0],[0,pp,0]]]) \\n bf.propagate(self.surfaces)\\n i,x=bf.calculate_intersections(bf.U[:,[0]],bf.Q_p[:,[0]],bf.U[:,[1]],bf.Q_p[:,[1]])\\n \\n i2,x2=bf.calculate_intersections(bf.U[:,[0]],bf.Q_p[:,[0]],bf.U[:,[2]],bf.Q_p[:,[2]])\\n \\n #print(i[:,:,2]-i2[:,:,2])\",\n \"def cfdProcessGeometry(self):\\r\\n \\r\\n # self.faceCentroids']= [[] for i in range(self.numberOfFaces'])]\\r\\n # self.faceSf']= [[] for i in range(self.numberOfFaces'])]\\r\\n # self.faceAreas']= [[] for i in range(self.numberOfFaces'])]\\r\\n \\r\\n ## Linear weight of distance from cell center to face\\r\\n self.faceWeights= [[0] for i in range(self.numberOfFaces)]\\r\\n\\r\\n ## Not\\r\\n self.faceCF= [[0, 0, 0] for i in range(self.numberOfFaces)]\\r\\n \\r\\n self.faceCf= [[0,0,0] for i in range(self.numberOfFaces)]\\r\\n \\r\\n self.faceFf= [[0,0,0] for i in range(self.numberOfFaces)]\\r\\n \\r\\n self.wallDist= [[] for i in range(self.numberOfFaces)]\\r\\n \\r\\n self.wallDistLimited= [[] for i in range(self.numberOfFaces)]\\r\\n \\r\\n self.elementCentroids= [[] for i in range(self.numberOfElements)]\\r\\n self.elementVolumes= [[] for i in range(self.numberOfElements)]\\r\\n \\r\\n \\\"\\\"\\\"\\r\\n Calculate:\\r\\n -face centroids (faceCentroids)\\r\\n -face normal (Sf)\\r\\n -face areas (faceAreas)\\r\\n \\\"\\\"\\\"\\r\\n \\r\\n #find cell with largest number of points\\r\\n maxPoints=len(max(self.faceNodes, key=len))\\r\\n forCross1 = [[] for i in range(maxPoints)]\\r\\n forCross2 = [[] for i in range(maxPoints)]\\r\\n local_faceCentroid=[[] for i in range(maxPoints)]\\r\\n \\r\\n for iFace in range(self.numberOfFaces):\\r\\n theNodeIndices = self.faceNodes[iFace]\\r\\n theNumberOfFaceNodes = len(theNodeIndices)\\r\\n \\r\\n #compute a rough centre of the face\\r\\n local_centre = [0,0,0]\\r\\n \\r\\n for iNode in theNodeIndices:\\r\\n local_centre = local_centre + self.nodeCentroids[int(iNode)]\\r\\n \\r\\n local_centre = local_centre/theNumberOfFaceNodes\\r\\n \\r\\n for iTriangle in range(theNumberOfFaceNodes):\\r\\n \\r\\n point1 = local_centre\\r\\n point2 = self.nodeCentroids[int(theNodeIndices[iTriangle])]\\r\\n \\r\\n if iTriangle < theNumberOfFaceNodes-1:\\r\\n point3 = self.nodeCentroids[int(theNodeIndices[iTriangle+1])]\\r\\n else:\\r\\n point3 = self.nodeCentroids[int(theNodeIndices[0])]\\r\\n \\r\\n local_faceCentroid[iTriangle].append((point1+point2+point3)/3)\\r\\n \\r\\n left=point2-point1\\r\\n right=point3-point1\\r\\n \\r\\n forCross1[iTriangle].append(left)\\r\\n forCross2[iTriangle].append(right)\\r\\n \\r\\n \\r\\n local_Sf=[np.zeros([self.numberOfFaces,3]) for i in range(maxPoints)]\\r\\n local_area=[np.zeros([self.numberOfFaces,3]) for i in range(maxPoints)]\\r\\n \\r\\n centroid=np.zeros([self.numberOfFaces,3])\\r\\n area=np.zeros([self.numberOfFaces])\\r\\n Sf=np.zeros([self.numberOfFaces,3])\\r\\n \\r\\n #cells with fewer faces than others are full of zeros\\r\\n for i in range(maxPoints):\\r\\n \\r\\n forCrossLeft=np.vstack(np.array(forCross1[i]))\\r\\n forCrossRight=np.vstack(np.array(forCross2[i]))\\r\\n \\r\\n local_Sf[i]=0.5*np.cross(forCrossLeft,forCrossRight)\\r\\n local_area[i]=np.linalg.norm(local_Sf[i],axis=1)\\r\\n \\r\\n centroid = centroid + np.array(local_faceCentroid[i])*local_area[i][:,None]\\r\\n Sf=Sf+local_Sf[i]\\r\\n area=area+local_area[i]\\r\\n \\r\\n self.faceCentroids=centroid/area[:,None]\\r\\n self.faceSf=Sf\\r\\n self.faceAreas=area \\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n Pure python version - causes slowness due to iterative np.cross()\\r\\n \\\"\\\"\\\"\\r\\n \\r\\n # for iFace in range(self.numberOfFaces):\\r\\n # theNodeIndices = self.faceNodes[iFace]\\r\\n # theNumberOfFaceNodes = len(theNodeIndices)\\r\\n # \\r\\n # #compute a rough centre of the face\\r\\n # local_centre = [0,0,0]\\r\\n # \\r\\n # for iNode in theNodeIndices:\\r\\n # \\r\\n # local_centre = local_centre + self.nodeCentroids[int(iNode)]\\r\\n # \\r\\n # local_centre = local_centre/theNumberOfFaceNodes\\r\\n # centroid = [0, 0, 0]\\r\\n # Sf = [0,0,0]\\r\\n # area = 0\\r\\n # \\r\\n # #finds area of virtual triangles and adds them to the find to find face area\\r\\n # #and direction (Sf)\\r\\n # \\r\\n # \\r\\n # \\r\\n # for iTriangle in range(theNumberOfFaceNodes):\\r\\n # point1 = local_centre\\r\\n # point2 = self.nodeCentroids[int(theNodeIndices[iTriangle])]\\r\\n # \\r\\n # if iTriangle < theNumberOfFaceNodes-1:\\r\\n # point3 = self.nodeCentroids[int(theNodeIndices[iTriangle+1])]\\r\\n # else:\\r\\n # point3 = self.nodeCentroids[int(theNodeIndices[0])]\\r\\n # \\r\\n # local_centroid = (point1 + point2 + point3)/3\\r\\n # \\r\\n # left=point2-point1\\r\\n # right=point3-point1\\r\\n # x = 0.5*((left[1] * right[2]) - (left[2] * right[1]))\\r\\n # y = 0.5*((left[2] * right[0]) - (left[0] * right[2]))\\r\\n # z = 0.5*((left[0] * right[1]) - (left[1] * right[0]))\\r\\n # local_Sf=np.array([x,y,z])\\r\\n # \\r\\n # local_area = np.linalg.norm(local_Sf)\\r\\n # \\r\\n # centroid = centroid + local_area*local_centroid\\r\\n # Sf = Sf + local_Sf\\r\\n # area = area + local_area\\r\\n # centroid = centroid/area\\r\\n # self.faceCentroids[iFace]=centroid\\r\\n # self.faceSf[iFace]=Sf\\r\\n # self.faceAreas[iFace]=area\\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n Calculate:\\r\\n -element centroids (elementCentroids)\\r\\n -element volumes (elementVolumes)\\r\\n \\\"\\\"\\\"\\r\\n for iElement in range(self.numberOfElements):\\r\\n \\r\\n theElementFaces = self.elementFaces[iElement]\\r\\n \\r\\n #compute a rough centre of the element\\r\\n local_centre = [0,0,0]\\r\\n \\r\\n for iFace in range(len(theElementFaces)):\\r\\n faceIndex = theElementFaces[iFace]\\r\\n local_centre = local_centre + self.faceCentroids[faceIndex]\\r\\n \\r\\n local_centre = local_centre/len(theElementFaces)\\r\\n \\r\\n localVolumeCentroidSum = [0,0,0]\\r\\n localVolumeSum = 0\\r\\n \\r\\n for iFace in range(len(theElementFaces)):\\r\\n faceIndex = theElementFaces[iFace]\\r\\n \\r\\n Cf = self.faceCentroids[faceIndex]-local_centre\\r\\n \\r\\n faceSign = -1\\r\\n if iElement == self.owners[faceIndex]:\\r\\n faceSign = 1\\r\\n \\r\\n local_Sf = faceSign*self.faceSf[faceIndex]\\r\\n \\r\\n localVolume = np.dot(local_Sf,Cf)/3\\r\\n \\r\\n localCentroid = 0.75*self.faceCentroids[faceIndex]+0.25*local_centre\\r\\n \\r\\n localVolumeCentroidSum = localVolumeCentroidSum + localCentroid*localVolume\\r\\n \\r\\n localVolumeSum = localVolumeSum + localVolume\\r\\n \\r\\n self.elementCentroids[iElement]=localVolumeCentroidSum/localVolumeSum\\r\\n self.elementVolumes[iElement]=localVolumeSum\\r\\n \\r\\n \\r\\n for iFace in range(self.numberOfInteriorFaces):\\r\\n \\r\\n n=self.faceSf[iFace]/np.linalg.norm(self.faceSf[iFace])\\r\\n own=self.owners[iFace]\\r\\n nei = self.neighbours[iFace]\\r\\n \\r\\n self.faceCF[iFace]=self.elementCentroids[nei]-self.elementCentroids[own]\\r\\n self.faceCf[iFace]=self.faceCentroids[iFace]-self.elementCentroids[own]\\r\\n self.faceFf[iFace]=self.faceCentroids[iFace]-self.elementCentroids[nei]\\r\\n self.faceWeights[iFace]=(-np.dot(self.faceFf[iFace],n))/(-np.dot(self.faceFf[iFace],n)+np.dot(self.faceCf[iFace],n))\\r\\n \\r\\n for iBFace in range(self.numberOfInteriorFaces, self.numberOfFaces):\\r\\n \\r\\n \\r\\n n=self.faceSf[iBFace]/np.linalg.norm(self.faceSf[iBFace])\\r\\n own=self.owners[iBFace]\\r\\n \\r\\n self.faceCF[iBFace]=self.faceCentroids[iBFace]-self.elementCentroids[own]\\r\\n self.faceCf[iBFace]=self.faceCentroids[iBFace]-self.elementCentroids[own] \\r\\n self.faceWeights[iBFace]=1\\r\\n self.wallDist[iBFace]= max(np.dot(self.faceCf[iBFace], n), 1e-24)\\r\\n self.wallDistLimited[iBFace]= max(self.wallDist[iBFace], 0.05*np.linalg.norm(self.faceCf[iBFace]))\",\n \"def __init__(self, vertices, edges, surfaces):\\n #self.target = target\\n #self.support = support\\n self.vertices = vertices\\n self.edges = edges\\n self.surfaces = surfaces\",\n \"def draw(self, surface):\\n for molecule in self.molecules:\\n molecule.draw(surface)\",\n \"def new_mesh_set(self, all_meshes):\\n if isinstance(all_meshes, Mesh):\\n mesh_tp = []\\n mesh_tp.append(all_meshes)\\n all_meshes = mesh_tp\\n\\n if not isinstance(all_meshes, list):\\n raise TypeError(\\\"Please send a list of mesh to update_mesh\\\")\\n self.all_meshes = all_meshes\\n\\n # Remove previous actors from the scene\\n for actor in self.mesh_actors:\\n self.parent_window.ren.RemoveActor(actor)\\n self.mesh_actors = list()\\n\\n # Create the geometry of a point (the coordinate) points = vtkPoints()\\n for i, mesh in enumerate(self.all_meshes):\\n if mesh.time.size != 1:\\n raise IndexError(\\\"Mesh should be from one frame only\\\")\\n\\n points = vtkPoints()\\n for j in range(mesh.channel.size):\\n # points.InsertNextPoint([0, 0, 0])\\n points.InsertNextPoint(mesh.data[:3, j, 0].tolist())\\n\\n # Create an array for each triangle\\n draw_patch = not mesh.automatic_triangles and not self.force_wireframe\\n if draw_patch:\\n poly_type = vtkPolygon\\n n_ids = 3\\n color = self.patch_color[i]\\n else:\\n poly_type = vtkPolyLine\\n n_ids = 4\\n color = self.mesh_color\\n cells = vtkCellArray()\\n\\n # Create the polygons\\n for j in range(mesh.triangles.shape[1]):\\n poly = poly_type()\\n poly.GetPointIds().SetNumberOfIds(n_ids) # make a tri\\n for k in range(len(mesh.triangles[:, j])):\\n poly.GetPointIds().SetId(k, mesh.triangles[k, j])\\n if not draw_patch:\\n poly.GetPointIds().SetId(3, mesh.triangles[0, j]) # Close the triangle\\n cells.InsertNextCell(poly)\\n\\n poly_data = vtkPolyData()\\n poly_data.SetPoints(points)\\n if draw_patch:\\n poly_data.SetPolys(cells)\\n else:\\n poly_data.SetLines(cells)\\n\\n mapper = vtkPolyDataMapper()\\n mapper.SetInputData(poly_data)\\n\\n # Create an actor\\n self.mesh_actors.append(vtkActor())\\n self.mesh_actors[i].SetMapper(mapper)\\n self.mesh_actors[i].GetProperty().SetColor(color)\\n self.mesh_actors[i].GetProperty().SetOpacity(self.mesh_opacity)\\n\\n self.parent_window.ren.AddActor(self.mesh_actors[i])\\n\\n # Update marker position\\n self.update_mesh(self.all_meshes)\",\n \"def createSurfaceGeo(self):\\n self.surfGeo = dict()\\n r = self.geoParam['CylinderLightGuideRadius']\\n self.surfGeo[r] = 'LightGuide'\\n #self.material = {'Moderator':None,'Detector':None,'LightGuide':None}\\n while(r + self.geoParam['DetectorThickness'] < self.geoParam['CylinderRadius']):\\n r += self.geoParam['DetectorThickness']\\n self.surfGeo[r] = 'Detector'\\n r += self.geoParam['DetectorSpacing']\\n if (r < self.geoParam['CylinderRadius']):\\n self.surfGeo[r] = 'LightGuide'\\n return self.surfGeo\",\n \"def add_face(self, vertices: Iterable[\\\"Vertex\\\"]) -> None:\\n self.faces.append(self.add_vertices(vertices))\",\n \"def draw(self, surface):\\n #\\n # Set the positions of all the items\\n y = 0\\n self.my_surface.fill((0, 0, 0, 0))\\n for idx, item in enumerate(self):\\n y += self.item_heights\\n item.pos = (item.width / 2, y - self.initial_offset)\\n #\\n # Now draw item\\n item.draw(self.my_surface)\\n # #\\n # # And the scrollbar\\n # self.scroll_grab.pos = (self.my_surface.get_size()[0] - S['scrolled-scroll-width'], 0)\\n # self.scroll_grab.draw(self.my_surface)\\n #\\n # Draw main surface\\n if self.background:\\n self.background.pos = self.pos\\n self.background.draw(surface)\\n self.region.pos = self.pos\\n self.region.draw(surface)\",\n \"def surface():\\n \\\"\\\"\\\"\\n Get surface for plotting.\\n\\n :return fsaverage: surface locations as in nilearn\\n :return surf: surface for plotting\\n \\\"\\\"\\\"\\n\\n fsaverage = fetch_surf_fsaverage('fsaverage')\\n surf = {}\\n\\n for key in [t + '_' + h for t in ['pial', 'infl'] for h in ['left', 'right']]:\\n\\n surf = load_surf_mesh(fsaverage[key])\\n x, y, z = np.asarray(surf[0].T, dtype='<f4')\\n i, j, k = np.asarray(surf[1].T, dtype='<i4')\\n\\n surf[key] = dict(x=x, y=y, z=z, i=i, j=j, k=k)\\n\\n return fsaverage, surf\",\n \"def set_und_surface(self):\\n if (self.dimension == '3D'):\\n self.part_RVE.Set(\\n cells=self.part_RVE.cells.getSequenceFromMask(mask=('[#1 ]', ), ),\\n name='Set_RVE')\\n elif (self.dimension == '2D'):\\n self.part_RVE.Set(\\n faces=self.part_RVE.faces.getSequenceFromMask(mask=('[#1 ]', ), ),\\n name='Set_RVE')\\n else:\\n print('dimension Error!')\",\n \"def faces(self, f):\\n self._faces = f\",\n \"def _getFacesAndMaterials_bpy(self):\\r\\n obj = self.obj\\r\\n mesh = obj.data\\r\\n polygonDict = {} # a dict that holds faces (dict), their vertices (dict: positions and materials)\\r\\n # self._checkForUndoMess()\\r\\n\\r\\n for n in range (0, len(mesh.polygons)):\\r\\n f = mesh.polygons[n] # current face\\r\\n\\r\\n # create local dict\\r\\n d = {}\\r\\n\\r\\n # get face material\\r\\n slot = obj.material_slots[f.material_index]\\r\\n mat = slot.material\\r\\n d['material'] = mat.name\\r\\n\\r\\n # get face vertices\\r\\n v_list = []\\r\\n for v in f.vertices: # browse through vertice index\\r\\n vect = obj.matrix_world * mesh.vertices[v].co\\r\\n v_list.append(vect)\\r\\n \\r\\n # add third twice for triangle face (expected by evertims raytracing client)\\r\\n if( len(f.vertices) == 3 ): \\r\\n vect = obj.matrix_world * mesh.vertices[ f.vertices[2] ].co\\r\\n v_list.append(vect)\\r\\n\\r\\n d['vertices'] = v_list\\r\\n\\r\\n # store local dict\\r\\n polygonDict[n] = d\\r\\n return polygonDict\",\n \"def __init__(self, surface, rect):\\n self.surface = surface\\n self.rect = rect\",\n \"def __init__(self, surface, rect):\\n self.surface = surface\\n self.rect = rect\",\n \"def get_faces(self):\\n for i, j in combinations(self.gens, 2):\\n c0 = self.triangle_verts[self.vertex_at_mirrors(i, j)]\\n f0 = []\\n m = self.cox_mat[i][j]\\n H = (i, j)\\n type = 0\\n if self.active[i] and self.active[j]:\\n type = 1\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k + (i,)))\\n elif self.active[i] and m > 2:\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (j, i) * k))\\n elif self.active[j] and m > 2:\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\\n else:\\n continue\\n\\n reps = set(self.word_generator(parabolic=H))\\n reps = self.G.sort_words(reps)\\n flist = []\\n for word in reps:\\n f = tuple(self.G.move(self.vtable, v, word) for v in f0)\\n if None not in f and not helpers.check_duplicate_face(f, flist):\\n center = self.transform(word, c0)\\n coords = [self.vertices_coords[k] for k in f]\\n face = DihedralFace(word, f, center, coords, type)\\n flist.append(face)\\n\\n self.face_indices[(i, j)] = flist\\n\\n self.num_faces = sum(len(L) for L in self.face_indices.values())\",\n \"def __init__(self, geometries, surfaceRefinement, case):\\n\\n self.geometries = geometries\\n self.surfaceRefinement = surfaceRefinement\\n self.case = case\\n #we set up the default settings for snappy\\n self.castellate = True\\n self.snap = True\\n self.addLayers = True\\n self.maxLocalCells = 1000000\\n self.maxGlobalCells = 200000\\n self.minRefinementCells = 200\\n self.maxLoadUnbalance = 0.1\\n self.nCellsBetweenLevels = 3\\n self.edgeRefinementLevel = 6\\n self.refinementSurfaceMin = 5\\n self.refinementSurfaceMax = 6\\n self.resolveFeatureAngle = 5\\n self.distanceRefinements = [0.1, 0.2]\\n self.distanceLevels = [4, 3]\\n self.locationToKeep = [0.001, 0.001, 0.0015]\\n self.allowFreeStandingFaces = True\\n self.nSmoothPatch = 3\\n self.snapTolerance = 2\\n self.nSolveIter = 30\\n self.nRelaxIter = 5\\n self.nFeatureSnapIter = 10\\n self.implicitFeatureSnap = False\\n self.explicitFeatureSnap = True\\n self.multiRegionFeatureSnap = False\\n self.relativeSizes = True\\n self.nSurfaceLayers = 1\\n self.expansionRatio = 1\\n self.finalLayerThickness = 0.1\\n self.minThickness = 0.03\\n self.nGrow = 0\\n self.featureAngle = 60\\n self.slipFeatureAngle = 30\\n self.nRelaxIter = 3\\n self.nSmoothSurfaceNormals = 1\\n self.nSmoothNormals = 1\\n self.nSmoothThickness = 10\\n self.maxFaceThicknessratio = 0.5\\n self.maxThicknessToMedialRatio = 0.3\\n self.minMedianAxisAngle = 90\\n self.nBufferCellsNoExtrude = 0\\n self.nLayerIter = 50\\n self.mergeTolerance = 1e-6\",\n \"def Surface(self, *args):\\n return _Adaptor3d.Adaptor3d_HSurface_Surface(self, *args)\",\n \"def update(self) -> pygame.Surface:\\n return self.surface\",\n \"def buildFaces(self):\\n for fi in range(len(self.poly1.faces)):\\n f = self.poly1.faces[fi]\\n for vi in range(len(f.vertices)):\\n v = f.vertices[vi]\\n if self.getIntersector(v) is not None and not v.isMarkedFor(f):\\n self.faceTrace(1, fi, vi)\\n v = f.vertices[0]\\n if v.isInterior() and not v.isMarkedFor(f):\\n interiorFaceTrace(f)\\n for fi in range(len(self.poly2.faces)):\\n f = self.poly2.faces[fi]\\n for vi in range(len(f.vertices)):\\n v = f.vertices[vi]\\n if self.getIntersector(v) is not None and not v.isMarkedFor(f) :\\n self.faceTrace(2, fi, vi)\\n v = f.vertices[0]\\n if v.isInterior() and not v.isMarkedFor(f):\\n interiorFaceTrace(f)\",\n \"def update(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 if xyz.size:\\n self.mesh.visible = True\\n self.mesh.set_data(xyz, edge_color=self.edgecolor, size=sData,\\n face_color=sColor, scaling=self.scaling,\\n edge_width=self.edgewidth, symbol=self.symbol)\\n # self.mesh.transform = self.transform\\n self.mesh.update()\\n else:\\n self.mesh.visible = False\",\n \"def __init__(self, Region):\\r\\n \\r\\n self.Region=Region\\r\\n \\r\\n ## Path to points files\\r\\n self.pointsFile = r\\\"%s/constant/polyMesh/points\\\" % self.Region.caseDirectoryPath\\r\\n\\r\\n ## Path to faces file\\r\\n self.facesFile = r\\\"%s/constant/polyMesh/faces\\\" % self.Region.caseDirectoryPath\\r\\n\\r\\n ## Path to owner file\\r\\n self.ownerFile = r\\\"%s/constant/polyMesh/owner\\\" % self.Region.caseDirectoryPath\\r\\n\\r\\n ## Path to neighbour file\\r\\n self.neighbourFile = r\\\"%s/constant/polyMesh/neighbour\\\" % self.Region.caseDirectoryPath\\r\\n\\r\\n ## Path to boundary file\\r\\n self.boundaryFile = r\\\"%s/constant/polyMesh/boundary\\\" % self.Region.caseDirectoryPath \\r\\n \\r\\n print('\\\\n')\\r\\n print('Reading contents of ./constant/polyMesh folder ...')\\r\\n \\r\\n self.cfdReadPointsFile()\\r\\n self.cfdReadFacesFile()\\r\\n self.cfdReadOwnerFile()\\r\\n self.cfdReadNeighbourFile()\\r\\n\\r\\n #maybe these should go in a function?\\r\\n self.numberOfBFaces=self.numberOfFaces-self.numberOfInteriorFaces\\r\\n self.numberOfElements = max(self.neighbours)+1 #because of zero indexing in Python\\r\\n self.numberOfBElements=self.numberOfFaces-self.numberOfInteriorFaces #seems strange that subtracting faces gives elements ...\\r\\n\\r\\n self.cfdReadBoundaryFile() \\r\\n self.cfdCheckIfCavity()\\r\\n \\r\\n print('Processing mesh ... please wait ....')\\r\\n \\r\\n self.cfdProcessElementTopology()\\r\\n self.cfdProcessNodeTopology()\\r\\n self.cfdProcessGeometry()\\r\\n \\r\\n self.cfdGetBoundaryElementsSubArrayForBoundaryPatch()\\r\\n self.cfdGetOwnersSubArrayForBoundaryPatch()\\r\\n self.cfdGetFaceSfSubArrayForBoundaryPatch()\\r\\n self.cfdGetFaceCentroidsSubArrayForBoundaryPatch()\\r\\n \\r\\n ## (list) 1D, indices refer to an interior face, list value is the face's owner\\r\\n self.interiorFaceOwners = self.owners[0:self.numberOfInteriorFaces]\\r\\n\\r\\n ## (list) 1D, indices refer to an interior face, list value is the face's neighbor cell\\r\\n self.interiorFaceNeighbours = self.neighbours[0:self.numberOfInteriorFaces]\\r\\n\\r\\n ## (list) 1D, face weighting factors. Values near 0.5 mean the face's centroid is approximately halfway between the center of the owner and neighbour cell centers, values less than 0.5 mean the face centroid is closer to the owner and those greater than 0.5 are closer to the neighbour cell).\\r\\n self.interiorFaceWeights = self.faceWeights[0:self.numberOfInteriorFaces]\\r\\n\\r\\n ## (array) 2D, normal vectors (Sf) of the interior faces (indices refer to face index)\\r\\n self.interiorFaceSf = self.faceSf[0:self.numberOfInteriorFaces]\\r\\n \\r\\n ## (array) 2D, CF vectors of the interior faces (indices refer to face index)\\r\\n self.interiorFaceCF = self.faceCF[0:self.numberOfInteriorFaces]\\r\\n \\r\\n ## (list) 1D, indices refer to an boundary face, list value refers to the face's owner\\r\\n self.owners_b = self.owners[self.numberOfInteriorFaces:self.numberOfFaces]\\r\\n\\r\\n ## (list) 1D, normal vectors (Sf) of the boundary faces (indices refer to face index). Boundary face normals always point out of the domain. \\r\\n self.Sf_b=self.faceSf[self.numberOfInteriorFaces:self.numberOfFaces]\",\n \"def update(self,image):\\r\\n \\r\\n self._faces=[]\\r\\n \\r\\n if util.isgray(image):\\r\\n image=cv2.equalizeHist(image)\\r\\n \\r\\n else:\\r\\n \\r\\n image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\\r\\n cv2.equalizeHist(image,image)\\r\\n \\r\\n minsize=util.widthheightdividedby(image,8)\\r\\n\\r\\n \\r\\n\\r\\n \\r\\n facerect=self._faceclassifier.detectMultiScale(image,\\r\\n self.scalefactor,\\r\\n self.minneighbors,\\r\\n self.flags,\\r\\n minsize)\\r\\n \\r\\n \\\"\\\"\\\"if facerects is not None:\\r\\n \\r\\n for facerect in facerects:\\r\\n face=face()\\r\\n \\r\\n face.facerect=facerect\\r\\n \\r\\n \\r\\n x,y,w,h=facerect\\r\\n \\r\\n # Seek an eye in the upper-left part of the face. \\r\\n searchRect = (x+w/7, y, w*2/7, h/2) \\r\\n face.leftEyeRect = self._detectOneObject( \\r\\n self._eyeClassifier, image, searchRect, 64) \\r\\n \\r\\n \\r\\n \\r\\n # Seek an eye in the upper-right part of the face. \\r\\n searchRect = (x+w*4/7, y, w*2/7, h/2) \\r\\n face.rightEyeRect = self._detectOneObject( \\r\\n self._eyeClassifier, image, searchRect, 64) \\r\\n \\r\\n \\r\\n \\r\\n # Seek a nose in the middle part of the face. \\r\\n searchRect = (x+w/4, y+h/4, w/2, h/2) \\r\\n face.noseRect = self._detectOneObject( \\r\\n self._noseClassifier, image, searchRect, 32) \\r\\n \\r\\n # Seek a mouth in the lower-middle part of the face. \\r\\n searchRect = (x+w/6, y+h*2/3, w*2/3, h/3) \\r\\n face.mouthRect = self._detectOneObject( \\r\\n self._mouthClassifier, image, searchRect, 16) \\r\\n \\r\\n \\r\\n \\r\\n self._faces.append(face)\\r\\n\\r\\n \\r\\n \\r\\n def _detectoneobject(self,\\r\\n classifier,\\r\\n image,\\r\\n rect,\\r\\n imagesizetominsizeratio):\\r\\n \\r\\n x ,y ,w ,h=rect\\r\\n \\r\\n minsize=util.widthheightdividedby(image,\\r\\n imagesizetominsizeratio)\\r\\n \\r\\n subimage=image[y:y+h,x:x+w]\\r\\n \\r\\n subrect=classifier.dectectMultiScale(subimage,\\r\\n self.scalefactor,\\r\\n self.minneighbors,\\r\\n self.flags,\\r\\n minsize)\\r\\n \\r\\n if len(subrect)==0:\\r\\n return None\\r\\n \\r\\n subx,suby,subw,subh=subrects[0]\\r\\n \\r\\n return (x+subx,y+suby,w+subw,h+subh)\\r\\n \\r\\n \\\"\\\"\\\"\",\n \"def compute_mixing_coefficients_surf(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n\\n # SET UP NEW MIXING COEFFICIENT ARRAYS\\n self.Kv_surf = np.zeros([Ly,N+1])\\n self.Kt_surf = np.zeros([Ly,N+1])\\n \\n self.ghat = np.zeros([Ly,N+1])\\n \\n\\n #################################\\n # \\tSURFACE KPP\\n ################################\\n #---> j-loop\\n \\n self.wm2 = []\\n self.ws2 = []\\n self.sigma_y = []\\n for j in range(Ly):\\n #--> k-loop (top to kbl[j])\\n # in fortran k=N-1,kbl(j),-1\\n for k in range(N-1,self.kbl[j]-1,-1):\\n k_w = k\\n k_r = k-1\\n\\n Bfsfc = self.Bfsfc_bl[j]\\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\\n \\n # CALCULATE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm2.append(wm)\\n self.ws2.append(ws)\\n # COMPUTE VERTICAL MIXING COEFFICIENTS\\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\\n self.sigma1 = sigma #for debugging\\n if j == 25: \\n self.sigma_y.append(sigma)\\n a1 = sigma - 2.\\n a2 = 3.-2.*sigma\\n a3 = sigma - 1.\\n\\n if sigma < 0.07:\\n cff = 0.5 * (sigma-0.07)**2/0.07\\n else:\\n cff = 0\\n \\n \\n if k == N-1: \\n self.wm_debug = wm\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n\\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\\n\\n if k == N-1:\\n self.ws_debug = ws\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n \\n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\\n #---> end k-loop \\n if self.LMD_NONLOCAL:\\n if Bfsfc < 0:\\n self.ghat[j,k_w] = 0\\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\\n else:\\n self.ghat[j,k_w] = 0.\\n\\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \\n if self.LMD_CONVEC and self.MLCONVEC: \\n for k in range(N-1,int(self.kbl[j]-1),-1):\\n k_w = k\\n k_r = k -1\\n\\n if self.bvf[j,k_w] < 0:\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\\n\\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\\n # IF BKPP IS SWITCHED OFF!!\\n for k in range(int(self.kbl[j]-1),-1,-1):\\n k_w = k\\n k_r = k -1\\n if self.LMD_NONLOCAL:\\n self.ghat[j,k_w] = 0\\n if self.LMD_CONVEC and self.LMD_BKPP == False:\\n if self.bvf[j,k_w] < 0:\\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\\n \\n\\n #---> end j-loop\",\n \"def update_surface(frame):\\n \\n #fig.suptitle(time[frame])\\n im.set_array(surf[frame])\\n im.set_extent([np.nanmin(xx[frame]), np.nanmax(xx[frame]), np.nanmin(yy[frame]), np.nanmax(yy[frame])])\\n \\n line.set_data([(times[:-1] + utc_to_east).plot_date[frame]]*2, ylim)\",\n \"def __init__(self, renderSurf):\\n self.surf = renderSurf\",\n \"def drawFace():\\r\\n\\tglPushMatrix()\\r\\n\\tglTranslatef(-0.5,-0.5,0)\\r\\n\\tglBegin(GL_LINE_LOOP)\\r\\n\\t\\r\\n\\tglVertex3f(0,VALUE,0)\\r\\n\\tglVertex3f(VALUE,0,0)\\r\\n\\t\\r\\n\\tglVertex3f(LENGTH-VALUE,0,0)\\r\\n\\tglVertex3f(LENGTH,VALUE,0)\\r\\n\\t\\r\\n\\tglVertex3f(LENGTH,LENGTH-VALUE,0)\\r\\n\\tglVertex3f(LENGTH-VALUE,LENGTH,0)\\r\\n\\t\\r\\n\\tglVertex3f(VALUE,LENGTH,0)\\r\\n\\tglVertex3f(0,LENGTH-VALUE,0)\\r\\n\\t\\r\\n\\tglEnd()\\r\\n\\tglPopMatrix()\",\n \"def surfaces(self):\\n return self._surfaces\",\n \"def __init__(self):\\n self.delCurves = []\\n return\",\n \"def surface(self):\\n # return sum(np.outer(basis_function, control_point) for basis_function, control_point in zip(self.basis_1, self.basis)).T\\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\\n # return sum(np.outer(basis_function_1, self.control_net[ii, jj]) + np.outer(basis_function_2, self.control_net[ii, jj]) for ((ii, basis_function_1), (jj, basis_function_2)) in zip(enumerate(self.basis_1), enumerate(self.basis_2))).T\\n\\n # x = np.zeros_like(self.xi_1_mesh)\\n # y = np.zeros_like(self.xi_1_mesh)\\n # z = np.zeros_like(self.xi_1_mesh)\\n xyz = np.zeros((*self.xi_1_mesh.shape, 3))\\n for (i, basis_function_i), (j, basis_function_j) in itertools.product(enumerate(self.basis_1), enumerate(self.basis_2)):\\n print(i, basis_function_i)\\n print(j, basis_function_j)\\n print(self.control_net[i, j])\\n # b1, b2 = np.meshgrid(basis_function_i, basis_function_j, indexing = 'ij')\\n control_x, control_y, control_z = self.control_net[i, j]\\n # print(b1.shape, b2.shape, np.array(self.control_net[i, j]).shape)\\n # print((b1 * b2).shape)\\n # z += np.outer(b1 * b2, self.control_net[i, j])\\n # print(np.shape(z))\\n print(np.outer(basis_function_i, basis_function_j))\\n # x += np.outer(basis_function_i, basis_function_j) * control_x\\n # y += np.outer(basis_function_i, basis_function_j) * control_y\\n # z += np.outer(basis_function_i, basis_function_j) * control_z\\n print(np.outer(basis_function_i, basis_function_j).shape)\\n print(np.outer(np.outer(basis_function_i, basis_function_j), self.control_net[i, j]).shape)\\n print(np.outer(np.outer(basis_function_i, basis_function_j), np.array(self.control_net[i, j])).shape)\\n r = np.einsum('i,j,k->ijk', basis_function_i, basis_function_j, np.array(self.control_net[i, j]))\\n print(r.shape)\\n xyz += r\\n\\n # print(x, y, z)\\n\\n # return x, y, z\\n return xyz\",\n \"def append(self, solf):\\n exist_map = {'vertex_index': len(self.get('vertices', [])),\\n 'texcoord_index': len(self.get('texcoords', [])),\\n 'normal_index': len(self.get('normals', [])),\\n 'param_index': len(self.get('params', []))}\\n exist_map.update(points=exist_map['vertex_index'],\\n curve2Ds=exist_map['param_index'])\\n # Vertex fields\\n for k in ['vertices', 'texcoords', 'normals', 'params']:\\n if k in solf:\\n if k not in self:\\n self[k] = []\\n self[k] += solf[k]\\n # Points/2D curves\\n for k in ['points', 'curve2Ds']:\\n if k in solf:\\n if k not in self:\\n self[k] = []\\n for x in solf[k]:\\n self[k].append([v + exist_map[k] for v in x])\\n # Face/line fields\\n for k in ['lines', 'faces']:\\n if k in solf:\\n if k not in self:\\n self[k] = []\\n for x in solf[k]:\\n iele = [{ik: v[ik] + exist_map[ik] for ik in v.keys()} for v in x]\\n self[k].append(iele)\\n # Curves\\n k = 'curves'\\n if k in solf:\\n if k not in self:\\n self[k] = []\\n for x in solf[k]:\\n iele = copy.deepcopy(x)\\n iele['vertex_indices'] = [v + exist_map['vertex_index']\\n for v in x['vertex_indices']]\\n # Surfaces\\n k = 'surfaces'\\n if k in solf:\\n if k not in self:\\n self[k] = []\\n for x in solf[k]:\\n iele = copy.deepcopy(x)\\n iele['vertex_indices'] = [{ik: v[ik] + exist_map[ik] for ik in v.keys()}\\n for v in x['vertex_indices']]\\n # Merge material using first in list\\n material = None\\n for x in [self, solf]:\\n if x.get('material', None) is not None:\\n material = x['material']\\n break\\n if material is not None:\\n self['material'] = material\\n return self\",\n \"def updateGeometryInfo(self,*args):\\r\\n self.wf.dataGridView.Rows.Clear()\\r\\n sceneRoot = Application.ActiveSceneRoot\\r\\n children = sceneRoot.FindChildren2( \\\"\\\", constants.siPolyMeshType, constants.siMeshFamily, True )\\r\\n for child in children:\\r\\n vTrans = child.Kinematics.Local.GetTransform2(None).Translation\\r\\n self.wf.AddRow( child.FullName, vTrans.X, vTrans.Y, vTrans.Z )\",\n \"def draw_on(self, surface):\\n for x, y in self.alive_cells():\\n #size = (self.box_size, self.box_size)\\n #position = (x * self.box_size, y * self.box_size)\\n #thickness = 1\\n pygame.draw.rect(surface, DARK_RED, (x * self.box_size, y * self.box_size,self.box_size, self.box_size ))\",\n \"def show(self):\\n # if a blender object already exists then the mesh_grower must have been finalized;\\n # in this case make a new mesh_grower and object\\n viz.add_box(self.lower_vertex, self.upper_vertex)\",\n \"def subdivision(mesh):\\n\\t\\n\\t\\n\\t# 1. generate new nodes in the centre of quad\\n\\t# 1/4 o-------o 1/4 o: existing vertices\\n\\t# | | *: newly-generated vertices\\n\\t# | * |\\n\\t# | |\\n\\t# 1/4 o-------o 1/4\\n\\n\\tnew_coor = mesh.give_nodes().give_coor()\\n\\t\\n\\tfor face_index in range(mesh.give_model_inf()[2]): \\n\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\tfor vertex_index in range(4):\\n\\t\\t\\tmesh.give_faces()\\n\\t\\t\\tnode_index = mesh.give_faces().give_node_list(face_index)[vertex_index]\\n\\n\\t\\t\\tnew_x += 0.25*mesh.give_nodes().give_coor(node_index)[0]\\n\\t\\t\\tnew_y += 0.25*mesh.give_nodes().give_coor(node_index)[1]\\n\\t\\t\\tnew_z += 0.25*mesh.give_nodes().give_coor(node_index)[2]\\n\\t\\t\\t\\n\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\t\\t\\n\\t# generating new nodes on the edge\\n\\t# figure out one edge is shared by how many surfaces\\n\\tedge_shared_by_faces_list = helper.find_edge_shared_by_which_faces(mesh.give_edges(), mesh.give_faces())\\n\\t\\n\\tfor edge_index in range(mesh.give_model_inf()[1]):\\n\\n\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\n\\t# 2. generate new node on boundary edge\\n\\t# o: existing vertices\\n\\t# 1/2 o---*---o 1/2 *: newly-generated vertices\\n\\t# \\n\\n\\t\\tnew_coor = mesh.give_nodes().give_coor()\\n\\t\\tif len(edge_shared_by_faces_list[edge_index]) == 1:\\t\\n\\t\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\tfor vertex_index in range(2):\\n\\t\\t\\t\\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\\n\\t\\t\\t\\tnew_x += 0.5*mesh.give_nodes().give_coor()[this_node][0]\\n\\t\\t\\t\\tnew_y += 0.5*mesh.give_nodes().give_coor()[this_node][1]\\n\\t\\t\\t\\tnew_z += 0.5*mesh.give_nodes().give_coor()[this_node][2]\\n\\t\\t\\t\\t\\n\\t\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\t\\t\\t\\t\\n\\t# 3. generate new node on interior edge\\n\\t# 1/16 o-------o 1/16 o: existing vertices\\n\\t# | | *: newly-generated vertices\\n\\t# 3/8 o---*---o 3/8\\n\\t# | |\\n\\t# 1/16 o-------o 1/16\\n\\n\\t\\telse:\\n\\t\\t\\tnew_x, new_y, new_z = (0., 0., 0.)\\n\\t\\t\\tconsidered_node = []\\n\\t\\t\\tfor vertex_index in range(2):\\n\\t\\t\\t\\tthis_node = mesh.give_edges().give_node(edge_index)[vertex_index]\\n\\t\\t\\t\\tconsidered_node.append(this_node)\\n\\t\\t\\t\\tnew_x += 3./8.*mesh.give_nodes().give_coor()[this_node][0]\\n\\t\\t\\t\\tnew_y += 3./8.*mesh.give_nodes().give_coor()[this_node][1]\\n\\t\\t\\t\\tnew_z += 3./8.*mesh.give_nodes().give_coor()[this_node][2]\\n\\t\\t\\t\\n\\t\\t\\t# faces contain this node\\n\\t\\t\\tpotential_node = []\\n\\t\\t\\tfor face_index in edge_shared_by_faces_list[edge_index]:\\t\\t\\n\\t\\t\\t\\tfor vertex_index in range(4):\\n\\t\\t\\t\\t\\t\\tpotential_node.append(mesh.give_faces().give_node_list(face_index)[vertex_index])\\n\\t\\t\\t\\n\\t\\t\\touter_node = []\\n\\t\\t\\tfor node in potential_node:\\n\\t\\t\\t\\tif (node not in considered_node) & (node not in outer_node):\\n\\t\\t\\t\\t\\touter_node.append(node)\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tfor vertex_index in outer_node:\\n\\t\\t\\t\\tnew_x += 1./16.*mesh.give_nodes().give_coor()[vertex_index][0]\\n\\t\\t\\t\\tnew_y += 1./16.*mesh.give_nodes().give_coor()[vertex_index][1]\\n\\t\\t\\t\\tnew_z += 1./16.*mesh.give_nodes().give_coor()[vertex_index][2]\\n\\t\\t\\t\\n\\t\\t\\tnew_coor.append((new_x, new_y, new_z))\\n\\n\\t# update the links of edges and surfaces\\n\\tnew_edge_list = []\\n\\tnew_face_list = []\\n\\tfor face_index in range(mesh.give_model_inf()[2]):\\n\\t\\told_node0 = mesh.give_faces().give_node_list(face_index)[0]\\n\\t\\told_node1 = mesh.give_faces().give_node_list(face_index)[1]\\n\\t\\told_node2 = mesh.give_faces().give_node_list(face_index)[2]\\n\\t\\told_node3 = mesh.give_faces().give_node_list(face_index)[3]\\n\\t\\t\\n\\t\\told_edge0 = mesh.give_faces().give_edge_list(face_index)[0]\\n\\t\\told_edge1 = mesh.give_faces().give_edge_list(face_index)[1]\\n\\t\\told_edge2 = mesh.give_faces().give_edge_list(face_index)[2]\\n\\t\\told_edge3 = mesh.give_faces().give_edge_list(face_index)[3]\\n\\t\\t\\n\\t\\tnew_node4 = old_edge0 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2] \\n\\t\\tnew_node5 = old_edge1 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\n\\t\\tnew_node6 = old_edge2 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\n\\t\\tnew_node7 = old_edge3 + mesh.give_model_inf()[0] + mesh.give_model_inf()[2]\\t\\n\\t\\tnew_node8 = mesh.give_model_inf()[0] + face_index\\n\\t\\t\\n\\t\\tif helper.in_list((old_node0, new_node4), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node0, new_node4))\\n\\t\\tif helper.in_list((new_node4, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node4, new_node8))\\n\\t\\tif helper.in_list((new_node8, new_node7), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node8, new_node7))\\n\\t\\tif helper.in_list((new_node7, old_node0), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node7, old_node0))\\n\\t\\tif helper.in_list((new_node4, old_node1), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node4, old_node1))\\n\\t\\tif helper.in_list((old_node1, new_node5), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node1, new_node5))\\n\\t\\tif helper.in_list((new_node5, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node5, new_node8))\\n\\t\\tif helper.in_list((new_node7, old_node3), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node7, old_node3))\\n\\t\\tif helper.in_list((old_node3, new_node6), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node3, new_node6))\\n\\t\\tif helper.in_list((new_node6, new_node8), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node6, new_node8))\\n\\t\\tif helper.in_list((new_node6, old_node2), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((new_node6, old_node2))\\n\\t\\tif helper.in_list((old_node2, new_node5), new_edge_list) == False: \\n\\t\\t\\tnew_edge_list.append((old_node2, new_node5))\\n\\t\\n\\t\\tnew_face_list.append((old_node0, new_node4, new_node8, new_node7))\\n\\t\\tnew_face_list.append((new_node4, old_node1, new_node5, new_node8))\\n\\t\\tnew_face_list.append((new_node7, new_node8, new_node6, old_node3))\\n\\t\\tnew_face_list.append((new_node8, new_node5, old_node2, new_node6))\\n\\t\\t\\n\\tnew_edges = geo.Edge(new_edge_list)\\n\\t\\n\\tnew_faces = geo.Face(new_face_list, new_edges)\\n\\t\\t\\n\\t# update existing nodes\\t\\n\\tfor node_index in range(mesh.give_model_inf()[0]):\\n\\t\\t\\n\\t\\tring1, ring2 = helper.find_neighbour_node(new_edges, new_faces, node_index)\\n\\t\\tvalence = helper.find_valence(node_index, new_faces) \\n\\t\\t#: valence: the number of faces sharing on specific edge\\n\\n\\t# 4. update existing corner vertex\\n\\t# 2/4 @---* 1/4 *: newly-generated vertices\\n\\t# | | @: existing vertices to be updated\\n\\t# 1/4 *---* 0 The higher mask values on neighbouring vertices, \\n\\t# the more likely a square mesh will be refined into a sphere.\\n\\t \\n\\t\\tif valence == 1:\\n\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tprint\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tnew_x += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\tnew_y += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\tnew_z += 1./4.*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\n\\t\\t\\tfor node_in_ring2 in ring2:\\n\\t\\t\\t\\tnew_x += 0.*mesh.give_nodes().give_coor()[node_in_ring2][0]\\n\\t\\t\\t\\tnew_y += 0.*mesh.give_nodes().give_coor()[node_in_ring2][1]\\n\\t\\t\\t\\tnew_z += 0.*mesh.give_nodes().give_coor()[node_in_ring2][2]\\n\\t\\t\\t\\t\\n\\t\\t\\tnew_x += 2./4.*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += 2./4.*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += 2./4.*mesh.give_nodes().give_coor()[node_index][2]\\n\\n\\t# 5. update existing boundary joint vertex\\n\\t# 3/4\\n\\t# 1/8 *---*---* 1/8 *: newly-generated vertices\\n\\t# | | | @: existing vertices to be updated\\n\\t# 0 *---*---* 0\\n\\n\\t\\telif valence == 2:\\n\\t\\t\\t\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tif helper.find_valence(node_in_ring1, new_faces) <= 2: \\n\\t\\t\\t\\t\\tnew_x += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\t\\tnew_y += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\t\\tnew_z += 1./8.*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tnew_x += 3./4.*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += 3./4.*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += 3./4.*mesh.give_nodes().give_coor()[node_index][2]\\n\\t\\n\\t# 6. update new node on interior edge\\n\\t# * r/k\\n\\t# /\\\\ b/k*\\n\\t# *__/ \\\\___ r/k\\n\\t# \\\\ \\\\ /¬¬/ *: newly-generated vertices: \\n\\t# \\\\ \\\\/ / b = 3/2/valence, r = 1/4/valence\\n\\t# *--@--* b/k\\t @: existing vertices to be updated: 1-b-r\\t\\t\\n\\t# / /\\\\ \\\\\\n\\t# /__/ \\\\__\\\\\\n\\t# * \\\\ / * r/k\\n\\t# \\\\/\\n\\t\\t\\n\\t\\telse:\\n\\t\\t\\tnew_x, new_y, new_z = (0, 0, 0)\\n\\t\\t\\tbeta = 3./2./valence\\n\\t\\t\\tgamma = 1./4./valence\\n\\t\\t\\tfor node_in_ring1 in ring1:\\n\\t\\t\\t\\tnew_x += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][0]\\n\\t\\t\\t\\tnew_y += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][1]\\n\\t\\t\\t\\tnew_z += beta/valence*mesh.give_nodes().give_coor()[node_in_ring1][2]\\n\\t\\t\\t\\n\\t\\t\\tfor node_in_ring2 in ring2:\\n\\t\\t\\t\\tnew_x += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][0]\\n\\t\\t\\t\\tnew_y += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][1]\\n\\t\\t\\t\\tnew_z += gamma/valence*mesh.give_nodes().give_coor()[node_in_ring2][2]\\n\\t\\t\\t\\n\\t\\t\\tnew_x += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][0]\\n\\t\\t\\tnew_y += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][1]\\n\\t\\t\\tnew_z += (1. - beta - gamma)*mesh.give_nodes().give_coor()[node_index][2]\\n\\t\\t\\n\\t\\tnew_coor[node_index] = (new_x, new_y, new_z)\\n\\t\\n\\tnew_nodes = geo.Node(new_coor)\\n\\t\\n\\tmesh.update(new_nodes, new_edges, new_faces)\\n\\t\\n\\t# return new_mesh\\n\\treturn mesh\",\n \"def surface(self):\\n return self._surface\",\n \"def plot_surface(self):\\n X, Y = np.meshgrid(self.x, self.y)\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n ax.plot_surface(X=X, Y=Y, Z=self.z)\\n plt.show()\",\n \"def draw_layers(self):\\n\\t\\tfor z in xrange(0,16):\\n\\t\\t\\t#create surface for this layer\\n\\t\\t\\tsrf = pygame.Surface((16,128))\\n\\t\\t\\tfor x in xrange(0,16):\\n\\t\\t\\t\\tfor y in xrange(0,128):\\n\\t\\t\\t\\t\\tv = self.data[ self.xyz_to_offset( x,y,z) ]\\n\\t\\t\\t\\t\\tif v != 0:\\n\\t\\t\\t\\t\\t\\tsrf.fill( BLOCKS.get(v, [0,0])[1], \\t(x, 127 -y, 1, 1 ))\\n\\t\\t\\t#save layer to dict for this chunk\\n\\t\\t\\tself.layers[z] = srf\",\n \"def _prepare_plane(self):\\n verticies = [\\n # main plane - note that the mainplane is scaled so the mat_plane\\n # matrix will it transform to the correct coordinates\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n\\n # coord plane\\n 0, 0,\\n 0, -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], 0,\\n 0, 0,\\n\\n # axes\\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\\n 0, 0, 0, -self.o_wh[1], #y\\n ]\\n\\n colors = [\\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n .9, .9, .9, 9.0, # plot box\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n 0.0, 0.0, 0.0, 1.0, #lines\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n ]\\n\\n self._fonts = []\\n for u in range(1, self._unit_count[0]+1):\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]+0.02)\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]-0.02)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\\n (-self.o_wh[1]+(self.i_border[3])*0.5)\\n ])\\n for u in range(0, self._unit_count[1]):\\n verticies.append(0.02)\\n verticies.append(-self._unit_w[1]*u)\\n verticies.append(-0.02)\\n verticies.append(-self._unit_w[1]*u)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\\n (0.025)*self._scaling[0],\\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\\n ])\\n\\n self._draw_plane_indicies = (0, 12)\\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\\n\\n # convert data into valid data format\\n verticies = numpy.array(verticies, dtype=numpy.float32)\\n colors = numpy.array(colors, dtype=numpy.float32)\\n\\n self._plane_vao = util.VAO()\\n self._plane_vbo = util.VBO(2)\\n\\n with self._plane_vao:\\n # plane verticies\\n with self._plane_vbo.get(0):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(0)\\n\\n # place vertex colors\\n with self._plane_vbo.get(1):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(1)\",\n \"def halfedgeConstruction(self,facetList):\\n\\t\\tedges = []\\n\\t\\t# the temporary map of the halfedges\\n\\t\\tedgeMap = {}\\n\\t\\tcount = 0\\n\\t\\tfor i in range(0,len(facetList)):\\n\\t\\t\\t# \\n\\t\\t\\tfor j in range(0,len(facetList[i])):\\n\\t\\t\\t\\t# j is the index of the current vertex\\n\\t\\t\\t\\tkey = (facetList[i][j-1],facetList[i][j])\\n\\t\\t\\t\\tedges.append(key)\\n\\t\\t\\t\\tedgeMap[key] = count\\n\\t\\t\\t\\tcount += 1\\n\\t\\t\\t\\t# initialze the current halfedge\\n\\t\\t\\t\\the = Halfedge()\\n\\t\\t\\t\\t# assume that the mesh has been well oriented\\n\\t\\t\\t\\the.setVertex(self._mesh._vertices[facetList[i][j]])\\n\\t\\t\\t\\tself._mesh._halfedges.append(he)\\n\\t\\t# construct the opposite halfedge\\n\\t\\tfor key in edgeMap:\\n\\t\\t\\ti = edgeMap[key]\\n\\t\\t\\tif self._mesh._halfedges[i].opposite() is None:\\n\\t\\t\\t\\t# the opposite has not been set\\n\\t\\t\\t\\toppo = key[1],key[0]\\n\\t\\t\\t\\tif oppo in edgeMap:\\n\\t\\t\\t\\t\\t# interior edge\\n\\t\\t\\t\\t\\tj = edgeMap[oppo]\\n\\t\\t\\t\\t\\tself._mesh._halfedges[i].setOpposite(self._mesh._halfedges[j])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[j].setOpposite(self._mesh._halfedges[i])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# border edge\\n\\t\\t\\t\\t\\t# construct a border halfedge\\n\\t\\t\\t\\t\\the = Halfedge()\\n\\t\\t\\t\\t\\t# the edge is border edge\\n\\t\\t\\t\\t\\the._isBorder = True\\n\\t\\t\\t\\t\\tself._mesh._halfedges[i].setOpposite(he)\\n\\t\\t\\t\\t\\the.setOpposite(self._mesh._halfedges[i])\\n\\t\\t\\t\\t\\t# append the halfedge\\n\\t\\t\\t\\t\\tself._mesh._halfedges.append(he)\\n\\t\\t\\t\\t\\tcount += 1\\n\\t\\t# set next and prev halfedge\\n\\t\\t# the interior edges\\n\\t\\tcount = 0\\n\\t\\tfor i in range(0,len(facetList)):\\n\\t\\t\\tfor j in range(0,len(facetList[i])):\\n\\t\\t\\t\\tif j == len(facetList[i])-1:\\n\\t\\t\\t\\t\\t# the last edge: the next edge is the beggining edge\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\\n\\t\\t\\t\\telif j == 0:\\n\\t\\t\\t\\t\\t# the beginning edge: the prev edge is the last one\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+len(facetList[i])-1])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# the interior edge\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setNext(self._mesh._halfedges[count+j+1])\\n\\t\\t\\t\\t\\tself._mesh._halfedges[count+j].setPrev(self._mesh._halfedges[count+j-1])\\n\\t\\t\\t# the count\\n\\t\\t\\tcount += len(facetList[i])\\n\\t\\t# the border edges\\n\\t\\tfor i in range(count,len(self._mesh._halfedges)):\\n\\t\\t\\the = self._mesh._halfedges[i]\\n\\t\\t\\t# first set the vertex\\n\\t\\t\\the.setVertex(he.opposite().prev().vertex())\\n\\t\\t\\t# two kinds of situation\\n\\t\\t\\tif he.opposite().prev().opposite().isBorder():\\n\\t\\t\\t\\the.setNext(he.opposite().prev().opposite())\\n\\t\\t\\telse:\\n\\t\\t\\t\\the.setNext(he.opposite().prev().opposite().prev().opposite())\\n\\t\\t\\tif he.opposite().next().opposite().isBorder():\\n\\t\\t\\t\\the.setPrev(he.opposite().next().opposite())\\n\\t\\t\\telse:\\n\\t\\t\\t\\the.setPrev(he.opposite().next().opposite().next().opposite())\",\n \"def draw(self, surface):\\n for box in self.checkboxes:\\n box.draw(surface)\",\n \"def face_lattice(self):\\n try:\\n return self._face_lattice\\n except AttributeError:\\n pass\\n \\n coatom_to_Hindex = [ h.index() for h in self.inequality_generator() ]\\n Hindex_to_coatom = [None] * self.n_Hrepresentation() \\n for i in range(0,len(coatom_to_Hindex)):\\n Hindex_to_coatom[ coatom_to_Hindex[i] ] = i\\n \\n atom_to_Vindex = [ v.index() for v in self.Vrep_generator() if not v.is_line() ]\\n Vindex_to_atom = [None] * self.n_Vrepresentation() \\n for i in range(0,len(atom_to_Vindex)):\\n Vindex_to_atom[ atom_to_Vindex[i] ] = i\\n \\n atoms_incidences = [ tuple([ Hindex_to_coatom[h.index()] \\n for h in v.incident() if h.is_inequality() ]) \\n for v in self.Vrepresentation() if not v.is_line() ]\\n \\n coatoms_incidences = [ tuple([ Vindex_to_atom[v.index()] \\n for v in h.incident() if not v.is_line() ])\\n for h in self.Hrepresentation() if h.is_inequality() ]\\n \\n atoms_vertices = [ Vindex_to_atom[v.index()] for v in self.vertex_generator() ]\\n equations = [ e.index() for e in self.equation_generator() ]\\n lines = [ l.index() for l in self.line_generator() ]\\n\\n def face_constructor(atoms,coatoms):\\n if len(atoms)==0:\\n Vindices = ()\\n else:\\n Vindices = tuple(sorted([ atom_to_Vindex[i] for i in atoms ]+lines))\\n Hindices = tuple(sorted([ coatom_to_Hindex[i] for i in coatoms ]+equations))\\n return PolyhedronFace(self, Vindices, Hindices)\\n\\n self._face_lattice = Hasse_diagram_from_incidences\\\\\\n (atoms_incidences, coatoms_incidences, face_constructor=face_constructor, required_atoms=atoms_vertices)\\n return self._face_lattice\",\n \"def update_mesh(self, all_meshes):\\n if isinstance(all_meshes, Mesh):\\n mesh_tp = []\\n mesh_tp.append(all_meshes)\\n all_meshes = mesh_tp\\n\\n for i, mesh in enumerate(all_meshes):\\n if mesh.time.size != 1:\\n raise IndexError(\\\"Mesh should be from one frame only\\\")\\n\\n if len(self.all_meshes) <= i or mesh.channel.size != self.all_meshes[i].channel.size:\\n self.new_mesh_set(all_meshes)\\n return # Prevent calling update_markers recursively\\n\\n if not isinstance(all_meshes, list):\\n raise TypeError(\\\"Please send a list of mesh to update_mesh\\\")\\n\\n self.all_meshes = all_meshes\\n\\n for i, mesh in enumerate(self.all_meshes):\\n points = vtkPoints()\\n n_vertex = mesh.channel.size\\n mesh = np.array(mesh)\\n for j in range(n_vertex):\\n points.InsertNextPoint(mesh[0:3, j])\\n\\n poly_line = self.mesh_actors[i].GetMapper().GetInput()\\n poly_line.SetPoints(points)\\n self.mesh_actors[i].GetProperty().SetLineWidth(self.mesh_linewidth)\",\n \"def faces(self) -> Polygon:\\n return Polygon(self.array, copy=False)\",\n \"def buildSurface(self, idx = 0, surface = 1, z = 1, verbose = 1,\\\\\\n strained = False, vacuum = 0, ab = False):\\n\\n \\\"\\\"\\\"Basis for the selected surface, and the cell repetitions\\\"\\\"\\\"\\n rep = np.zeros((3, 4))\\n new_base = np.zeros((3, 3))\\n\\n altBase1 = np.zeros((3, 3))\\n altBase2 = np.zeros((3, 3))\\n if ab:\\n B1, B2 = self.getAB()\\n\\n if surface == 1:\\n old_base = self.base_1\\n spec = self.spec_1\\n mass = self.mass_1\\n pos = self.pos_1\\n\\n new_base[2, 2] = self.base_1[2, 2] * z\\n new_base[0:2, 0:2] = self.cell_1[idx, :, :]\\n \\n if ab:\\n altBase1[:2, :2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\\n altBase1[2, 2] = B1[2, 2] * z\\n \\n rep[0:2, 0:2] = self.rep_1[idx, :, :]\\n rep[:, 2] = np.sum(rep, axis = 1)\\n elif surface == 2:\\n old_base = self.base_2\\n spec = self.spec_2\\n mass = self.mass_2\\n pos = self.pos_2\\n\\n new_base[2, 2] = self.base_2[2, 2] * z\\n new_base[0:2, 0:2] = self.cell_2[idx, :, :]\\n \\n if ab:\\n altBase2[:2, :2] = np.matmul(B2[:2, :2], self.rep_2[idx, :, :])\\n altBase2[2, 2] = B2[2, 2] * z\\n\\n rep[0:2, 0:2] = self.rep_2[idx, :, :]\\n rep[:, 2] = np.sum(rep, axis = 1)\\n\\n \\\"\\\"\\\"Set all hi-lo limits for the cell repetitions\\\"\\\"\\\"\\n h = 2\\n rep = [rep[0, :].min() - h, rep[0, :].max() + h,\\\\\\n rep[1, :].min() - h, rep[1, :].max() + h,\\\\\\n 0, z - 1]\\n\\n \\\"\\\"\\\"Extend the cell as spcefied\\\"\\\"\\\"\\n pos_ext, spec_ext, mass_ext = ut.extendCell(base = old_base, rep = rep,\\\\\\n pos = pos.T, spec = spec,\\\\\\n mass = mass)\\n\\n if surface == 1:\\n \\\"\\\"\\\"Change to alternative base_1 if specified\\\"\\\"\\\"\\n if ab:\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n new_base = altBase1\\n pos_ext = np.matmul(new_base, pos_d)\\n if verbose > 0:\\n string = \\\"Surface 1 constructed with alternative base\\\"\\n ut.infoPrint(string)\\n\\n elif surface == 2:\\n \\\"\\\"\\\"Initial rotation\\\"\\\"\\\"\\n initRot = np.deg2rad(self.ang[idx])\\n\\n \\\"\\\"\\\"Rotate the positions pos_rot = R*pos\\\"\\\"\\\"\\n pos_ext = ut.rotate(pos_ext, initRot, verbose = verbose - 1)\\n\\n \\\"\\\"\\\"Construct it in the alternative base_2 if specified\\\"\\\"\\\"\\n if ab:\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n new_base = altBase2\\n pos_ext = np.matmul(new_base, pos_d)\\n if verbose > 0:\\n string = \\\"Surface 2 constructed with alternative base\\\"\\n ut.infoPrint(string)\\n\\n \\\"\\\"\\\"Strain the cell if specified\\\"\\\"\\\"\\n if strained:\\n\\n \\\"\\\"\\\"If the cell is to be strained then convert to direct coordinates\\\"\\\"\\\"\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n\\n \\\"\\\"\\\"Convert back to cartesian coordinates.\\\"\\\"\\\"\\n if ab:\\n \\\"\\\"\\\"Strain it to the alternative base_1\\\"\\\"\\\"\\n new_base[0:2, 0:2] = np.matmul(B1[:2, :2], self.rep_1[idx, :, :])\\n string = \\\"Surface 2 strained to match surface 1 with an alternative base\\\"\\n \\n else:\\n \\\"\\\"\\\"Strain it to the bottom surface\\\"\\\"\\\"\\n new_base[0:2, 0:2] = self.cell_1[idx, :, :].copy()\\n string = \\\"Surface 2 strained to match surface 1\\\"\\n\\n pos_ext = np.matmul(new_base, pos_d)\\n\\n if verbose > 0:\\n ut.infoPrint(string)\\n\\n \\\"\\\"\\\"Convert the entire new cell to direct coordinates\\\"\\\"\\\"\\n pos_d = np.matmul(np.linalg.inv(new_base), pos_ext)\\n\\n \\\"\\\"\\\"Remove all positions outside [0, 1)\\\"\\\"\\\"\\n pos_d = np.round(pos_d, 8)\\n new_base = np.round(new_base, 8)\\n\\n keep = np.all(pos_d < 1, axis = 0) * np.all(pos_d >= 0, axis = 0)\\n pos_d = pos_d[:, keep]\\n species = spec_ext[keep]\\n mass = mass_ext[keep]\\n\\n \\\"\\\"\\\"Return to cartesian coordinates and change shape to (...,3)\\\"\\\"\\\"\\n pos = np.matmul(new_base, pos_d).T\\n\\n \\\"\\\"\\\"Add vacuum if specified\\\"\\\"\\\"\\n new_base[2, 2] = new_base[2, 2] + vacuum\\n if verbose: \\n string = \\\"Vacuum added: %.2f\\\"\\\\\\n % (vacuum)\\n ut.infoPrint(string)\\n\\n return new_base, pos, species, mass\",\n \"def update_points(self, *args):\\n points = [Window.width / 2, Window.height / 2, .5, .5]\\n i = 0\\n while i < 2 * pi:\\n i += 0.01 * pi\\n points.extend([\\n Window.width / 2 + cos(i) * (self.radius + self.sin_wobble *\\n sin(i * self.sin_wobble_speed)),\\n Window.height / 2 + sin(i) * (self.radius + self.sin_wobble *\\n sin(i * self.sin_wobble_speed)),\\n self.offset_x + sin(i),\\n self.offset_y + cos(i)])\\n\\n self.mesh_points = points\",\n \"def _draw(self):\\r\\n \\r\\n if self.active:\\r\\n self.surface = self.activeSurface # Set active surface to be displayed.\\r\\n else:\\r\\n self.surface = self.passiveSurface # Set passive surface to be displayed.\\r\",\n \"def test_face_in_face(self):\\n w = mt.createCube(marker=1, boundaryMarker=1)\\n b = w.boundary(2)\\n\\n pad = mt.createFacet(mt.createCircle(radius=0.2, segments=12,\\n isHole=True))\\n b2 = pad.boundary(0)\\n\\n # rotate to match target norm and pos\\n rot = pg.core.getRotation(b2.norm(), b.norm())\\n pad.transform(rot)\\n pad.translate(b.center())\\n\\n # create a boundary with new marker match the hole\\n w.copyBoundary(b2)\\n\\n w.createBoundary(w.nodes([w.createNode(n.pos()).id() for n in b2.nodes()]),\\n marker=2)\\n\\n #print(w.boundaryMarkers())\\n\\n mesh = mt.createMesh(w)\\n\\n #pg.show(mesh)\\n # w.exportPLC('pad.poly')\\n # mesh.exportBoundaryVTU('b.vtu')\\n np.testing.assert_array_equal(pg.unique(pg.sort(mesh.boundaryMarkers())),\\n [0, 1, 2])\\n\\n # print(mesh)\\n # mesh.exportBoundaryVTU('b.vtu')\\n pg.show(mesh)\",\n \"def create_reference_array(self):\\r\\n self.active = True\\r\\n self.pxarray = pygame.surfarray.pixels3d(self.surface)\\r\\n pygame.display.flip()\\r\\n return\",\n \"def __init__(self):\\n self.lattices = []\\n self.meshfns = []\",\n \"def new_mesh_set(self, all_meshes):\\n if isinstance(all_meshes, Mesh):\\n mesh_tp = MeshCollection()\\n mesh_tp.append(all_meshes)\\n all_meshes = mesh_tp\\n\\n if all_meshes.get_num_frames() is not 1:\\n raise IndexError(\\\"Mesh should be from one frame only\\\")\\n\\n if not isinstance(all_meshes, MeshCollection):\\n raise TypeError(\\\"Please send a list of mesh to update_mesh\\\")\\n self.all_meshes = all_meshes\\n\\n # Remove previous actors from the scene\\n for actor in self.mesh_actors:\\n self.parent_window.ren.RemoveActor(actor)\\n self.mesh_actors = list()\\n\\n # Create the geometry of a point (the coordinate) points = vtkPoints()\\n for (i, mesh) in enumerate(self.all_meshes):\\n points = vtkPoints()\\n for j in range(mesh.get_num_vertex()):\\n points.InsertNextPoint([0, 0, 0])\\n\\n # Create an array for each triangle\\n cell = vtkCellArray()\\n for j in range(mesh.get_num_triangles()): # For each triangle\\n line = vtkPolyLine()\\n line.GetPointIds().SetNumberOfIds(4)\\n for k in range(len(mesh.triangles[j])): # For each index\\n line.GetPointIds().SetId(k, mesh.triangles[j, k])\\n line.GetPointIds().SetId(3, mesh.triangles[j, 0]) # Close the triangle\\n cell.InsertNextCell(line)\\n poly_line = vtkPolyData()\\n poly_line.SetPoints(points)\\n poly_line.SetLines(cell)\\n\\n # Create a mapper\\n mapper = vtkPolyDataMapper()\\n mapper.SetInputData(poly_line)\\n\\n # Create an actor\\n self.mesh_actors.append(vtkActor())\\n self.mesh_actors[i].SetMapper(mapper)\\n\\n self.parent_window.ren.AddActor(self.mesh_actors[i])\\n self.parent_window.ren.ResetCamera()\\n\\n # Update marker position\\n self.update_mesh(self.all_meshes)\",\n \"def change_face(self, face):\\n if self.face is not None:\\n self.face.remove_point(self)\\n\\n self.face = face\\n self.face.add_point(self)\",\n \"def update_mesh(self, all_meshes):\\n if isinstance(all_meshes, Mesh):\\n mesh_tp = MeshCollection()\\n mesh_tp.append(all_meshes)\\n all_meshes = mesh_tp\\n\\n if all_meshes.get_num_frames() is not 1:\\n raise IndexError(\\\"Mesh should be from one frame only\\\")\\n\\n for i in range(len(all_meshes)):\\n if all_meshes.get_mesh(i).get_num_vertex() is not self.all_meshes.get_mesh(i).get_num_vertex():\\n self.new_mesh_set(all_meshes)\\n return # Prevent calling update_markers recursively\\n\\n if not isinstance(all_meshes, MeshCollection):\\n raise TypeError(\\\"Please send a list of mesh to update_mesh\\\")\\n\\n self.all_meshes = all_meshes\\n\\n for (i, mesh) in enumerate(self.all_meshes):\\n points = vtkPoints()\\n for j in range(mesh.get_num_vertex()):\\n points.InsertNextPoint(mesh[0:3, j])\\n\\n poly_line = self.mesh_actors[i].GetMapper().GetInput()\\n poly_line.SetPoints(points)\",\n \"def __init__(self, mesh):\\n self._mesh = mesh\\n # number of triangles in this patch\\n self._nTris = 0\\n # offset into mesh._indices where this patch starts\\n self._startIndex = mesh.vertexCount()\\n # indices into the parent mesh's vertex list\\n self._indices = []\\n # r, g, b, a\\n self._color = [0.1, 0.1, 0.7, 1.0]\\n # 'wire', 'flat', or 'smooth'\\n self._surfaceMode = 'smooth'\\n # DEBUG:\\n self._showNormals = False\",\n \"def SplitSurface(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_FaceDivide_SplitSurface(self, *args)\",\n \"def faceTrace(self, pi, fi, vi):\\n if pi == 1:\\n face = self.poly1.faces[fi]\\n elif pi == 2:\\n face = self.poly2.faces[fi]\\n else:\\n raise ValueError('pi must be 1 or 2')\\n n = len(face.vertices)\\n initialV = face.vertices[vi]\\n newFace = [initialV]\\n initialI = self.getIntersector(initialV)\\n assert initialI is not None # This checks that the vertex was actually an intersection\\n # This part determines which side of the face is the way to go\\n if self.getIntersector(face.vertices[(vi + 1) % n]) is not None or face.vertices[(vi + 1) % n].isInterior():\\n step = 1\\n elif self.getIntersector(face.vertices[(vi - 1) % n]) is not None or face.vertices[(vi - 1) % n].isInterior():\\n step = -1\\n else:\\n raise ValueError('The vertex given has no adjacent interior or intersector vertex')\\n i = (vi + step) % n\\n force = True\\n while force or i != (vi + step) % n:\\n force = False\\n # Tracing the interior\\n while (face.vertices[i]).isInterior():\\n newFace.append(self.newVertex(face.vertices[i]))\\n face.vertices[i].markFTraced(face)\\n # print('fTracing', i)\\n i += step\\n # Tracing the surface\\n newFace.append(self.newVertex(face.vertices[i]))\\n face.vertices[i].markFTraced(face)\\n lastI = self.getIntersector(face.vertices[i])\\n potentialInters = self.nextIntersectors(lastI)\\n if abs((vector(potentialInters[0].v) - vector(lastI.v))\\n .dotProduct(face.normalVect())) < COMPARISON_EPSILON:\\n inter = potentialInters[0]\\n elif abs((vector(potentialInters[1].v) - vector(lastI.v))\\n .dotProduct(face.normalVect())) < COMPARISON_EPSILON:\\n inter = potentialInters[1]\\n else:\\n raise Exception('The nextIntersectors are weird (1)')\\n while inter.v not in face.vertices:\\n nextInters = self.nextIntersectors(inter)\\n if nextInters[0] != lastI:\\n lastI = inter\\n inter = nextInters[0]\\n elif nextInters[1] != lastI:\\n lastI = inter\\n inter = nextInters[1]\\n else:\\n raise Exception('The nextIntersectors are weird (2)')\\n newFace.append(lastI.v)\\n inter.v.markFTraced(face)\\n i = (face.vertices.index(inter.v) + step) % n\\n if step == -1:\\n newFace.reverse()\\n self.result.addFace(newFace, True)\",\n \"def draw(self, surface):\\n\\n\\t\\tsurface.blit(self.image, self.rect.topleft)\",\n \"def traceSurface(self, inter):\\n assert self.nonDoubleIntersectors()\\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\\n assert all(f.hasNoDoubleVertices() for f in self.poly1.faces)\\n assert all(f.hasNoDoubleVertices() for f in self.poly2.faces)\\n assert self.nonDoubleVertices()\\n i = self.nextIntersectors(inter)[0]\\n assert i.v != inter.v\\n assert i.v.dist(inter.v) != 0\\n lastI = inter\\n self.result.addEdge(self.newVertex(lastI), self.newVertex(i))\\n i.sTraced = True\\n while i != inter:\\n nextInts = self.nextIntersectors(i)\\n if nextInts[0] != lastI:\\n lastI = i\\n i = nextInts[0]\\n else:\\n lastI = i\\n i = nextInts[1]\\n self.result.addEdge(self.newVertex(lastI), self.newVertex(i))\\n i.sTraced = True\",\n \"def change_colour_surface(surface, r, g, b):\\n arr = pg.surfarray.pixels3d(surface)\\n arr[:, :, 0] = r\\n arr[:, :, 1] = g\\n arr[:, :, 2] = b\",\n \"def subdivide(self, subdivision, new_point):\\n\\n\\t\\tassert(subdivision.ndim == 3)\\n\\n\\t\\t# Find the attached faces.\\n\\t\\tface1, face2, face3, face4 = self.attached_faces\\n\\n\\t\\t# Find the attached lines, and be able to associate them with the\\n\\t\\t# faces.\\n\\t\\tline12, = face1.attached_lines & face2.attached_lines\\n\\t\\tline13, = face1.attached_lines & face3.attached_lines\\n\\t\\tline14, = face1.attached_lines & face4.attached_lines\\n\\t\\tline23, = face2.attached_lines & face3.attached_lines\\n\\t\\tline24, = face2.attached_lines & face4.attached_lines\\n\\t\\tline34, = face3.attached_lines & face4.attached_lines\\n\\n\\t\\t# Find the attached points, and be able to associate them with the \\n\\t\\t# faces.\\n\\t\\tpoint123, = line12.attached_points & line13.attached_points\\n\\t\\tpoint124, = line12.attached_points & line14.attached_points\\n\\t\\tpoint134, = line13.attached_points & line14.attached_points\\n\\t\\tpoint234, = line23.attached_points & line24.attached_points\\n\\n\\t\\t# Create the new lines.\\n\\t\\tnew_line123 = matplot3dext.objects.line.Line(point123, new_point)\\n\\t\\tnew_line124 = matplot3dext.objects.line.Line(point124, new_point)\\n\\t\\tnew_line134 = matplot3dext.objects.line.Line(point134, new_point)\\n\\t\\tnew_line234 = matplot3dext.objects.line.Line(point234, new_point)\\n\\n\\t\\t# Create the new faces.\\n\\t\\tnew_face12 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline12, new_line123, new_line124)\\n\\t\\tnew_face13 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline13, new_line123, new_line134)\\n\\t\\tnew_face14 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline14, new_line124, new_line134)\\n\\t\\tnew_face23 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline23, new_line123, new_line234)\\n\\t\\tnew_face24 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline24, new_line124, new_line234)\\n\\t\\tnew_face34 = matplot3dext.objects.face.Face(\\n\\t\\t\\t\\tline34, new_line134, new_line234)\\n\\n\\t\\t# Create the new tetrahedra.\\n\\t\\t#\\n\\t\\t# Make a sketch to understand what's going on now.\\n\\t\\tnew_tetrahedron1 = Tetrahedron(\\n\\t\\t\\t\\tface1, new_face12, new_face13, new_face14)\\n\\t\\tnew_tetrahedron2 = Tetrahedron(\\n\\t\\t\\t\\tface2, new_face12, new_face23, new_face24)\\n\\t\\tnew_tetrahedron3 = Tetrahedron(\\n\\t\\t\\t\\tface3, new_face13, new_face23, new_face34)\\n\\t\\tnew_tetrahedron4 = TetrahedroN(\\n\\t\\t\\t\\tface4, new_face14, new_face24, new_face34)\\n\\n\\t\\tself.replace_by([new_tetrahdron1, new_tetrahedron2, \\n\\t\\t\\t\\tnew_tetrahedron3, new_tetrahedron4], subdivision.world)\\n\\n\\t\\treturn new_point\",\n \"def Face_Cycle_R(self,event):\\n t=event.widget.find_closest(event.x, event.y)[0]\\n u=int(self.canvas.itemcget(t,\\\"tags\\\").split()[1])\\n if u not in [4,13,22,31,40,49]:\\n v=self.colours_face[self.ocol[self.canvas.itemcget(t,\\\"fill\\\")][1]][0][0]\\n self.cubestring[u]=v\\n self.cube.cube = self.cubestring#Cube.set(self.cubestring)\\n self.map_face()\\n else:\\n print(\\\"Cant Change Center Cubit\\\")\",\n \"def assemble_hyper_surface(self):\\n def get_row_no(k0):\\n hdf = pd.HDFStore(self.ewlibpath, 'r')\\n hdf0 = hdf.get(k0)\\n idx = np.where((np.abs(hdf0.th_wavelength-self.wavelength)<=0.025)\\n & (np.abs(hdf0.th_EP - self.ep)<=0.02)\\n & (hdf0.element == self.element))[0]\\n if idx.size!=0:\\n idx = idx[0]\\n else:\\n idx = -1\\n hdf.close()\\n return idx\\n\\n if self.interpolated:\\n raise NotImplementedError(\\\"Interpolated model doesn't have such method!\\\")\\n\\n row_no = get_row_no(self._keys[0])\\n if row_no == -1:\\n warnings.warn(\\\"Data for interpolation is not enough!\\\")\\n self._hyper_surface = None\\n return self._hyper_surface\\n else:\\n f = h5py.File(self.ewlibpath, 'r')\\n if self.cal == \\\"nlte\\\":\\n ews = [np.array(f[k+\\\"/table\\\"])[row_no][1][3] for k in self._keys]\\n else:\\n ews = [np.array(f[k+\\\"/table\\\"])[row_no][1][2] for k in self._keys]\\n f.close()\\n\\n\\n datapoints = np.concatenate((np.array(self._atmos_pars), np.transpose([ews])), axis=1)\\n datapoints = datapoints[~np.isnan(datapoints).any(axis=1)]\\n\\n if datapoints.shape[0] <= 3:\\n warnings.warn(\\\"Data for interpolation is not enough!\\\")\\n self._hyper_surface = None\\n del datapoints\\n return self._hyper_surface\\n else:\\n self._hyper_surface = datapoints\\n print(\\\"Grid is prepared!\\\")\\n del datapoints\\n return self._hyper_surface\",\n \"def __init__( self , l , w , h , pos = [ 0 , 0 , 0 ] ):\\r\\n # NOTE: Poses are stored as transforms , since that is what you need poses for anyway\\r\\n \\r\\n # FIXME : This object needs a transform to the parent frame\\r\\n \\r\\n self.vertices = ( # List of untransformed vertices\\r\\n 0 , 0 , 0 ,\\t# vertex 0 3-------2 # NOTE: Z+ is UP\\r\\n l , 0 , 0 ,\\t# vertex 1 !\\\\ !\\\\\\r\\n 0 , 0 , h ,\\t# vertex 2 ! \\\\ Z \\\\\\r\\n l , 0 , h ,\\t# vertex 3 ! 7=======6\\r\\n 0 , w , 0 ,\\t# vertex 4 1--|X---0 |\\r\\n l , w , 0 ,\\t# vertex 5 \\\\ | \\\\ |\\r\\n 0 , w , h ,\\t# vertex 6 \\\\| Y|\\r\\n l , w , h ,\\t# vertex 7 5=======4\\r\\n )\\r\\n \\r\\n self.vertX = list( self.vertices ) # List of transformed vertices\\r\\n \\r\\n self.indices = ( # NOTE: Vertices must have CCW order to point the normals towards exterior , \\r\\n 0 , 1 , 3 , 2 , # back face 3-----2 3-----2 right hand rule , otherwise dot products computed for backface-culling \\r\\n 4 , 6 , 7 , 5 , # front face !\\\\ up \\\\ !back !\\\\ will have the wrong sign! faces vanish!\\r\\n 0 , 2 , 6 , 4 , # left face right7=====6 ! ! 6\\r\\n 1 , 5 , 7 , 3 , # right face 1 |front| 1-----0l|eft \\r\\n 0 , 4 , 5 , 1 , # down face \\\\| | \\\\down \\\\|\\r\\n 2 , 3 , 7 , 6 , # up face 5=====4 5=====4 \\r\\n )\\r\\n \\r\\n self.linDices = (\\r\\n 3 , 2 ,\\r\\n 2 , 6 ,\\r\\n 6 , 7 ,\\r\\n 7 , 3 ,\\r\\n 3 , 1 ,\\r\\n 2 , 0 ,\\r\\n 6 , 4 ,\\r\\n 7 , 5 ,\\r\\n 0 , 4 ,\\r\\n 4 , 5 ,\\r\\n 5 , 1 ,\\r\\n 1 , 0\\r\\n )\\r\\n \\r\\n self.color = ( 88 , 181 , 74 ) # Body color\\r\\n self.colorLine = ( 0 , 0 , 255 ) # Line color\\r\\n \\r\\n self.pos3D = pos # 3D position in the parent frame\\r\\n \\r\\n self.thetaDeg = 0.0\\r\\n self.thetaRad = 0.0\\r\\n self.rotAxis = [ 0.0 , 0.0 , 1.0 ]\\r\\n \\r\\n self.rotnByOGL = False # Flag for whether to apply rotation by OpenGL: True - OpenGL , False - Matrix Algebra\\r\",\n \"def surfacePairs(self):\\n return self._els\",\n \"def __init__(self, vertices, edges, faces):\\n self.vertices = vertices\\n self.edges = edges\\n self.faces = faces\",\n \"def _get_surfaces(idf):\\n surfaces = idf.getsurfaces() + idf.getshadingsurfaces() + idf.getsubsurfaces()\\n return surfaces\",\n \"def select_faces(maxAngle):\\n date_1 = datetime.datetime.now()\\n print(\\\"Start\\\")\\n\\n print(maxAngle, maxAngle*180/pi)\\n\\n # Get the active object\\n obj = bpy.context.active_object\\n\\n # Add the vertices location in an array\\n tabVertices = []\\n for vertex in obj.data.vertices:\\n tabVertices.append(obj.matrix_world @ vertex.co)\\n\\n # Find the downward vector in function of the angles of the mesh\\n matrix_new = obj.matrix_world.to_3x3().inverted()\\n no_world = matrix_new @ mathutils.Vector((0,0,-1))\\n no_world.normalize() \\n print(no_world)\\n vecDir = no_world\\n\\n\\n # Arrays for the function C parameters\\n tabPoly = []\\n tabNormalX = []\\n tabNormalY = []\\n tabNormalZ = []\\n tabFaces = []\\n\\n tabPoint1X = []\\n tabPoint1Y = []\\n tabPoint2X = []\\n tabPoint2Y = []\\n tabPoint3X = []\\n tabPoint3Y = []\\n tabPoint1Z = []\\n tabPoint2Z = []\\n tabPoint3Z = []\\n\\n # Fill the arrays\\n for poly in obj.data.polygons:\\n tabPoly.append(poly.index)\\n tabNormalX.append(poly.normal[0])\\n tabNormalY.append(poly.normal[1])\\n tabNormalZ.append(poly.normal[2])\\n tabFaces.append(0)\\n \\n tabPoint1X.append(tabVertices[poly.vertices[0]].x)\\n tabPoint1Y.append(tabVertices[poly.vertices[0]].y)\\n tabPoint2X.append(tabVertices[poly.vertices[1]].x)\\n tabPoint2Y.append(tabVertices[poly.vertices[1]].y)\\n tabPoint3X.append(tabVertices[poly.vertices[2]].x)\\n tabPoint3Y.append(tabVertices[poly.vertices[2]].y)\\n tabPoint1Z.append(tabVertices[poly.vertices[0]].z)\\n tabPoint2Z.append(tabVertices[poly.vertices[1]].z)\\n tabPoint3Z.append(tabVertices[poly.vertices[2]].z)\\n\\n print(len(tabPoly)) \\n\\n print(os.path.dirname(__file__))\\n # Get the filepath of the dll file\\n functionC = ctypes.CDLL(os.path.dirname(__file__) + \\\"\\\\\\\\function.dll\\\")\\n\\n # Create array for C function\\n seq = ctypes.c_int * len(tabPoly)\\n arrIndex = seq(*tabPoly)\\n\\n seq = ctypes.c_float * len(tabNormalX)\\n arrNormalX = seq(*tabNormalX)\\n seq = ctypes.c_float * len(tabNormalY)\\n arrNormalY = seq(*tabNormalY)\\n seq = ctypes.c_float * len(tabNormalZ)\\n arrNormalZ = seq(*tabNormalZ)\\n\\n seq = ctypes.c_int * len(tabFaces)\\n arrFaces = seq(*tabFaces)\\n\\n seq = ctypes.c_float * len(tabPoint1X)\\n arrPoint1X = seq(*tabPoint1X)\\n seq = ctypes.c_float * len(tabPoint1Y)\\n arrPoint1Y = seq(*tabPoint1Y)\\n seq = ctypes.c_float * len(tabPoint2X)\\n arrPoint2X = seq(*tabPoint2X)\\n seq = ctypes.c_float * len(tabPoint2Y)\\n arrPoint2Y = seq(*tabPoint2Y)\\n seq = ctypes.c_float * len(tabPoint3X)\\n arrPoint3X = seq(*tabPoint3X)\\n seq = ctypes.c_float * len(tabPoint3Y)\\n arrPoint3Y = seq(*tabPoint3Y)\\n seq = ctypes.c_float * len(tabPoint1Z)\\n arrPoint1Z = seq(*tabPoint1Z)\\n seq = ctypes.c_float * len(tabPoint2Z)\\n arrPoint2Z = seq(*tabPoint2Z)\\n seq = ctypes.c_float * len(tabPoint3Z)\\n arrPoint3Z = seq(*tabPoint3Z)\\n\\n date_3 = datetime.datetime.now()\\n \\n # Call the C function\\n functionC.select_faces(arrIndex,len(tabPoly),arrNormalX,arrNormalY,arrNormalZ,ctypes.c_float(maxAngle),ctypes.c_float(vecDir.x),ctypes.c_float(vecDir.y),ctypes.c_float(vecDir.z),arrFaces,arrPoint1X,arrPoint1Y,arrPoint2X,arrPoint2Y,arrPoint3X,arrPoint3Y,arrPoint1Z,arrPoint2Z,arrPoint3Z)\\n\\n date_4 = datetime.datetime.now()\\n\\n # Switch in edit mode\\n bpy.ops.object.mode_set(mode = 'EDIT')\\n # Deselect all the faces\\n bpy.ops.mesh.select_all(action = 'DESELECT')\\n bpy.ops.mesh.select_mode(type=\\\"FACE\\\")\\n # Switch in object mode\\n bpy.ops.object.mode_set(mode = 'OBJECT')\\n\\n # Select all the faces needed support\\n for i in range(len(arrFaces)):\\n if arrFaces[i] == 1:\\n obj.data.polygons[tabPoly[i]].select = True\\n print(len(arrFaces))\\n \\n # Switch in edit mode\\n bpy.ops.object.mode_set(mode = 'EDIT')\\n print(\\\"End\\\")\\n\\n date_2 = datetime.datetime.now()\\n time_delta = (date_2 - date_1)\\n total_seconds = time_delta.total_seconds()\\n print(total_seconds)\\n \\n time_delta = (date_4 - date_3)\\n total_seconds = time_delta.total_seconds()\\n print(\\\"C time : \\\", total_seconds)\",\n \"def mesh_add_vertex_to_face_edge(mesh, key, fkey, v):\\n vertices = mesh.face_vertices(fkey)\\n i = vertices.index(v)\\n u = vertices[i - 1]\\n vertices.insert(key, i - 1)\\n mesh.halfedge[u][key] = fkey\\n mesh.halfedge[key][v] = fkey\\n if u not in mesh.halfedge[key]:\\n mesh.halfedge[key][u] = None\\n if key not in mesh.halfedge[v]:\\n mesh.halfedge[v][key] = None\\n del mesh.halfedge[u][v]\\n if u in mesh.halfedge[v]:\\n del mesh.halfedge[v][u]\\n if (u, v) in mesh.edgedata:\\n del mesh.edgedata[u, v]\\n if (v, u) in mesh.edgedata:\\n del mesh.edgedata[v, u]\",\n \"def _get_collection(surface_type, surfaces, opacity, facecolor, edgecolors=\\\"black\\\"):\\n if surface_type == \\\"shading\\\":\\n coords = [getcoords(s) for s in surfaces if not hasattr(s, \\\"Surface_Type\\\")]\\n else:\\n coords = [\\n getcoords(s)\\n for s in surfaces\\n if hasattr(s, \\\"Surface_Type\\\")\\n and s.Surface_Type.lower() == surface_type.lower()\\n ]\\n trimmed_coords = [c for c in coords if c] # dump any empty surfaces\\n collection = Poly3DCollection(\\n trimmed_coords, alpha=opacity, facecolor=facecolor, edgecolors=edgecolors\\n )\\n return collection\",\n \"def refresh(self):\\n\\n # delete the existing plane first before recreating our plane by resetting the plane to an empty plane\\n self.plane = []\\n # calling our create_plane() to redraw our plane.\\n self.create_plane()\",\n \"def top(self, surface):\\n #def target(self):\\n \\\"\\\"\\\"Defines the target book\\\"\\\"\\\"\\n #def adjacent(self, surface, surface, surface, surface, surface):\\n \\\"\\\"\\\"Defines the adjacent surfaces for each surface\\\"\\\"\\\"\\n #def touches(self, surface, surface):\\n \\\"\\\"\\\"Defines surfaces touching other surfaces\\\"\\\"\\\"\",\n \"def Init(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_SplitSurface_Init(self, *args)\",\n \"def draw(self, surface):\\r\\n surface.blit(self.image, self.rect)\",\n \"def __init__(self, width, height, color, main_surface):\\n self.main_surface = main_surface\\n self.width = width\\n self.height = height\\n self.color = color\",\n \"def draw_f():\\n fig = plt.figure()\\n ax = fig.gca(projection='3d')\\n x_matrix = np.arange(-10, 11, 0.1)\\n y_matrix = np.arange(-10, 11, 0.1)\\n x_matrix, y_matrix = np.meshgrid(x_matrix, y_matrix)\\n # print(x_matrix)\\n u_matrix = x_matrix.copy()\\n for i in range(x_matrix.shape[0]):\\n for j in range(x_matrix.shape[0]):\\n u_matrix[i][j] = f(x_matrix[i][j], y_matrix[i][j])\\n surf = ax.plot_surface(x_matrix, y_matrix, u_matrix)\\n\\n plt.show()\\n return surf\",\n \"def add_preview_surface(stage: Usd.Stage, prim: Usd.Prim,\\n diffuse: Tuple[float, float, float],\\n roughness: float,\\n metallic: float):\\n # Create material associated to the prim\\n path = f\\\"{prim.GetPath()}/mat\\\"\\n material = UsdShade.Material.Define(stage, path)\\n # Create a shader associated with the material\\n pbrShader = UsdShade.Shader.Define(stage, f\\\"{path}/shader\\\")\\n pbrShader.CreateIdAttr(\\\"UsdPreviewSurface\\\")\\n pbrShader.CreateInput(\\\"diffuseColor\\\", Sdf.ValueTypeNames.Float3).Set(diffuse)\\n pbrShader.CreateInput(\\\"roughness\\\", Sdf.ValueTypeNames.Float).Set(roughness)\\n pbrShader.CreateInput(\\\"metallic\\\", Sdf.ValueTypeNames.Float).Set(metallic)\\n # Bind shader to the material surface\\n material.CreateSurfaceOutput().ConnectToSource(pbrShader, \\\"surface\\\")\\n # Bind material to the prim\\n UsdShade.MaterialBindingAPI(prim).Bind(material)\",\n \"def interiorFaceTrace(self, f):\\n assert all(v.isInterior() for v in f.vertices)\\n self.result.addFace([self.newVertex(v) for v in f.vertices])\",\n \"def __init__(self, mesh: Mesh):\\n self.mesh = mesh\\n self.f = [0]*len(mesh.delaunay.simplices)\",\n \"def Sphere_Bezier(refinements=0):\\n \\n S = np.array([0,0,0])\\n T = np.array([0,0,1])\\n V = np.array([0,0,0,0.5,0.5,1,1,1])\\n q = 2\\n m = 4\\n Pj = np.array([[0,0,1],[1,0,1],[1,0,0],[1,0,-1],[0,0,-1]])\\n wj = np.array([1,1/np.sqrt(2),1,1/np.sqrt(2),1])\\n\\n sphere = Bezier.MakeRevolvedSurface(S,T,2*np.pi,q,V,m,Pj,wj)\\n \\n # Make knot refinements before decomposing\\n if refinements:\\n uniqueU = np.unique(sphere.U)\\n for i in xrange(uniqueU.size-1):\\n XI = np.linspace(uniqueU[i],uniqueU[i+1],refinements+2)[1:-1]\\n sphere.refineknotvector(XI,'U')\\n uniqueV = np.unique(sphere.V)\\n for i in xrange(uniqueV.size-1):\\n XI = np.linspace(uniqueV[i],uniqueV[i+1],refinements+2)[1:-1]\\n sphere.refineknotvector(XI,'V')\\n \\n sphere=sphere.decompose()\\n\\n element_list = [Bezier.BezierElement(sphere[i,:,:,:]) for i in xrange(sphere.shape[0])]\\n \\n \\n sphere_domain = Bezier.Domain(element_list)\\n mesh = Bezier.Mesh([sphere_domain])\\n \\n mesh.dList[0].edges = mesh.numElements * 2\\n mesh.dList[0].corners = 8\\n mesh.dList[0].extraordinary_points = 8\\n\\n \\n return mesh\",\n \"def add_surf(self, surf: Surface, pos: Tuple[int, int]):\\n self.manual_surfaces.append((pos, surf))\",\n \"def buildEdges(self):\\n assert self.poly1.pnFacesInPoly() and self.poly2.pnFacesInPoly()\\n assert self.nonDoubleIntersectors()\\n # print('2.1')\\n for i in self.inter1:\\n assert self.nonDoubleIntersectors()\\n # print('test')\\n assert all(all(v in self.poly1.vertices for v in f.vertices) for f in self.poly1.faces)\\n if not i.isSTraced():\\n self.traceSurface(i)\\n # print('2.2')\\n for i in self.inter2:\\n if not i.isSTraced():\\n self.traceSurface(i)\\n for i in self.inter1:\\n if not i.isITraced():\\n self.traceInterior(i)\\n for i in self.inter2:\\n if not i.isITraced():\\n self.traceInterior(i)\",\n \"def __init__(self, face1, face2, face3, face4, world):\\n\\n\\t\\tself.attached_faces = set([face1, face2, face3, face4])\\n\\n\\t\\t# Attach to the faces ...\\n\\n\\t\\tfor face in self.attached_faces:\\n\\t\\t\\tface.attach_tetrahedron(self)\\n\\n\\t\\t# Attach to all points ...\\n\\n\\t\\tself.attached_points = set()\\n\\t\\tfor face in self.attached_faces:\\n\\t\\t\\tself.attached_points |= face.attached_points\\n\\n\\t\\tfor point in self.attached_points:\\n\\t\\t\\tpoint.attach_tetrahedron(self)\\n\\n\\t\\t# Create the inverse coordinate matrix ...\\n\\n\\t\\tline1, line2, line3, line4, line5, line6 = \\\\\\n\\t\\t\\t\\tface1.attached_lines | face2.attached_lines | \\\\\\n\\t\\t\\t\\tface3.attached_lines | face4.attached_lines\\n\\n\\t\\tself.base_point, \\\\\\n\\t\\t\\t\\tself.end_point1, self.end_point2, self.end_point3 = \\\\\\n\\t\\t\\t\\tline1.attached_points | line2.attached_points | \\\\\\n\\t\\t\\t\\tline3.attached_points | line4.attached_points | \\\\\\n\\t\\t\\t\\tline5.attached_points | line6.attached_points\\n\\n\\t\\tself.end_points = [self.end_point1, self.end_point2, self.end_point3]\\n\\n\\t\\tself.base = self.base_point.position\\n\\t\\tself.ends = numpy.asarray(\\n\\t\\t\\t\\t[self.end_point1.position,\\n\\t\\t\\t\\t self.end_point2.position,\\n\\t\\t\\t\\t self.end_point3.position]) - self.base\\n\\t\\tself.coordinate_matrix = numpy.linalg.inv(self.ends.T)\\n\\n\\t\\tworld.add_tetrahedron(self)\",\n \"def on_draw( self ):\\r\\n self.clear()\\r\\n self.setup_3D()\\r\\n print \\\"DEBUG:\\\" , \\\"There are\\\" , len( self.renderlist ) , \\\"items in 'self.renderlist'\\\"\\r\\n for obj in self.renderlist:\\r\\n obj.draw()\",\n \"def initialize_shade(self,shade_name,shade_color,alpha):\\n\\n self.shades[shade_name] = [0, pygame.Surface(self.image.get_size())]\\n self.shades[shade_name][1].fill(shade_color)\\n self.shades[shade_name][1].set_alpha(alpha)\",\n \"def __drawCube(self):\\n self.cubePos = [[[(160, 160), (200, 160), (240, 160)],\\n [(160, 200), (200, 200), (240, 200)],\\n [(160, 240), (200, 240), (240, 240)]],\\n [[(400, 160), (440, 160), (480, 160)],\\n [(400, 200), (440, 200), (480, 200)],\\n [(400, 240), (440, 240), (480, 240)]],\\n [[(280, 160), (320, 160), (360, 160)],\\n [(280, 200), (320, 200), (360, 200)],\\n [(280, 240), (320, 240), (360, 240)]],\\n [[(40, 160), (80, 160), (120, 160)],\\n [(40, 200), (80, 200), (120, 200)],\\n [(40, 240), (80, 240), (120, 240)]],\\n [[(160, 40), (200, 40), (240, 40)],\\n [(160, 80), (200, 80), (240, 80)],\\n [(160, 120), (200, 120), (240, 120)]],\\n [[(160, 280), (200, 280), (240, 280)],\\n [(160, 320), (200, 320), (240, 320)],\\n [(160, 360), (200, 360), (240, 360)]]]\\n self.cubeColor = {1: 'green', 2: 'blue', 3: 'red', 4: 'orange',\\\\\\n 5: 'white', 6: 'yellow'}\\n for x in range(6):\\n for y in range(3):\\n for z in range(3):\\n pos = self.cubePos[x][y][z]\\n color = self.cubeColor[self.cube.cube[x][y][z]]\\n self.cv.create_rectangle(pos[0], pos[1], pos[0]+40, pos[1]+40,\\n fill=color, width='2')\",\n \"def save_surface_mesh(self, fname):\\n triangulation = self.surf_mesh\\n surf_indx = self.surface_indices\\n points = self.cluster.get_positions()\\n with open(fname, 'w') as out:\\n # Write mandatory header\\n out.write(\\\"$MeshFormat\\\\n\\\")\\n out.write(\\\"2.2 0 8\\\\n\\\")\\n out.write(\\\"$EndMeshFormat\\\\n\\\\n\\\")\\n\\n\\n # Write points\\n out.write(\\\"$Nodes\\\\n\\\")\\n out.write(\\\"{}\\\\n\\\".format(points.shape[0]))\\n for i in range(points.shape[0]):\\n vec = points[i, :]\\n out.write(\\\"{} {} {} {}\\\\n\\\".format(i+1, vec[0], vec[1], vec[2]))\\n out.write(\\\"$EndNodes\\\\n\\\")\\n\\n # Write triangles\\n out.write(\\\"$Elements\\\\n\\\")\\n out.write(\\\"{}\\\\n\\\".format(len(triangulation)))\\n for i, tri in enumerate(triangulation):\\n out.write(\\\"{} 2 0 {} {} {}\\\\n\\\".format(i+1, tri[0]+1, tri[1]+1, tri[2]+1))\\n out.write(\\\"$EndElements\\\\n\\\")\\n\\n if self._interface_energy:\\n # Interface energy has been computed\\n # We store the values as node data\\n out.write(\\\"$NodeData\\\\n\\\")\\n out.write(\\\"1\\\\n\\\")\\n out.write(\\\"\\\\\\\"Gamma\\\\\\\"\\\\n\\\")\\n out.write(\\\"1\\\\n0.0\\\\n\\\")\\n out.write(\\\"4\\\\n0\\\\n1\\\\n{}\\\\n0\\\\n\\\".format(len(self._interface_energy)))\\n for indx, interf in zip(surf_indx, self._interface_energy):\\n out.write(\\\"{} {}\\\\n\\\".format(indx+1, interf[1]))\\n out.write(\\\"$EndNodeData\\\\n\\\")\\n print(\\\"Surface mesh saved to {}\\\".format(fname))\",\n \"def copy(self):\\n new = Face(np.array(self.norm[:]), self.colour[:])\\n return new\",\n \"def imshow_surface(self):\\n plt.imshow(self.z)\\n plt.colorbar()\\n plt.show()\",\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 create_surface(self):\\n oval = graphics.Oval(graphics.Point(5,0), graphics.Point(300, -10))\\n oval.setFill(\\\"gray\\\")\\n return oval\",\n \"def create_mesh(self):\\n print(\\\"create_mesh\\\")\\n faces = self.get_faces()\\n print(\\\"num faces: {}\\\".format(len(faces)))\\n\\n # TODO: perform face filtering to remove long edges in Z direction\\n # filtered_faces = self.get_filtered_faces(faces)\\n # print(\\\"num filtered faces: {}\\\".format(len(filtered_faces)))\\n\\n vertices = self.xyz_points.T\\n\\n # handle texture mappings\\n vertex_index_to_texture = []\\n for j in range(0, self.height):\\n for i in range(0, self.width):\\n # vertex_index = (j * self.width) + ij\\n w = i / self.width\\n h = (self.height - j - 1) / self.height\\n vertex_index_to_texture.append(\\n (w, h)\\n )\\n\\n # Create material.\\n # TODO: make the string/filename randomly generated and unique\\n file0 = open(os.path.join(self.args.path, \\\"triangle_mesh.obj.mtl\\\"), \\\"w\\\") # write mode\\n file0.write(\\\"newmtl material_0\\\\n\\\")\\n # Save image here.\\n cv2.imwrite(os.path.join(self.args.path, \\\"triangle_mesh.png\\\"), self.bgr)\\n file0.write(\\\"map_Kd triangle_mesh.png\\\\n\\\")\\n file0.close()\\n\\n # https://en.wikipedia.org/wiki/Wavefront_.obj_file\\n # https://github.com/mmatl/pyrender/blob/master/examples/models/fuze.obj\\n obj_path = os.path.join(self.args.path, \\\"triangle_mesh.obj\\\")\\n file1 = open(obj_path, \\\"w\\\") # write mode\\n file1.write(\\\"mtllib ./triangle_mesh.obj.mtl\\\\n\\\")\\n for vertex in vertices:\\n x, y, z = vertex\\n file1.write(\\\"v {} {} {}\\\\n\\\".format(x, y, z))\\n file1.write(\\\"usemtl material_0\\\\n\\\")\\n for w, h in vertex_index_to_texture:\\n file1.write(\\\"vt {} {}\\\\n\\\".format(w, h))\\n for face in faces:\\n a, b, c = face\\n a += 1\\n b += 1\\n c += 1\\n file1.write(\\\"f {}/{} {}/{} {}/{}\\\\n\\\".format(\\n a, a, b, b, c, c\\n )\\n )\\n file1.close()\\n\\n # Load the trimesh from OBJ file.\\n trimesh_mesh = trimesh.load(obj_path)\\n # trimesh_mesh.show()\\n\\n mesh = pyrender.Mesh.from_trimesh(trimesh_mesh, smooth=False)\\n self.scene = pyrender.Scene(ambient_light=[3.0, 3.0, 3.0])\\n\\n camera = pyrender.IntrinsicsCamera(\\n self.focal_length, self.focal_length, self.width / 2, self.height / 2\\n )\\n self.camera_pose = np.array([\\n [1.0, 0.0, 0.0, 0.0],\\n [0.0, 1.0, 0.0, 0.0],\\n [0.0, 0.0, 1.0, 0.0],\\n [0.0, 0.0, 0.0, 1.0],\\n ])\\n # https://pyrender.readthedocs.io/en/latest/examples/cameras.html#creating-cameras\\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html\\n r = R.from_rotvec(np.array([0, np.pi, 0]))\\n r = R.from_rotvec(np.array([0.0, 0, np.pi])) * r\\n matrix = r.as_matrix()\\n self.camera_pose[:3, :3] = matrix\\n\\n light = pyrender.PointLight(\\n color=[1.0, 1.0, 1.0],\\n intensity=0.0\\n )\\n\\n self.nm = pyrender.Node(mesh=mesh, matrix=np.eye(4))\\n self.nl = pyrender.Node(light=light, matrix=np.eye(4))\\n self.nc = pyrender.Node(camera=camera, matrix=np.eye(4))\\n self.scene.add_node(self.nm)\\n self.scene.add_node(self.nl)\\n self.scene.add_node(self.nc)\\n\\n # Set the pose and show the image.\\n temppose = self.extrinsics @ self.camera_pose\\n self.scene.set_pose(self.nl, pose=temppose)\\n self.scene.set_pose(self.nc, pose=temppose)\\n pyrender.Viewer(self.scene, use_raymond_lighting=True,\\n viewport_size=(self.width, self.height))\",\n \"def get_bforce_wm_ws_Gx_surf(self):\\n\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w'] \\n \\n self.Gm1 = np.zeros([Ly])\\n self.dGm1_dS = np.zeros([Ly]) \\n self.Gt1 = np.zeros([Ly])\\n self.dGt1_dS = np.zeros([Ly]) \\n self.Bfsfc_bl = np.zeros([Ly])\\n self.Av_bl = np.zeros([Ly])\\n self.dAv_bl = np.zeros([Ly])\\n \\n #debugging\\n self.wm_surf = np.zeros([Ly])\\n self.ws_surf = np.zeros([Ly]) \\n\\n #---> j-loop\\n for j in range(Ly): \\n k_w = self.kbl[j] # KBL is \\\"new bl index after calling find_new_kbl()\\n z_bl = z_u_w[j,N] - self.hbls[j]\\n zscale = self.hbls[j] \\n \\n if self.swr_frac[j,k_w-1] > 0:\\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\\n \\n else:\\n Bfsfc = self.Bo[j] + self.Bosol[j]\\n \\n # CALCUALTE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm_surf[j] = wm\\n self.ws_surf[j] = ws \\n\\n if self.LIMIT_UNSTABLE_ONLY:\\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\\n else:\\n f1 = 0\\n\\n \\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n\\n #MOMENTUM \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl[j] = Av_bl\\n self.dAv_bl[j] = dAv_bl\\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \\n\\n #TEMPERATURE(BUOYANCY)\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \\n\\n self.Bfsfc_bl[j] = Bfsfc\",\n \"def _create_main_shape(self):\\n\\n a, b = gc( self.size/2,\\n self._ZERO_DEGREES - self.angle,\\n self._180_DEGREES + self.angle)\\n self.wafer_points = zip(a,b)\\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\\n self.cell.add(self.wafer_polygon)\",\n \"def unfold_object(current_surface,surface_dict,neighbors_dict):\\n\\n # Initialize a dictionary for the unfolded surfaces\\n unfolded_surfaces = dict()\\n\\n # Generate a list of surface numbers\\n surface_list = list(surface_dict.keys())\\n\\n # Add center surface to dictionary without modification\\n unfolded_surfaces[current_surface] = surface_dict[current_surface]\\n\\n # Remove center surface from surface numbers list\\n surface_list.remove(current_surface)\\n\\n # Generate an open list that contains the neighboring surface numbers to the center surface\\n open_list = [(neighbor,[current_surface]) for neighbor in neighbors_dict[current_surface]]\\n\\n # Run until all surfaces are added to the unfolding\\n while len(surface_list) > 0:\\n\\n # Next item in open list\\n item = open_list[0]\\n\\n # Initialize a list of parents\\n parents = list()\\n\\n # If neighbor is not already added\\n if item[0] in surface_list:\\n # Get folded version of the surface\\n folded_surf = surface_dict[item[0]]\\n child = item[0]\\n\\n # while there are still other parents of neighboring surface \\n # (when more than one unfolding is required for a neighbor of the neighbor)\\n while len(item[1])>0:\\n # get parent surface no\\n parent = item[1][-1]\\n # unfold surface on the parent\\n folded_surf = unfold_surface(surface_dict,neighbors_dict,item[1][-1],folded_surf,neighbors_dict[parent][child])\\n # parent becomes the child\\n child = item[1][-1]\\n # remove parent and add to the parents list\\n parents.append(item[1].pop())\\n\\n unfolded_surf = folded_surf\\n\\n else:\\n open_list.pop(0)\\n continue\\n\\n unfolded_surfaces[item[0]] = unfolded_surf\\n \\n surface_list.remove(item[0])\\n\\n parents.reverse()\\n # for neighbors of the current neighbor\\n for neighbor in neighbors_dict[item[0]]:\\n # if not already added\\n if neighbor in surface_list:\\n # add to the open list with correct parenting order\\n open_list.append((neighbor,parents+[item[0]]))\\n else:\\n continue\\n open_list.pop(0)\\n return unfolded_surfaces\",\n \"def faces(self):\\r\\n return self._faces\",\n \"def goify(self, layout=None):\\n xx,yy,zz = self.getXYZ(layout)\\n surf = dict(\\n type='surface',\\n x=xx,\\n y=yy,\\n z=zz\\n )\\n return surf\",\n \"def recalc_verts(self):\\n tongue_w = self.TEX.height\\n\\n along = self.fly_pos - self.mouth_pos\\n across = along.normalized().rotated(90) * tongue_w * 0.5\\n\\n along *= self.length\\n\\n self.dl.vertices = [c for v in [\\n self.mouth_pos - across,\\n self.mouth_pos - across + along,\\n self.mouth_pos + across + along,\\n self.mouth_pos + across,\\n ] for c in v]\",\n \"def draw(self, surface):\\n checked_color = (0, 196, 0) if self.checked else pg.Color(\\\"white\\\")\\n surface.fill(pg.Color(\\\"black\\\"), self.rect)\\n surface.fill(self.color, self.rect.inflate(-2,-2))\\n surface.fill(pg.Color(\\\"white\\\"), self.rect.inflate(-6,-6))\\n surface.fill((205,205,205), self.rect.inflate(-8,-8))\\n surface.fill(checked_color, self.select_rect)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6337671","0.62322086","0.6138106","0.60926324","0.60289365","0.6019346","0.59726006","0.58784676","0.58642536","0.5785459","0.5726048","0.5694008","0.5689473","0.568601","0.56728286","0.56689453","0.56689453","0.56234235","0.56112266","0.5610793","0.5605653","0.5602124","0.5600303","0.55846435","0.5581235","0.5567139","0.5563844","0.55559886","0.55538327","0.5520282","0.55164057","0.5515014","0.550968","0.55091554","0.55046636","0.5501857","0.5492804","0.5489116","0.54866165","0.5486522","0.546883","0.54555494","0.54410857","0.5440638","0.5432469","0.54238087","0.5420984","0.54187614","0.54181045","0.5416436","0.5412031","0.5409267","0.5402246","0.539904","0.5396399","0.53941387","0.5391299","0.5389586","0.5388317","0.5385683","0.5379179","0.537728","0.53703517","0.53588945","0.53550136","0.5354122","0.53505677","0.53494614","0.53459513","0.5337388","0.53338844","0.5331012","0.53236806","0.53222525","0.53170145","0.5314598","0.53050816","0.5302763","0.5296892","0.52964765","0.5292716","0.5291966","0.5274735","0.52707124","0.526818","0.5267848","0.52616614","0.5254851","0.52539074","0.52532274","0.5249838","0.5249838","0.5249303","0.52481955","0.5243847","0.5237592","0.52361083","0.52353376","0.52300626","0.52283144","0.52230084"],"string":"[\n \"0.6337671\",\n \"0.62322086\",\n \"0.6138106\",\n \"0.60926324\",\n \"0.60289365\",\n \"0.6019346\",\n \"0.59726006\",\n \"0.58784676\",\n \"0.58642536\",\n \"0.5785459\",\n \"0.5726048\",\n \"0.5694008\",\n \"0.5689473\",\n \"0.568601\",\n \"0.56728286\",\n \"0.56689453\",\n \"0.56689453\",\n \"0.56234235\",\n \"0.56112266\",\n \"0.5610793\",\n \"0.5605653\",\n \"0.5602124\",\n \"0.5600303\",\n \"0.55846435\",\n \"0.5581235\",\n \"0.5567139\",\n \"0.5563844\",\n \"0.55559886\",\n \"0.55538327\",\n \"0.5520282\",\n \"0.55164057\",\n \"0.5515014\",\n \"0.550968\",\n \"0.55091554\",\n \"0.55046636\",\n \"0.5501857\",\n \"0.5492804\",\n \"0.5489116\",\n \"0.54866165\",\n \"0.5486522\",\n \"0.546883\",\n \"0.54555494\",\n \"0.54410857\",\n \"0.5440638\",\n \"0.5432469\",\n \"0.54238087\",\n \"0.5420984\",\n \"0.54187614\",\n \"0.54181045\",\n \"0.5416436\",\n \"0.5412031\",\n \"0.5409267\",\n \"0.5402246\",\n \"0.539904\",\n \"0.5396399\",\n \"0.53941387\",\n \"0.5391299\",\n \"0.5389586\",\n \"0.5388317\",\n \"0.5385683\",\n \"0.5379179\",\n \"0.537728\",\n \"0.53703517\",\n \"0.53588945\",\n \"0.53550136\",\n \"0.5354122\",\n \"0.53505677\",\n \"0.53494614\",\n \"0.53459513\",\n \"0.5337388\",\n \"0.53338844\",\n \"0.5331012\",\n \"0.53236806\",\n \"0.53222525\",\n \"0.53170145\",\n \"0.5314598\",\n \"0.53050816\",\n \"0.5302763\",\n \"0.5296892\",\n \"0.52964765\",\n \"0.5292716\",\n \"0.5291966\",\n \"0.5274735\",\n \"0.52707124\",\n \"0.526818\",\n \"0.5267848\",\n \"0.52616614\",\n \"0.5254851\",\n \"0.52539074\",\n \"0.52532274\",\n \"0.5249838\",\n \"0.5249838\",\n \"0.5249303\",\n \"0.52481955\",\n \"0.5243847\",\n \"0.5237592\",\n \"0.52361083\",\n \"0.52353376\",\n \"0.52300626\",\n \"0.52283144\",\n \"0.52230084\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78795,"cells":{"query":{"kind":"string","value":"Removes all the Wires"},"document":{"kind":"string","value":"def Clear(self, *args):\n return _BRepAlgo.BRepAlgo_FaceRestrictor_Clear(self, *args)"},"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 delete_all_wells(self):\n self.wells = []","def remove_all(self):\n # Post a delete all notice to the manager\n self._remove_all()","def remove_all(self):\n # Post a delete all notice to the manager\n self._remove_all()","def deleteAll(self):\n for tlight in self.trafficLights:\n del tlight\n del self.trafficLights","def removeResourceSims(self):\n for sim in self.resourceSims:\n self.world.removeFromWorld(sim)\n self.resourceSims = []","def clear(self):\n for i in range(0, len(self.weights)):\n self.weights[i] = 0","def eraseAll(self): # remove all robots\n\t\tself.__robotList = []","def remove_all_lights(self):\n self.RemoveAllLights()\n self._lights.clear()","def deleteAllNeedlesFromScene(self):\n #productive #onButton\n profprint()\n while slicer.util.getNodes('python-catch-round_'+str(self.round)+'*') != {}:\n nodes = slicer.util.getNodes('python-catch-round_'+str(self.round)+'*')\n for node in nodes.values():\n slicer.mrmlScene.RemoveNode(node)","def remove_all(self):\n self.initial = None\n self.contour = None\n self.control_points = []","def remove_all(self):\n self._options.clear()\n self._programs.clear()","def remove_all():\n \"\"\" Removes all from the database \"\"\"\n redis_store.flushall()","def RemovedWires(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_RemoveInternalWires_RemovedWires(self, *args)","def reset(self):\n for layer in self.network:\n layer.clean()","def clean(self):\n for i in self.winfo_children():\n i.destroy()","def disconnect(self):\n self.costs = set()\n self.disconnectedHouses = []\n self.nthChoiceHouses = []\n self.allConnected = True\n for house in self.houses:\n house.connection = set()\n house.distance = 1000\n house.possible_connections = []\n for battery in self.batteries:\n battery.connectedHouses = []\n battery.capacity = battery.maxCapacity\n battery.totalDistance = set()","def ClearTools(self):\r\n\r\n self.Clear()","def Perform(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_RemoveInternalWires_Perform(self, *args)","def clear(self):\n\n self.wads = []\n\n self.sprites = {}\n self.sprite_image_cache = {}\n self.palette = None\n\n self.sound_cache = {}","def removeMySims(self):\n for sim in self.sims:\n try:\n sim.destroy()\n except:\n sim.removeNode()","def clear_all(self):\n raise NotImplementedError","async def clear_all(self) -> None:","def remove_all(ctx):\n skale = ctx.obj['skale']\n cnt = 0\n for sname in get_all_schains_names(skale):\n skale.manager.delete_schain(sname)\n cnt += 1\n print(f'Success. {cnt} schains were removed')","def reset(self):\n self._weights.clear()","def _removeFX(self):\r\n\t\tnodesToClean = [CONST.FOAM_FLUID_SHAPENODE, CONST.WAKE_FLUID_SHAPENODE, 'fluids_hrc']\r\n\t\tfor eachNode in nodesToClean:\r\n\t\t\ttry:\r\n\t\t\t\tcmds.delete(each)\r\n\t\t\texcept:\r\n\t\t\t\tpass\r\n\r\n\t\tfor eachCache in cmds.ls(type = 'cacheFile'):\r\n\t\t\tcmds.delete(eachCache)","def clear(self):\n self.recorders = set([])\n self.reset()\n\n # Stop any currently running SpiNNaker application\n self.stop()","def clear(self):\n self.weight = 0","def clear(self):\n [roi.clear() for roi in self.rois]","def remove_images(self):\n hardware_components.log_method(self, \"remove_images\")\n communication_object = self._get_control_software().connection\n communication_object.remove_all()","def remove_all(self, *items):\n for item in items:\n self.remove(item)","def clear_all():\n bpy.ops.object.select_all(action='SELECT')\n bpy.ops.object.delete()","def clear_elements(self):\n\n pass","def reset(self):\n for tlight in self.trafficLights:\n self.trafficLights[tlight].reset()","def _cleanup(self):\n\n self.netIns = []\n self.netOuts = []\n self.Gradients = [None]*self.size","def clear_all(cls):\n del cls.buttons[:]","def remove():","def clear_brain(self):\n self._log.debug(\"Clearing brain\")\n query = \"delete {?s ?p ?o} where {?s ?p ?o .} \"\n _ = self._connection.query(query, post=True)","def _purge(self):\n for _ in self.all():\n self.delete(_)","def remove_all():\n storage = FileStorage()\n objects = storage.all()\n objects = list(objects.values())\n\n for element in objects:\n storage.delete(element)\n objects = storage.all()","def remove_all_recs(self):\n return self.storage.clear()","def remove_all_objs(self):\n objs = self.scene.get_objects()\n objs_attached = self.scene.get_attached_objects()\n # remove add objects\n for key in objs.keys():\n self.remove_obj(key)\n # remove attached objects\n for key in objs_attached.keys():\n self.unlink_obj(objs_attached[key].link_name, key)","def clearTroves(self):\n self.primaryTroveList.thaw(\"\")\n self.newTroves.thaw(\"\")\n self.oldTroves.thaw(\"\")","def clear_db():\n humans = Human4j.nodes.all()\n for h in humans:\n h.delete()\n binomes = Binome4j.nodes.all()\n for b in binomes:\n b.delete()\n projects = Project4j.nodes.all()\n for p in projects:\n p.delete()\n sherpas = Sherpa4j.nodes.all()\n for sh in sherpas:\n sh.delete()\n students = Pioupiou4j.nodes.all()\n for piou in students:\n piou.delete()\n partenaires = Partenaire4j.nodes.all()\n for part in partenaires:\n part.delete()\n ps = Planete_Solidaire.nodes.all()\n for misc in ps:\n misc.delete()","def clearAllSettings(self) -> None:\n ...","def removeRadarSims(self):\n for sim in self.radarSims:\n self.world.removeFromWorld(sim)\n self.radarSims = []","def forget(self):\n self.ingress_tbl.clear()\n self.rootsw_tbl.clear()","def clear(self):\n \n self.node_set.clear()\n self.prefix.clear()\n self.suffix.clear()\n self.num_node = 0\n self.edges = 0","def delete_networks(self):\n logging.debug(\"cleanup called\")\n # for network in self.networks.key():\n # self.networks[network].delete()\n for network in self.networks.values():\n logging.warn(\"Deleting network '%s'\" % network)\n print \"Deleting network '%s'\" % network\n # print self.networks[network]\n network.delete()\n self.networks = {}","def clearList(self):\r\n self.addons.clear()","def delete_AllImgs(self):\n self.listImages.remove_all_imgs()","def remove(self):\n for db in self.values():\n db.remove()","def unoccupied(self):\n self.is_occupied = 0\n for hex in self.fon:\n hex.remove_neighbor()\n hex.set_quality()","def clear_all_triplex_loads(self):\n # Start by getting all the triplex_load objects.\n tl_list = self.get_objects_by_type(object_type='triplex_load')\n\n # If there aren't any triplex loads, warn and return.\n if tl_list is None:\n self.log.warning('clear_all_triplex_loads called, but there '\n 'are not any triplex_loads in the model!')\n return\n\n # Clear 'em out!\n for tl in tl_list:\n self.remove_properties_from_item(item_dict=tl,\n property_list=TRIPLEX_PARAMS)\n\n # All done.","def clearHotspots( self ):\n self._hotspots = []","def clear(self):\r\n ElementSet.clear(self)\r\n self.update()","def remove_checks(self):\n for checkbox in self.checkboxes:\n checkbox.setChecked(False)\n mw.checked_stats = []\n mw.bonuses = {'Charisma': 2}","def KillAllAnts(cls):\n cls.antArray.clear()","def DeleteAllItems(self):\r\n\r\n self.DeleteRoot()","def clean(self):\n\n for metric in self.metricList:\n listf = glob.glob(\n '{}/*_{}_{}*'.format(self.outDir, metric.name, self.num))\n if len(listf) > 0:\n for val in listf:\n os.system('rm {}'.format(val))","def clear_all(self):\n self.clear_files_paths()\n self.clear_programs()","def clear():","def clear_all(self):\n self.clear_redis()\n self.clear_cache()","def _remove_all(self):\n self._items.clear()\n self._listbox.delete(0, END)","def clear(self):\n self.raster_path_line.clear()\n self.labels_path.clear()\n self.shapefile_path.clear()\n self.costumelabels.clear()\n self.layer_name.clear()\n self.class_name.clear()\n self.idfield.clear()","def reset_wm(self):\n\n self.plan = []\n self.hist = []","def clearStore(self):\n os.remove(self.uid+\".pcl\")\n self.items = []","def reset_weights(self):\n self.policy_backbone.reset_weights()\n self.value_backbone.reset_weights()\n self.action_head.reset_weights()\n self.critic_head.reset_weights()","def forceload_removeall(server):\n screenCmd(server, 'forceload remove all')\n screenCmd(\n server, 'execute in compactmachines:compact_world run forceload remove all'\n )","def clear(self):\n self._zombie_list = []\n self._human_list = []\n poc_grid.Grid.clear(self)","def clear(self):\n self.xi[:] = 0\n self.meanlogr[:] = 0\n self.weight[:] = 0\n self.npairs[:] = 0","def delete_all_logical_switches(options):\n vdn_scope = get_transport_zone(options)\n virtual_wire = VirtualWire(vdn_scope)\n virtual_wire_objects = virtual_wire.full_query()\n for vwire in virtual_wire_objects:\n print \"name %s\" % vwire.objectId\n virtual_wire.id = vwire.objectId\n virtual_wire.delete()","def clearScanSetups(self, value=None):\n for ss in self.scanSetups.values():\n ss.unload()\n self.scanSetups = {}","def cleanup_all(cls):\n for i in tuple(cls.instances):\n i.cleanup()","def clear_all(self):\n self._set_all(0x00, 0x00, 0x00)","def cleanup():\n for s in [missiles, explosions, bonus]:\n\n set_to_remove = set([])\n for m in s:\n if m.isDead:\n set_to_remove.add(m)\n\n s.difference_update(set_to_remove)","def collect_garbage(selfie):\n trash = list(selfie.garbage)\n\n for tweet in trash:\n try:\n selfie.api.statuses.destroy(id=tweet['id'], _method='POST')\n except:\n log.exception('Delete failed!')\n else:\n selfie.garbage.remove(tweet)","def reset_weights(self):\n self.head.reset_weights()","def delete_all(self):\n # delete everything\n shutil.rmtree(self.location)","def clear_registered_nodes(self):\n self.__nodes.clear()\n self.__names.clear()\n self.__aliases.clear()","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):","def clear(self):\n poc_grid.Grid.clear(self)\n self._zombie_list = []\n self._human_list = []\n # need proof it works","def clear(self):\r\n poc_grid.Grid.clear(self)\r\n self._zombie_list = []\r\n self._human_list = []","def clear():\n\t\tModel.counter = 0","def clear(self):\n for vertex in self.vertices():\n del self[vertex]","def clear(self):\r\n\t\tself.free_objects[:] = []","def clean_registries(self):\n registry = self.connection.get_finished_registry(name=self.name)\n registry.cleanup()\n registry = self.connection.get_started_registry(name=self.name)\n registry.cleanup()","def removeAll(self):\n self.pDict.clear()","def clear(self):\n for pathItem in self.pathItem_list:\n self.scene.removeItem(pathItem)","def _delete_all(self):\n logging.info(\"Remove all nodes and relations from database.\")\n self.graph.delete_all()\n return","def clear(self):\n [group.clear() for group in self.roi_groups]\n self.signal_status_message.emit('Cleared data')","def deleteAllAutoNeedlesFromScene(self):\r\n # productive #onButton\r\n profprint()\r\n while slicer.util.getNodes('auto-seg_' + str(self.round) + '*') != {}:\r\n nodes = slicer.util.getNodes('auto-seg_' + str(self.round) + '*')\r\n for node in nodes.values():\r\n slicer.mrmlScene.RemoveNode(node)","def PurgeAll(self):\n\t\tself.acad.ActiveDocument.PurgeAll()","def clearAll(self):\n self.lineEditFSN.setText(\"\")\n self.comboBoxType.setCurrentIndex(-1)\n# self.comboBoxPriority.setCurrentIndex(-1)\n self.comboBoxSource.setCurrentIndex(-1)\n self.comboBoxBU.setCurrentIndex(-1)\n self.comboBoxSuperCategory.setCurrentIndex(-1)\n self.comboBoxCategory.setCurrentIndex(-1)\n self.comboBoxSubCategory.setCurrentIndex(-1)\n self.comboBoxVertical.setCurrentIndex(-1)\n self.spinBoxWordCount.setValue(0)\n self.lineEditBrand.setText(\"\")\n self.lineEditRefLink.setText(\"\")\n self.lineEditUploadLink.setText(\"\")\n\n self.buttonAddFSN.setChecked(True)","def removeIrisToOcc(self):\n\t\tshas = self._getShapes()\n\t\tfor sha in shas:\n\t\t\tif sha.a.iris_Occ.exists:\n\t\t\t\tsha.a.iris_Occ.delete()","def prune(self, rel=None):\n deleted = self._registry._get_not_reachable(self.root, rel=rel)\n for d in deleted:\n self._delete_cuds_triples(d)"],"string":"[\n \"def delete_all_wells(self):\\n self.wells = []\",\n \"def remove_all(self):\\n # Post a delete all notice to the manager\\n self._remove_all()\",\n \"def remove_all(self):\\n # Post a delete all notice to the manager\\n self._remove_all()\",\n \"def deleteAll(self):\\n for tlight in self.trafficLights:\\n del tlight\\n del self.trafficLights\",\n \"def removeResourceSims(self):\\n for sim in self.resourceSims:\\n self.world.removeFromWorld(sim)\\n self.resourceSims = []\",\n \"def clear(self):\\n for i in range(0, len(self.weights)):\\n self.weights[i] = 0\",\n \"def eraseAll(self): # remove all robots\\n\\t\\tself.__robotList = []\",\n \"def remove_all_lights(self):\\n self.RemoveAllLights()\\n self._lights.clear()\",\n \"def deleteAllNeedlesFromScene(self):\\n #productive #onButton\\n profprint()\\n while slicer.util.getNodes('python-catch-round_'+str(self.round)+'*') != {}:\\n nodes = slicer.util.getNodes('python-catch-round_'+str(self.round)+'*')\\n for node in nodes.values():\\n slicer.mrmlScene.RemoveNode(node)\",\n \"def remove_all(self):\\n self.initial = None\\n self.contour = None\\n self.control_points = []\",\n \"def remove_all(self):\\n self._options.clear()\\n self._programs.clear()\",\n \"def remove_all():\\n \\\"\\\"\\\" Removes all from the database \\\"\\\"\\\"\\n redis_store.flushall()\",\n \"def RemovedWires(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_RemoveInternalWires_RemovedWires(self, *args)\",\n \"def reset(self):\\n for layer in self.network:\\n layer.clean()\",\n \"def clean(self):\\n for i in self.winfo_children():\\n i.destroy()\",\n \"def disconnect(self):\\n self.costs = set()\\n self.disconnectedHouses = []\\n self.nthChoiceHouses = []\\n self.allConnected = True\\n for house in self.houses:\\n house.connection = set()\\n house.distance = 1000\\n house.possible_connections = []\\n for battery in self.batteries:\\n battery.connectedHouses = []\\n battery.capacity = battery.maxCapacity\\n battery.totalDistance = set()\",\n \"def ClearTools(self):\\r\\n\\r\\n self.Clear()\",\n \"def Perform(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_RemoveInternalWires_Perform(self, *args)\",\n \"def clear(self):\\n\\n self.wads = []\\n\\n self.sprites = {}\\n self.sprite_image_cache = {}\\n self.palette = None\\n\\n self.sound_cache = {}\",\n \"def removeMySims(self):\\n for sim in self.sims:\\n try:\\n sim.destroy()\\n except:\\n sim.removeNode()\",\n \"def clear_all(self):\\n raise NotImplementedError\",\n \"async def clear_all(self) -> None:\",\n \"def remove_all(ctx):\\n skale = ctx.obj['skale']\\n cnt = 0\\n for sname in get_all_schains_names(skale):\\n skale.manager.delete_schain(sname)\\n cnt += 1\\n print(f'Success. {cnt} schains were removed')\",\n \"def reset(self):\\n self._weights.clear()\",\n \"def _removeFX(self):\\r\\n\\t\\tnodesToClean = [CONST.FOAM_FLUID_SHAPENODE, CONST.WAKE_FLUID_SHAPENODE, 'fluids_hrc']\\r\\n\\t\\tfor eachNode in nodesToClean:\\r\\n\\t\\t\\ttry:\\r\\n\\t\\t\\t\\tcmds.delete(each)\\r\\n\\t\\t\\texcept:\\r\\n\\t\\t\\t\\tpass\\r\\n\\r\\n\\t\\tfor eachCache in cmds.ls(type = 'cacheFile'):\\r\\n\\t\\t\\tcmds.delete(eachCache)\",\n \"def clear(self):\\n self.recorders = set([])\\n self.reset()\\n\\n # Stop any currently running SpiNNaker application\\n self.stop()\",\n \"def clear(self):\\n self.weight = 0\",\n \"def clear(self):\\n [roi.clear() for roi in self.rois]\",\n \"def remove_images(self):\\n hardware_components.log_method(self, \\\"remove_images\\\")\\n communication_object = self._get_control_software().connection\\n communication_object.remove_all()\",\n \"def remove_all(self, *items):\\n for item in items:\\n self.remove(item)\",\n \"def clear_all():\\n bpy.ops.object.select_all(action='SELECT')\\n bpy.ops.object.delete()\",\n \"def clear_elements(self):\\n\\n pass\",\n \"def reset(self):\\n for tlight in self.trafficLights:\\n self.trafficLights[tlight].reset()\",\n \"def _cleanup(self):\\n\\n self.netIns = []\\n self.netOuts = []\\n self.Gradients = [None]*self.size\",\n \"def clear_all(cls):\\n del cls.buttons[:]\",\n \"def remove():\",\n \"def clear_brain(self):\\n self._log.debug(\\\"Clearing brain\\\")\\n query = \\\"delete {?s ?p ?o} where {?s ?p ?o .} \\\"\\n _ = self._connection.query(query, post=True)\",\n \"def _purge(self):\\n for _ in self.all():\\n self.delete(_)\",\n \"def remove_all():\\n storage = FileStorage()\\n objects = storage.all()\\n objects = list(objects.values())\\n\\n for element in objects:\\n storage.delete(element)\\n objects = storage.all()\",\n \"def remove_all_recs(self):\\n return self.storage.clear()\",\n \"def remove_all_objs(self):\\n objs = self.scene.get_objects()\\n objs_attached = self.scene.get_attached_objects()\\n # remove add objects\\n for key in objs.keys():\\n self.remove_obj(key)\\n # remove attached objects\\n for key in objs_attached.keys():\\n self.unlink_obj(objs_attached[key].link_name, key)\",\n \"def clearTroves(self):\\n self.primaryTroveList.thaw(\\\"\\\")\\n self.newTroves.thaw(\\\"\\\")\\n self.oldTroves.thaw(\\\"\\\")\",\n \"def clear_db():\\n humans = Human4j.nodes.all()\\n for h in humans:\\n h.delete()\\n binomes = Binome4j.nodes.all()\\n for b in binomes:\\n b.delete()\\n projects = Project4j.nodes.all()\\n for p in projects:\\n p.delete()\\n sherpas = Sherpa4j.nodes.all()\\n for sh in sherpas:\\n sh.delete()\\n students = Pioupiou4j.nodes.all()\\n for piou in students:\\n piou.delete()\\n partenaires = Partenaire4j.nodes.all()\\n for part in partenaires:\\n part.delete()\\n ps = Planete_Solidaire.nodes.all()\\n for misc in ps:\\n misc.delete()\",\n \"def clearAllSettings(self) -> None:\\n ...\",\n \"def removeRadarSims(self):\\n for sim in self.radarSims:\\n self.world.removeFromWorld(sim)\\n self.radarSims = []\",\n \"def forget(self):\\n self.ingress_tbl.clear()\\n self.rootsw_tbl.clear()\",\n \"def clear(self):\\n \\n self.node_set.clear()\\n self.prefix.clear()\\n self.suffix.clear()\\n self.num_node = 0\\n self.edges = 0\",\n \"def delete_networks(self):\\n logging.debug(\\\"cleanup called\\\")\\n # for network in self.networks.key():\\n # self.networks[network].delete()\\n for network in self.networks.values():\\n logging.warn(\\\"Deleting network '%s'\\\" % network)\\n print \\\"Deleting network '%s'\\\" % network\\n # print self.networks[network]\\n network.delete()\\n self.networks = {}\",\n \"def clearList(self):\\r\\n self.addons.clear()\",\n \"def delete_AllImgs(self):\\n self.listImages.remove_all_imgs()\",\n \"def remove(self):\\n for db in self.values():\\n db.remove()\",\n \"def unoccupied(self):\\n self.is_occupied = 0\\n for hex in self.fon:\\n hex.remove_neighbor()\\n hex.set_quality()\",\n \"def clear_all_triplex_loads(self):\\n # Start by getting all the triplex_load objects.\\n tl_list = self.get_objects_by_type(object_type='triplex_load')\\n\\n # If there aren't any triplex loads, warn and return.\\n if tl_list is None:\\n self.log.warning('clear_all_triplex_loads called, but there '\\n 'are not any triplex_loads in the model!')\\n return\\n\\n # Clear 'em out!\\n for tl in tl_list:\\n self.remove_properties_from_item(item_dict=tl,\\n property_list=TRIPLEX_PARAMS)\\n\\n # All done.\",\n \"def clearHotspots( self ):\\n self._hotspots = []\",\n \"def clear(self):\\r\\n ElementSet.clear(self)\\r\\n self.update()\",\n \"def remove_checks(self):\\n for checkbox in self.checkboxes:\\n checkbox.setChecked(False)\\n mw.checked_stats = []\\n mw.bonuses = {'Charisma': 2}\",\n \"def KillAllAnts(cls):\\n cls.antArray.clear()\",\n \"def DeleteAllItems(self):\\r\\n\\r\\n self.DeleteRoot()\",\n \"def clean(self):\\n\\n for metric in self.metricList:\\n listf = glob.glob(\\n '{}/*_{}_{}*'.format(self.outDir, metric.name, self.num))\\n if len(listf) > 0:\\n for val in listf:\\n os.system('rm {}'.format(val))\",\n \"def clear_all(self):\\n self.clear_files_paths()\\n self.clear_programs()\",\n \"def clear():\",\n \"def clear_all(self):\\n self.clear_redis()\\n self.clear_cache()\",\n \"def _remove_all(self):\\n self._items.clear()\\n self._listbox.delete(0, END)\",\n \"def clear(self):\\n self.raster_path_line.clear()\\n self.labels_path.clear()\\n self.shapefile_path.clear()\\n self.costumelabels.clear()\\n self.layer_name.clear()\\n self.class_name.clear()\\n self.idfield.clear()\",\n \"def reset_wm(self):\\n\\n self.plan = []\\n self.hist = []\",\n \"def clearStore(self):\\n os.remove(self.uid+\\\".pcl\\\")\\n self.items = []\",\n \"def reset_weights(self):\\n self.policy_backbone.reset_weights()\\n self.value_backbone.reset_weights()\\n self.action_head.reset_weights()\\n self.critic_head.reset_weights()\",\n \"def forceload_removeall(server):\\n screenCmd(server, 'forceload remove all')\\n screenCmd(\\n server, 'execute in compactmachines:compact_world run forceload remove all'\\n )\",\n \"def clear(self):\\n self._zombie_list = []\\n self._human_list = []\\n poc_grid.Grid.clear(self)\",\n \"def clear(self):\\n self.xi[:] = 0\\n self.meanlogr[:] = 0\\n self.weight[:] = 0\\n self.npairs[:] = 0\",\n \"def delete_all_logical_switches(options):\\n vdn_scope = get_transport_zone(options)\\n virtual_wire = VirtualWire(vdn_scope)\\n virtual_wire_objects = virtual_wire.full_query()\\n for vwire in virtual_wire_objects:\\n print \\\"name %s\\\" % vwire.objectId\\n virtual_wire.id = vwire.objectId\\n virtual_wire.delete()\",\n \"def clearScanSetups(self, value=None):\\n for ss in self.scanSetups.values():\\n ss.unload()\\n self.scanSetups = {}\",\n \"def cleanup_all(cls):\\n for i in tuple(cls.instances):\\n i.cleanup()\",\n \"def clear_all(self):\\n self._set_all(0x00, 0x00, 0x00)\",\n \"def cleanup():\\n for s in [missiles, explosions, bonus]:\\n\\n set_to_remove = set([])\\n for m in s:\\n if m.isDead:\\n set_to_remove.add(m)\\n\\n s.difference_update(set_to_remove)\",\n \"def collect_garbage(selfie):\\n trash = list(selfie.garbage)\\n\\n for tweet in trash:\\n try:\\n selfie.api.statuses.destroy(id=tweet['id'], _method='POST')\\n except:\\n log.exception('Delete failed!')\\n else:\\n selfie.garbage.remove(tweet)\",\n \"def reset_weights(self):\\n self.head.reset_weights()\",\n \"def delete_all(self):\\n # delete everything\\n shutil.rmtree(self.location)\",\n \"def clear_registered_nodes(self):\\n self.__nodes.clear()\\n self.__names.clear()\\n self.__aliases.clear()\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\",\n \"def clear(self):\\n poc_grid.Grid.clear(self)\\n self._zombie_list = []\\n self._human_list = []\\n # need proof it works\",\n \"def clear(self):\\r\\n poc_grid.Grid.clear(self)\\r\\n self._zombie_list = []\\r\\n self._human_list = []\",\n \"def clear():\\n\\t\\tModel.counter = 0\",\n \"def clear(self):\\n for vertex in self.vertices():\\n del self[vertex]\",\n \"def clear(self):\\r\\n\\t\\tself.free_objects[:] = []\",\n \"def clean_registries(self):\\n registry = self.connection.get_finished_registry(name=self.name)\\n registry.cleanup()\\n registry = self.connection.get_started_registry(name=self.name)\\n registry.cleanup()\",\n \"def removeAll(self):\\n self.pDict.clear()\",\n \"def clear(self):\\n for pathItem in self.pathItem_list:\\n self.scene.removeItem(pathItem)\",\n \"def _delete_all(self):\\n logging.info(\\\"Remove all nodes and relations from database.\\\")\\n self.graph.delete_all()\\n return\",\n \"def clear(self):\\n [group.clear() for group in self.roi_groups]\\n self.signal_status_message.emit('Cleared data')\",\n \"def deleteAllAutoNeedlesFromScene(self):\\r\\n # productive #onButton\\r\\n profprint()\\r\\n while slicer.util.getNodes('auto-seg_' + str(self.round) + '*') != {}:\\r\\n nodes = slicer.util.getNodes('auto-seg_' + str(self.round) + '*')\\r\\n for node in nodes.values():\\r\\n slicer.mrmlScene.RemoveNode(node)\",\n \"def PurgeAll(self):\\n\\t\\tself.acad.ActiveDocument.PurgeAll()\",\n \"def clearAll(self):\\n self.lineEditFSN.setText(\\\"\\\")\\n self.comboBoxType.setCurrentIndex(-1)\\n# self.comboBoxPriority.setCurrentIndex(-1)\\n self.comboBoxSource.setCurrentIndex(-1)\\n self.comboBoxBU.setCurrentIndex(-1)\\n self.comboBoxSuperCategory.setCurrentIndex(-1)\\n self.comboBoxCategory.setCurrentIndex(-1)\\n self.comboBoxSubCategory.setCurrentIndex(-1)\\n self.comboBoxVertical.setCurrentIndex(-1)\\n self.spinBoxWordCount.setValue(0)\\n self.lineEditBrand.setText(\\\"\\\")\\n self.lineEditRefLink.setText(\\\"\\\")\\n self.lineEditUploadLink.setText(\\\"\\\")\\n\\n self.buttonAddFSN.setChecked(True)\",\n \"def removeIrisToOcc(self):\\n\\t\\tshas = self._getShapes()\\n\\t\\tfor sha in shas:\\n\\t\\t\\tif sha.a.iris_Occ.exists:\\n\\t\\t\\t\\tsha.a.iris_Occ.delete()\",\n \"def prune(self, rel=None):\\n deleted = self._registry._get_not_reachable(self.root, rel=rel)\\n for d in deleted:\\n self._delete_cuds_triples(d)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6894521","0.68552023","0.68552023","0.67969257","0.6740532","0.6709369","0.66663945","0.66131437","0.65450144","0.6478279","0.64725685","0.6429976","0.64166206","0.63693064","0.63480186","0.6325027","0.63126177","0.63076156","0.63052785","0.6294209","0.62588865","0.6242327","0.623032","0.61866045","0.6172797","0.61535543","0.6152395","0.61065185","0.6103268","0.61029065","0.6086051","0.6082821","0.60755765","0.606614","0.6056788","0.6047704","0.60373765","0.6002214","0.59966683","0.59937257","0.598812","0.5983327","0.5980342","0.5968534","0.5966278","0.5965449","0.5962686","0.59473825","0.5941514","0.59333736","0.59299237","0.59259677","0.59228295","0.59209585","0.59167767","0.59112513","0.5909786","0.59061074","0.58974","0.5895429","0.5893444","0.5889806","0.588625","0.58792543","0.5876807","0.58699185","0.58618903","0.5852203","0.5834716","0.5827371","0.5826658","0.5816392","0.58060575","0.5805827","0.580552","0.5804746","0.5803131","0.58012867","0.57940614","0.57923055","0.57923055","0.57923055","0.57923055","0.57923055","0.57923055","0.57923055","0.57906365","0.57887584","0.5782816","0.57824636","0.5781677","0.5779385","0.57782197","0.5778047","0.5777447","0.57748187","0.5774434","0.576991","0.57616746","0.57603455","0.5744546"],"string":"[\n \"0.6894521\",\n \"0.68552023\",\n \"0.68552023\",\n \"0.67969257\",\n \"0.6740532\",\n \"0.6709369\",\n \"0.66663945\",\n \"0.66131437\",\n \"0.65450144\",\n \"0.6478279\",\n \"0.64725685\",\n \"0.6429976\",\n \"0.64166206\",\n \"0.63693064\",\n \"0.63480186\",\n \"0.6325027\",\n \"0.63126177\",\n \"0.63076156\",\n \"0.63052785\",\n \"0.6294209\",\n \"0.62588865\",\n \"0.6242327\",\n \"0.623032\",\n \"0.61866045\",\n \"0.6172797\",\n \"0.61535543\",\n \"0.6152395\",\n \"0.61065185\",\n \"0.6103268\",\n \"0.61029065\",\n \"0.6086051\",\n \"0.6082821\",\n \"0.60755765\",\n \"0.606614\",\n \"0.6056788\",\n \"0.6047704\",\n \"0.60373765\",\n \"0.6002214\",\n \"0.59966683\",\n \"0.59937257\",\n \"0.598812\",\n \"0.5983327\",\n \"0.5980342\",\n \"0.5968534\",\n \"0.5966278\",\n \"0.5965449\",\n \"0.5962686\",\n \"0.59473825\",\n \"0.5941514\",\n \"0.59333736\",\n \"0.59299237\",\n \"0.59259677\",\n \"0.59228295\",\n \"0.59209585\",\n \"0.59167767\",\n \"0.59112513\",\n \"0.5909786\",\n \"0.59061074\",\n \"0.58974\",\n \"0.5895429\",\n \"0.5893444\",\n \"0.5889806\",\n \"0.588625\",\n \"0.58792543\",\n \"0.5876807\",\n \"0.58699185\",\n \"0.58618903\",\n \"0.5852203\",\n \"0.5834716\",\n \"0.5827371\",\n \"0.5826658\",\n \"0.5816392\",\n \"0.58060575\",\n \"0.5805827\",\n \"0.580552\",\n \"0.5804746\",\n \"0.5803131\",\n \"0.58012867\",\n \"0.57940614\",\n \"0.57923055\",\n \"0.57923055\",\n \"0.57923055\",\n \"0.57923055\",\n \"0.57923055\",\n \"0.57923055\",\n \"0.57923055\",\n \"0.57906365\",\n \"0.57887584\",\n \"0.5782816\",\n \"0.57824636\",\n \"0.5781677\",\n \"0.5779385\",\n \"0.57782197\",\n \"0.5778047\",\n \"0.5777447\",\n \"0.57748187\",\n \"0.5774434\",\n \"0.576991\",\n \"0.57616746\",\n \"0.57603455\",\n \"0.5744546\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78796,"cells":{"query":{"kind":"string","value":"Evaluate all the faces limited by the set of Wires."},"document":{"kind":"string","value":"def Perform(self, *args):\n return _BRepAlgo.BRepAlgo_FaceRestrictor_Perform(self, *args)"},"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 WiresToFaces(self, *args):\n return _BRepAlgo.BRepAlgo_Loop_WiresToFaces(self, *args)","def findFaces(self):\n\t\trects = self.detectAll()\n\t\tif len(rects)==0:\n\t\t\trects = []\n\t\telse:\n\t\t\trects[:, 2:] += rects[:, :2]\n\t\tself.analyzeFrame(rects)","def get_filtered_faces(self, faces):\n filtered_faces = []\n for face in faces:\n i, j, k = face\n thresh = 100.0\n if self.get_distance_between_points(i, j) > thresh:\n continue\n elif self.get_distance_between_points(j, k) > thresh:\n continue\n elif self.get_distance_between_points(i, k) > thresh:\n continue\n filtered_faces.append(face)\n return filtered_faces","def detectFaces():\n faceEngine = VLFaceEngine()\n detector = faceEngine.createFaceDetector(DetectorType.FACE_DET_V3)\n\n imageWithOneFace = VLImage.load(filename=EXAMPLE_O)\n pprint.pprint(detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False).asDict())\n detection = detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False)\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection))\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection.boundingBox.rect))\n\n imageWithSeveralFaces = VLImage.load(filename=EXAMPLE_SEVERAL_FACES)\n severalFaces = detector.detect([imageWithSeveralFaces], detect5Landmarks=False, detect68Landmarks=False)\n\n pprint.pprint(\n detector.redetect(\n images=[\n ImageForRedetection(imageWithSeveralFaces, [face.boundingBox.rect for face in severalFaces[0]]),\n ImageForRedetection(imageWithOneFace, [detection.boundingBox.rect]),\n ImageForRedetection(imageWithOneFace, [Rect(0, 0, 1, 1)]),\n ]\n )\n )","def faces(self):\r\n return self._faces","def faces(self):\n\n if self._faces is None:\n if self._vertices is None:\n return None\n self.triangulate()\n return self._faces","def get_bounded_faces(self):\n return [face for face in self.faces if face.is_bounded()]","def solved(self):\n return all(cell == 1 for row in self.faces for cell in row) or all(cell == 0 for row in self.faces for cell in row)","def _interiorFaces(self):\n XYids = self._XYFaceIDs\n XZids = self._XZFaceIDs\n YZids = self._YZFaceIDs\n\n interiorIDs = numerix.concatenate((numerix.ravel(XYids[ ..., 1:-1]),\n numerix.ravel(XZids[:, 1:-1,:]),\n numerix.ravel(YZids[1:-1, ...].swapaxes(0, 1))))\n\n from fipy.variables.faceVariable import FaceVariable\n interiorFaces = FaceVariable(mesh=self, value=False)\n interiorFaces[interiorIDs] = True\n return interiorFaces","def forward(self):\n priors = []\n for k, f in enumerate(self.feature_maps):\n scale = self.image_size / self.strides[k]\n # for i, j in product(range(f), repeat=2):\n for i in range(f[0]):\n for j in range(f[1]):\n # print(i, j)\n # unit center x,y\n cx = (j + 0.5) / scale\n cy = (i + 0.5) / scale\n\n # small sized square box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # big sized square box\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # change h/w ratio of the small sized box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n for ratio in self.aspect_ratios[k]:\n ratio = sqrt(ratio)\n priors.append([cx, cy, w * ratio, h / ratio])\n priors.append([cx, cy, w / ratio, h * ratio])\n\n priors = torch.Tensor(priors)\n if self.clip:\n priors.clamp_(max=1, min=0)\n return priors","def faces(self):\n return map(Face, self._top_exp.faces())","def boundary(self):\n answer = self.zero()\n for k, v in self.items():\n for idx, cube in enumerate(k):\n acc_dim = sum((cube_l.dimension for cube_l in k[:idx]))\n for i in range(cube.dimension):\n for epsilon in (0, 1):\n new_cube = cube.face(i, epsilon)\n new_k = k[:idx] + (new_cube,) + k[idx + 1:]\n sign_exp = (acc_dim + i + epsilon) % 2\n answer += answer.create({new_k: v * (-1)**sign_exp})\n return answer","def faces(self, f):\n self._faces = f","def num_faces(self):\n return self._top_exp.number_of_faces()","def _exteriorFaces(self):\n XYids = self._XYFaceIDs\n XZids = self._XZFaceIDs\n YZids = self._YZFaceIDs\n\n exteriorIDs = numerix.concatenate((numerix.ravel(XYids[..., 0].swapaxes(0, 1)),\n numerix.ravel(XYids[..., -1].swapaxes(0, 1)),\n numerix.ravel(XZids[:, 0,:]),\n numerix.ravel(XZids[:, -1,:]),\n numerix.ravel(YZids[ 0, ...]),\n numerix.ravel(YZids[-1, ...])))\n\n from fipy.variables.faceVariable import FaceVariable\n exteriorFaces = FaceVariable(mesh=self, value=False)\n exteriorFaces[exteriorIDs] = True\n return exteriorFaces","def select_resize_all():\n date_1 = datetime.datetime.now()\n print(\"Start\")\n\n # Get the active object\n obj = bpy.context.active_object\n\n # Switch in object mode \n bpy.ops.object.mode_set(mode='OBJECT')\n\n # Get the selected faces and their min and max location in x and y\n tabSelectedFaces = []\n xMax = float('-inf')\n xMin = float('inf')\n yMax = float('-inf')\n yMin = float('inf')\n for poly in obj.data.polygons:\n if poly.select == True:\n tabSelectedFaces.append(poly)\n xMax = max(xMax, obj.data.vertices[poly.vertices[0]].co.x, obj.data.vertices[poly.vertices[1]].co.x, obj.data.vertices[poly.vertices[2]].co.x)\n xMin = min(xMin, obj.data.vertices[poly.vertices[0]].co.x, obj.data.vertices[poly.vertices[1]].co.x, obj.data.vertices[poly.vertices[2]].co.x)\n yMax = max(yMax, obj.data.vertices[poly.vertices[0]].co.y, obj.data.vertices[poly.vertices[1]].co.y, obj.data.vertices[poly.vertices[2]].co.y)\n yMin = min(yMin, obj.data.vertices[poly.vertices[0]].co.y, obj.data.vertices[poly.vertices[1]].co.y, obj.data.vertices[poly.vertices[2]].co.y)\n\n # Switch in edit mode \n bpy.ops.object.mode_set(mode='EDIT')\n\n # Load mesh\n me = bpy.context.edit_object.data\n bm = bmesh.from_edit_mesh(me)\n # Ensure internal data needed for int subscription is initialized\n bm.faces.ensure_lookup_table()\n\n # While all connected faces are not selected\n while bm.faces:\n # Find connected faces to the selection\n grow_faces = set(f for f in bm.verts if f.select for f in f.link_faces if not f.select)\n\n # If no more faces, leave the loop\n if grow_faces == set():\n break;\n\n # Select the faces and update min and max x and y location\n for f in grow_faces:\n f.select = True\n xMax = max(xMax, f.verts[0].co.x, f.verts[1].co.x, f.verts[2].co.x)\n xMin = min(xMin, f.verts[0].co.x, f.verts[1].co.x, f.verts[2].co.x)\n yMax = max(yMax, f.verts[0].co.y, f.verts[1].co.y, f.verts[2].co.y)\n yMin = min(yMin, f.verts[0].co.y, f.verts[1].co.y, f.verts[2].co.y)\n \n print(xMax,xMin,xMax-xMin) \n print(yMax,yMin,yMax-yMin) \n\n # Update the information for the resize action\n bpy.context.scene.sizeX = xMax-xMin\n bpy.context.scene.oldResizeX = 1\n bpy.context.scene.sizeY = yMax-yMin\n bpy.context.scene.oldResizeY = 1\n\n # Transfer the data back to the object's mesh \n bmesh.update_edit_mesh(me)\n\n print(\"End Script\")\n\n date_2 = datetime.datetime.now()\n time_delta = (date_2 - date_1)\n total_seconds = time_delta.total_seconds()\n print(\"Time : \", total_seconds)","def faces_apply(op, faces, flip):\n return [face_apply(op, face, flip) for face in faces]","def _getFaces(self, it_mesh_poly):\n\n faces = []\n it_mesh_poly.reset()\n while not it_mesh_poly.isDone():\n faces += it_mesh_poly.getVertices()\n it_mesh_poly.next(1)\n\n return faces","def get_faces(self):\n for i, j in combinations(self.gens, 2):\n c0 = self.triangle_verts[self.vertex_at_mirrors(i, j)]\n f0 = []\n m = self.cox_mat[i][j]\n H = (i, j)\n type = 0\n if self.active[i] and self.active[j]:\n type = 1\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\n f0.append(self.G.move(self.vtable, 0, (i, j) * k + (i,)))\n elif self.active[i] and m > 2:\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (j, i) * k))\n elif self.active[j] and m > 2:\n for k in range(m):\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\n else:\n continue\n\n reps = set(self.word_generator(parabolic=H))\n reps = self.G.sort_words(reps)\n flist = []\n for word in reps:\n f = tuple(self.G.move(self.vtable, v, word) for v in f0)\n if None not in f and not helpers.check_duplicate_face(f, flist):\n center = self.transform(word, c0)\n coords = [self.vertices_coords[k] for k in f]\n face = DihedralFace(word, f, center, coords, type)\n flist.append(face)\n\n self.face_indices[(i, j)] = flist\n\n self.num_faces = sum(len(L) for L in self.face_indices.values())","def depthFaceSelect(self, triangleSelected,depth, materials):\t\n\t\tlayersR = list()\n\t\tlayersG = list()\n\t\tlayersB = list()\n\t\t\n\t\tlayerMaterial = list()\n\t\tself.volumeComposition = list()\n\t\tfor l in range(len(materials)):\n\t\t\tlayerMaterial.append(list())\n\t\t\tself.volumeComposition.append(list())\n\t\t\n\t\tvolumeGeneral = list()\n\t\tself.boolLayers = []\n\t\t\n\t\tfor i in self.slicePoints:\n\t\t\tboolResult2 = self.voxel_slice(i, self.vertices, self.triangles, self.res, self.llc, self.sliceProto, 2)\n\t\t\tprint boolResult2.shape\n\t\t\ttupleResultR = numpy.zeros(boolResult2.shape, dtype=uint8)\n\t\t\ttupleResultG = numpy.zeros(boolResult2.shape, dtype=uint8)\n\t\t\ttupleResultB = numpy.zeros(boolResult2.shape, dtype=uint8)\n\t\t\ttupleMaterial = list()\n\t\t\tfor l in range(len(materials)):\n\t\t\t\ttupleMaterial.append(numpy.zeros(boolResult2.shape, dtype=float))\n\t\t\t#tupleMaterial = numpy.zeros(boolResult2.shape, dtype=f)\n\t\t\t#lines=self.findSelectedContour(self.vertices,triangleSelected,i ,numpy.array([0,0,1]))\n\t\t\t#boolResult1 = self.findVoxelOfSelectedContour(i, lines, self.res, self.llc, self.sliceProto, depth)\n\t\t\tj = numpy.nditer(boolResult2, flags=['multi_index'], op_flags=['readwrite'])\n\n\t\t\twhile not j.finished:\t\n\t\t\t\tprint type(j.multi_index)\n\t\t\t\tprint j.multi_index\n\t\t\t\tif j[0] == True:\n\t\t\t\t\ttupleResultB[j.multi_index] = materials[0][0]\n\t\t\t\t\ttupleResultG[j.multi_index] = materials[0][1]\n\t\t\t\t\ttupleResultR[j.multi_index] = materials[0][2]\n\t\t\t\t\ttupleMaterial[0][j.multi_index] = 1.0 \n\t\t\t\telse:\n\t\t\t\t\ttupleResultB[j.multi_index] = 0\n\t\t\t\t\ttupleResultG[j.multi_index] = 0\n\t\t\t\t\ttupleResultR[j.multi_index] = 0\n\t\t\t\tj.iternext()\t\t\t\t\n\t\t\t\t\t\n\t\t\tfor k in range(len(triangleSelected)):\n\t\t\t\tboolResult1 = self.findVoxelOfSelectedContour(i, self.vertices, triangleSelected[k], self.res, self.llc, self.sliceProto, depth[k])\n\t\t\t\tboolResult = numpy.logical_and(boolResult1, boolResult2)\n\t\t\t\tprint boolResult.shape\n\n\t\t\t\tj = numpy.nditer(boolResult2, flags=['multi_index'], op_flags=['readwrite'])\n\t\t\t\twhile not j.finished:\n\t\t\t\t\tif j[0] == True:\n\t\t\t\t\t\tif boolResult[j.multi_index] == True:\n\t\t\t\t\t\t\ttupleResultB[j.multi_index] = materials[k + 1][0]\n\t\t\t\t\t\t\ttupleResultG[j.multi_index] = materials[k + 1][1]\n\t\t\t\t\t\t\ttupleResultR[j.multi_index] = materials[k + 1][2]\n\t\t\t\t\t\t\ttupleMaterial[k + 1][j.multi_index] = 1.0 \n\t\t\t\t\t\t\ttupleMaterial[0][j.multi_index] = 0.0\n\t\t\t\t\t\t#else:\n\t\t\t\t\t\t#\ttupleResultB[j.multi_index] = 255\n\t\t\t\t\t\t#\ttupleResultG[j.multi_index] = 0\n\t\t\t\t\t\t#\ttupleResultR[j.multi_index] = 0\t\t\t\t\t\n\t\t\t\t\tj.iternext()\n\t\t\tself.boolLayers.append(boolResult2)\n\t\t\tlayersR.append(tupleResultR)\n\t\t\tlayersG.append(tupleResultG)\n\t\t\tlayersB.append(tupleResultB)\n\t\t\tfor l in range(len(materials)):\n\t\t\t\tlayerMaterial[l].append(tupleMaterial[l])\n\t\t\t\t\n\t\tprint \"i got here\"\n\t\tself.volumeR=numpy.array(layersR) # create the 3d volume\n\t\tself.volumeG=numpy.array(layersG) \n\t\tself.volumeB=numpy.array(layersB)\n\t\t\n\t\tfor l in range(len(materials)):\n\t\t\tself.volumeComposition[l] = numpy.array(layerMaterial[l])\n\t\tvolumeGeneral.append(self.volumeR)\n\t\tvolumeGeneral.append(self.volumeG)\n\t\tvolumeGeneral.append(self.volumeB)\n\t\t\n\t\treturn volumeGeneral","def select_faces(maxAngle):\n date_1 = datetime.datetime.now()\n print(\"Start\")\n\n print(maxAngle, maxAngle*180/pi)\n\n # Get the active object\n obj = bpy.context.active_object\n\n # Add the vertices location in an array\n tabVertices = []\n for vertex in obj.data.vertices:\n tabVertices.append(obj.matrix_world @ vertex.co)\n\n # Find the downward vector in function of the angles of the mesh\n matrix_new = obj.matrix_world.to_3x3().inverted()\n no_world = matrix_new @ mathutils.Vector((0,0,-1))\n no_world.normalize() \n print(no_world)\n vecDir = no_world\n\n\n # Arrays for the function C parameters\n tabPoly = []\n tabNormalX = []\n tabNormalY = []\n tabNormalZ = []\n tabFaces = []\n\n tabPoint1X = []\n tabPoint1Y = []\n tabPoint2X = []\n tabPoint2Y = []\n tabPoint3X = []\n tabPoint3Y = []\n tabPoint1Z = []\n tabPoint2Z = []\n tabPoint3Z = []\n\n # Fill the arrays\n for poly in obj.data.polygons:\n tabPoly.append(poly.index)\n tabNormalX.append(poly.normal[0])\n tabNormalY.append(poly.normal[1])\n tabNormalZ.append(poly.normal[2])\n tabFaces.append(0)\n \n tabPoint1X.append(tabVertices[poly.vertices[0]].x)\n tabPoint1Y.append(tabVertices[poly.vertices[0]].y)\n tabPoint2X.append(tabVertices[poly.vertices[1]].x)\n tabPoint2Y.append(tabVertices[poly.vertices[1]].y)\n tabPoint3X.append(tabVertices[poly.vertices[2]].x)\n tabPoint3Y.append(tabVertices[poly.vertices[2]].y)\n tabPoint1Z.append(tabVertices[poly.vertices[0]].z)\n tabPoint2Z.append(tabVertices[poly.vertices[1]].z)\n tabPoint3Z.append(tabVertices[poly.vertices[2]].z)\n\n print(len(tabPoly)) \n\n print(os.path.dirname(__file__))\n # Get the filepath of the dll file\n functionC = ctypes.CDLL(os.path.dirname(__file__) + \"\\\\function.dll\")\n\n # Create array for C function\n seq = ctypes.c_int * len(tabPoly)\n arrIndex = seq(*tabPoly)\n\n seq = ctypes.c_float * len(tabNormalX)\n arrNormalX = seq(*tabNormalX)\n seq = ctypes.c_float * len(tabNormalY)\n arrNormalY = seq(*tabNormalY)\n seq = ctypes.c_float * len(tabNormalZ)\n arrNormalZ = seq(*tabNormalZ)\n\n seq = ctypes.c_int * len(tabFaces)\n arrFaces = seq(*tabFaces)\n\n seq = ctypes.c_float * len(tabPoint1X)\n arrPoint1X = seq(*tabPoint1X)\n seq = ctypes.c_float * len(tabPoint1Y)\n arrPoint1Y = seq(*tabPoint1Y)\n seq = ctypes.c_float * len(tabPoint2X)\n arrPoint2X = seq(*tabPoint2X)\n seq = ctypes.c_float * len(tabPoint2Y)\n arrPoint2Y = seq(*tabPoint2Y)\n seq = ctypes.c_float * len(tabPoint3X)\n arrPoint3X = seq(*tabPoint3X)\n seq = ctypes.c_float * len(tabPoint3Y)\n arrPoint3Y = seq(*tabPoint3Y)\n seq = ctypes.c_float * len(tabPoint1Z)\n arrPoint1Z = seq(*tabPoint1Z)\n seq = ctypes.c_float * len(tabPoint2Z)\n arrPoint2Z = seq(*tabPoint2Z)\n seq = ctypes.c_float * len(tabPoint3Z)\n arrPoint3Z = seq(*tabPoint3Z)\n\n date_3 = datetime.datetime.now()\n \n # Call the C function\n functionC.select_faces(arrIndex,len(tabPoly),arrNormalX,arrNormalY,arrNormalZ,ctypes.c_float(maxAngle),ctypes.c_float(vecDir.x),ctypes.c_float(vecDir.y),ctypes.c_float(vecDir.z),arrFaces,arrPoint1X,arrPoint1Y,arrPoint2X,arrPoint2Y,arrPoint3X,arrPoint3Y,arrPoint1Z,arrPoint2Z,arrPoint3Z)\n\n date_4 = datetime.datetime.now()\n\n # Switch in edit mode\n bpy.ops.object.mode_set(mode = 'EDIT')\n # Deselect all the faces\n bpy.ops.mesh.select_all(action = 'DESELECT')\n bpy.ops.mesh.select_mode(type=\"FACE\")\n # Switch in object mode\n bpy.ops.object.mode_set(mode = 'OBJECT')\n\n # Select all the faces needed support\n for i in range(len(arrFaces)):\n if arrFaces[i] == 1:\n obj.data.polygons[tabPoly[i]].select = True\n print(len(arrFaces))\n \n # Switch in edit mode\n bpy.ops.object.mode_set(mode = 'EDIT')\n print(\"End\")\n\n date_2 = datetime.datetime.now()\n time_delta = (date_2 - date_1)\n total_seconds = time_delta.total_seconds()\n print(total_seconds)\n \n time_delta = (date_4 - date_3)\n total_seconds = time_delta.total_seconds()\n print(\"C time : \", total_seconds)","def _evaluate(self, w, x, y, z):\n if _isscalar(w):\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\n else:\n w_pos = self.wSearchFunc(self.w_list, w)\n w_pos[w_pos < 1] = 1\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n z_pos = self.zSearchFunc(self.z_list, z)\n z_pos[z_pos < 1] = 1\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n i = w_pos # for convenience\n j = x_pos\n k = y_pos\n l = z_pos\n alpha = (w - self.w_list[i - 1]) / (self.w_list[i] - self.w_list[i - 1])\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\n f = (1 - alpha) * (\n (1 - beta)\n * (\n (1 - gamma) * (1 - delta) * self.f_values[i - 1, j - 1, k - 1, l - 1]\n + (1 - gamma) * delta * self.f_values[i - 1, j - 1, k - 1, l]\n + gamma * (1 - delta) * self.f_values[i - 1, j - 1, k, l - 1]\n + gamma * delta * self.f_values[i - 1, j - 1, k, l]\n )\n + beta\n * (\n (1 - gamma) * (1 - delta) * self.f_values[i - 1, j, k - 1, l - 1]\n + (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\n + gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\n + gamma * delta * self.f_values[i - 1, j, k, l]\n )\n ) + alpha * (\n (1 - beta)\n * (\n (1 - gamma) * (1 - delta) * self.f_values[i, j - 1, k - 1, l - 1]\n + (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\n + gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\n + gamma * delta * self.f_values[i, j - 1, k, l]\n )\n + beta\n * (\n (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\n + (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\n + gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\n + gamma * delta * self.f_values[i, j, k, l]\n )\n )\n return f","def search(self):\n W = np.zeros((self.subsets.shape[0],)) \n for i,E in enumerate(self.subsets):\n self.graph.setV(E) # set the nodes to their values\n W[i] = self.graph.computeW()\n self.Ws = W","def faces(self):\r\n \r\n faceset = set()\r\n for faset in self.SCFaset:\r\n for face in sub_lists(faset):\r\n faceset.add(tuple(face))\r\n return list(faceset)","def cube_faces(xmin, xmax, ymin, ymax, zmin, zmax):\n faces = []\n\n x, y = np.mgrid[xmin:xmax:3j, ymin:ymax:3j]\n z = np.ones(y.shape) * zmin\n faces.append((x, y, z))\n\n x, y = np.mgrid[xmin:xmax:3j, ymin:ymax:3j]\n z = np.ones(y.shape) * zmax\n faces.append((x, y, z))\n\n x, z = np.mgrid[xmin:xmax:3j, zmin:zmax:3j]\n y = np.ones(z.shape) * ymin\n faces.append((x, y, z))\n\n x, z = np.mgrid[xmin:xmax:3j, zmin:zmax:3j]\n y = np.ones(z.shape) * ymax\n faces.append((x, y, z))\n\n y, z = np.mgrid[ymin:ymax:3j, zmin:zmax:3j]\n x = np.ones(z.shape) * xmin\n faces.append((x, y, z))\n\n y, z = np.mgrid[ymin:ymax:3j, zmin:zmax:3j]\n x = np.ones(z.shape) * xmax\n faces.append((x, y, z))\n\n return faces","def wires_from_face(self, face) -> Iterator[TopoDS_Wire]:\n assert isinstance(face, Face)\n return map(Wire, self._top_exp.wires_from_face(face.topods_shape()))","def itercubes(self, **kwargs):\n for ifuslot in self.fplane.ifuslots:\n yield ifuslot, self.extract_ifu_sensitivity_cube(ifuslot, \n **kwargs)","def fight(self):\n for j in range(self.num):\n for i in range(self.num):\n self.genepool[0][j].fight(self.genepool[1][i],self.gameOne)\n self.genepool[1][j].fight(self.genepool[0][i],self.gameTwo)\n for i in range(self.num):\n self.genepool[0][i].fitness /= self.num\n self.genepool[1][i].fitness /= self.num","def box_faces(images):\n return (_box_faces(image) for image in images)","def detect_faces(self, img):\n with tf.Graph().as_default():\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=.7)\n sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))\n with sess.as_default():\n pnet, rnet, onet = detect_face.create_mtcnn(sess, None)\n\n minsize = 20 # minimum size of face\n threshold = [ 0.6, 0.7, 0.7 ] # three steps's threshold\n factor = 0.709 # scale factor\n\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\n\n nrof_faces = bounding_boxes.shape[0]\n img_size = np.asarray(img.shape)[0:2]\n\n faces = []\n faces_rects = []\n\n for i in range(nrof_faces):\n det = bounding_boxes[i,0:4]\n bb = np.zeros(4, dtype=np.int32)\n bb[0] = np.maximum(det[0]-5/2, 0)\n bb[1] = np.maximum(det[1]-5/2, 0)\n bb[2] = np.minimum(det[2]+5/2, img_size[1])\n bb[3] = np.minimum(det[3]+5/2, img_size[0])\n faces.append(img[bb[1]:bb[3], bb[0]:bb[2], :])\n faces_rects.append({'name': 'none', 'x': bb[0], 'y': bb[1], 'w': bb[2]-bb[0], 'h': bb[3]-bb[1]})\n\n return [img, faces, faces_rects]","def colorVertsExceedingMaxInfs(mesh_list, max_infs=8, color=True):\n vert_list = list()\n for mesh in mesh_list:\n vc = (cmds.polyEvaluate(mesh, v=1)) + 1\n sc = getSkinCluster(mesh)\n\n if sc:\n for i in range(1, vc):\n vtx = \"%s.vtx[%s]\" % (mesh, i)\n vtx_jnts = cmds.skinPercent(sc, vtx, ignoreBelow=.001, q=1, t=None)\n if vtx_jnts:\n if len(vtx_jnts) > max_infs:\n vert_list.append(vtx)\n\n if vert_list:\n cmds.select(vert_list)\n cmds.sets(name=\"Vertices_Exceeding_Max_Skin_Influences\")\n LOG.warning(\"WARNING: Meshes in scene have vertices with more than {} influences!\".format(str(max_infs)))\n\n if color:\n cmds.polyColorPerVertex(rgb=(1, 0, 0), cdo=1)\n cmds.select(vert_list)\n else:\n LOG.info(\"All meshes in scene are within max skin influence per vertex range of {}\".format(str(max_infs)))","def GetBoundaryLoops(self):\n\n self.__do_essential_memebers_exist__()\n\n if self.InferBoundaryElementType() != \"line\":\n raise NotImplementedError(\"Computing boundary loops is only supported for tri/quad meshes for now\")\n\n self.GetEdges()\n\n # First create a node to neighbour map i.e. node as key and its two neighbouring nodes as value\n nodeToNeighboursMap = dict()\n for i in range(self.edges.shape[0]):\n\n if self.edges[i,0] not in nodeToNeighboursMap:\n nodeToNeighboursMap[self.edges[i,0]] = [self.edges[i,1],-1]\n else:\n nodeToNeighboursMap[self.edges[i,0]][1] = self.edges[i,1]\n\n if self.edges[i,1] not in nodeToNeighboursMap:\n nodeToNeighboursMap[self.edges[i,1]] = [self.edges[i,0],-1]\n else:\n nodeToNeighboursMap[self.edges[i,1]][1] = self.edges[i,0]\n\n # Now create a vector of face loops\n faceLoops = []\n while nodeToNeighboursMap:\n # Insert the first node from node to edge map and its two neighbours in order and erase it from the map\n faceLoop = []\n mapBegin = next(iter(nodeToNeighboursMap))\n faceLoop.append(nodeToNeighboursMap[mapBegin][0])\n faceLoop.append(mapBegin)\n faceLoop.append(nodeToNeighboursMap[mapBegin][1])\n nodeToNeighboursMap.pop(mapBegin, None)\n\n while True:\n # Pick the last node in the current face loop and find its neighbours\n if faceLoop[-1] in nodeToNeighboursMap:\n tmp = faceLoop[-1]\n mapIter = nodeToNeighboursMap[faceLoop[-1]]\n # Check if we have not reached the end of the loop i.e. the first element\n if mapIter[0] != faceLoop[0] and mapIter[1] != faceLoop[0]:\n if mapIter[0] == faceLoop[-2]:\n faceLoop.append(mapIter[1])\n elif mapIter[1] == faceLoop[-2]:\n faceLoop.append(mapIter[0])\n else:\n nodeToNeighboursMap.pop(faceLoop[0], None)\n\n nodeToNeighboursMap.pop(tmp, None)\n else:\n faceLoop = np.array(faceLoop)\n faceLoops.append(faceLoop)\n break\n\n return faceLoops","def fight(self):\n for j in range(self.num):\n for i in range(self.num):\n self.genepool[0][j].fight(self.genepool[1][i],self.gameOne,self.len)\n self.genepool[1][j].fight(self.genepool[0][i],self.gameTwo,self.len)\n for i in range(self.num):\n self.genepool[0][i].fitness /= self.num\n self.genepool[1][i].fitness /= self.num","def recogniseFace(self, imagefilenames, selectedFileName, selectedDirectory, numOfEigenfaces, thresholdVal):\r\n print 'recogniseFace()::'\r\n self.facet.checkCache(selectedDirectory, imagefilenames, numOfEigenfaces)\r\n mindist, matchfile = self.facet.findMatchingImage(selectedFileName, numOfEigenfaces, thresholdVal)\r\n self.processMatchResult(matchfile, mindist, numOfEigenfaces)","def faces(self):\n res = []\n if(self.isFacesLoaded() == False):\n return res\n for face in self.getCurrentCacheData()['faces']:\n face = Face().setJSONData(face)\n if(face.confidence > self.faceDetector.confThreshold):\n res.append(face)\n return res","def update(self,image):\r\n \r\n self._faces=[]\r\n \r\n if util.isgray(image):\r\n image=cv2.equalizeHist(image)\r\n \r\n else:\r\n \r\n image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\r\n cv2.equalizeHist(image,image)\r\n \r\n minsize=util.widthheightdividedby(image,8)\r\n\r\n \r\n\r\n \r\n facerect=self._faceclassifier.detectMultiScale(image,\r\n self.scalefactor,\r\n self.minneighbors,\r\n self.flags,\r\n minsize)\r\n \r\n \"\"\"if facerects is not None:\r\n \r\n for facerect in facerects:\r\n face=face()\r\n \r\n face.facerect=facerect\r\n \r\n \r\n x,y,w,h=facerect\r\n \r\n # Seek an eye in the upper-left part of the face. \r\n searchRect = (x+w/7, y, w*2/7, h/2) \r\n face.leftEyeRect = self._detectOneObject( \r\n self._eyeClassifier, image, searchRect, 64) \r\n \r\n \r\n \r\n # Seek an eye in the upper-right part of the face. \r\n searchRect = (x+w*4/7, y, w*2/7, h/2) \r\n face.rightEyeRect = self._detectOneObject( \r\n self._eyeClassifier, image, searchRect, 64) \r\n \r\n \r\n \r\n # Seek a nose in the middle part of the face. \r\n searchRect = (x+w/4, y+h/4, w/2, h/2) \r\n face.noseRect = self._detectOneObject( \r\n self._noseClassifier, image, searchRect, 32) \r\n \r\n # Seek a mouth in the lower-middle part of the face. \r\n searchRect = (x+w/6, y+h*2/3, w*2/3, h/3) \r\n face.mouthRect = self._detectOneObject( \r\n self._mouthClassifier, image, searchRect, 16) \r\n \r\n \r\n \r\n self._faces.append(face)\r\n\r\n \r\n \r\n def _detectoneobject(self,\r\n classifier,\r\n image,\r\n rect,\r\n imagesizetominsizeratio):\r\n \r\n x ,y ,w ,h=rect\r\n \r\n minsize=util.widthheightdividedby(image,\r\n imagesizetominsizeratio)\r\n \r\n subimage=image[y:y+h,x:x+w]\r\n \r\n subrect=classifier.dectectMultiScale(subimage,\r\n self.scalefactor,\r\n self.minneighbors,\r\n self.flags,\r\n minsize)\r\n \r\n if len(subrect)==0:\r\n return None\r\n \r\n subx,suby,subw,subh=subrects[0]\r\n \r\n return (x+subx,y+suby,w+subw,h+subh)\r\n \r\n \"\"\"","def faces_only(self):\n return self._faces_only","def iter_wfaces(self, world: bool = True, detail: bool = True) -> Iterator['Side']:\n for brush in self.iter_wbrushes(world, detail):\n yield from brush","def buildFaces(self):\n for fi in range(len(self.poly1.faces)):\n f = self.poly1.faces[fi]\n for vi in range(len(f.vertices)):\n v = f.vertices[vi]\n if self.getIntersector(v) is not None and not v.isMarkedFor(f):\n self.faceTrace(1, fi, vi)\n v = f.vertices[0]\n if v.isInterior() and not v.isMarkedFor(f):\n interiorFaceTrace(f)\n for fi in range(len(self.poly2.faces)):\n f = self.poly2.faces[fi]\n for vi in range(len(f.vertices)):\n v = f.vertices[vi]\n if self.getIntersector(v) is not None and not v.isMarkedFor(f) :\n self.faceTrace(2, fi, vi)\n v = f.vertices[0]\n if v.isInterior() and not v.isMarkedFor(f):\n interiorFaceTrace(f)","def update(self):\n self.w = len(set([y for sublist in [self.ckt[x].fins for x in self.frontier if len(self.ckt[x].fins) > 0] for y in sublist]))\n self.output = set([x for x in self.members if len(self.ckt[x].fots) == 0])\n self.max_w = self.w","def map_face(self):\n #Array Order: U0,D1,R2,L3,F4,B5,\n \n cube_list = []\n cube_list = self.cube.definition()\n \n for index, cubit in enumerate(self.faces['Up']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\n for index, cubit in enumerate(self.faces['Ri']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\n for index, cubit in enumerate(self.faces['Ft']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\n for index, cubit in enumerate(self.faces['Dn']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\n for index, cubit in enumerate(self.faces['Le']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\n for index, cubit in enumerate(self.faces['Bk']):\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])","def euler(faces, edges, verticies):\n\n # Return the calculated value\n return verticies + edges - faces","def fr(self):\n return np.sum([filt.fr for filt in self.filters], axis=0)","def get_faces(self, img):\n results = self.detect_and_draw(img, False)\n (width, height) = cv.GetSize(img)\n for result in results:\n self.add_property('name', 'face')\n self.add_property('pixel_location', result[0])\n self.add_property('relative_location', (float(result[0][0]) / width, float(result[0][1]) / height))\n self.add_property('angle_and_distance', result[1])\n self.add_property('face_area', result[2])\n self.add_property('width', result[4])\n self.add_property('height', result[5])\n self.add_property('relative_face_area', (float(result[2]) / (width * height)))\n self.add_property('confidence', result[3])\n self.add_property('dimensions', (width, height))\n self.add_property('rotation', self.rotation)\n self.store_observation()","def detectFaces_allFiles(directory):\n files_list = glob.glob(directory)\n for file in files_list:\n print(file)\n img = cv2.imread(file)\n if img is not None:\n height, width, channel = img.shape\n faces = face_cascade.detectMultiScale(img, 1.3, 5)\n age = find_age(file)\n\n if age >= 0:\n if faces != ():\n for (x, y, w, h) in faces:\n # On decale y vers le haut pour mieux centrer le visage\n if y - int(0.1*h) >= 0:\n y -= int(0.1*h)\n h *= 1.2\n else:\n h += y + int(0.1*h)\n y = 0\n if h > width:\n h = width\n # A partir de l'origine du visage (point en haut a gauche), on definit\n # notre carre, de cote le nouveau h\n if x + 0.8*h > width:\n x_right = width\n x_left = width - int(h)\n elif x - 0.2*h < 0:\n x_left = 0\n x_right = int(h)\n else:\n x_right = min(int(x) + int(0.8*h), int(width))\n x_left = int(x_right) - int(h)\n y_top = int(y)\n y_bottom = int(y) + int(h)\n roi_color = img[y_top:y_bottom, x_left:x_right]\n cv2.imwrite(\"./FacePhoto/{}.jpg\".format(extract_filename(file)), resize_image(roi_color, 227))\n else:\n files_list.remove(file)\n else:\n files_list.remove(file)\n cv2.destroyAllWindows()\n return files_list","def _box_faces(image):\n for face in image.faces:\n _box_face(image, face)\n return image","def detect_faces(self, img) -> list:\r\n if img is None or not hasattr(img, \"shape\"):\r\n raise InvalidImage(\"Image not valid.\")\r\n\r\n height, width, _ = img.shape\r\n stage_status = StageStatus(width=width, height=height)\r\n\r\n m = 12 / self._min_face_size\r\n min_layer = np.amin([height, width]) * m\r\n\r\n scales = self.__compute_scale_pyramid(m, min_layer)\r\n\r\n stages = [self.__stage1, self.__stage2, self.__stage3]\r\n result = [scales, stage_status]\r\n\r\n # We pipe here each of the stages\r\n for stage in stages:\r\n result = stage(img, result[0], result[1])\r\n\r\n [total_boxes, points] = result\r\n\r\n bounding_boxes = []\r\n\r\n for bounding_box, keypoints in zip(total_boxes, points.T):\r\n x = max(0, int(bounding_box[0]))\r\n y = max(0, int(bounding_box[1]))\r\n width = int(bounding_box[2] - x)\r\n height = int(bounding_box[3] - y)\r\n bounding_boxes.append({\r\n 'box': [x, y, width, height],\r\n 'confidence': bounding_box[-1],\r\n 'keypoints': {\r\n 'left_eye': (int(keypoints[0]), int(keypoints[5])),\r\n 'right_eye': (int(keypoints[1]), int(keypoints[6])),\r\n 'nose': (int(keypoints[2]), int(keypoints[7])),\r\n 'mouth_left': (int(keypoints[3]), int(keypoints[8])),\r\n 'mouth_right': (int(keypoints[4]), int(keypoints[9])),\r\n }\r\n })\r\n\r\n return bounding_boxes","def RemovedFaces(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_RemoveInternalWires_RemovedFaces(self, *args)","def triangulate_all_faces(\n self,\n triangle_face_tol=0.01, # Tolerance between triangle and surface\n tol_relative_to_face=True, # The tolerance value is relative to the face size\n angle_tol_rads=0.1, # Angle between normals/tangents at triangle vertices\n ):\n mesh = BRepMesh_IncrementalMesh(\n self.topods_shape(),\n triangle_face_tol,\n tol_relative_to_face,\n angle_tol_rads,\n True,\n )\n mesh.Perform()\n return mesh.IsDone()","def step(self, model):\n weights = []\n if (self.prune_scope == 'global'):\n # First collect all weights\n for step, (name, param) in enumerate(self.prune_parameters):\n scale = 1\n # Pointer to the original tensor\n tensor = param.data#.cpu().numpy()\n # Gradient-based selection\n if (self.prune_selection == 'gradient_max'):\n grad = param.grad#.cpu().numpy()\n tensor = grad[torch.nonzero(tensor, as_tuple=True)]#np.nonzero(tensor)]\n elif (self.prune_selection == 'gradient_min'):\n grad = 1 / (torch.abs(param.grad) + 1e-7) #.cpu().numpy()\n tensor = grad[torch.nonzero(tensor, as_tuple=True)]#np.nonzero(tensor)]\n #tensor = torch.abs(torch.max(tensor) - tensor) #np.max(tensor) - tensor\n # Retrieve non-pruned weights\n if (self.prune_scale == 'dimension'):\n scale = tensor.size\n if (self.prune_scale == 'normalize'):\n scale = torch.max(torch.abs(tensor))#np.max(np.abs(tensor))\n if (self.prune_scale == 'xavier'):\n scale = 1.0 / np.sqrt(2.0 / tensor.shape[0] + tensor.shape[1])\n alive = tensor[torch.nonzero(tensor, as_tuple=True)]#np.nonzero(tensor)]\n alive /= scale \n # Add to global weights\n weights.append(alive)\n # Flatten the whole weights\n weights = torch.cat(weights)#np.concatenate(weights)\n value = abs(weights)\n # Compute global percentile\n percentile_value = torch_percentile(value, self.percent) #np.percentile(value, self.percent)\n # Now apply the global or compute local factor\n for step, (name, param) in enumerate(self.prune_parameters):\n scale = 1\n # Pointer to the original tensor\n tensor = param.data #.cpu().numpy()\n # Gradient-based selection\n if (self.prune_selection == 'gradient_max'):\n tensor = param.grad#.cpu().numpy()\n elif (self.prune_selection == 'gradient_min'):\n tensor = 1.0 / (torch.abs(param.grad) + 1e-7)#np.abs(param.grad.cpu().numpy())\n #tensor = torch.abs(torch.max(tensor) - tensor) #np.max(tensor) - tensor\n # Compute scaling\n if (self.prune_scale == 'dimension'):\n scale = tensor.size\n if (self.prune_scale == 'normalize'):\n scale = torch.max(torch.abs(tensor)) #np.max(np.abs(tensor))\n if (self.prune_scale == 'xavier'):\n scale = 1.0 / np.sqrt(2.0 / tensor.shape[0] + tensor.shape[1])\n local_weights = tensor\n local_weights /= scale\n # We do not prune bias term\n if (self.prune_scope == 'local'):\n weights = tensor[torch.nonzero(param.data, as_tuple=True)] #tensor[np.nonzero(tensor)]\n # Retrieve non-pruned weights\n value = abs(weights)\n # Compute global percentile\n percentile_value = torch_percentile(value, self.percent)\n # Use the selection function to compute mask\n new_mask = PruningMasking.ranking(self, name, local_weights, percentile_value, self.mask[step])\n # Store the computed mask\n self.mask[step] = new_mask\n step = 0\n return model","def computeBoundaryFaces(elemsF, facesN):\n # Sort indexes and add 1 position in order to use indexes as Matlab\n A0 = np.sort(elemsF[:, 0]) + 1\n I0 = np.argsort(elemsF[:, 0]) + 1\n A1 = np.sort(elemsF[:, 1]) + 1\n I1 = np.argsort(elemsF[:, 1]) + 1\n A2 = np.sort(elemsF[:, 2]) + 1\n I2 = np.argsort(elemsF[:, 2]) + 1\n A3 = np.sort(elemsF[:, 3]) + 1\n I3 = np.argsort(elemsF[:, 3]) + 1\n\n # Number of faces\n nFaces = elemsF.max()\n\n # As consequence, dimensions of E must be increased\n # 2 rows and 1 column\n E = np.zeros((nFaces+2, 9))\n\n E[A0, 1] = I0\n E[A1, 2] = I1\n E[A2, 3] = I2\n E[A3, 4] = I3\n\n # If the same face is listed in the same row of 'elemsF'\n # more than, once it will simply be missed! Because of this we\n # have to insert the following dummy variables in order to\n # determine the boundary faces.\n tmp = np.diff(A0) == 0\n ind0 = np.where(tmp)[False]\n tmp = np.diff(A1) == 0\n ind1 = np.where(tmp)[False]\n tmp = np.diff(A2) == 0\n ind2 = np.where(tmp)[False]\n tmp = np.diff(A3) == 0\n ind3 = np.where(tmp)[False]\n\n E[A0[ind0], 5] = 1\n E[A1[ind1], 6] = 1\n E[A2[ind2], 7] = 1\n E[A3[ind3], 8] = 1\n\n # Delete extra rows and column\n E = np.delete(E, (0), axis=0)\n E = np.delete(E, (0), axis=1)\n\n # Final sorting\n E.sort()\n E = np.fliplr(E)\n\n # Get boundary nodes by first examining which columns in E\n # have only one nonzero element, meaning that this face is\n # related to only one single tetra, which means it is on the\n # boundary of the domain. Since faces are defined by their nodes,\n # we have the boundary nodes too.\n # Get boundary faces to nodes\n ind = (E[:, 1] == 0)\n bfacesN = np.array(np.transpose(facesN[ind, :]), dtype=np.int)\n\n # Get indexes of boundary faces\n ind = np.where(ind == True)\n bFaces = np.array(np.transpose(ind), dtype=np.int)\n size = bFaces.shape\n nBoundaryFaces = size[0]\n bFaces = bFaces.reshape((nBoundaryFaces))\n\n return bfacesN, bFaces, nBoundaryFaces","def GetSelectedUVFaces_InEditMode(bmeshref, uvlayer):\r\n cont = 0\r\n selecteduvfaces = []\r\n for face in bmeshref.faces:\r\n thisFaceSelected = True\r\n for vert in face.loops:\r\n if vert[uvlayer].select == False:\r\n thisFaceSelected = False\r\n \r\n if thisFaceSelected == True:\r\n selecteduvfaces.append(cont)\r\n cont += 1\r\n return selecteduvfaces","def findfeatures(self):\n self.set_wdiff()\n\n #xp, wp=st.findfeatures(self.xarr, self.farr, self.slines, self.sfluxes,\n # self.ws, mdiff=self.mdiff, wdiff=self.wdiff, sigma=self.sigma, niter=self.niter, sections=3)\n xp,wp=st.crosslinematch(self.xarr, self.farr, self.slines, self.sfluxes,\n self.ws, mdiff=self.mdiff, wdiff=20, sigma=self.sigma, niter=self.niter)\n for x, w in zip(xp, wp):\n if w not in self.wp and w>-1: \n self.xp.append(x)\n self.wp.append(w)\n self.plotFeatures()\n self.redraw_canvas()","def get_factors(self, triples):\n pass","def computeFacePlane(nodes, bFaces, bFacesN):\n # Number of boundary faces\n nBndFaces = np.size(bFaces)\n\n # Get computational domain limits\n min_x = np.min(nodes[:,0])\n max_x = np.max(nodes[:,0])\n min_y = np.min(nodes[:,1])\n max_y = np.max(nodes[:,1])\n min_z = np.min(nodes[:,2])\n max_z = np.max(nodes[:,2])\n\n # Set plane equation for each side\n # We consider following configuration:\n\n # g ------------- h\n # /| /| where:\n # / | / | a = [min_x, min_y, min_z]\n # / | / | b = [max_x, min_y, min_z]\n # / | / | c = [min_x, max_y, min_z]\n # e --------------f | d = [max_x, max_y, min_z]\n # | | | | e = [min_x, min_y, max_z]\n # | |c --------|----|d f = [max_x, min_y, max_z]\n # | / | / g = [min_x, max_y, max_z]\n # | / | / h = [max_x, max_y, max_z]\n # | / | /\n # a ------------- b\n\n # With xyz-axis:\n # Z+ Y+\n # | /\n # | /\n # |/\n # ------X+\n\n # Therefore, each plane of the cube is defined by two vectors:\n # Bottom: ab, ac ---> flag: 0\n # Left: ac, ae ---> flag: 1\n # Front: ab, ae ---> flag: 2\n # Rigth: bd, bf ---> flag: 3\n # Back: dc, dh ---> flag: 4\n # Top: ef, eg ---> flag: 5\n\n # Initialize main points\n a = np.array([min_x, min_y, min_z], np.float)\n b = np.array([max_x, min_y, min_z], np.float)\n c = np.array([min_x, max_y, min_z], np.float)\n d = np.array([max_x, max_y, min_z], np.float)\n e = np.array([min_x, min_y, max_z], np.float)\n f = np.array([max_x, min_y, max_z], np.float)\n g = np.array([min_x, max_y, max_z], np.float)\n h = np.array([max_x, max_y, max_z], np.float)\n\n # Compute normal vectors to planes\n normal_bottom = np.cross(a-b, a-c)\n normal_left = np.cross(a-c, a-e)\n normal_front = np.cross(a-b, a-e)\n normal_right = np.cross(b-d, b-f)\n normal_back = np.cross(d-c, d-h)\n normal_top = np.cross(e-f, e-g)\n\n # Allocate space for tag plane\n planeFace = np.zeros(nBndFaces, dtype=np.int)\n plane_list = np.zeros(6, dtype=np.float)\n\n # Solve plane equation for each boundary face\n for i in np.arange(nBndFaces):\n # Get nodes of face\n faceNodes = nodes[bFacesN[:,i],:]\n\n # Compute face centroid\n centroid = np.sum(faceNodes, 0)/3.\n\n # Solve equation for bottom plane\n plane_list[0] = np.dot(normal_bottom, centroid-a)\n # Solve equation for left plane\n plane_list[1] = np.dot(normal_left, centroid-a)\n # Solve equation for front plane\n plane_list[2] = np.dot(normal_front, centroid-a)\n # Solve equation for right plane\n plane_list[3] = np.dot(normal_right, centroid-b)\n # Solve equation for back plane\n plane_list[4] = np.dot(normal_back, centroid-d)\n # Solve equation for top plane\n plane_list[5] = np.dot(normal_top, centroid-e)\n # Get to what plane the face belongs\n # Flags for faces:\n # Bottom ---> flag: 0\n # Left ---> flag: 1\n # Front ---> flag: 2\n # Rigth ---> flag: 3\n # Back ---> flag: 4\n # Top ---> flag: 5\n planeFace[i] = np.where(np.abs(plane_list)<1.e-13)[0][0]\n\n return planeFace","def refineMesh(cls, meshrefinement, options):\n refineElementsCountAround = options['Refine number of elements around']\n refineElementsCountAlong = options['Refine number of elements along']\n refineElementsCountThroughWall = options['Refine number of elements through wall']\n\n meshrefinement.refineAllElementsCubeStandard3d(refineElementsCountAround, refineElementsCountAlong,\n refineElementsCountThroughWall)\n return","def test_vs_filtering():\n vs = virtualscreening(n_cpu=-1)\n\n vs.load_ligands('sdf', os.path.join(test_data_dir, 'data/dude/xiap/actives_docked.sdf'))\n vs.apply_filter('ro5', soft_fail=1)\n assert_equal(len(list(vs.fetch())), 49)\n\n vs.load_ligands('sdf', os.path.join(test_data_dir, 'data/dude/xiap/actives_docked.sdf'))\n vs.apply_filter('ro3', soft_fail=2)\n assert_equal(len(list(vs.fetch())), 9)","def get_faces(image):\n return (image.crop(face) for face in image.faces)","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 evaluate(self):\n #fac o lista cu toate perechile si vad daca se repeta vreuna (pana acum)\n nr=0\n \n pairs = []\n for i in range(0,self.__size):\n for j in range(0, self.__size):\n if self.__solution[i] != [] and self.__solution[i+self.__size] != [] : #sa am de unde face perechea\n p=[]\n p.append(self.__solution[i][j])\n p.append(self.__solution[i+self.__size][j])\n pairs.append(p)\n for p in pairs:\n if pairs.count(p) == 1:\n nr += 1\n\n return self.__size*self.__size - nr + 1 # pun acel +1 ca sa nu fie 0 niciodata -> ca sa nu am probleme la impartire\n # la 0 mai incolo\n #return nr","def loading_faces(source_image_set_path, dest_image_set_path, source_image_set):\n dimensions_of_img = find_dimensions_not_attentive_imgs\n if 'attentive' in dest_image_set_path:\n dimensions_of_img = find_dimensions_attentive_imgs\n for image_name in source_image_set:\n\n # loading gray image\n gray_image = cv2.imread(source_image_set_path + \"/\" + image_name, 0)\n\n # find co-ordinates of faces in images\n y1, x2, y2, x1 = dimensions_of_img(*face_recognition.face_locations(gray_image)[0], np.shape(gray_image))\n\n # crop image and resize to particular dimension\n crop_img = gray_image[y1:y2, x1:x2]\n resize_crop_img = cv2.resize(crop_img, (int(dimension[0:3]), int(dimension[0:3])))\n\n # load images from source to destination directory\n cv2.imwrite(dest_image_set_path + \"/\" + image_name, resize_crop_img)","def check_nfaces(sections):\n return _check_nentries(sections, \"NFACES\", \"FACES\")","def occupied(self):\n self.is_occupied = 1\n for hex in self.fon:\n hex.add_neighbor()\n hex.set_quality()","def GetBoundaryFacesTet(self):\n\n p = self.InferPolynomialDegree()\n\n # DO NOT COMPUTE IF ALREADY COMPUTED\n if isinstance(self.faces,np.ndarray):\n if self.faces.shape[0] > 1:\n # IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION\n if self.faces.shape[1] == 3 and p > 1:\n pass\n else:\n return\n\n node_arranger = NodeArrangementTet(p-1)[0]\n\n # CONCATENATE ALL THE FACES MADE FROM ELEMENTS\n all_faces = np.concatenate((self.elements[:,:3],self.elements[:,[0,1,3]],\n self.elements[:,[0,2,3]],self.elements[:,[1,2,3]]),axis=0)\n # GET UNIQUE ROWS\n uniques, idx, inv = unique2d(all_faces,consider_sort=True,order=False,return_index=True,return_inverse=True)\n\n # ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY FACES\n freqs_inv = itemfreq(inv)\n faces_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]\n # NOT ARRANGED\n self.faces = uniques[faces_ext_flags,:]\n\n # DETERMINE WHICH FACE OF THE ELEMENT THEY ARE\n boundary_face_to_element = np.zeros((faces_ext_flags.shape[0],2),dtype=np.int64)\n # THE FOLLOWING WILL COMPUTE FACES BASED ON SORTING AND NOT TAKING INTO ACCOUNT\n # THE ELEMENT CONNECTIVITY\n # boundary_face_to_element[:,0] = np.remainder(idx[faces_ext_flags],self.elements.shape[0])\n # boundary_face_to_element[:,1] = np.floor_divide(idx[faces_ext_flags],self.elements.shape[0])\n # OR EQUIVALENTLY\n # boundary_face_to_element[:,0] = idx[faces_ext_flags] % self.elements.shape[0]\n # boundary_face_to_element[:,1] = idx[faces_ext_flags] // self.elements.shape[0]\n\n # FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR\n # IN ELEMENT CONNECTIVITY\n # THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF FACES\n all_faces_in_faces = in2d(all_faces,self.faces,consider_sort=True)\n all_faces_in_faces = np.where(all_faces_in_faces==True)[0]\n\n # boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)\n boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]\n boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]\n\n # ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS\n self.faces = self.elements[boundary_face_to_element[:,0][:,None],node_arranger[boundary_face_to_element[:,1],:]]\n self.faces = self.faces.astype(np.uint64)\n self.boundary_face_to_element = boundary_face_to_element","def get_factors():","def populateFaces(matrix, indexRef, noiseLevel):\n for face in faces:\n setValue(matrix, face, indexRef, noiseLevel)","def factors(self):\n self.assert_sampled()\n return self._factors","def compute_relations(self):\n\n visible_nodes = {}\n\n self.cameras = self.get_all_cameras()\n rospy.logdebug(self.cameras)\n\n if self.cameras.items():\n try:\n if self.visibility_monitor is None:\n self.visibility_monitor = VisibilityMonitor(self.ctx, self.source)\n rospy.loginfo(\"[perspective_filter] Visibility monitor now running, please active the Pygame windows.\")\n visible_nodes = self.visibility_monitor.compute_all()\n rospy.logdebug(\"[perspective_filter] %d perspectives computed \" % len(visible_nodes))\n #rospy.logdebug(visible_nodes)\n except Exception as e:\n rospy.logwarn(\"[perspective_filter] Exception occurred while computing relation : %s\" % str(e))\n if self.visibility_monitor:\n self.visible_nodes = {} #visible_nodes\n for camera_name, visibles_obj in visible_nodes.items():\n camera_id = self.source.scene.nodebyname(camera_name)[0].id\n self.visible_nodes[camera_id] = visibles_obj\n for node in visibles_obj:\n if node.parent in self.cameras.keys():\n if self.source.scene.nodes[node.parent] not in visibles_obj:\n visibles_obj.append(self.source.scene.nodes[node.parent])\n\n for agent_id, nodes_seen in self.visible_nodes.items():\n agent = self.source.scene.nodes[agent_id]\n for node in nodes_seen:\n if agent_id in self.previously_visible_nodes:\n if node not in self.previously_visible_nodes[agent_id]:\n self.start_predicate(self.source.timeline, \"isVisibleBy\", node.name, object_name=agent.name)\n else:\n self.start_predicate(self.source.timeline, \"isVisibleBy\", node.name, object_name=agent.name)\n\n for agent_id, nodes_previously_seen in self.previously_visible_nodes.items():\n agent = self.source.scene.nodes[agent_id]\n for node in nodes_previously_seen:\n if agent_id in self.visible_nodes:\n if node not in self.visible_nodes[agent_id]:\n self.end_predicate(self.source.timeline, \"isVisibleBy\", node.name, object_name=agent.name)\n else:\n self.end_predicate(self.source.timeline, \"isVisibleBy\", node.name, object_name=agent.name)\n\n self.publish_perspectives()\n self.previously_visible_nodes = self.visible_nodes","def clear_face(self):\n rospy.loginfo('clearing all learned faces')\n self._clear_srv()","def select_area(minArea): \n # Switch in edit mode \n bpy.ops.object.mode_set(mode='EDIT')\n \n # Deselect everything\n bpy.ops.mesh.select_all(action=\"DESELECT\")\n \n # Load mesh\n me = bpy.context.edit_object.data\n bm = bmesh.from_edit_mesh(me)\n # Ensure internal data needed for int subscription is initialized\n bm.faces.ensure_lookup_table()\n\n # Array containing the different areas\n loops = []\n faces = bm.faces\n\n # Loop for detect multiple areas\n while faces:\n faces[0].select_set(True) # Select 1st face\n bpy.ops.mesh.select_linked() # Select all linked faces makes a full loop\n loops.append([f.index for f in faces if f.select])\n bpy.ops.mesh.hide(unselected=False) # Hide the detected loop\n faces = [f for f in bm.faces if not f.hide] # Update faces\n\n # Unhide all faces\n bpy.ops.mesh.reveal()\n print(\"Mesh has {} parts\".format(len(loops)))\n\n print(\"\\nThe face lists are:\")\n for loop in loops:\n print(loop)\n \n # Switch in edit mode \n bpy.ops.object.mode_set(mode='EDIT')\n # Deselect everything\n bpy.ops.mesh.select_all(action=\"DESELECT\")\n # Switch in object mode\n bpy.ops.object.mode_set(mode='OBJECT')\n\n # Loop to select areas are higher than the area min\n area = 0 \n for rows in range(len(loops)):\n area = 0\n for columns in loops[rows]:\n # Calculate the area\n area = area + bpy.context.active_object.data.polygons[columns].area\n print(rows)\n print(area)\n print(minArea)\n # Compare the area with the area min\n if area > minArea:\n for columns in loops[rows]:\n # Select all the faces of the area\n bpy.context.active_object.data.polygons[columns].select = True\n\n # Switch in edit mode \n bpy.ops.object.mode_set(mode='EDIT')","def prune_(self):\n idx = self.factor_lams() > 0\n self.factors = [f[:, idx] for f in self.factors]\n self.rank = np.sum(idx)","def forward(self, images):\n features = self.resnet(images)\n features = Variable(features.data)\n features = self.pooling(features)\n # print(features)\n features = features.view(features.size(0),-1)\n # print(features)\n # print(resnet.fc.in_features)\n features = self.bn(self.linear(features))\n return features\n # with torch.no_grad():\n # features = self.resnet(images)\n # features = features.reshape(features.size(0), -1)\n # features = self.bn(self.linear(features))\n # return features","def ObserveEvidence(self,E):\r\n for f in self.factors:\r\n f.ObserveEvidence(E)","def GetInteriorFacesTet(self):\n\n if not isinstance(self.all_faces,np.ndarray):\n self.GetFacesTet()\n if not isinstance(self.faces,np.ndarray):\n self.GetBoundaryFacesTet()\n\n face_flags = in2d(self.all_faces.astype(self.faces.dtype),self.faces,consider_sort=True)\n face_flags[face_flags==True] = 1\n face_flags[face_flags==False] = 0\n interior_faces = self.all_faces[face_flags==False,:]\n\n return interior_faces, face_flags","def test_faces(self):\n\n self.test_shape.workplane = \"XY\"\n self.test_shape.rotation_axis = \"Z\"\n\n assert self.test_shape.area == pytest.approx((((math.pi * (10**2)) * 2) + (math.pi * (10 * 2) * 100)) * 8)\n assert len(self.test_shape.areas) == 24\n assert self.test_shape.areas.count(pytest.approx(math.pi * (10**2))) == 16\n assert self.test_shape.areas.count(pytest.approx(math.pi * (10 * 2) * 100)) == 8","def evaluator(self, candidates, args):\r\n fitness = []\r\n if self._use_ants:\r\n for candidate in candidates:\r\n total = 0\r\n for c in candidate:\r\n total += self.weights[c.element[0]][c.element[1]]\r\n last = (candidate[-1].element[1], candidate[0].element[0])\r\n total += self.weights[last[0]][last[1]]\r\n fitness.append(1 / total)\r\n else:\r\n for candidate in candidates:\r\n total = 0\r\n for src, dst in zip(candidate, candidate[1:] + [candidate[0]]):\r\n total += self.weights[src][dst]\r\n fitness.append(1 / total)\r\n return fitness","def check_constraints(labels, fws, propnames, criteria, MB=None, mapall=False):\n\n (min_area,\n max_area,\n max_intensity_mb,\n max_eccentricity,\n min_solidity,\n min_euler_number,\n min_extent) = criteria\n\n rp = regionprops(labels, intensity_image=MB, cache=True)\n\n for prop in rp:\n\n if mapall:\n fws = set_fws(fws, prop, propnames, is_valid=True)\n continue\n\n # TODO: ordering\n if min_area is not None:\n if prop.area < min_area:\n fws = set_fws(fws, prop, propnames, is_valid=False)\n continue\n if max_area is not None:\n if prop.area > max_area:\n fws = set_fws(fws, prop, propnames, is_valid=False)\n continue\n if max_intensity_mb is not None:\n if prop.mean_intensity > max_intensity_mb:\n fws = set_fws(fws, prop, propnames, is_valid=False)\n continue\n if max_eccentricity is not None:\n if prop.eccentricity > max_eccentricity:\n fws = set_fws(fws, prop, propnames, is_valid=False)\n continue\n if min_solidity is not None:\n if prop.solidity < min_solidity:\n fws = set_fws(fws, prop, propnames, is_valid=False)\n continue\n if min_euler_number is not None:\n if prop.euler_number < min_euler_number:\n fws = set_fws(fws, prop, propnames, is_valid=False)\n continue\n if min_extent is not None:\n if prop.extent < min_extent:\n fws = set_fws(fws, prop, propnames, is_valid=False)\n continue\n\n fws = set_fws(fws, prop, propnames, is_valid=True)\n\n return fws","def evaluate_detections(self, all_boxes, output_dir=None):\n raise NotImplementedError","def mbieLoop (self) :\n self.iterCnt = 0\n while self.iterCnt < 5000:\n s = self.mdp.s0\n for h in range(self.H) :\n self.QUpper = QBoundsSolver(self.mdp, self.PHat, self.QUpper, self.Ntotal, 0.1, True, self.stop)\n a = np.argmax(self.QUpper[s])\n s_, self.R[s,a] = self.mdp.step(s, a)\n self.updateVisitStatistics(s, a, s_)\n s = s_\n\n if self.iterCnt % 10 == 0: \n print(self.iterCnt)\n print(self.QUpper)\n\n self.iterCnt += 1","def get_faces(self, image):\n\t\t\n\t\t# Convert the image to grayscale and normalise\n\t\tcv.CvtColor(image, self.gray, cv.CV_BGR2GRAY)\n\t\tcv.EqualizeHist(self.gray, self.gray)\n\t\t\n\t\t# Detect faces\n\t\treturn cv.HaarDetectObjects(self.gray, self.cascade, self.storage,\n\t\t scale_factor = 1.3,\n\t\t min_neighbors = 2,\n\t\t flags = cv.CV_HAAR_DO_CANNY_PRUNING,\n\t\t min_size = (40,40))","def island_aging(self):\n for y in self.island_map:\n for cell in y:\n cell.aging()","def get_faces():\n detected_faces = request()\n\n if not detected_faces:\n raise FaceNotDetectedError()\n return detected_faces","def compileIF_WFS(filebase='', vmax=10.0, ftype='h5'):\n for idx in ax.cellmap:\n measureIF_WFS(idx, N=1, volt=vmax, filebase=filebase, ftype=ftype)","def execute(self):\r\n factors = self.factors\r\n variables = list(self.variables)\r\n variables.remove(self.query)\r\n\r\n for fac in factors:\r\n self.set_observations(fac)\r\n\r\n for var in variables:\r\n if var not in self.obs:\r\n factors = self.eliminate_variable(var, factors)\r\n\r\n result = factor_module.multiply_batch(self.query, factors)\r\n denominator = sum(result.get_cpt())\r\n print(denominator)\r\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}","def rook_neighbors_face(self, face):\n edges = self.cw_face_edges(face)\n return list(set([ self.left_region[edge] for edge in edges]))","def __iter__(self):\n for element in self.focals:\n yield element","def validate():\n # Switch in object mode \n bpy.ops.object.mode_set(mode='OBJECT')\n \n # Apply modifier\n bpy.ops.object.apply_all_modifiers()\n \n # Get the active objec\n obj = bpy.context.active_object\n print(\"Number of faces\", len(obj.data.polygons))","def count_oob(cube):\n out_range = (cube > 4).any(1) | (cube < -4).any(1)\n out_range = out_range.sum() / cube.shape[0]\n return out_range","def evaluate(self, gameState, action, ghosts):\r\n features = self.getFeatures(gameState, action)\r\n weights = self.getWeights(gameState, action)\r\n return features * weights","def Clear(self, *args):\n return _BRepAlgo.BRepAlgo_FaceRestrictor_Clear(self, *args)","def getLiters(self):\n return self._count/self._ppl","def collect_best_features(self):\n bincsp = self.binary_csp # just to make code shorter\n n_folds = len(self.binary_csp.folds)\n n_class_pairs = len(self.binary_csp.class_pairs)\n result_shape = (n_folds, n_class_pairs)\n self.train_feature = np.empty(result_shape, dtype=object)\n self.train_feature_full_fold = np.empty(result_shape, dtype=object)\n self.test_feature = np.empty(result_shape, dtype=object)\n self.test_feature_full_fold = np.empty(result_shape, dtype=object)\n self.selected_filters_per_filterband = np.empty(result_shape, dtype=object)\n for fold_i in range(n_folds):\n for class_pair_i in range(n_class_pairs):\n bin_csp_train_features = deepcopy(bincsp.train_feature[\n self.selected_filter_inds, fold_i, class_pair_i])\n bin_csp_train_features_full_fold = deepcopy(\n bincsp.train_feature_full_fold[\n self.selected_filter_inds,\n fold_i, class_pair_i])\n bin_csp_test_features = deepcopy(bincsp.test_feature[\n self.selected_filter_inds, fold_i, class_pair_i])\n bin_csp_test_features_full_fold = deepcopy(\n bincsp.test_feature_full_fold[\n self.selected_filter_inds,fold_i, class_pair_i])\n selected_filters_per_filt = self.select_best_filters_best_filterbands(\n bin_csp_train_features, max_features=self.n_features,\n forward_steps=self.forward_steps, \n backward_steps=self.backward_steps,\n stop_when_no_improvement=self.stop_when_no_improvement)\n self.train_feature[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_train_features, selected_filters_per_filt)\n self.train_feature_full_fold[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_train_features_full_fold, selected_filters_per_filt)\n \n self.test_feature[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_test_features, selected_filters_per_filt)\n self.test_feature_full_fold[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_test_features_full_fold, selected_filters_per_filt)\n \n self.selected_filters_per_filterband[fold_i, class_pair_i] = \\\n selected_filters_per_filt","def return_factors(self):\n if self.global_rank==0:print([i.shape for i in self.factors])\n return self.factors","def train(self):\n\n\t\tcentroids, x_assignee = self._init_centroid(data=self._train_x)\n\t\tcount = 0\n\t\t\n\t\tprev_r = np.array([])\n\n\t\twhile True:\n\t\t\tr = self._expectation(centroids = centroids, x_assignee = x_assignee)\n\t\t\tcentroids = self._maximization(r_list = r, x_assignee = x_assignee)\n\n\t\t\tif len(prev_r) is not 0:\n\t\t\t\tif (float(np.mean(np.equal(r, prev_r))) == 1.0):\n\t\t\t\t\tcount +=1\n\t\t\t\telse: \n\t\t\t\t\tcount=0\n\t\t\tif count == 10:\n\t\t\t\tbreak\n\t\t\tprev_r = r\n\n\n\t\treturn r, centroids","def reduce(self, inputProportions, maxDeviation, triangleBudget, remeshType, reduceType):\n return bool()","def graphics_nfaces(self):\n nfaces_ = _pychidg.f90wrap_graphics_nfaces(self=self._handle)\n return nfaces_","def iter_waters(self):\n fpred = lambda f: f.is_water()\n return itertools.ifilter(fpred, self.iter_fragments())","def iterate(self):\n ret = super(ExpandableAlgorithm, self).pre_iteration()\n if ret is None:\n return None\n active, passive, neighbors, features_active, features_passive = ret\n params = [features_active, features_passive]\n if self._post_args:\n params += self._post_args\n s = self._overlap_function(*params)\n if self.condition_axelrod:\n if self.__condition_axelrod(s, features_active, features_passive):\n return True\n if self.condition_centola:\n if self.__condition_centola(s, active, passive, neighbors):\n return True","def compare_many_faces(args):\n\n (emb, nrof_images) = compare_faces(args)\n for i in range(nrof_images):\n print('%1d ' % i, end='')\n for j in range(nrof_images):\n dist = np.sqrt(np.sum(np.square(np.subtract(emb[i, :], emb[j, :]))))\n print(' %1.4f ' % dist, end='')\n print('')","def evaluate_detections(self, all_boxes, output_dir=None):\n raise NotImplementedError"],"string":"[\n \"def WiresToFaces(self, *args):\\n return _BRepAlgo.BRepAlgo_Loop_WiresToFaces(self, *args)\",\n \"def findFaces(self):\\n\\t\\trects = self.detectAll()\\n\\t\\tif len(rects)==0:\\n\\t\\t\\trects = []\\n\\t\\telse:\\n\\t\\t\\trects[:, 2:] += rects[:, :2]\\n\\t\\tself.analyzeFrame(rects)\",\n \"def get_filtered_faces(self, faces):\\n filtered_faces = []\\n for face in faces:\\n i, j, k = face\\n thresh = 100.0\\n if self.get_distance_between_points(i, j) > thresh:\\n continue\\n elif self.get_distance_between_points(j, k) > thresh:\\n continue\\n elif self.get_distance_between_points(i, k) > thresh:\\n continue\\n filtered_faces.append(face)\\n return filtered_faces\",\n \"def detectFaces():\\n faceEngine = VLFaceEngine()\\n detector = faceEngine.createFaceDetector(DetectorType.FACE_DET_V3)\\n\\n imageWithOneFace = VLImage.load(filename=EXAMPLE_O)\\n pprint.pprint(detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False).asDict())\\n detection = detector.detectOne(imageWithOneFace, detect5Landmarks=False, detect68Landmarks=False)\\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection))\\n pprint.pprint(detector.redetectOne(image=imageWithOneFace, bBox=detection.boundingBox.rect))\\n\\n imageWithSeveralFaces = VLImage.load(filename=EXAMPLE_SEVERAL_FACES)\\n severalFaces = detector.detect([imageWithSeveralFaces], detect5Landmarks=False, detect68Landmarks=False)\\n\\n pprint.pprint(\\n detector.redetect(\\n images=[\\n ImageForRedetection(imageWithSeveralFaces, [face.boundingBox.rect for face in severalFaces[0]]),\\n ImageForRedetection(imageWithOneFace, [detection.boundingBox.rect]),\\n ImageForRedetection(imageWithOneFace, [Rect(0, 0, 1, 1)]),\\n ]\\n )\\n )\",\n \"def faces(self):\\r\\n return self._faces\",\n \"def faces(self):\\n\\n if self._faces is None:\\n if self._vertices is None:\\n return None\\n self.triangulate()\\n return self._faces\",\n \"def get_bounded_faces(self):\\n return [face for face in self.faces if face.is_bounded()]\",\n \"def solved(self):\\n return all(cell == 1 for row in self.faces for cell in row) or all(cell == 0 for row in self.faces for cell in row)\",\n \"def _interiorFaces(self):\\n XYids = self._XYFaceIDs\\n XZids = self._XZFaceIDs\\n YZids = self._YZFaceIDs\\n\\n interiorIDs = numerix.concatenate((numerix.ravel(XYids[ ..., 1:-1]),\\n numerix.ravel(XZids[:, 1:-1,:]),\\n numerix.ravel(YZids[1:-1, ...].swapaxes(0, 1))))\\n\\n from fipy.variables.faceVariable import FaceVariable\\n interiorFaces = FaceVariable(mesh=self, value=False)\\n interiorFaces[interiorIDs] = True\\n return interiorFaces\",\n \"def forward(self):\\n priors = []\\n for k, f in enumerate(self.feature_maps):\\n scale = self.image_size / self.strides[k]\\n # for i, j in product(range(f), repeat=2):\\n for i in range(f[0]):\\n for j in range(f[1]):\\n # print(i, j)\\n # unit center x,y\\n cx = (j + 0.5) / scale\\n cy = (i + 0.5) / scale\\n\\n # small sized square box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # big sized square box\\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # change h/w ratio of the small sized box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n for ratio in self.aspect_ratios[k]:\\n ratio = sqrt(ratio)\\n priors.append([cx, cy, w * ratio, h / ratio])\\n priors.append([cx, cy, w / ratio, h * ratio])\\n\\n priors = torch.Tensor(priors)\\n if self.clip:\\n priors.clamp_(max=1, min=0)\\n return priors\",\n \"def faces(self):\\n return map(Face, self._top_exp.faces())\",\n \"def boundary(self):\\n answer = self.zero()\\n for k, v in self.items():\\n for idx, cube in enumerate(k):\\n acc_dim = sum((cube_l.dimension for cube_l in k[:idx]))\\n for i in range(cube.dimension):\\n for epsilon in (0, 1):\\n new_cube = cube.face(i, epsilon)\\n new_k = k[:idx] + (new_cube,) + k[idx + 1:]\\n sign_exp = (acc_dim + i + epsilon) % 2\\n answer += answer.create({new_k: v * (-1)**sign_exp})\\n return answer\",\n \"def faces(self, f):\\n self._faces = f\",\n \"def num_faces(self):\\n return self._top_exp.number_of_faces()\",\n \"def _exteriorFaces(self):\\n XYids = self._XYFaceIDs\\n XZids = self._XZFaceIDs\\n YZids = self._YZFaceIDs\\n\\n exteriorIDs = numerix.concatenate((numerix.ravel(XYids[..., 0].swapaxes(0, 1)),\\n numerix.ravel(XYids[..., -1].swapaxes(0, 1)),\\n numerix.ravel(XZids[:, 0,:]),\\n numerix.ravel(XZids[:, -1,:]),\\n numerix.ravel(YZids[ 0, ...]),\\n numerix.ravel(YZids[-1, ...])))\\n\\n from fipy.variables.faceVariable import FaceVariable\\n exteriorFaces = FaceVariable(mesh=self, value=False)\\n exteriorFaces[exteriorIDs] = True\\n return exteriorFaces\",\n \"def select_resize_all():\\n date_1 = datetime.datetime.now()\\n print(\\\"Start\\\")\\n\\n # Get the active object\\n obj = bpy.context.active_object\\n\\n # Switch in object mode \\n bpy.ops.object.mode_set(mode='OBJECT')\\n\\n # Get the selected faces and their min and max location in x and y\\n tabSelectedFaces = []\\n xMax = float('-inf')\\n xMin = float('inf')\\n yMax = float('-inf')\\n yMin = float('inf')\\n for poly in obj.data.polygons:\\n if poly.select == True:\\n tabSelectedFaces.append(poly)\\n xMax = max(xMax, obj.data.vertices[poly.vertices[0]].co.x, obj.data.vertices[poly.vertices[1]].co.x, obj.data.vertices[poly.vertices[2]].co.x)\\n xMin = min(xMin, obj.data.vertices[poly.vertices[0]].co.x, obj.data.vertices[poly.vertices[1]].co.x, obj.data.vertices[poly.vertices[2]].co.x)\\n yMax = max(yMax, obj.data.vertices[poly.vertices[0]].co.y, obj.data.vertices[poly.vertices[1]].co.y, obj.data.vertices[poly.vertices[2]].co.y)\\n yMin = min(yMin, obj.data.vertices[poly.vertices[0]].co.y, obj.data.vertices[poly.vertices[1]].co.y, obj.data.vertices[poly.vertices[2]].co.y)\\n\\n # Switch in edit mode \\n bpy.ops.object.mode_set(mode='EDIT')\\n\\n # Load mesh\\n me = bpy.context.edit_object.data\\n bm = bmesh.from_edit_mesh(me)\\n # Ensure internal data needed for int subscription is initialized\\n bm.faces.ensure_lookup_table()\\n\\n # While all connected faces are not selected\\n while bm.faces:\\n # Find connected faces to the selection\\n grow_faces = set(f for f in bm.verts if f.select for f in f.link_faces if not f.select)\\n\\n # If no more faces, leave the loop\\n if grow_faces == set():\\n break;\\n\\n # Select the faces and update min and max x and y location\\n for f in grow_faces:\\n f.select = True\\n xMax = max(xMax, f.verts[0].co.x, f.verts[1].co.x, f.verts[2].co.x)\\n xMin = min(xMin, f.verts[0].co.x, f.verts[1].co.x, f.verts[2].co.x)\\n yMax = max(yMax, f.verts[0].co.y, f.verts[1].co.y, f.verts[2].co.y)\\n yMin = min(yMin, f.verts[0].co.y, f.verts[1].co.y, f.verts[2].co.y)\\n \\n print(xMax,xMin,xMax-xMin) \\n print(yMax,yMin,yMax-yMin) \\n\\n # Update the information for the resize action\\n bpy.context.scene.sizeX = xMax-xMin\\n bpy.context.scene.oldResizeX = 1\\n bpy.context.scene.sizeY = yMax-yMin\\n bpy.context.scene.oldResizeY = 1\\n\\n # Transfer the data back to the object's mesh \\n bmesh.update_edit_mesh(me)\\n\\n print(\\\"End Script\\\")\\n\\n date_2 = datetime.datetime.now()\\n time_delta = (date_2 - date_1)\\n total_seconds = time_delta.total_seconds()\\n print(\\\"Time : \\\", total_seconds)\",\n \"def faces_apply(op, faces, flip):\\n return [face_apply(op, face, flip) for face in faces]\",\n \"def _getFaces(self, it_mesh_poly):\\n\\n faces = []\\n it_mesh_poly.reset()\\n while not it_mesh_poly.isDone():\\n faces += it_mesh_poly.getVertices()\\n it_mesh_poly.next(1)\\n\\n return faces\",\n \"def get_faces(self):\\n for i, j in combinations(self.gens, 2):\\n c0 = self.triangle_verts[self.vertex_at_mirrors(i, j)]\\n f0 = []\\n m = self.cox_mat[i][j]\\n H = (i, j)\\n type = 0\\n if self.active[i] and self.active[j]:\\n type = 1\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k + (i,)))\\n elif self.active[i] and m > 2:\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (j, i) * k))\\n elif self.active[j] and m > 2:\\n for k in range(m):\\n f0.append(self.G.move(self.vtable, 0, (i, j) * k))\\n else:\\n continue\\n\\n reps = set(self.word_generator(parabolic=H))\\n reps = self.G.sort_words(reps)\\n flist = []\\n for word in reps:\\n f = tuple(self.G.move(self.vtable, v, word) for v in f0)\\n if None not in f and not helpers.check_duplicate_face(f, flist):\\n center = self.transform(word, c0)\\n coords = [self.vertices_coords[k] for k in f]\\n face = DihedralFace(word, f, center, coords, type)\\n flist.append(face)\\n\\n self.face_indices[(i, j)] = flist\\n\\n self.num_faces = sum(len(L) for L in self.face_indices.values())\",\n \"def depthFaceSelect(self, triangleSelected,depth, materials):\\t\\n\\t\\tlayersR = list()\\n\\t\\tlayersG = list()\\n\\t\\tlayersB = list()\\n\\t\\t\\n\\t\\tlayerMaterial = list()\\n\\t\\tself.volumeComposition = list()\\n\\t\\tfor l in range(len(materials)):\\n\\t\\t\\tlayerMaterial.append(list())\\n\\t\\t\\tself.volumeComposition.append(list())\\n\\t\\t\\n\\t\\tvolumeGeneral = list()\\n\\t\\tself.boolLayers = []\\n\\t\\t\\n\\t\\tfor i in self.slicePoints:\\n\\t\\t\\tboolResult2 = self.voxel_slice(i, self.vertices, self.triangles, self.res, self.llc, self.sliceProto, 2)\\n\\t\\t\\tprint boolResult2.shape\\n\\t\\t\\ttupleResultR = numpy.zeros(boolResult2.shape, dtype=uint8)\\n\\t\\t\\ttupleResultG = numpy.zeros(boolResult2.shape, dtype=uint8)\\n\\t\\t\\ttupleResultB = numpy.zeros(boolResult2.shape, dtype=uint8)\\n\\t\\t\\ttupleMaterial = list()\\n\\t\\t\\tfor l in range(len(materials)):\\n\\t\\t\\t\\ttupleMaterial.append(numpy.zeros(boolResult2.shape, dtype=float))\\n\\t\\t\\t#tupleMaterial = numpy.zeros(boolResult2.shape, dtype=f)\\n\\t\\t\\t#lines=self.findSelectedContour(self.vertices,triangleSelected,i ,numpy.array([0,0,1]))\\n\\t\\t\\t#boolResult1 = self.findVoxelOfSelectedContour(i, lines, self.res, self.llc, self.sliceProto, depth)\\n\\t\\t\\tj = numpy.nditer(boolResult2, flags=['multi_index'], op_flags=['readwrite'])\\n\\n\\t\\t\\twhile not j.finished:\\t\\n\\t\\t\\t\\tprint type(j.multi_index)\\n\\t\\t\\t\\tprint j.multi_index\\n\\t\\t\\t\\tif j[0] == True:\\n\\t\\t\\t\\t\\ttupleResultB[j.multi_index] = materials[0][0]\\n\\t\\t\\t\\t\\ttupleResultG[j.multi_index] = materials[0][1]\\n\\t\\t\\t\\t\\ttupleResultR[j.multi_index] = materials[0][2]\\n\\t\\t\\t\\t\\ttupleMaterial[0][j.multi_index] = 1.0 \\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttupleResultB[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultG[j.multi_index] = 0\\n\\t\\t\\t\\t\\ttupleResultR[j.multi_index] = 0\\n\\t\\t\\t\\tj.iternext()\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tfor k in range(len(triangleSelected)):\\n\\t\\t\\t\\tboolResult1 = self.findVoxelOfSelectedContour(i, self.vertices, triangleSelected[k], self.res, self.llc, self.sliceProto, depth[k])\\n\\t\\t\\t\\tboolResult = numpy.logical_and(boolResult1, boolResult2)\\n\\t\\t\\t\\tprint boolResult.shape\\n\\n\\t\\t\\t\\tj = numpy.nditer(boolResult2, flags=['multi_index'], op_flags=['readwrite'])\\n\\t\\t\\t\\twhile not j.finished:\\n\\t\\t\\t\\t\\tif j[0] == True:\\n\\t\\t\\t\\t\\t\\tif boolResult[j.multi_index] == True:\\n\\t\\t\\t\\t\\t\\t\\ttupleResultB[j.multi_index] = materials[k + 1][0]\\n\\t\\t\\t\\t\\t\\t\\ttupleResultG[j.multi_index] = materials[k + 1][1]\\n\\t\\t\\t\\t\\t\\t\\ttupleResultR[j.multi_index] = materials[k + 1][2]\\n\\t\\t\\t\\t\\t\\t\\ttupleMaterial[k + 1][j.multi_index] = 1.0 \\n\\t\\t\\t\\t\\t\\t\\ttupleMaterial[0][j.multi_index] = 0.0\\n\\t\\t\\t\\t\\t\\t#else:\\n\\t\\t\\t\\t\\t\\t#\\ttupleResultB[j.multi_index] = 255\\n\\t\\t\\t\\t\\t\\t#\\ttupleResultG[j.multi_index] = 0\\n\\t\\t\\t\\t\\t\\t#\\ttupleResultR[j.multi_index] = 0\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tj.iternext()\\n\\t\\t\\tself.boolLayers.append(boolResult2)\\n\\t\\t\\tlayersR.append(tupleResultR)\\n\\t\\t\\tlayersG.append(tupleResultG)\\n\\t\\t\\tlayersB.append(tupleResultB)\\n\\t\\t\\tfor l in range(len(materials)):\\n\\t\\t\\t\\tlayerMaterial[l].append(tupleMaterial[l])\\n\\t\\t\\t\\t\\n\\t\\tprint \\\"i got here\\\"\\n\\t\\tself.volumeR=numpy.array(layersR) # create the 3d volume\\n\\t\\tself.volumeG=numpy.array(layersG) \\n\\t\\tself.volumeB=numpy.array(layersB)\\n\\t\\t\\n\\t\\tfor l in range(len(materials)):\\n\\t\\t\\tself.volumeComposition[l] = numpy.array(layerMaterial[l])\\n\\t\\tvolumeGeneral.append(self.volumeR)\\n\\t\\tvolumeGeneral.append(self.volumeG)\\n\\t\\tvolumeGeneral.append(self.volumeB)\\n\\t\\t\\n\\t\\treturn volumeGeneral\",\n \"def select_faces(maxAngle):\\n date_1 = datetime.datetime.now()\\n print(\\\"Start\\\")\\n\\n print(maxAngle, maxAngle*180/pi)\\n\\n # Get the active object\\n obj = bpy.context.active_object\\n\\n # Add the vertices location in an array\\n tabVertices = []\\n for vertex in obj.data.vertices:\\n tabVertices.append(obj.matrix_world @ vertex.co)\\n\\n # Find the downward vector in function of the angles of the mesh\\n matrix_new = obj.matrix_world.to_3x3().inverted()\\n no_world = matrix_new @ mathutils.Vector((0,0,-1))\\n no_world.normalize() \\n print(no_world)\\n vecDir = no_world\\n\\n\\n # Arrays for the function C parameters\\n tabPoly = []\\n tabNormalX = []\\n tabNormalY = []\\n tabNormalZ = []\\n tabFaces = []\\n\\n tabPoint1X = []\\n tabPoint1Y = []\\n tabPoint2X = []\\n tabPoint2Y = []\\n tabPoint3X = []\\n tabPoint3Y = []\\n tabPoint1Z = []\\n tabPoint2Z = []\\n tabPoint3Z = []\\n\\n # Fill the arrays\\n for poly in obj.data.polygons:\\n tabPoly.append(poly.index)\\n tabNormalX.append(poly.normal[0])\\n tabNormalY.append(poly.normal[1])\\n tabNormalZ.append(poly.normal[2])\\n tabFaces.append(0)\\n \\n tabPoint1X.append(tabVertices[poly.vertices[0]].x)\\n tabPoint1Y.append(tabVertices[poly.vertices[0]].y)\\n tabPoint2X.append(tabVertices[poly.vertices[1]].x)\\n tabPoint2Y.append(tabVertices[poly.vertices[1]].y)\\n tabPoint3X.append(tabVertices[poly.vertices[2]].x)\\n tabPoint3Y.append(tabVertices[poly.vertices[2]].y)\\n tabPoint1Z.append(tabVertices[poly.vertices[0]].z)\\n tabPoint2Z.append(tabVertices[poly.vertices[1]].z)\\n tabPoint3Z.append(tabVertices[poly.vertices[2]].z)\\n\\n print(len(tabPoly)) \\n\\n print(os.path.dirname(__file__))\\n # Get the filepath of the dll file\\n functionC = ctypes.CDLL(os.path.dirname(__file__) + \\\"\\\\\\\\function.dll\\\")\\n\\n # Create array for C function\\n seq = ctypes.c_int * len(tabPoly)\\n arrIndex = seq(*tabPoly)\\n\\n seq = ctypes.c_float * len(tabNormalX)\\n arrNormalX = seq(*tabNormalX)\\n seq = ctypes.c_float * len(tabNormalY)\\n arrNormalY = seq(*tabNormalY)\\n seq = ctypes.c_float * len(tabNormalZ)\\n arrNormalZ = seq(*tabNormalZ)\\n\\n seq = ctypes.c_int * len(tabFaces)\\n arrFaces = seq(*tabFaces)\\n\\n seq = ctypes.c_float * len(tabPoint1X)\\n arrPoint1X = seq(*tabPoint1X)\\n seq = ctypes.c_float * len(tabPoint1Y)\\n arrPoint1Y = seq(*tabPoint1Y)\\n seq = ctypes.c_float * len(tabPoint2X)\\n arrPoint2X = seq(*tabPoint2X)\\n seq = ctypes.c_float * len(tabPoint2Y)\\n arrPoint2Y = seq(*tabPoint2Y)\\n seq = ctypes.c_float * len(tabPoint3X)\\n arrPoint3X = seq(*tabPoint3X)\\n seq = ctypes.c_float * len(tabPoint3Y)\\n arrPoint3Y = seq(*tabPoint3Y)\\n seq = ctypes.c_float * len(tabPoint1Z)\\n arrPoint1Z = seq(*tabPoint1Z)\\n seq = ctypes.c_float * len(tabPoint2Z)\\n arrPoint2Z = seq(*tabPoint2Z)\\n seq = ctypes.c_float * len(tabPoint3Z)\\n arrPoint3Z = seq(*tabPoint3Z)\\n\\n date_3 = datetime.datetime.now()\\n \\n # Call the C function\\n functionC.select_faces(arrIndex,len(tabPoly),arrNormalX,arrNormalY,arrNormalZ,ctypes.c_float(maxAngle),ctypes.c_float(vecDir.x),ctypes.c_float(vecDir.y),ctypes.c_float(vecDir.z),arrFaces,arrPoint1X,arrPoint1Y,arrPoint2X,arrPoint2Y,arrPoint3X,arrPoint3Y,arrPoint1Z,arrPoint2Z,arrPoint3Z)\\n\\n date_4 = datetime.datetime.now()\\n\\n # Switch in edit mode\\n bpy.ops.object.mode_set(mode = 'EDIT')\\n # Deselect all the faces\\n bpy.ops.mesh.select_all(action = 'DESELECT')\\n bpy.ops.mesh.select_mode(type=\\\"FACE\\\")\\n # Switch in object mode\\n bpy.ops.object.mode_set(mode = 'OBJECT')\\n\\n # Select all the faces needed support\\n for i in range(len(arrFaces)):\\n if arrFaces[i] == 1:\\n obj.data.polygons[tabPoly[i]].select = True\\n print(len(arrFaces))\\n \\n # Switch in edit mode\\n bpy.ops.object.mode_set(mode = 'EDIT')\\n print(\\\"End\\\")\\n\\n date_2 = datetime.datetime.now()\\n time_delta = (date_2 - date_1)\\n total_seconds = time_delta.total_seconds()\\n print(total_seconds)\\n \\n time_delta = (date_4 - date_3)\\n total_seconds = time_delta.total_seconds()\\n print(\\\"C time : \\\", total_seconds)\",\n \"def _evaluate(self, w, x, y, z):\\n if _isscalar(w):\\n w_pos = max(min(self.wSearchFunc(self.w_list, w), self.w_n - 1), 1)\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\\n else:\\n w_pos = self.wSearchFunc(self.w_list, w)\\n w_pos[w_pos < 1] = 1\\n w_pos[w_pos > self.w_n - 1] = self.w_n - 1\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n z_pos = self.zSearchFunc(self.z_list, z)\\n z_pos[z_pos < 1] = 1\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n i = w_pos # for convenience\\n j = x_pos\\n k = y_pos\\n l = z_pos\\n alpha = (w - self.w_list[i - 1]) / (self.w_list[i] - self.w_list[i - 1])\\n beta = (x - self.x_list[j - 1]) / (self.x_list[j] - self.x_list[j - 1])\\n gamma = (y - self.y_list[k - 1]) / (self.y_list[k] - self.y_list[k - 1])\\n delta = (z - self.z_list[l - 1]) / (self.z_list[l] - self.z_list[l - 1])\\n f = (1 - alpha) * (\\n (1 - beta)\\n * (\\n (1 - gamma) * (1 - delta) * self.f_values[i - 1, j - 1, k - 1, l - 1]\\n + (1 - gamma) * delta * self.f_values[i - 1, j - 1, k - 1, l]\\n + gamma * (1 - delta) * self.f_values[i - 1, j - 1, k, l - 1]\\n + gamma * delta * self.f_values[i - 1, j - 1, k, l]\\n )\\n + beta\\n * (\\n (1 - gamma) * (1 - delta) * self.f_values[i - 1, j, k - 1, l - 1]\\n + (1 - gamma) * delta * self.f_values[i - 1, j, k - 1, l]\\n + gamma * (1 - delta) * self.f_values[i - 1, j, k, l - 1]\\n + gamma * delta * self.f_values[i - 1, j, k, l]\\n )\\n ) + alpha * (\\n (1 - beta)\\n * (\\n (1 - gamma) * (1 - delta) * self.f_values[i, j - 1, k - 1, l - 1]\\n + (1 - gamma) * delta * self.f_values[i, j - 1, k - 1, l]\\n + gamma * (1 - delta) * self.f_values[i, j - 1, k, l - 1]\\n + gamma * delta * self.f_values[i, j - 1, k, l]\\n )\\n + beta\\n * (\\n (1 - gamma) * (1 - delta) * self.f_values[i, j, k - 1, l - 1]\\n + (1 - gamma) * delta * self.f_values[i, j, k - 1, l]\\n + gamma * (1 - delta) * self.f_values[i, j, k, l - 1]\\n + gamma * delta * self.f_values[i, j, k, l]\\n )\\n )\\n return f\",\n \"def search(self):\\n W = np.zeros((self.subsets.shape[0],)) \\n for i,E in enumerate(self.subsets):\\n self.graph.setV(E) # set the nodes to their values\\n W[i] = self.graph.computeW()\\n self.Ws = W\",\n \"def faces(self):\\r\\n \\r\\n faceset = set()\\r\\n for faset in self.SCFaset:\\r\\n for face in sub_lists(faset):\\r\\n faceset.add(tuple(face))\\r\\n return list(faceset)\",\n \"def cube_faces(xmin, xmax, ymin, ymax, zmin, zmax):\\n faces = []\\n\\n x, y = np.mgrid[xmin:xmax:3j, ymin:ymax:3j]\\n z = np.ones(y.shape) * zmin\\n faces.append((x, y, z))\\n\\n x, y = np.mgrid[xmin:xmax:3j, ymin:ymax:3j]\\n z = np.ones(y.shape) * zmax\\n faces.append((x, y, z))\\n\\n x, z = np.mgrid[xmin:xmax:3j, zmin:zmax:3j]\\n y = np.ones(z.shape) * ymin\\n faces.append((x, y, z))\\n\\n x, z = np.mgrid[xmin:xmax:3j, zmin:zmax:3j]\\n y = np.ones(z.shape) * ymax\\n faces.append((x, y, z))\\n\\n y, z = np.mgrid[ymin:ymax:3j, zmin:zmax:3j]\\n x = np.ones(z.shape) * xmin\\n faces.append((x, y, z))\\n\\n y, z = np.mgrid[ymin:ymax:3j, zmin:zmax:3j]\\n x = np.ones(z.shape) * xmax\\n faces.append((x, y, z))\\n\\n return faces\",\n \"def wires_from_face(self, face) -> Iterator[TopoDS_Wire]:\\n assert isinstance(face, Face)\\n return map(Wire, self._top_exp.wires_from_face(face.topods_shape()))\",\n \"def itercubes(self, **kwargs):\\n for ifuslot in self.fplane.ifuslots:\\n yield ifuslot, self.extract_ifu_sensitivity_cube(ifuslot, \\n **kwargs)\",\n \"def fight(self):\\n for j in range(self.num):\\n for i in range(self.num):\\n self.genepool[0][j].fight(self.genepool[1][i],self.gameOne)\\n self.genepool[1][j].fight(self.genepool[0][i],self.gameTwo)\\n for i in range(self.num):\\n self.genepool[0][i].fitness /= self.num\\n self.genepool[1][i].fitness /= self.num\",\n \"def box_faces(images):\\n return (_box_faces(image) for image in images)\",\n \"def detect_faces(self, img):\\n with tf.Graph().as_default():\\n gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=.7)\\n sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))\\n with sess.as_default():\\n pnet, rnet, onet = detect_face.create_mtcnn(sess, None)\\n\\n minsize = 20 # minimum size of face\\n threshold = [ 0.6, 0.7, 0.7 ] # three steps's threshold\\n factor = 0.709 # scale factor\\n\\n bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)\\n\\n nrof_faces = bounding_boxes.shape[0]\\n img_size = np.asarray(img.shape)[0:2]\\n\\n faces = []\\n faces_rects = []\\n\\n for i in range(nrof_faces):\\n det = bounding_boxes[i,0:4]\\n bb = np.zeros(4, dtype=np.int32)\\n bb[0] = np.maximum(det[0]-5/2, 0)\\n bb[1] = np.maximum(det[1]-5/2, 0)\\n bb[2] = np.minimum(det[2]+5/2, img_size[1])\\n bb[3] = np.minimum(det[3]+5/2, img_size[0])\\n faces.append(img[bb[1]:bb[3], bb[0]:bb[2], :])\\n faces_rects.append({'name': 'none', 'x': bb[0], 'y': bb[1], 'w': bb[2]-bb[0], 'h': bb[3]-bb[1]})\\n\\n return [img, faces, faces_rects]\",\n \"def colorVertsExceedingMaxInfs(mesh_list, max_infs=8, color=True):\\n vert_list = list()\\n for mesh in mesh_list:\\n vc = (cmds.polyEvaluate(mesh, v=1)) + 1\\n sc = getSkinCluster(mesh)\\n\\n if sc:\\n for i in range(1, vc):\\n vtx = \\\"%s.vtx[%s]\\\" % (mesh, i)\\n vtx_jnts = cmds.skinPercent(sc, vtx, ignoreBelow=.001, q=1, t=None)\\n if vtx_jnts:\\n if len(vtx_jnts) > max_infs:\\n vert_list.append(vtx)\\n\\n if vert_list:\\n cmds.select(vert_list)\\n cmds.sets(name=\\\"Vertices_Exceeding_Max_Skin_Influences\\\")\\n LOG.warning(\\\"WARNING: Meshes in scene have vertices with more than {} influences!\\\".format(str(max_infs)))\\n\\n if color:\\n cmds.polyColorPerVertex(rgb=(1, 0, 0), cdo=1)\\n cmds.select(vert_list)\\n else:\\n LOG.info(\\\"All meshes in scene are within max skin influence per vertex range of {}\\\".format(str(max_infs)))\",\n \"def GetBoundaryLoops(self):\\n\\n self.__do_essential_memebers_exist__()\\n\\n if self.InferBoundaryElementType() != \\\"line\\\":\\n raise NotImplementedError(\\\"Computing boundary loops is only supported for tri/quad meshes for now\\\")\\n\\n self.GetEdges()\\n\\n # First create a node to neighbour map i.e. node as key and its two neighbouring nodes as value\\n nodeToNeighboursMap = dict()\\n for i in range(self.edges.shape[0]):\\n\\n if self.edges[i,0] not in nodeToNeighboursMap:\\n nodeToNeighboursMap[self.edges[i,0]] = [self.edges[i,1],-1]\\n else:\\n nodeToNeighboursMap[self.edges[i,0]][1] = self.edges[i,1]\\n\\n if self.edges[i,1] not in nodeToNeighboursMap:\\n nodeToNeighboursMap[self.edges[i,1]] = [self.edges[i,0],-1]\\n else:\\n nodeToNeighboursMap[self.edges[i,1]][1] = self.edges[i,0]\\n\\n # Now create a vector of face loops\\n faceLoops = []\\n while nodeToNeighboursMap:\\n # Insert the first node from node to edge map and its two neighbours in order and erase it from the map\\n faceLoop = []\\n mapBegin = next(iter(nodeToNeighboursMap))\\n faceLoop.append(nodeToNeighboursMap[mapBegin][0])\\n faceLoop.append(mapBegin)\\n faceLoop.append(nodeToNeighboursMap[mapBegin][1])\\n nodeToNeighboursMap.pop(mapBegin, None)\\n\\n while True:\\n # Pick the last node in the current face loop and find its neighbours\\n if faceLoop[-1] in nodeToNeighboursMap:\\n tmp = faceLoop[-1]\\n mapIter = nodeToNeighboursMap[faceLoop[-1]]\\n # Check if we have not reached the end of the loop i.e. the first element\\n if mapIter[0] != faceLoop[0] and mapIter[1] != faceLoop[0]:\\n if mapIter[0] == faceLoop[-2]:\\n faceLoop.append(mapIter[1])\\n elif mapIter[1] == faceLoop[-2]:\\n faceLoop.append(mapIter[0])\\n else:\\n nodeToNeighboursMap.pop(faceLoop[0], None)\\n\\n nodeToNeighboursMap.pop(tmp, None)\\n else:\\n faceLoop = np.array(faceLoop)\\n faceLoops.append(faceLoop)\\n break\\n\\n return faceLoops\",\n \"def fight(self):\\n for j in range(self.num):\\n for i in range(self.num):\\n self.genepool[0][j].fight(self.genepool[1][i],self.gameOne,self.len)\\n self.genepool[1][j].fight(self.genepool[0][i],self.gameTwo,self.len)\\n for i in range(self.num):\\n self.genepool[0][i].fitness /= self.num\\n self.genepool[1][i].fitness /= self.num\",\n \"def recogniseFace(self, imagefilenames, selectedFileName, selectedDirectory, numOfEigenfaces, thresholdVal):\\r\\n print 'recogniseFace()::'\\r\\n self.facet.checkCache(selectedDirectory, imagefilenames, numOfEigenfaces)\\r\\n mindist, matchfile = self.facet.findMatchingImage(selectedFileName, numOfEigenfaces, thresholdVal)\\r\\n self.processMatchResult(matchfile, mindist, numOfEigenfaces)\",\n \"def faces(self):\\n res = []\\n if(self.isFacesLoaded() == False):\\n return res\\n for face in self.getCurrentCacheData()['faces']:\\n face = Face().setJSONData(face)\\n if(face.confidence > self.faceDetector.confThreshold):\\n res.append(face)\\n return res\",\n \"def update(self,image):\\r\\n \\r\\n self._faces=[]\\r\\n \\r\\n if util.isgray(image):\\r\\n image=cv2.equalizeHist(image)\\r\\n \\r\\n else:\\r\\n \\r\\n image=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)\\r\\n cv2.equalizeHist(image,image)\\r\\n \\r\\n minsize=util.widthheightdividedby(image,8)\\r\\n\\r\\n \\r\\n\\r\\n \\r\\n facerect=self._faceclassifier.detectMultiScale(image,\\r\\n self.scalefactor,\\r\\n self.minneighbors,\\r\\n self.flags,\\r\\n minsize)\\r\\n \\r\\n \\\"\\\"\\\"if facerects is not None:\\r\\n \\r\\n for facerect in facerects:\\r\\n face=face()\\r\\n \\r\\n face.facerect=facerect\\r\\n \\r\\n \\r\\n x,y,w,h=facerect\\r\\n \\r\\n # Seek an eye in the upper-left part of the face. \\r\\n searchRect = (x+w/7, y, w*2/7, h/2) \\r\\n face.leftEyeRect = self._detectOneObject( \\r\\n self._eyeClassifier, image, searchRect, 64) \\r\\n \\r\\n \\r\\n \\r\\n # Seek an eye in the upper-right part of the face. \\r\\n searchRect = (x+w*4/7, y, w*2/7, h/2) \\r\\n face.rightEyeRect = self._detectOneObject( \\r\\n self._eyeClassifier, image, searchRect, 64) \\r\\n \\r\\n \\r\\n \\r\\n # Seek a nose in the middle part of the face. \\r\\n searchRect = (x+w/4, y+h/4, w/2, h/2) \\r\\n face.noseRect = self._detectOneObject( \\r\\n self._noseClassifier, image, searchRect, 32) \\r\\n \\r\\n # Seek a mouth in the lower-middle part of the face. \\r\\n searchRect = (x+w/6, y+h*2/3, w*2/3, h/3) \\r\\n face.mouthRect = self._detectOneObject( \\r\\n self._mouthClassifier, image, searchRect, 16) \\r\\n \\r\\n \\r\\n \\r\\n self._faces.append(face)\\r\\n\\r\\n \\r\\n \\r\\n def _detectoneobject(self,\\r\\n classifier,\\r\\n image,\\r\\n rect,\\r\\n imagesizetominsizeratio):\\r\\n \\r\\n x ,y ,w ,h=rect\\r\\n \\r\\n minsize=util.widthheightdividedby(image,\\r\\n imagesizetominsizeratio)\\r\\n \\r\\n subimage=image[y:y+h,x:x+w]\\r\\n \\r\\n subrect=classifier.dectectMultiScale(subimage,\\r\\n self.scalefactor,\\r\\n self.minneighbors,\\r\\n self.flags,\\r\\n minsize)\\r\\n \\r\\n if len(subrect)==0:\\r\\n return None\\r\\n \\r\\n subx,suby,subw,subh=subrects[0]\\r\\n \\r\\n return (x+subx,y+suby,w+subw,h+subh)\\r\\n \\r\\n \\\"\\\"\\\"\",\n \"def faces_only(self):\\n return self._faces_only\",\n \"def iter_wfaces(self, world: bool = True, detail: bool = True) -> Iterator['Side']:\\n for brush in self.iter_wbrushes(world, detail):\\n yield from brush\",\n \"def buildFaces(self):\\n for fi in range(len(self.poly1.faces)):\\n f = self.poly1.faces[fi]\\n for vi in range(len(f.vertices)):\\n v = f.vertices[vi]\\n if self.getIntersector(v) is not None and not v.isMarkedFor(f):\\n self.faceTrace(1, fi, vi)\\n v = f.vertices[0]\\n if v.isInterior() and not v.isMarkedFor(f):\\n interiorFaceTrace(f)\\n for fi in range(len(self.poly2.faces)):\\n f = self.poly2.faces[fi]\\n for vi in range(len(f.vertices)):\\n v = f.vertices[vi]\\n if self.getIntersector(v) is not None and not v.isMarkedFor(f) :\\n self.faceTrace(2, fi, vi)\\n v = f.vertices[0]\\n if v.isInterior() and not v.isMarkedFor(f):\\n interiorFaceTrace(f)\",\n \"def update(self):\\n self.w = len(set([y for sublist in [self.ckt[x].fins for x in self.frontier if len(self.ckt[x].fins) > 0] for y in sublist]))\\n self.output = set([x for x in self.members if len(self.ckt[x].fots) == 0])\\n self.max_w = self.w\",\n \"def map_face(self):\\n #Array Order: U0,D1,R2,L3,F4,B5,\\n \\n cube_list = []\\n cube_list = self.cube.definition()\\n \\n for index, cubit in enumerate(self.faces['Up']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index]])\\n for index, cubit in enumerate(self.faces['Ri']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+9]])\\n for index, cubit in enumerate(self.faces['Ft']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+18]])\\n for index, cubit in enumerate(self.faces['Dn']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+27]])\\n for index, cubit in enumerate(self.faces['Le']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+36]])\\n for index, cubit in enumerate(self.faces['Bk']):\\n self.canvas.itemconfig(cubit,fill=self.face_colours[cube_list[index+45]])\",\n \"def euler(faces, edges, verticies):\\n\\n # Return the calculated value\\n return verticies + edges - faces\",\n \"def fr(self):\\n return np.sum([filt.fr for filt in self.filters], axis=0)\",\n \"def get_faces(self, img):\\n results = self.detect_and_draw(img, False)\\n (width, height) = cv.GetSize(img)\\n for result in results:\\n self.add_property('name', 'face')\\n self.add_property('pixel_location', result[0])\\n self.add_property('relative_location', (float(result[0][0]) / width, float(result[0][1]) / height))\\n self.add_property('angle_and_distance', result[1])\\n self.add_property('face_area', result[2])\\n self.add_property('width', result[4])\\n self.add_property('height', result[5])\\n self.add_property('relative_face_area', (float(result[2]) / (width * height)))\\n self.add_property('confidence', result[3])\\n self.add_property('dimensions', (width, height))\\n self.add_property('rotation', self.rotation)\\n self.store_observation()\",\n \"def detectFaces_allFiles(directory):\\n files_list = glob.glob(directory)\\n for file in files_list:\\n print(file)\\n img = cv2.imread(file)\\n if img is not None:\\n height, width, channel = img.shape\\n faces = face_cascade.detectMultiScale(img, 1.3, 5)\\n age = find_age(file)\\n\\n if age >= 0:\\n if faces != ():\\n for (x, y, w, h) in faces:\\n # On decale y vers le haut pour mieux centrer le visage\\n if y - int(0.1*h) >= 0:\\n y -= int(0.1*h)\\n h *= 1.2\\n else:\\n h += y + int(0.1*h)\\n y = 0\\n if h > width:\\n h = width\\n # A partir de l'origine du visage (point en haut a gauche), on definit\\n # notre carre, de cote le nouveau h\\n if x + 0.8*h > width:\\n x_right = width\\n x_left = width - int(h)\\n elif x - 0.2*h < 0:\\n x_left = 0\\n x_right = int(h)\\n else:\\n x_right = min(int(x) + int(0.8*h), int(width))\\n x_left = int(x_right) - int(h)\\n y_top = int(y)\\n y_bottom = int(y) + int(h)\\n roi_color = img[y_top:y_bottom, x_left:x_right]\\n cv2.imwrite(\\\"./FacePhoto/{}.jpg\\\".format(extract_filename(file)), resize_image(roi_color, 227))\\n else:\\n files_list.remove(file)\\n else:\\n files_list.remove(file)\\n cv2.destroyAllWindows()\\n return files_list\",\n \"def _box_faces(image):\\n for face in image.faces:\\n _box_face(image, face)\\n return image\",\n \"def detect_faces(self, img) -> list:\\r\\n if img is None or not hasattr(img, \\\"shape\\\"):\\r\\n raise InvalidImage(\\\"Image not valid.\\\")\\r\\n\\r\\n height, width, _ = img.shape\\r\\n stage_status = StageStatus(width=width, height=height)\\r\\n\\r\\n m = 12 / self._min_face_size\\r\\n min_layer = np.amin([height, width]) * m\\r\\n\\r\\n scales = self.__compute_scale_pyramid(m, min_layer)\\r\\n\\r\\n stages = [self.__stage1, self.__stage2, self.__stage3]\\r\\n result = [scales, stage_status]\\r\\n\\r\\n # We pipe here each of the stages\\r\\n for stage in stages:\\r\\n result = stage(img, result[0], result[1])\\r\\n\\r\\n [total_boxes, points] = result\\r\\n\\r\\n bounding_boxes = []\\r\\n\\r\\n for bounding_box, keypoints in zip(total_boxes, points.T):\\r\\n x = max(0, int(bounding_box[0]))\\r\\n y = max(0, int(bounding_box[1]))\\r\\n width = int(bounding_box[2] - x)\\r\\n height = int(bounding_box[3] - y)\\r\\n bounding_boxes.append({\\r\\n 'box': [x, y, width, height],\\r\\n 'confidence': bounding_box[-1],\\r\\n 'keypoints': {\\r\\n 'left_eye': (int(keypoints[0]), int(keypoints[5])),\\r\\n 'right_eye': (int(keypoints[1]), int(keypoints[6])),\\r\\n 'nose': (int(keypoints[2]), int(keypoints[7])),\\r\\n 'mouth_left': (int(keypoints[3]), int(keypoints[8])),\\r\\n 'mouth_right': (int(keypoints[4]), int(keypoints[9])),\\r\\n }\\r\\n })\\r\\n\\r\\n return bounding_boxes\",\n \"def RemovedFaces(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_RemoveInternalWires_RemovedFaces(self, *args)\",\n \"def triangulate_all_faces(\\n self,\\n triangle_face_tol=0.01, # Tolerance between triangle and surface\\n tol_relative_to_face=True, # The tolerance value is relative to the face size\\n angle_tol_rads=0.1, # Angle between normals/tangents at triangle vertices\\n ):\\n mesh = BRepMesh_IncrementalMesh(\\n self.topods_shape(),\\n triangle_face_tol,\\n tol_relative_to_face,\\n angle_tol_rads,\\n True,\\n )\\n mesh.Perform()\\n return mesh.IsDone()\",\n \"def step(self, model):\\n weights = []\\n if (self.prune_scope == 'global'):\\n # First collect all weights\\n for step, (name, param) in enumerate(self.prune_parameters):\\n scale = 1\\n # Pointer to the original tensor\\n tensor = param.data#.cpu().numpy()\\n # Gradient-based selection\\n if (self.prune_selection == 'gradient_max'):\\n grad = param.grad#.cpu().numpy()\\n tensor = grad[torch.nonzero(tensor, as_tuple=True)]#np.nonzero(tensor)]\\n elif (self.prune_selection == 'gradient_min'):\\n grad = 1 / (torch.abs(param.grad) + 1e-7) #.cpu().numpy()\\n tensor = grad[torch.nonzero(tensor, as_tuple=True)]#np.nonzero(tensor)]\\n #tensor = torch.abs(torch.max(tensor) - tensor) #np.max(tensor) - tensor\\n # Retrieve non-pruned weights\\n if (self.prune_scale == 'dimension'):\\n scale = tensor.size\\n if (self.prune_scale == 'normalize'):\\n scale = torch.max(torch.abs(tensor))#np.max(np.abs(tensor))\\n if (self.prune_scale == 'xavier'):\\n scale = 1.0 / np.sqrt(2.0 / tensor.shape[0] + tensor.shape[1])\\n alive = tensor[torch.nonzero(tensor, as_tuple=True)]#np.nonzero(tensor)]\\n alive /= scale \\n # Add to global weights\\n weights.append(alive)\\n # Flatten the whole weights\\n weights = torch.cat(weights)#np.concatenate(weights)\\n value = abs(weights)\\n # Compute global percentile\\n percentile_value = torch_percentile(value, self.percent) #np.percentile(value, self.percent)\\n # Now apply the global or compute local factor\\n for step, (name, param) in enumerate(self.prune_parameters):\\n scale = 1\\n # Pointer to the original tensor\\n tensor = param.data #.cpu().numpy()\\n # Gradient-based selection\\n if (self.prune_selection == 'gradient_max'):\\n tensor = param.grad#.cpu().numpy()\\n elif (self.prune_selection == 'gradient_min'):\\n tensor = 1.0 / (torch.abs(param.grad) + 1e-7)#np.abs(param.grad.cpu().numpy())\\n #tensor = torch.abs(torch.max(tensor) - tensor) #np.max(tensor) - tensor\\n # Compute scaling\\n if (self.prune_scale == 'dimension'):\\n scale = tensor.size\\n if (self.prune_scale == 'normalize'):\\n scale = torch.max(torch.abs(tensor)) #np.max(np.abs(tensor))\\n if (self.prune_scale == 'xavier'):\\n scale = 1.0 / np.sqrt(2.0 / tensor.shape[0] + tensor.shape[1])\\n local_weights = tensor\\n local_weights /= scale\\n # We do not prune bias term\\n if (self.prune_scope == 'local'):\\n weights = tensor[torch.nonzero(param.data, as_tuple=True)] #tensor[np.nonzero(tensor)]\\n # Retrieve non-pruned weights\\n value = abs(weights)\\n # Compute global percentile\\n percentile_value = torch_percentile(value, self.percent)\\n # Use the selection function to compute mask\\n new_mask = PruningMasking.ranking(self, name, local_weights, percentile_value, self.mask[step])\\n # Store the computed mask\\n self.mask[step] = new_mask\\n step = 0\\n return model\",\n \"def computeBoundaryFaces(elemsF, facesN):\\n # Sort indexes and add 1 position in order to use indexes as Matlab\\n A0 = np.sort(elemsF[:, 0]) + 1\\n I0 = np.argsort(elemsF[:, 0]) + 1\\n A1 = np.sort(elemsF[:, 1]) + 1\\n I1 = np.argsort(elemsF[:, 1]) + 1\\n A2 = np.sort(elemsF[:, 2]) + 1\\n I2 = np.argsort(elemsF[:, 2]) + 1\\n A3 = np.sort(elemsF[:, 3]) + 1\\n I3 = np.argsort(elemsF[:, 3]) + 1\\n\\n # Number of faces\\n nFaces = elemsF.max()\\n\\n # As consequence, dimensions of E must be increased\\n # 2 rows and 1 column\\n E = np.zeros((nFaces+2, 9))\\n\\n E[A0, 1] = I0\\n E[A1, 2] = I1\\n E[A2, 3] = I2\\n E[A3, 4] = I3\\n\\n # If the same face is listed in the same row of 'elemsF'\\n # more than, once it will simply be missed! Because of this we\\n # have to insert the following dummy variables in order to\\n # determine the boundary faces.\\n tmp = np.diff(A0) == 0\\n ind0 = np.where(tmp)[False]\\n tmp = np.diff(A1) == 0\\n ind1 = np.where(tmp)[False]\\n tmp = np.diff(A2) == 0\\n ind2 = np.where(tmp)[False]\\n tmp = np.diff(A3) == 0\\n ind3 = np.where(tmp)[False]\\n\\n E[A0[ind0], 5] = 1\\n E[A1[ind1], 6] = 1\\n E[A2[ind2], 7] = 1\\n E[A3[ind3], 8] = 1\\n\\n # Delete extra rows and column\\n E = np.delete(E, (0), axis=0)\\n E = np.delete(E, (0), axis=1)\\n\\n # Final sorting\\n E.sort()\\n E = np.fliplr(E)\\n\\n # Get boundary nodes by first examining which columns in E\\n # have only one nonzero element, meaning that this face is\\n # related to only one single tetra, which means it is on the\\n # boundary of the domain. Since faces are defined by their nodes,\\n # we have the boundary nodes too.\\n # Get boundary faces to nodes\\n ind = (E[:, 1] == 0)\\n bfacesN = np.array(np.transpose(facesN[ind, :]), dtype=np.int)\\n\\n # Get indexes of boundary faces\\n ind = np.where(ind == True)\\n bFaces = np.array(np.transpose(ind), dtype=np.int)\\n size = bFaces.shape\\n nBoundaryFaces = size[0]\\n bFaces = bFaces.reshape((nBoundaryFaces))\\n\\n return bfacesN, bFaces, nBoundaryFaces\",\n \"def GetSelectedUVFaces_InEditMode(bmeshref, uvlayer):\\r\\n cont = 0\\r\\n selecteduvfaces = []\\r\\n for face in bmeshref.faces:\\r\\n thisFaceSelected = True\\r\\n for vert in face.loops:\\r\\n if vert[uvlayer].select == False:\\r\\n thisFaceSelected = False\\r\\n \\r\\n if thisFaceSelected == True:\\r\\n selecteduvfaces.append(cont)\\r\\n cont += 1\\r\\n return selecteduvfaces\",\n \"def findfeatures(self):\\n self.set_wdiff()\\n\\n #xp, wp=st.findfeatures(self.xarr, self.farr, self.slines, self.sfluxes,\\n # self.ws, mdiff=self.mdiff, wdiff=self.wdiff, sigma=self.sigma, niter=self.niter, sections=3)\\n xp,wp=st.crosslinematch(self.xarr, self.farr, self.slines, self.sfluxes,\\n self.ws, mdiff=self.mdiff, wdiff=20, sigma=self.sigma, niter=self.niter)\\n for x, w in zip(xp, wp):\\n if w not in self.wp and w>-1: \\n self.xp.append(x)\\n self.wp.append(w)\\n self.plotFeatures()\\n self.redraw_canvas()\",\n \"def get_factors(self, triples):\\n pass\",\n \"def computeFacePlane(nodes, bFaces, bFacesN):\\n # Number of boundary faces\\n nBndFaces = np.size(bFaces)\\n\\n # Get computational domain limits\\n min_x = np.min(nodes[:,0])\\n max_x = np.max(nodes[:,0])\\n min_y = np.min(nodes[:,1])\\n max_y = np.max(nodes[:,1])\\n min_z = np.min(nodes[:,2])\\n max_z = np.max(nodes[:,2])\\n\\n # Set plane equation for each side\\n # We consider following configuration:\\n\\n # g ------------- h\\n # /| /| where:\\n # / | / | a = [min_x, min_y, min_z]\\n # / | / | b = [max_x, min_y, min_z]\\n # / | / | c = [min_x, max_y, min_z]\\n # e --------------f | d = [max_x, max_y, min_z]\\n # | | | | e = [min_x, min_y, max_z]\\n # | |c --------|----|d f = [max_x, min_y, max_z]\\n # | / | / g = [min_x, max_y, max_z]\\n # | / | / h = [max_x, max_y, max_z]\\n # | / | /\\n # a ------------- b\\n\\n # With xyz-axis:\\n # Z+ Y+\\n # | /\\n # | /\\n # |/\\n # ------X+\\n\\n # Therefore, each plane of the cube is defined by two vectors:\\n # Bottom: ab, ac ---> flag: 0\\n # Left: ac, ae ---> flag: 1\\n # Front: ab, ae ---> flag: 2\\n # Rigth: bd, bf ---> flag: 3\\n # Back: dc, dh ---> flag: 4\\n # Top: ef, eg ---> flag: 5\\n\\n # Initialize main points\\n a = np.array([min_x, min_y, min_z], np.float)\\n b = np.array([max_x, min_y, min_z], np.float)\\n c = np.array([min_x, max_y, min_z], np.float)\\n d = np.array([max_x, max_y, min_z], np.float)\\n e = np.array([min_x, min_y, max_z], np.float)\\n f = np.array([max_x, min_y, max_z], np.float)\\n g = np.array([min_x, max_y, max_z], np.float)\\n h = np.array([max_x, max_y, max_z], np.float)\\n\\n # Compute normal vectors to planes\\n normal_bottom = np.cross(a-b, a-c)\\n normal_left = np.cross(a-c, a-e)\\n normal_front = np.cross(a-b, a-e)\\n normal_right = np.cross(b-d, b-f)\\n normal_back = np.cross(d-c, d-h)\\n normal_top = np.cross(e-f, e-g)\\n\\n # Allocate space for tag plane\\n planeFace = np.zeros(nBndFaces, dtype=np.int)\\n plane_list = np.zeros(6, dtype=np.float)\\n\\n # Solve plane equation for each boundary face\\n for i in np.arange(nBndFaces):\\n # Get nodes of face\\n faceNodes = nodes[bFacesN[:,i],:]\\n\\n # Compute face centroid\\n centroid = np.sum(faceNodes, 0)/3.\\n\\n # Solve equation for bottom plane\\n plane_list[0] = np.dot(normal_bottom, centroid-a)\\n # Solve equation for left plane\\n plane_list[1] = np.dot(normal_left, centroid-a)\\n # Solve equation for front plane\\n plane_list[2] = np.dot(normal_front, centroid-a)\\n # Solve equation for right plane\\n plane_list[3] = np.dot(normal_right, centroid-b)\\n # Solve equation for back plane\\n plane_list[4] = np.dot(normal_back, centroid-d)\\n # Solve equation for top plane\\n plane_list[5] = np.dot(normal_top, centroid-e)\\n # Get to what plane the face belongs\\n # Flags for faces:\\n # Bottom ---> flag: 0\\n # Left ---> flag: 1\\n # Front ---> flag: 2\\n # Rigth ---> flag: 3\\n # Back ---> flag: 4\\n # Top ---> flag: 5\\n planeFace[i] = np.where(np.abs(plane_list)<1.e-13)[0][0]\\n\\n return planeFace\",\n \"def refineMesh(cls, meshrefinement, options):\\n refineElementsCountAround = options['Refine number of elements around']\\n refineElementsCountAlong = options['Refine number of elements along']\\n refineElementsCountThroughWall = options['Refine number of elements through wall']\\n\\n meshrefinement.refineAllElementsCubeStandard3d(refineElementsCountAround, refineElementsCountAlong,\\n refineElementsCountThroughWall)\\n return\",\n \"def test_vs_filtering():\\n vs = virtualscreening(n_cpu=-1)\\n\\n vs.load_ligands('sdf', os.path.join(test_data_dir, 'data/dude/xiap/actives_docked.sdf'))\\n vs.apply_filter('ro5', soft_fail=1)\\n assert_equal(len(list(vs.fetch())), 49)\\n\\n vs.load_ligands('sdf', os.path.join(test_data_dir, 'data/dude/xiap/actives_docked.sdf'))\\n vs.apply_filter('ro3', soft_fail=2)\\n assert_equal(len(list(vs.fetch())), 9)\",\n \"def get_faces(image):\\n return (image.crop(face) for face in image.faces)\",\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 evaluate(self):\\n #fac o lista cu toate perechile si vad daca se repeta vreuna (pana acum)\\n nr=0\\n \\n pairs = []\\n for i in range(0,self.__size):\\n for j in range(0, self.__size):\\n if self.__solution[i] != [] and self.__solution[i+self.__size] != [] : #sa am de unde face perechea\\n p=[]\\n p.append(self.__solution[i][j])\\n p.append(self.__solution[i+self.__size][j])\\n pairs.append(p)\\n for p in pairs:\\n if pairs.count(p) == 1:\\n nr += 1\\n\\n return self.__size*self.__size - nr + 1 # pun acel +1 ca sa nu fie 0 niciodata -> ca sa nu am probleme la impartire\\n # la 0 mai incolo\\n #return nr\",\n \"def loading_faces(source_image_set_path, dest_image_set_path, source_image_set):\\n dimensions_of_img = find_dimensions_not_attentive_imgs\\n if 'attentive' in dest_image_set_path:\\n dimensions_of_img = find_dimensions_attentive_imgs\\n for image_name in source_image_set:\\n\\n # loading gray image\\n gray_image = cv2.imread(source_image_set_path + \\\"/\\\" + image_name, 0)\\n\\n # find co-ordinates of faces in images\\n y1, x2, y2, x1 = dimensions_of_img(*face_recognition.face_locations(gray_image)[0], np.shape(gray_image))\\n\\n # crop image and resize to particular dimension\\n crop_img = gray_image[y1:y2, x1:x2]\\n resize_crop_img = cv2.resize(crop_img, (int(dimension[0:3]), int(dimension[0:3])))\\n\\n # load images from source to destination directory\\n cv2.imwrite(dest_image_set_path + \\\"/\\\" + image_name, resize_crop_img)\",\n \"def check_nfaces(sections):\\n return _check_nentries(sections, \\\"NFACES\\\", \\\"FACES\\\")\",\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 GetBoundaryFacesTet(self):\\n\\n p = self.InferPolynomialDegree()\\n\\n # DO NOT COMPUTE IF ALREADY COMPUTED\\n if isinstance(self.faces,np.ndarray):\\n if self.faces.shape[0] > 1:\\n # IF LINEAR VERSION IS COMPUTED, DO COMPUTE HIGHER VERSION\\n if self.faces.shape[1] == 3 and p > 1:\\n pass\\n else:\\n return\\n\\n node_arranger = NodeArrangementTet(p-1)[0]\\n\\n # CONCATENATE ALL THE FACES MADE FROM ELEMENTS\\n all_faces = np.concatenate((self.elements[:,:3],self.elements[:,[0,1,3]],\\n self.elements[:,[0,2,3]],self.elements[:,[1,2,3]]),axis=0)\\n # GET UNIQUE ROWS\\n uniques, idx, inv = unique2d(all_faces,consider_sort=True,order=False,return_index=True,return_inverse=True)\\n\\n # ROWS THAT APPEAR ONLY ONCE CORRESPOND TO BOUNDARY FACES\\n freqs_inv = itemfreq(inv)\\n faces_ext_flags = freqs_inv[freqs_inv[:,1]==1,0]\\n # NOT ARRANGED\\n self.faces = uniques[faces_ext_flags,:]\\n\\n # DETERMINE WHICH FACE OF THE ELEMENT THEY ARE\\n boundary_face_to_element = np.zeros((faces_ext_flags.shape[0],2),dtype=np.int64)\\n # THE FOLLOWING WILL COMPUTE FACES BASED ON SORTING AND NOT TAKING INTO ACCOUNT\\n # THE ELEMENT CONNECTIVITY\\n # boundary_face_to_element[:,0] = np.remainder(idx[faces_ext_flags],self.elements.shape[0])\\n # boundary_face_to_element[:,1] = np.floor_divide(idx[faces_ext_flags],self.elements.shape[0])\\n # OR EQUIVALENTLY\\n # boundary_face_to_element[:,0] = idx[faces_ext_flags] % self.elements.shape[0]\\n # boundary_face_to_element[:,1] = idx[faces_ext_flags] // self.elements.shape[0]\\n\\n # FURTHER RE-ARRANGEMENT / ARANGE THE NODES BASED ON THE ORDER THEY APPEAR\\n # IN ELEMENT CONNECTIVITY\\n # THIS STEP IS NOT NECESSARY INDEED - ITS JUST FOR RE-ARANGMENT OF FACES\\n all_faces_in_faces = in2d(all_faces,self.faces,consider_sort=True)\\n all_faces_in_faces = np.where(all_faces_in_faces==True)[0]\\n\\n # boundary_face_to_element = np.zeros((all_faces_in_faces.shape[0],2),dtype=np.int64)\\n boundary_face_to_element[:,0] = all_faces_in_faces % self.elements.shape[0]\\n boundary_face_to_element[:,1] = all_faces_in_faces // self.elements.shape[0]\\n\\n # ARRANGE FOR ANY ORDER OF BASES/ELEMENTS AND ASSIGN DATA MEMBERS\\n self.faces = self.elements[boundary_face_to_element[:,0][:,None],node_arranger[boundary_face_to_element[:,1],:]]\\n self.faces = self.faces.astype(np.uint64)\\n self.boundary_face_to_element = boundary_face_to_element\",\n \"def get_factors():\",\n \"def populateFaces(matrix, indexRef, noiseLevel):\\n for face in faces:\\n setValue(matrix, face, indexRef, noiseLevel)\",\n \"def factors(self):\\n self.assert_sampled()\\n return self._factors\",\n \"def compute_relations(self):\\n\\n visible_nodes = {}\\n\\n self.cameras = self.get_all_cameras()\\n rospy.logdebug(self.cameras)\\n\\n if self.cameras.items():\\n try:\\n if self.visibility_monitor is None:\\n self.visibility_monitor = VisibilityMonitor(self.ctx, self.source)\\n rospy.loginfo(\\\"[perspective_filter] Visibility monitor now running, please active the Pygame windows.\\\")\\n visible_nodes = self.visibility_monitor.compute_all()\\n rospy.logdebug(\\\"[perspective_filter] %d perspectives computed \\\" % len(visible_nodes))\\n #rospy.logdebug(visible_nodes)\\n except Exception as e:\\n rospy.logwarn(\\\"[perspective_filter] Exception occurred while computing relation : %s\\\" % str(e))\\n if self.visibility_monitor:\\n self.visible_nodes = {} #visible_nodes\\n for camera_name, visibles_obj in visible_nodes.items():\\n camera_id = self.source.scene.nodebyname(camera_name)[0].id\\n self.visible_nodes[camera_id] = visibles_obj\\n for node in visibles_obj:\\n if node.parent in self.cameras.keys():\\n if self.source.scene.nodes[node.parent] not in visibles_obj:\\n visibles_obj.append(self.source.scene.nodes[node.parent])\\n\\n for agent_id, nodes_seen in self.visible_nodes.items():\\n agent = self.source.scene.nodes[agent_id]\\n for node in nodes_seen:\\n if agent_id in self.previously_visible_nodes:\\n if node not in self.previously_visible_nodes[agent_id]:\\n self.start_predicate(self.source.timeline, \\\"isVisibleBy\\\", node.name, object_name=agent.name)\\n else:\\n self.start_predicate(self.source.timeline, \\\"isVisibleBy\\\", node.name, object_name=agent.name)\\n\\n for agent_id, nodes_previously_seen in self.previously_visible_nodes.items():\\n agent = self.source.scene.nodes[agent_id]\\n for node in nodes_previously_seen:\\n if agent_id in self.visible_nodes:\\n if node not in self.visible_nodes[agent_id]:\\n self.end_predicate(self.source.timeline, \\\"isVisibleBy\\\", node.name, object_name=agent.name)\\n else:\\n self.end_predicate(self.source.timeline, \\\"isVisibleBy\\\", node.name, object_name=agent.name)\\n\\n self.publish_perspectives()\\n self.previously_visible_nodes = self.visible_nodes\",\n \"def clear_face(self):\\n rospy.loginfo('clearing all learned faces')\\n self._clear_srv()\",\n \"def select_area(minArea): \\n # Switch in edit mode \\n bpy.ops.object.mode_set(mode='EDIT')\\n \\n # Deselect everything\\n bpy.ops.mesh.select_all(action=\\\"DESELECT\\\")\\n \\n # Load mesh\\n me = bpy.context.edit_object.data\\n bm = bmesh.from_edit_mesh(me)\\n # Ensure internal data needed for int subscription is initialized\\n bm.faces.ensure_lookup_table()\\n\\n # Array containing the different areas\\n loops = []\\n faces = bm.faces\\n\\n # Loop for detect multiple areas\\n while faces:\\n faces[0].select_set(True) # Select 1st face\\n bpy.ops.mesh.select_linked() # Select all linked faces makes a full loop\\n loops.append([f.index for f in faces if f.select])\\n bpy.ops.mesh.hide(unselected=False) # Hide the detected loop\\n faces = [f for f in bm.faces if not f.hide] # Update faces\\n\\n # Unhide all faces\\n bpy.ops.mesh.reveal()\\n print(\\\"Mesh has {} parts\\\".format(len(loops)))\\n\\n print(\\\"\\\\nThe face lists are:\\\")\\n for loop in loops:\\n print(loop)\\n \\n # Switch in edit mode \\n bpy.ops.object.mode_set(mode='EDIT')\\n # Deselect everything\\n bpy.ops.mesh.select_all(action=\\\"DESELECT\\\")\\n # Switch in object mode\\n bpy.ops.object.mode_set(mode='OBJECT')\\n\\n # Loop to select areas are higher than the area min\\n area = 0 \\n for rows in range(len(loops)):\\n area = 0\\n for columns in loops[rows]:\\n # Calculate the area\\n area = area + bpy.context.active_object.data.polygons[columns].area\\n print(rows)\\n print(area)\\n print(minArea)\\n # Compare the area with the area min\\n if area > minArea:\\n for columns in loops[rows]:\\n # Select all the faces of the area\\n bpy.context.active_object.data.polygons[columns].select = True\\n\\n # Switch in edit mode \\n bpy.ops.object.mode_set(mode='EDIT')\",\n \"def prune_(self):\\n idx = self.factor_lams() > 0\\n self.factors = [f[:, idx] for f in self.factors]\\n self.rank = np.sum(idx)\",\n \"def forward(self, images):\\n features = self.resnet(images)\\n features = Variable(features.data)\\n features = self.pooling(features)\\n # print(features)\\n features = features.view(features.size(0),-1)\\n # print(features)\\n # print(resnet.fc.in_features)\\n features = self.bn(self.linear(features))\\n return features\\n # with torch.no_grad():\\n # features = self.resnet(images)\\n # features = features.reshape(features.size(0), -1)\\n # features = self.bn(self.linear(features))\\n # return features\",\n \"def ObserveEvidence(self,E):\\r\\n for f in self.factors:\\r\\n f.ObserveEvidence(E)\",\n \"def GetInteriorFacesTet(self):\\n\\n if not isinstance(self.all_faces,np.ndarray):\\n self.GetFacesTet()\\n if not isinstance(self.faces,np.ndarray):\\n self.GetBoundaryFacesTet()\\n\\n face_flags = in2d(self.all_faces.astype(self.faces.dtype),self.faces,consider_sort=True)\\n face_flags[face_flags==True] = 1\\n face_flags[face_flags==False] = 0\\n interior_faces = self.all_faces[face_flags==False,:]\\n\\n return interior_faces, face_flags\",\n \"def test_faces(self):\\n\\n self.test_shape.workplane = \\\"XY\\\"\\n self.test_shape.rotation_axis = \\\"Z\\\"\\n\\n assert self.test_shape.area == pytest.approx((((math.pi * (10**2)) * 2) + (math.pi * (10 * 2) * 100)) * 8)\\n assert len(self.test_shape.areas) == 24\\n assert self.test_shape.areas.count(pytest.approx(math.pi * (10**2))) == 16\\n assert self.test_shape.areas.count(pytest.approx(math.pi * (10 * 2) * 100)) == 8\",\n \"def evaluator(self, candidates, args):\\r\\n fitness = []\\r\\n if self._use_ants:\\r\\n for candidate in candidates:\\r\\n total = 0\\r\\n for c in candidate:\\r\\n total += self.weights[c.element[0]][c.element[1]]\\r\\n last = (candidate[-1].element[1], candidate[0].element[0])\\r\\n total += self.weights[last[0]][last[1]]\\r\\n fitness.append(1 / total)\\r\\n else:\\r\\n for candidate in candidates:\\r\\n total = 0\\r\\n for src, dst in zip(candidate, candidate[1:] + [candidate[0]]):\\r\\n total += self.weights[src][dst]\\r\\n fitness.append(1 / total)\\r\\n return fitness\",\n \"def check_constraints(labels, fws, propnames, criteria, MB=None, mapall=False):\\n\\n (min_area,\\n max_area,\\n max_intensity_mb,\\n max_eccentricity,\\n min_solidity,\\n min_euler_number,\\n min_extent) = criteria\\n\\n rp = regionprops(labels, intensity_image=MB, cache=True)\\n\\n for prop in rp:\\n\\n if mapall:\\n fws = set_fws(fws, prop, propnames, is_valid=True)\\n continue\\n\\n # TODO: ordering\\n if min_area is not None:\\n if prop.area < min_area:\\n fws = set_fws(fws, prop, propnames, is_valid=False)\\n continue\\n if max_area is not None:\\n if prop.area > max_area:\\n fws = set_fws(fws, prop, propnames, is_valid=False)\\n continue\\n if max_intensity_mb is not None:\\n if prop.mean_intensity > max_intensity_mb:\\n fws = set_fws(fws, prop, propnames, is_valid=False)\\n continue\\n if max_eccentricity is not None:\\n if prop.eccentricity > max_eccentricity:\\n fws = set_fws(fws, prop, propnames, is_valid=False)\\n continue\\n if min_solidity is not None:\\n if prop.solidity < min_solidity:\\n fws = set_fws(fws, prop, propnames, is_valid=False)\\n continue\\n if min_euler_number is not None:\\n if prop.euler_number < min_euler_number:\\n fws = set_fws(fws, prop, propnames, is_valid=False)\\n continue\\n if min_extent is not None:\\n if prop.extent < min_extent:\\n fws = set_fws(fws, prop, propnames, is_valid=False)\\n continue\\n\\n fws = set_fws(fws, prop, propnames, is_valid=True)\\n\\n return fws\",\n \"def evaluate_detections(self, all_boxes, output_dir=None):\\n raise NotImplementedError\",\n \"def mbieLoop (self) :\\n self.iterCnt = 0\\n while self.iterCnt < 5000:\\n s = self.mdp.s0\\n for h in range(self.H) :\\n self.QUpper = QBoundsSolver(self.mdp, self.PHat, self.QUpper, self.Ntotal, 0.1, True, self.stop)\\n a = np.argmax(self.QUpper[s])\\n s_, self.R[s,a] = self.mdp.step(s, a)\\n self.updateVisitStatistics(s, a, s_)\\n s = s_\\n\\n if self.iterCnt % 10 == 0: \\n print(self.iterCnt)\\n print(self.QUpper)\\n\\n self.iterCnt += 1\",\n \"def get_faces(self, image):\\n\\t\\t\\n\\t\\t# Convert the image to grayscale and normalise\\n\\t\\tcv.CvtColor(image, self.gray, cv.CV_BGR2GRAY)\\n\\t\\tcv.EqualizeHist(self.gray, self.gray)\\n\\t\\t\\n\\t\\t# Detect faces\\n\\t\\treturn cv.HaarDetectObjects(self.gray, self.cascade, self.storage,\\n\\t\\t scale_factor = 1.3,\\n\\t\\t min_neighbors = 2,\\n\\t\\t flags = cv.CV_HAAR_DO_CANNY_PRUNING,\\n\\t\\t min_size = (40,40))\",\n \"def island_aging(self):\\n for y in self.island_map:\\n for cell in y:\\n cell.aging()\",\n \"def get_faces():\\n detected_faces = request()\\n\\n if not detected_faces:\\n raise FaceNotDetectedError()\\n return detected_faces\",\n \"def compileIF_WFS(filebase='', vmax=10.0, ftype='h5'):\\n for idx in ax.cellmap:\\n measureIF_WFS(idx, N=1, volt=vmax, filebase=filebase, ftype=ftype)\",\n \"def execute(self):\\r\\n factors = self.factors\\r\\n variables = list(self.variables)\\r\\n variables.remove(self.query)\\r\\n\\r\\n for fac in factors:\\r\\n self.set_observations(fac)\\r\\n\\r\\n for var in variables:\\r\\n if var not in self.obs:\\r\\n factors = self.eliminate_variable(var, factors)\\r\\n\\r\\n result = factor_module.multiply_batch(self.query, factors)\\r\\n denominator = sum(result.get_cpt())\\r\\n print(denominator)\\r\\n return {val: pr / denominator for val, pr in zip([True, False], result.get_cpt())}\",\n \"def rook_neighbors_face(self, face):\\n edges = self.cw_face_edges(face)\\n return list(set([ self.left_region[edge] for edge in edges]))\",\n \"def __iter__(self):\\n for element in self.focals:\\n yield element\",\n \"def validate():\\n # Switch in object mode \\n bpy.ops.object.mode_set(mode='OBJECT')\\n \\n # Apply modifier\\n bpy.ops.object.apply_all_modifiers()\\n \\n # Get the active objec\\n obj = bpy.context.active_object\\n print(\\\"Number of faces\\\", len(obj.data.polygons))\",\n \"def count_oob(cube):\\n out_range = (cube > 4).any(1) | (cube < -4).any(1)\\n out_range = out_range.sum() / cube.shape[0]\\n return out_range\",\n \"def evaluate(self, gameState, action, ghosts):\\r\\n features = self.getFeatures(gameState, action)\\r\\n weights = self.getWeights(gameState, action)\\r\\n return features * weights\",\n \"def Clear(self, *args):\\n return _BRepAlgo.BRepAlgo_FaceRestrictor_Clear(self, *args)\",\n \"def getLiters(self):\\n return self._count/self._ppl\",\n \"def collect_best_features(self):\\n bincsp = self.binary_csp # just to make code shorter\\n n_folds = len(self.binary_csp.folds)\\n n_class_pairs = len(self.binary_csp.class_pairs)\\n result_shape = (n_folds, n_class_pairs)\\n self.train_feature = np.empty(result_shape, dtype=object)\\n self.train_feature_full_fold = np.empty(result_shape, dtype=object)\\n self.test_feature = np.empty(result_shape, dtype=object)\\n self.test_feature_full_fold = np.empty(result_shape, dtype=object)\\n self.selected_filters_per_filterband = np.empty(result_shape, dtype=object)\\n for fold_i in range(n_folds):\\n for class_pair_i in range(n_class_pairs):\\n bin_csp_train_features = deepcopy(bincsp.train_feature[\\n self.selected_filter_inds, fold_i, class_pair_i])\\n bin_csp_train_features_full_fold = deepcopy(\\n bincsp.train_feature_full_fold[\\n self.selected_filter_inds,\\n fold_i, class_pair_i])\\n bin_csp_test_features = deepcopy(bincsp.test_feature[\\n self.selected_filter_inds, fold_i, class_pair_i])\\n bin_csp_test_features_full_fold = deepcopy(\\n bincsp.test_feature_full_fold[\\n self.selected_filter_inds,fold_i, class_pair_i])\\n selected_filters_per_filt = self.select_best_filters_best_filterbands(\\n bin_csp_train_features, max_features=self.n_features,\\n forward_steps=self.forward_steps, \\n backward_steps=self.backward_steps,\\n stop_when_no_improvement=self.stop_when_no_improvement)\\n self.train_feature[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_train_features, selected_filters_per_filt)\\n self.train_feature_full_fold[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_train_features_full_fold, selected_filters_per_filt)\\n \\n self.test_feature[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_test_features, selected_filters_per_filt)\\n self.test_feature_full_fold[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_test_features_full_fold, selected_filters_per_filt)\\n \\n self.selected_filters_per_filterband[fold_i, class_pair_i] = \\\\\\n selected_filters_per_filt\",\n \"def return_factors(self):\\n if self.global_rank==0:print([i.shape for i in self.factors])\\n return self.factors\",\n \"def train(self):\\n\\n\\t\\tcentroids, x_assignee = self._init_centroid(data=self._train_x)\\n\\t\\tcount = 0\\n\\t\\t\\n\\t\\tprev_r = np.array([])\\n\\n\\t\\twhile True:\\n\\t\\t\\tr = self._expectation(centroids = centroids, x_assignee = x_assignee)\\n\\t\\t\\tcentroids = self._maximization(r_list = r, x_assignee = x_assignee)\\n\\n\\t\\t\\tif len(prev_r) is not 0:\\n\\t\\t\\t\\tif (float(np.mean(np.equal(r, prev_r))) == 1.0):\\n\\t\\t\\t\\t\\tcount +=1\\n\\t\\t\\t\\telse: \\n\\t\\t\\t\\t\\tcount=0\\n\\t\\t\\tif count == 10:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tprev_r = r\\n\\n\\n\\t\\treturn r, centroids\",\n \"def reduce(self, inputProportions, maxDeviation, triangleBudget, remeshType, reduceType):\\n return bool()\",\n \"def graphics_nfaces(self):\\n nfaces_ = _pychidg.f90wrap_graphics_nfaces(self=self._handle)\\n return nfaces_\",\n \"def iter_waters(self):\\n fpred = lambda f: f.is_water()\\n return itertools.ifilter(fpred, self.iter_fragments())\",\n \"def iterate(self):\\n ret = super(ExpandableAlgorithm, self).pre_iteration()\\n if ret is None:\\n return None\\n active, passive, neighbors, features_active, features_passive = ret\\n params = [features_active, features_passive]\\n if self._post_args:\\n params += self._post_args\\n s = self._overlap_function(*params)\\n if self.condition_axelrod:\\n if self.__condition_axelrod(s, features_active, features_passive):\\n return True\\n if self.condition_centola:\\n if self.__condition_centola(s, active, passive, neighbors):\\n return True\",\n \"def compare_many_faces(args):\\n\\n (emb, nrof_images) = compare_faces(args)\\n for i in range(nrof_images):\\n print('%1d ' % i, end='')\\n for j in range(nrof_images):\\n dist = np.sqrt(np.sum(np.square(np.subtract(emb[i, :], emb[j, :]))))\\n print(' %1.4f ' % dist, end='')\\n print('')\",\n \"def evaluate_detections(self, all_boxes, output_dir=None):\\n raise NotImplementedError\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6536707","0.5573983","0.54805946","0.54441386","0.54284626","0.53461635","0.5334527","0.53106356","0.530548","0.5246779","0.51937175","0.516544","0.516158","0.5131471","0.51164645","0.51044893","0.5103975","0.5064539","0.5041223","0.50377566","0.5032868","0.50323033","0.5014267","0.50036377","0.49915013","0.49672168","0.4949491","0.49298576","0.49184927","0.49164477","0.49137834","0.48956153","0.4883333","0.48820755","0.48792997","0.48701096","0.48675424","0.48673725","0.48312202","0.48244718","0.4816293","0.47978848","0.4794992","0.47888994","0.47726473","0.47530422","0.47431135","0.4739767","0.47390714","0.4737123","0.47186548","0.47134978","0.4707887","0.4702814","0.46962082","0.46955267","0.46787727","0.46782878","0.46727234","0.46689647","0.46635076","0.46527874","0.46515888","0.4631433","0.46299908","0.46215647","0.46211994","0.46195963","0.46151602","0.46148145","0.46148083","0.46067807","0.460506","0.46049368","0.4601276","0.45904478","0.45903856","0.45900926","0.45859587","0.45827168","0.45770657","0.45757186","0.4565859","0.4565649","0.45626512","0.456108","0.45609507","0.4559955","0.4558038","0.45563498","0.45514336","0.45511118","0.45507812","0.45500717","0.45496175","0.45415467","0.45383587","0.4533976","0.45266896","0.4525089"],"string":"[\n \"0.6536707\",\n \"0.5573983\",\n \"0.54805946\",\n \"0.54441386\",\n \"0.54284626\",\n \"0.53461635\",\n \"0.5334527\",\n \"0.53106356\",\n \"0.530548\",\n \"0.5246779\",\n \"0.51937175\",\n \"0.516544\",\n \"0.516158\",\n \"0.5131471\",\n \"0.51164645\",\n \"0.51044893\",\n \"0.5103975\",\n \"0.5064539\",\n \"0.5041223\",\n \"0.50377566\",\n \"0.5032868\",\n \"0.50323033\",\n \"0.5014267\",\n \"0.50036377\",\n \"0.49915013\",\n \"0.49672168\",\n \"0.4949491\",\n \"0.49298576\",\n \"0.49184927\",\n \"0.49164477\",\n \"0.49137834\",\n \"0.48956153\",\n \"0.4883333\",\n \"0.48820755\",\n \"0.48792997\",\n \"0.48701096\",\n \"0.48675424\",\n \"0.48673725\",\n \"0.48312202\",\n \"0.48244718\",\n \"0.4816293\",\n \"0.47978848\",\n \"0.4794992\",\n \"0.47888994\",\n \"0.47726473\",\n \"0.47530422\",\n \"0.47431135\",\n \"0.4739767\",\n \"0.47390714\",\n \"0.4737123\",\n \"0.47186548\",\n \"0.47134978\",\n \"0.4707887\",\n \"0.4702814\",\n \"0.46962082\",\n \"0.46955267\",\n \"0.46787727\",\n \"0.46782878\",\n \"0.46727234\",\n \"0.46689647\",\n \"0.46635076\",\n \"0.46527874\",\n \"0.46515888\",\n \"0.4631433\",\n \"0.46299908\",\n \"0.46215647\",\n \"0.46211994\",\n \"0.46195963\",\n \"0.46151602\",\n \"0.46148145\",\n \"0.46148083\",\n \"0.46067807\",\n \"0.460506\",\n \"0.46049368\",\n \"0.4601276\",\n \"0.45904478\",\n \"0.45903856\",\n \"0.45900926\",\n \"0.45859587\",\n \"0.45827168\",\n \"0.45770657\",\n \"0.45757186\",\n \"0.4565859\",\n \"0.4565649\",\n \"0.45626512\",\n \"0.456108\",\n \"0.45609507\",\n \"0.4559955\",\n \"0.4558038\",\n \"0.45563498\",\n \"0.45514336\",\n \"0.45511118\",\n \"0.45507812\",\n \"0.45500717\",\n \"0.45496175\",\n \"0.45415467\",\n \"0.45383587\",\n \"0.4533976\",\n \"0.45266896\",\n \"0.4525089\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5327577"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":78797,"cells":{"query":{"kind":"string","value":"Links as image of ."},"document":{"kind":"string","value":"def Bind(self, *args):\n return _BRepAlgo.BRepAlgo_Image_Bind(self, *args)"},"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 image(self, link, title, alt):\n if not link.startswith(('http://', 'https://')):\n source_dir = os.path.dirname(self.source_path)\n link = os.path.abspath(os.path.join(source_dir, link))\n return '<img src=\"%s\" title=\"%s\" alt=\"%s\" />' % (link, title, alt)","def create_HTML_a_img(link_url, image_url):\n img = '<img src=\"' + image_url + '\">'\n linked_image = create_HTML_a(link_url, img)\n return linked_image","def _collect_img_links(self):\n raise NotImplementedError","def getNewsIconURL(newsBrain):","def correct_img_links(body_main_content, schema_name, list_name_image):\n for name_image in list_name_image:\n body_main_content = body_main_content.replace(\n \"src=\\\"\" + name_image + \"\\\"\",\n \"src=\\\"{% static \\\"schema_viewer/oxygen/\" + schema_name + \"/\" + name_image + \"\\\" %}\\\"\"\n )\n return body_main_content","def image_link_collector(self, count):\n pass","def image(self, src, title, text):\n src = escape_link(src)\n text = escape(text, quote=True)\n if title:\n title = escape(title, quote=True)\n html = '<img src=\"%s\" alt=\"%s\" title=\"%s\"' % (src, text, title)\n else:\n html = '<img src=\"%s\" alt=\"%s\"' % (src, text)\n if self.options.get('use_xhtml'):\n return '%s />' % html\n return '%s>' % html","def get_image_url():","def MakeImageURL(fname, hyperlink='openfile', **kwargs):\n prefix = 'cdb://image/'\n if not _isSupportedUriPath(fname):\n fname = 'file:///%s' % os.path.basename(fname)\n else:\n fname = fname.replace('\\\\', '/')\n if hyperlink:\n hyperlink = ' cdb:hyperlink:%s' % hyperlink\n else:\n hyperlink = ''\n return '%s%s%s' % (prefix, fname, hyperlink)","def get_image_link(self):\n table = self.soup.find('table')\n image_tag = table.find('img')\n image_name = self.soup.find_all(\"b\")[1].text\n return image_tag['src'], image_name\n\n # image = td.find_all('img')\n # print(image)\n # if image is not None:\n # return urljoin(self.base_url, image['src'])","def getLink(self):","def test_image_links(self):\r\n print('\\nTest image links: ', end='', flush=True)\r\n driver = self.driver\r\n driver.get(MY_URL)\r\n all_images = driver.find_elements_by_tag_name('img')\r\n for image in all_images:\r\n src = image.get_attribute('src')\r\n alt = image.get_attribute('alt')\r\n r = requests.get(src)\r\n assert r.status_code == 200, 'Bad http status (%d) for %s' % (r.status_code, src)\r\n assert len(alt) > 0, 'Missing or empty alt tag for %s' % (src)\r\n print('.', end=\"\", flush=True)\r\n if DEBUG:\r\n print ('Src=%s' % src)","def get_image_link():\n image_links = set()\n supplemented_keyword = urllib.parse.quote(\n supplemented_keywords[random.randint(0,\n len(supplemented_keywords) - 1)],\n safe='')\n main_keyword = urllib.parse.quote(\n main_keywords[random.randint(0,\n len(main_keywords) - 1)], safe='')\n\n # print('the theme of cats: ' + supplemented_keyword)\n\n search_query = (main_keyword + ' ' + supplemented_keyword).replace(\n ' ', '%20')\n url = 'https://www.google.com/search?q=' + \\\n search_query + '&source=lnms&tbm=isch'\n image_links = image_links.union(parse_page(url))\n\n image_link = list(image_links)[random.randint(0, len(image_links) - 1)]\n # print('link:' + image_link)\n\n while 'https://' not in image_link or r'\\\\u' in image_link or '.jpg' not in image_link:\n image_link = list(image_links)[random.randint(0, len(image_links) - 1)]\n # print('link:' + image_link)\n\n return image_link","def __init__(self, filename, hyperlink=None, width=None, height=None, kind='direct',\r\n mask='auto', lazy=1, hAlign='CENTER'):\r\n super(HyperlinkedImage, self).__init__(filename, width, height, kind, mask, lazy, hAlign=hAlign)\r\n self.hyperlink = hyperlink","def image_link(self):\r\n\r\n if not self._image_link:\r\n warnings.warn(\"Seems like you are trying to pull out the image link while not having it.\", Warning, stacklevel=2)\r\n\r\n return self._image_link","def GET_link_thumb(self, *a, **kw):\r\n return \"nothing to see here.\"","def links_json(self, absolutize_url):\n return [\n {\n \"href\": absolutize_url(\"v2/{0}/images/{1}\"\n .format(self.tenant_id, self.image_id)),\n \"rel\": \"self\"\n },\n {\n \"href\": absolutize_url(\"{0}/images/{1}\"\n .format(self.tenant_id, self.image_id)),\n \"rel\": \"bookmark\"\n },\n {\n \"href\": absolutize_url(\"/images/{0}\"\n .format(self.image_id)),\n \"type\": \"application/vnd.openstack.image\",\n \"rel\": \"alternate\"\n }\n ]","def links_json(self, absolutize_url):\n return [\n {\n \"href\": absolutize_url(\"v2/{0}/images/{1}\"\n .format(self.tenant_id, self.image_id)),\n \"rel\": \"self\"\n },\n {\n \"href\": absolutize_url(\"{0}/images/{1}\"\n .format(self.tenant_id, self.image_id)),\n \"rel\": \"bookmark\"\n },\n {\n \"href\": absolutize_url(\"/images/{0}\"\n .format(self.image_id)),\n \"type\": \"application/vnd.openstack.image\",\n \"rel\": \"alternate\"\n }\n ]","def add_anchor_image(self, element, body):\n # TODO defensive coding\n src_url = element.attrib['src']\n picid, picname, picdescription, width, height = self.download_image(src_url)\n picrelid = 'rId'+str(len(self.relationships)+1)\n self.relationships.append(['http://schemas.openxmlformats.org/officeDocument/2006/relationships/image', 'media/'+picname])\n graphic = self.create_graphic_tag(width, height, picrelid, picid, picname, picdescription)\n anchor = docx.makeelement('anchor', nsprefix='wp',\n attributes={'allowOverlap':'1',\n 'behindDoc':'0',\n 'distB':'0',\n 'distL':'0',\n 'distR':'0',\n 'distT':'0',\n 'layoutInCell':'1',\n 'locked':'0',\n 'relativeHeight':'3',\n 'simplePos':'0'})\n anchor.append(docx.makeelement('simplePos', nsprefix='wp', attributes={'x':'0', 'y':'0'}))\n positionH = docx.makeelement('positionH', nsprefix='wp', attributes={'relativeFrom':'column',})\n positionH.append(docx.makeelement('posOffset', tagtext='1506220', nsprefix='wp'))\n anchor.append(positionH)\n positionV = docx.makeelement('positionV', nsprefix='wp', attributes={'relativeFrom':'paragraph',})\n positionV.append(docx.makeelement('posOffset', tagtext='0', nsprefix='wp'))\n anchor.append(positionV)\n anchor.append(docx.makeelement('extent', nsprefix='wp', attributes={'cx':str(width), 'cy':str(height)}))\n anchor.append(docx.makeelement('effectExtent', nsprefix='wp', attributes={'b':'0', 'l':'0', 'r':'0', 't':'0'}))\n anchor.append(docx.makeelement('wrapNone', nsprefix='wp'))\n anchor.append(docx.makeelement('docPr', nsprefix='wp', attributes={'id': picid, 'name': 'Picture 1', 'descr': picdescription}))\n cNvGraphicFramePr = docx.makeelement('cNvGraphicFramePr', nsprefix='wp')\n cNvGraphicFramePr.append(docx.makeelement('graphicFrameLocks', nsprefix='a', attributes={'noChangeAspect':'1',}))\n anchor.append(cNvGraphicFramePr)\n # now we can append the actual graphic\n anchor.append(graphic)\n drawing = docx.makeelement('drawing', nsprefix='w')\n drawing.append(anchor)\n r = docx.makeelement('r', nsprefix='w')\n r.append(docx.makeelement('rPr', nsprefix='w'))\n r.append(drawing)\n p = docx.makeelement('p', nsprefix='w')\n pPr = docx.makeelement('pPr', nsprefix='w')\n pPr.append(docx.makeelement('pStyle', nsprefix='w', attributes={'val':'style0',}))\n p.append(pPr)\n p.append(r)\n body.append(p)","def get_image(result):\n article_id = result['id']\n id_ = article_id[14:]\n href = article_id[:14]\n\n #FIXME: not working\n image_url = \"http://www.jpress.nli.org.il/Olive/APA/NLI_heb/get/GetImage.ashx?kind=block&href=%s&id=%s&ext=.png\" %(href, id_)\n \n return image_url","def hook_image_tag(self, parser, space, name):\n link = name\n caption = name\n params = {}\n\n # Parse the inner syntax, e.g. [[Image:src|option=val|caption]]\n separator = name.find('|')\n items = []\n if separator != -1:\n items = link.split('|')\n link = items[0]\n # If the last item contains '=', it's not a caption\n if items[-1].find('=') == -1:\n caption = items[-1]\n items = items[1:-1]\n else:\n caption = link\n items = items[1:]\n\n # parse the relevant items\n params = self._buildImageParams(items)\n img_path = self._getImagePath(link)\n\n template = jingo.env.get_template('wikiparser/hook_image.html')\n r_kwargs = {'img_path': img_path, 'caption': caption, 'params': params}\n return template.render(**r_kwargs)","def replfunc(self, match):\n url = match.group(1)\n imgformat = url.split('.')[-1]\n if url.startswith('http'):\n data = urlopen(url).read()\n elif url.startswith('data'):\n img = '<img src=\"' + url + '\" ' + match.group(2) + ' />'\n return img\n else:\n with open(url, 'rb') as f:\n data = f.read()\n\n self.log.info(\"embedding url: %s, format: %s\" % (url, imgformat))\n b64_data = base64.b64encode(data).decode(\"utf-8\")\n if imgformat == \"svg\":\n img = '<img src=\"data:image/svg+xml;base64,' + \\\n b64_data + '\" ' + match.group(2) + '/>'\n elif imgformat == \"pdf\":\n img = '<img src=\"data:application/pdf;base64,' + \\\n b64_data + '\" ' + match.group(2) + '/>'\n else:\n img = '<img src=\"data:image/' + imgformat + \\\n ';base64,' + b64_data + '\" ' + match.group(2) + ' />'\n return img","def get_thumbnail_url():","def get_image_links(data):\n painting_links = []\n\n print(data)\n\n for painting in data:\n painting_links.append(painting['image'])\n\n return painting_links","def process_image_url(value, field):\n if field.width:\n if not value:\n return u\"无\"\n return mark_safe(\"\"\"\n <a href=\"{0}\" target=\"_blank\"><img src=\"{0}\" width=\"{1}\" a>\n \"\"\".format(absolute_media_path(value), field.width))\n # only show url address.\n elif value:\n shorten_value = ''\n if len(value) > 20:\n shorten_value = value[0:12] + \"...\"\n return mark_safe(\"\"\"\n <a href=\"{0}\" target=\"_blank\" title=\"{0}\" >{1}</a>\n \"\"\".format(absolute_media_path(value), shorten_value if shorten_value else value))\n else:\n return \"\"","def __urlImageGenerator(cls, link):\n\n try:\n a = Article(url=link)\n a.download()\n a.parse()\n a.fetch_images()\n\n for img in a.imgs:\n yield img\n except Exception:\n pass","def show_image_ref():\n return get_image_ref()","def link(self, obj):\n return format_html(\n '<a href=\"{url}\">{url}</a>',\n url='https://sms.cam.ac.uk/media/{}'.format(obj.id)\n )","def generate_link_kml(self, d):\n return \"\"\"\\\n <NetworkLink>\n <name>%(image_filename)s</name>\n <Region>\n <Lod>\n <minLodPixels>%(minlodpixels)d</minLodPixels>\n <maxLodPixels>-1</maxLodPixels>\n </Lod>\n <LatLonAltBox>\n <north>%(north).14f</north>\n <south>%(south).14f</south>\n <east>%(east).14f</east>\n <west>%(west).14f</west>\n </LatLonAltBox>\n </Region>\n <Link>\n <href>%(link_url)s</href>\n <viewRefreshMode>onRegion</viewRefreshMode>\n </Link>\n </NetworkLink>\"\"\" % d","def formatArrayHyperlink(txt, lnk, filename):\n if oapackage.oahelper.oaIsBinary(filename):\n ss = e.a(txt + e.small(\" (binary)\"), href=lnk, class_=\"binarylink\")\n else:\n ss = e.a(txt, href=lnk, class_=\"normal\")\n return ss","def image_preview(self):\r\n h = '<img src=\"%s\" alt=\"Campaign badge\"/>' % self.image.url\r\n return mark_safe(h)","def img_url_display(self):\n url = '%s=s%s' % (self.img_url, self.DISPLAY_SIZE_PX)\n if self.img_rot in Plaque.ALLOWED_ROTATIONS:\n url = \"%s-r%s\" % (url, self.img_rot)\n return url","def testImgAndUrlUseSameUrl(self):\n self.assertIn(self.chart.display.Url(500, 100, use_html_entities=True),\n self.chart.display.Img(500, 100))","def saveImages(self):\n if self.imageLink and not self.image:\n f= open('imageLink.txt','wb')\n f.write(bytes(str(self.imageLink), 'UTF-8'))\n f.close()\n req = urllib3.urlopen(self.imageLink, headers={'User-Agent': 'Mozilla/5.0'})\n result = urllib3.urlopen(req)\n self.image.save(os.path.basename(self.imageLink),ContentFile(result.read()))\n print (\"Image saved\")\n self.save()","def getimgs():","def test_class_image(self):\n fwa = FakeWikiArchivo(\n 'abcd <a href=\"/wiki/foobar\" class=\"image\">FooBar</a> dcba'\n )\n _, r = self.peishranc(fwa)\n self.assertEqual(r, [])","def figure_links(self):\n dirpath = os.path.join(config[\"src_dir\"], config[\"figures_subdir\"])\n assert os.path.exists(dirpath), f\"- figures subdirectory {dirpath} was not found\"\n figures = [f for f in os.listdir(dirpath) if os.path.isfile(os.path.join(dirpath, f))\n and not f.startswith('.') and not f.endswith('.tex') and not f.endswith('.pdf')]\n figures = filter(lambda f: any([re.search(f, cell.source) for cell in self.content.cells]), figures)\n return [(os.path.join(config[\"figures_subdir\"], figure), f\"{config['github_pages_url']}/figures/{figure}\") for figure in figures]","def test_main():\n parser = HTMLTagParser()\n parser.parse('<img>some text</img><a href=\"www\"><t>,</t>linkkkk</a>')\n for link in parser.links:\n print(link.attributes, link.data)\n for image in parser.images:\n print(image.attributes, image.data)","def link(address):","def embed_image(self, node):\r\n xlink = node.get('xlink:href')\r\n if xlink and xlink[:5] == 'data:':\r\n # No need, data alread embedded\r\n return\r\n\r\n url = urllib.parse.urlparse(xlink)\r\n href = urllib.request.url2pathname(url.path)\r\n\r\n # Primary location always the filename itself.\r\n path = self.absolute_href(href or '')\r\n\r\n # Backup directory where we can find the image\r\n if not os.path.isfile(path):\r\n path = node.get('sodipodi:absref', path)\r\n\r\n if not os.path.isfile(path):\r\n inkex.errormsg('File not found \"{}\". Unable to embed image.'.format(path))\r\n return\r\n\r\n with open(path, \"rb\") as handle:\r\n # Don't read the whole file to check the header\r\n file_type = self.get_image_type(path, handle.read(10))\r\n handle.seek(0)\r\n\r\n if file_type:\r\n # Future: Change encodestring to encodebytes when python3 only\r\n node.set('xlink:href', 'data:{};base64,{}'.format(\r\n file_type, base64.encodebytes(handle.read()).decode('ascii')))\r\n node.pop('sodipodi:absref')\r\n else:\r\n inkex.errormsg(\"%s is not of type image/png, image/jpeg, \"\r\n \"image/bmp, image/gif, image/tiff, or image/x-icon\" % path)","def gen_links(text):\n return []","def test_with_links(self):\n self.result.figure_link = 'some_link'\n self.result.start_figure_link = 'other_link'\n figure_link, start_link = fitting_report.get_figure_paths(self.result)\n self.assertEqual(figure_link, os.path.join('figures', 'some_link'))\n self.assertEqual(start_link, os.path.join('figures', 'other_link'))","def get_image_comic_url(session, response):\n soup = bs(response.text, 'lxml')\n for div in soup.find_all('div', class_=\"img-comic-container\"):\n for a in div.find_all('a', class_=\"img-comic-link\"):\n for img in a.find_all('img', src=True):\n return \"https:\" + img['src']","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 generate_file_link_html_from_url(self, s3_public_url, file_name):\r\n image_link = \"\"\"\r\n <a href=\"{0}\" target=\"_blank\">{1}</a>\r\n \"\"\".format(s3_public_url, file_name)\r\n return image_link","def embed_images(self):\n for img in self.book.xpath(\"//img[ not(starts-with(@src, 'data:')) and @src!= '']\"):\n img_src = img.attrib[\"src\"]\n img_raw = self.get_remote_content(img_src)\n if img_raw != None:\n img_64 = base64.b64encode(img_raw)\n file_info = os.path.splitext(img_src)\n ext = file_info[1].replace(\".\", \"\")\n ext = re.sub(\"\\?.*$\", \"\" , ext)\n \n if ext == \"svg\":\n svg = html.fromstring(img_raw.decode(\"utf-8\"))\n img.clear()\n img.tag = \"svg\"\n img[:] = [svg]\n else:\n img.set(\"src\", \"data:image/{};base64,{}\".format(ext, img_64.decode(\"utf-8\")))","def create_link(self):\n self.filename = App.get_running_app().root.ids.camera_screen.capture()\n self.url = FileSharer(self.filename).share()\n self.ids.label.text = self.url","def fix_links():\n pass","def file_from_external_link(self, uri):\n images = []\n uri = uri.split('://')[1]\n objgen = pagegenerators.LinksearchPageGenerator(uri, namespaces=[6],\n site=self.commons)\n for page in objgen:\n images.append(pywikibot.FilePage(self.commons, page.title()))\n\n # I have no clue how the above results in duplicates, but it does so...\n images = list(set(images))\n\n return images","def make_node_urls(self, node_data):\n node_display = node_data['display_url']\n if node_data['__typename'] == 'GraphVideo':\n return ['video', node_display, node_data['video_url']]\n\n return ['image', node_display, node_display]","async def img(ctx, message):\n \"\"\":param: ctx\"\"\"\n \"\"\":param: message\"\"\"\n \"\"\"return image url\"\"\"\n link_list = []\n\n url = \"http://imgur.com/search?q=\" + message\n response = urlopen(url)\n html = response.read()\n soup = BeautifulSoup(html, \"lxml\")\n for a in soup.find_all('a', href=True):\n if((a['href'][0:9]) == \"/gallery/\"):\n link_list.append(\"https://imgur.com/\" + a['href'])\n if(len(link_list) >=1):\n random_num = random.randint(0, len(link_list) - 1)\n await bot.say(link_list[random_num])\n else:\n await bot.say(\"there is no contente for \"+message)","def _make_doi_clickable(link):\n return f\"https://doi.org/{link}\"","def check_link_tag(self):\r\n node = self.article.raw_doc\r\n meta = self.parser.getElementsByTag(node, tag='link', attr='rel', value='image_src')\r\n for item in meta:\r\n src = self.parser.getAttribute(item, attr='href')\r\n if src:\r\n return self.get_image(item, src, extraction_type='linktag')\r\n return None","def makeLinks(self):\n self.deleteIndexFileIfExists()\n _fileNames = self.getHTMLFileNames()\n _msgPart1 = \"<a href=\\\"\"\n _msgPart2 = \"\\\" target=\\\"loadHTMLResults\\\">\"\n _msgPart3 = \"</a><br>\"\n _link = \"\"\n for _fileName in _fileNames:\n _origFileName = _fileName\n _linkName = _fileName.split('.')[0]\n _createAnchorTag = (_msgPart1+str(_origFileName)+_msgPart2+str(_linkName)+_msgPart3)\n _link = _link + _createAnchorTag\n return _link","def replace_local_hyperlinks(\n text,\n base_url=\"https://github.com/project-rig/nengo_spinnaker/blob/master/\"\n ):\n def get_new_url(url):\n return base_url + url[2:]\n\n # Deal with anonymous URLS\n for match in re.finditer(r\"^__ (?P<url>\\./.*)\", text, re.MULTILINE):\n orig_url = match.groupdict()[\"url\"]\n url = get_new_url(orig_url)\n\n text = re.sub(\"^__ {}\".format(orig_url),\n \"__ {}\".format(url), text, flags=re.MULTILINE)\n\n # Deal with named URLS\n for match in re.finditer(r\"^\\.\\. _(?P<identifier>[^:]*): (?P<url>\\./.*)\",\n text, re.MULTILINE):\n identifier = match.groupdict()[\"identifier\"]\n orig_url = match.groupdict()[\"url\"]\n url = get_new_url(orig_url)\n\n text = re.sub(\n \"^\\.\\. _{}: {}\".format(identifier, orig_url),\n \".. _{}: {}\".format(identifier, url),\n text, flags=re.MULTILINE)\n\n # Deal with image URLS\n for match in re.finditer(r\"^\\.\\. image:: (?P<url>\\./.*)\",\n text, re.MULTILINE):\n orig_url = match.groupdict()[\"url\"]\n url = get_new_url(orig_url)\n\n text = text.replace(\".. image:: {}\".format(orig_url),\n \".. image:: {}\".format(url))\n\n return text","async def olá(self):\r\n\t\tawait self.client.say('© Maddie 2017')\r\n\t\te = Embed()\r\n\t\te.set_image(url='https://cdn.discovery.pgsitecore.com/en-us/-/media/Olay_PathFinder/Images/a/OLAY%20TE%207IN1%20DEEP%20PENETRATING%20MOISTURE%20BODY%20WASH_Front.png?w=460&v=1-201705260605')\r\n\t\tawait self.client.say(embed=e)","def fix_image_links_in_static_portlet(portal):\n\n def get_image_uid(image):\n \"\"\"Return image UID.\"\"\"\n folder = portal['imagens']\n if image in folder:\n return folder[image].UID()\n\n manager = getUtility(IPortletManager, name='plone.rightcolumn', context=portal)\n mapping = getMultiAdapter((portal, manager), IPortletAssignmentMapping)\n\n assert 'midias-sociais' in mapping\n portlet = mapping['midias-sociais']\n images = [\n 'ico-facebook.png', 'ico-twitter.png', 'ico-linkedin.png',\n 'ico-youtube.png', 'ico-flickr.png'\n ]\n for i in images:\n uid = 'resolveuid/' + get_image_uid(i)\n portlet.text = portlet.text.replace(i, uid)\n logger.debug(u'Links substituidos no portlet de midias sociais')\n\n assert 'banners' in mapping\n portlet = mapping['banners']\n image = 'acesso-a-informacao.png'\n uid = 'resolveuid/' + get_image_uid(image) + '/image_mini'\n portlet.text = portlet.text.replace(image, uid)\n logger.debug(u'Link substituido no portlet de acesso a informacao')","def getimage(self):","def _generate_links(self):\n index = 0\n links = \"\"\n for ch in self.text:\n if ch == '[':\n links += \"(^\"\n elif ch == ']':\n links += \")$|\"\n index += 1\n elif links[-1:] != '|' and links != \"\":\n links += ch\n self.links = compile(links[:-1].lower())","def url(self):\n\t\treturn self.base_url+\"{}/{}/{}.jpg\".format(self.template,self._escape(self.top_text),self._escape(self.bottom_text))+(\"?\"+\"&\".join([\"{}={}\".format(k,quote(self.kwargs[k])) for k in self.kwargs]) if self.kwargs else \"\")","def create_link(seconds, image_name, size):\n token = signing.dumps([str(timezone.now() + timedelta(seconds=int(seconds))), image_name, size])\n return settings.SERVER_PATH + reverse(\"image:dynamic-image\", kwargs={\"token\": token})","def add_image_hrefs(feed):\n supported_image_types = ('image/jpeg', 'image/png')\n entries = feed.get('entries', [])\n for entry in entries:\n if 'image' not in entry:\n try:\n for link in entry.get('links', []):\n try:\n if link.get('type') in supported_image_types:\n entry['image'] = link.get('href')\n break\n except AttributeError:\n continue\n except (TypeError, AttributeError):\n pass\n\n image_getters = (\n lambda e: e['image'] if isinstance(e['image'], basestring) else None,\n lambda e: e['image']['href'] if e['image'] else None,\n lambda e: prioritize_jpeg(e['media_thumbnail']),\n lambda e: prioritize_jpeg(e['media_content']))\n\n for getter in image_getters:\n try:\n image = getter(entry)\n if image:\n entry['image'] = image\n break\n except (KeyError, IndexError, TypeError):\n pass\n return feed","def link_click(_):\r\n\r\n tag_name = about_content.tag_names(tkinter.CURRENT)[0]\r\n about_content.tag_config(tag_name, foreground=\"#551A8B\")\r\n if tag_name == 'hyper':\r\n webbrowser.open(\"https://www.facebook.com/nihal.agarwal.14\")\r\n else:\r\n webbrowser.open(\"https://github.com/NihalAgarwal/Windows-Wi-Fi-Manager\")","def link(self, obj):\n return format_html(\n '<a href=\"{url}\">{url}</a>',\n url='https://sms.cam.ac.uk/collection/{}'.format(obj.id)\n )","def link(self, link, title, text):\n link = escape_link(link)\n return [MdStyleInstructionLink(link)] + text","def logosmall(self):\n try:\n asset = self.app.module_map.uploader.get(self.barcamp.logo)\n except AssetNotFound:\n asset = None\n if not asset:\n return u\"\"\n v = asset.variants['medium_user']\n url = self.app.url_for(\"asset\", asset_id = v._id)\n return \"\"\"<a href=\"%s\"><img src=\"%s\" width=\"%s\" height=\"%s\"></a>\"\"\" %(\n self.handler.url_for(\"barcamps.index\", slug = self.barcamp.slug),\n url,\n v.metadata['width'],\n v.metadata['height'])","def image(self, text):\n pattern = re.compile(r\"\"\"\n (?:[\\[{])? # pre\n \\! # opening !\n (\\<|\\=|\\>)? # optional alignment atts\n (%s) # optional style,class atts\n (?:\\. )? # optional dot-space\n ([^\\s(!]+) # presume this is the src\n \\s? # optional space\n (?:\\(([^\\)]+)\\))? # optional title\n \\! # closing\n (?::(\\S+))? # optional href\n (?:[\\]}]|(?=\\s|$)) # lookahead: space or end of string\n \"\"\" % self.c, re.U | re.X)\n return pattern.sub(self.fImage, text)","def iter_links(self):","def url_maker():\n chars = string.ascii_lowercase + string.ascii_uppercase + string.digits\n tempchar = [random.choice(chars) for n in range(5)]\n return \"http://i.imgur.com/\" + \"\".join(tempchar)","def getExpandedLinks():","def image_reference(self, image_id):\n info = self.image_info[image_id]\n if info[\"source\"] == \"coco\":\n return \"http://cocodataset.org/#explore?id={}\".format(info[\"id\"])\n else:\n super(CocoDataset, self).image_reference(image_id)","def _icons(self, c_brain):\n if c_brain.portal_type not in self.i_cache:\n icon_link = ''\n purl = api.portal.get_tool('portal_url')()\n typeInfo = api.portal.get_tool('portal_types')[c_brain.portal_type]\n if typeInfo.icon_expr:\n # we assume that stored icon_expr is like string:${portal_url}/myContentIcon.png\n # or like string:${portal_url}/++resource++imio.dashboard/dashboardpodtemplate.png\n contentIcon = '/'.join(typeInfo.icon_expr.split('/')[1:])\n title = translate(typeInfo.title, domain=typeInfo.i18n_domain, context=self.request)\n icon_link = u\"<img title='%s' src='%s/%s' />\" % (safe_unicode(escape(title)), purl, contentIcon)\n self.i_cache[c_brain.portal_type] = icon_link\n return self.i_cache[c_brain.portal_type]","def thumbnail_url(link):\r\n return 'http:/%s%s.png' % (s3_thumbnail_bucket, link._fullname)","def url_for(**options):\n\n url_parts = get_url_parts(**options)\n image_hash = hashlib.md5(b(options[\"image_url\"])).hexdigest()\n url_parts.append(image_hash)\n\n return \"/\".join(url_parts)","def l10n_img(ctx, url):\n return static(l10n_img_file_name(ctx, url))","def link(self):\n return f\"[{self.numbered_title}]({self.html_url})\"","def get_image_url(article):\n get_image = article.find_all(\"img\")[0]\n return get_image.get(\"src\").replace(\"../../\", \"http://books.toscrape.com/\")","def create_image_caption_pairs(self):","def get_url_image(self, obj):\n return settings.IMAGE_HOST + obj.image.url","def get_url_image(self, obj):\n return settings.IMAGE_HOST + obj.image.url","def get_url_image(self, obj):\n return settings.IMAGE_HOST + obj.image.url","async def link(self, ctx):\n item_matches = self.re.findall(ctx.message.content)\n if not item_matches:\n return\n tasks = []\n print(item_matches)\n for item in item_matches[:5]:\n tasks.append(self.bot.loop.run_in_executor(None,\n find_one, item.strip('[[').strip(']]'),\n self.client, self.bot.loop))\n results = await asyncio.gather(*tasks)\n results = [x for x in results if x]\n images = []\n for result in results:\n if result.base == \"Prophecy\":\n flavor = 'prophecy'\n elif 'gem' in result.tags:\n flavor = 'gem'\n print(result.vendors)\n else:\n flavor = result.rarity\n r = utils.ItemRender(flavor)\n images.append(r.render(result))\n if len(images) > 1:\n box = [0, 0]\n for image in images:\n box[0] = box[0] + image.size[0]\n if image.size[1] > box[1]:\n box[1] = image.size[1]\n box[0] = box[0] + (2*len(images))\n img = Image.new('RGBA', box, color='black')\n #img.show()\n paste_coords = [0, 0]\n for image in images:\n #image.show()\n img.paste(image.convert('RGBA'), box=paste_coords[:])\n paste_coords[0] = paste_coords[0] + image.size[0] + 2\n else:\n img = images[0]\n image_fp = BytesIO()\n img.save(image_fp, 'png')\n image_fp.seek(0)\n print(\"Image ready\")\n await ctx.channel.send(file=File(image_fp, filename='image.png'))","def cleanup_links(path, inspect_links=False):\n with open(path) as f:\n text = f.read()\n\n# if 'BokehJS does not appear to have successfully loaded' in text:\n# for k, v in BOKEH_REPLACEMENTS.items():\n# text = text.replace(k, v)\n\n text = component_links(text, path)\n soup = BeautifulSoup(text, features=\"html.parser\")\n for a in soup.findAll('a'):\n href = a.get('href', '')\n if '.ipynb' in href and 'http' not in href:\n # for k, v in LINK_REPLACEMENTS.items():\n # href = href.replace(k, v)\n a['href'] = href.replace('.ipynb', '.html')\n\n # check to make sure that path exists, if not, try un-numbered version\n try_path = os.path.join(os.path.dirname(path), a['href'])\n if not os.path.exists(try_path):\n num_name = os.path.basename(try_path)\n name = re.split(r\"^\\d+( |-|_)\", num_name)[-1]\n new_path = try_path.replace(num_name, name)\n if os.path.exists(new_path):\n a['href'] = os.path.relpath(new_path, os.path.dirname(path))\n else:\n also_tried = 'Also tried: {}'.format(name) if name != num_name else ''\n warnings.warn('Found missing link {} in: {}. {}'.format(a['href'], path, also_tried))\n\n if inspect_links and 'http' in a['href']:\n print(a['href'])\n for img in soup.findAll('img'):\n src = img.get('src', '')\n if 'http' not in src and 'assets' in src:\n try_path = os.path.join(os.path.dirname(path), src)\n if not os.path.exists(try_path):\n also_tried = os.path.join('..', src)\n if os.path.exists(os.path.join(os.path.dirname(path), also_tried)):\n img['src'] = also_tried\n else:\n warnings.warn('Found reference to missing image {} in: {}. Also tried: {}'.format(src, path, also_tried))\n with open(path, 'w') as f:\n f.write(str(soup))","def post_line_to_list_of_local_image_links(line):\n normal_img = '<img .*?src=\"([^\"]*?)(?:&thumb=1)?\".*?>'\n md_img = '!\\[[^\\]]*\\]\\(([^)]*?)(?:&thumb=1)?\\)'\n exp = re.compile(normal_img + \"|\" + md_img)\n results = itertools.chain(*re.findall(exp, line))\n\n return [item for item in results if item and not item.startswith(\"http\")]","def _getImagePath(self, link):\n return settings.WIKI_UPLOAD_URL + urlquote(link)","def append_links(self, lines, lang):\n lines.append(\"verbatim \")\n lines.append(\"section Links\")\n lines.append(\"external http://polcasaglia.blogspot.com Blog\")\n lines.append(\"external http://www.uisp-fe.it/calcio.php UISP\" )\n lines.append(\"verbatim \")\n return lines","def image_preview(self):\r\n h = '<img src=\"%s\" alt=\"%s\"/>' % (self.image_resized_url, self.title)\r\n return mark_safe(h)","def add_three_images(document_text, image_link_template, image_folder, images, width):\n for idx in range(3):\n document_text += \"\\n\"\n image_info = r'<td>{0}</td>'.format(image_link_template.format(\n os.path.join(image_folder, images[idx]), width))\n document_text = add_document_text(document_text, image_info)\n return document_text","def parse_links(self, content):\n ret = set()\n\n soup = BeautifulSoup(content)\n all_a = [x['href'] for x in soup.findAll('a')]\n all_img = [x['src'] for x in soup.findAll('img') if x['src']]\n\n for x in all_a:\n # Special exception for /tracks/signup/... - that URL always redirects\n if 'login' in x or not x.startswith('/') or x.startswith('/tracks/signup/'):\n continue\n\n ret.add(x)\n\n return ret, all_img","def barbican_url(self):","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 get_img_ref_from_attrs(attrs):\n\n for attr in attrs:\n if attr[0]== 'src':\n if isImage(attr[1]):\n list_of_img_refs.append(attr[1])\n\n if attr[0] == 'href':\n if isImage(attr[1]):\n list_of_img_refs.append(attr[1])","def add_link():\n return True","async def _misc_IMGplumbob(self, ctx):\r\n await self.bot.say('{}, http://i.imgur.com/q8xJsJQ.gif'.format(ctx.message.author.mention))","def _extract_image_links(self, publication, feed_self_url):\n self._logger.debug(\n \"Started extracting image links from {0}\".format(\n encode(publication.images)\n )\n )\n\n # FIXME: This code most likely will not work in general.\n # There's no guarantee that these images have the same media type,\n # or that the second-largest image isn't far too large to use as a thumbnail.\n # Instead of using the second-largest image as a thumbnail,\n # find the image that would make the best thumbnail\n # because of its dimensions, media type, and aspect ratio:\n # IDEAL_COVER_ASPECT_RATIO = 2.0/3\n # IDEAL_IMAGE_HEIGHT = 240\n # IDEAL_IMAGE_WIDTH = 160\n\n sorted_raw_image_links = list(\n reversed(\n sorted(\n publication.images.links, key=lambda link: (link.width or 0, link.height or 0)\n )\n )\n )\n image_links = []\n\n if len(sorted_raw_image_links) > 0:\n cover_link = self._extract_link(\n sorted_raw_image_links[0],\n feed_self_url,\n default_link_rel=Hyperlink.IMAGE,\n )\n image_links.append(cover_link)\n\n if len(sorted_raw_image_links) > 1:\n cover_link = self._extract_link(\n sorted_raw_image_links[1],\n feed_self_url,\n default_link_rel=Hyperlink.THUMBNAIL_IMAGE,\n )\n image_links.append(cover_link)\n\n self._logger.debug(\n \"Finished extracting image links from {0}: {1}\".format(\n encode(publication.images), encode(image_links)\n )\n )\n\n return image_links","def make_link_to(self, index, caption):\n \n # index is an int\n return '<a href=\"/log/'+str(index)+'\"> '+caption+' '+str(index)+'</a>'","def get_image_url(img):\n # element['data-src'] and element.get('data-src') doesn't work\n for k, v in img.items():\n if k == 'data-src':\n # https://t.nhentai.net/galleries/<gallerycode>/<page#>t.<extension>\n # https://i.nhentai.net/galleries/<gallerycode>/<page#>.<extension>\n return v[:8] + 'i' + v[9:32] + v[32:].replace('t.', '.', 1)","def create_html(pic_info,sum_pic,upload_path,yun_link=('1','2')):\n save_file=pic_info+'.txt'\n content=\"\"\"\n <p>\n <img src=\"%s%s\" style=\"\" title=\"%s\"/>\n </p>\n <p>\n <img src=\"%s%s\" style=\"\" title=\"%s\"/>\n </p>\n <p>\n <img src=\"%s%s\" style=\"\" title=\"%s\"/>\n </p>\n <p>\n <img src=\"%s%s\" style=\"\" title=\"%s\"/>\n </p>\n <p>\n <span style=\"color: #FF0000; font-size: 24px;\">link: \n </span>\n <a href=\"%s\" target=\"_blank\" \n style=\"font-size: 24px; text-decoration: underline;\">\n <span style=\"font-size: 24px;\">%s\n </span>\n </a> \n <span style=\"font-size: 24px;\">\n <span style=\"color: #FF0000; font-size: 24px;\">code:\n </span>\n %s\n </span>\n </p>\\n\\n\\n\\n\\n\\n\\n\\n\\n\n \"\"\"%(upload_path,sum_pic[0],sum_pic[0],upload_path,sum_pic[1],sum_pic[1],\n upload_path,sum_pic[2],sum_pic[2],upload_path,sum_pic[3],sum_pic[3],\n yun_link[0],yun_link[0],yun_link[1])\n with open(save_file, 'w') as f:\n f.write(content)\n f.close()","def icon(self):","def _do_links(self, text):\r\n MAX_LINK_TEXT_SENTINEL = 3000 # markdown2 issue 24\r\n\r\n # `anchor_allowed_pos` is used to support img links inside\r\n # anchors, but not anchors inside anchors. An anchor's start\r\n # pos must be `>= anchor_allowed_pos`.\r\n anchor_allowed_pos = 0\r\n\r\n curr_pos = 0\r\n while True: # Handle the next link.\r\n # The next '[' is the start of:\r\n # - an inline anchor: [text](url \"title\")\r\n # - a reference anchor: [text][id]\r\n # - an inline img: ![text](url \"title\")\r\n # - a reference img: ![text][id]\r\n # - a footnote ref: [^id]\r\n # (Only if 'footnotes' extra enabled)\r\n # - a footnote defn: [^id]: ...\r\n # (Only if 'footnotes' extra enabled) These have already\r\n # been stripped in _strip_footnote_definitions() so no\r\n # need to watch for them.\r\n # - a link definition: [id]: url \"title\"\r\n # These have already been stripped in\r\n # _strip_link_definitions() so no need to watch for them.\r\n # - not markup: [...anything else...\r\n try:\r\n start_idx = text.index('[', curr_pos)\r\n except ValueError:\r\n break\r\n text_length = len(text)\r\n\r\n # Find the matching closing ']'.\r\n # Markdown.pl allows *matching* brackets in link text so we\r\n # will here too. Markdown.pl *doesn't* currently allow\r\n # matching brackets in img alt text -- we'll differ in that\r\n # regard.\r\n bracket_depth = 0\r\n for p in range(start_idx+1, min(start_idx+MAX_LINK_TEXT_SENTINEL,\r\n text_length)):\r\n ch = text[p]\r\n if ch == ']':\r\n bracket_depth -= 1\r\n if bracket_depth < 0:\r\n break\r\n elif ch == '[':\r\n bracket_depth += 1\r\n else:\r\n # Closing bracket not found within sentinel length.\r\n # This isn't markup.\r\n curr_pos = start_idx + 1\r\n continue\r\n link_text = text[start_idx+1:p]\r\n\r\n # Possibly a footnote ref?\r\n if \"footnotes\" in self.extras and link_text.startswith(\"^\"):\r\n normed_id = re.sub(r'\\W', '-', link_text[1:])\r\n if normed_id in self.footnotes:\r\n self.footnote_ids.append(normed_id)\r\n result = '<sup class=\"footnote-ref\" id=\"fnref-%s\">' \\\r\n '<a href=\"#fn-%s\">%s</a></sup>' \\\r\n % (normed_id, normed_id, len(self.footnote_ids))\r\n text = text[:start_idx] + result + text[p+1:]\r\n else:\r\n # This id isn't defined, leave the markup alone.\r\n curr_pos = p+1\r\n continue\r\n\r\n # Now determine what this is by the remainder.\r\n p += 1\r\n if p == text_length:\r\n return text\r\n\r\n # Inline anchor or img?\r\n if text[p] == '(': # attempt at perf improvement\r\n match = self._tail_of_inline_link_re.match(text, p)\r\n if match:\r\n # Handle an inline anchor or img.\r\n is_img = start_idx > 0 and text[start_idx-1] == \"!\"\r\n if is_img:\r\n start_idx -= 1\r\n\r\n url, title = match.group(\"url\"), match.group(\"title\")\r\n if url and url[0] == '<':\r\n url = url[1:-1] # '<url>' -> 'url'\r\n # We've got to encode these to avoid conflicting\r\n # with italics/bold.\r\n url = url.replace('*', self._escape_table['*']) \\\r\n .replace('_', self._escape_table['_'])\r\n if title:\r\n title_str = ' title=\"%s\"' % (\r\n _xml_escape_attr(title)\r\n .replace('*', self._escape_table['*'])\r\n .replace('_', self._escape_table['_']))\r\n else:\r\n title_str = ''\r\n if is_img:\r\n result = '<img src=\"%s\" alt=\"%s\"%s%s' \\\r\n % (url.replace('\"', '"'),\r\n _xml_escape_attr(link_text),\r\n title_str, self.empty_element_suffix)\r\n if \"smarty-pants\" in self.extras:\r\n result = result.replace('\"', self._escape_table['\"'])\r\n curr_pos = start_idx + len(result)\r\n text = text[:start_idx] + result + text[match.end():]\r\n elif start_idx >= anchor_allowed_pos:\r\n result_head = '<a href=\"%s\"%s>' % (url, title_str)\r\n result = '%s%s</a>' % (result_head, link_text)\r\n if \"smarty-pants\" in self.extras:\r\n result = result.replace('\"', self._escape_table['\"'])\r\n # <img> allowed from curr_pos on, <a> from\r\n # anchor_allowed_pos on.\r\n curr_pos = start_idx + len(result_head)\r\n anchor_allowed_pos = start_idx + len(result)\r\n text = text[:start_idx] + result + text[match.end():]\r\n else:\r\n # Anchor not allowed here.\r\n curr_pos = start_idx + 1\r\n continue\r\n\r\n # Reference anchor or img?\r\n else:\r\n match = self._tail_of_reference_link_re.match(text, p)\r\n if match:\r\n # Handle a reference-style anchor or img.\r\n is_img = start_idx > 0 and text[start_idx-1] == \"!\"\r\n if is_img:\r\n start_idx -= 1\r\n link_id = match.group(\"id\").lower()\r\n if not link_id:\r\n link_id = link_text.lower() # for links like [this][]\r\n if link_id in self.urls:\r\n url = self.urls[link_id]\r\n # We've got to encode these to avoid conflicting\r\n # with italics/bold.\r\n url = url.replace('*', self._escape_table['*']) \\\r\n .replace('_', self._escape_table['_'])\r\n title = self.titles.get(link_id)\r\n if title:\r\n before = title\r\n title = _xml_escape_attr(title) \\\r\n .replace('*', self._escape_table['*']) \\\r\n .replace('_', self._escape_table['_'])\r\n title_str = ' title=\"%s\"' % title\r\n else:\r\n title_str = ''\r\n if is_img:\r\n result = '<img src=\"%s\" alt=\"%s\"%s%s' \\\r\n % (url.replace('\"', '"'),\r\n link_text.replace('\"', '"'),\r\n title_str, self.empty_element_suffix)\r\n if \"smarty-pants\" in self.extras:\r\n result = result.replace('\"', self._escape_table['\"'])\r\n curr_pos = start_idx + len(result)\r\n text = text[:start_idx] + result + text[match.end():]\r\n elif start_idx >= anchor_allowed_pos:\r\n result = '<a href=\"%s\"%s>%s</a>' \\\r\n % (url, title_str, link_text)\r\n result_head = '<a href=\"%s\"%s>' % (url, title_str)\r\n result = '%s%s</a>' % (result_head, link_text)\r\n if \"smarty-pants\" in self.extras:\r\n result = result.replace('\"', self._escape_table['\"'])\r\n # <img> allowed from curr_pos on, <a> from\r\n # anchor_allowed_pos on.\r\n curr_pos = start_idx + len(result_head)\r\n anchor_allowed_pos = start_idx + len(result)\r\n text = text[:start_idx] + result + text[match.end():]\r\n else:\r\n # Anchor not allowed here.\r\n curr_pos = start_idx + 1\r\n else:\r\n # This id isn't defined, leave the markup alone.\r\n curr_pos = match.end()\r\n continue\r\n\r\n # Otherwise, it isn't markup.\r\n curr_pos = start_idx + 1\r\n\r\n return text","def svg(self) -> str:\n return SPOUSE_LINK_TEMPLATE.format(**self._fields)"],"string":"[\n \"def image(self, link, title, alt):\\n if not link.startswith(('http://', 'https://')):\\n source_dir = os.path.dirname(self.source_path)\\n link = os.path.abspath(os.path.join(source_dir, link))\\n return '<img src=\\\"%s\\\" title=\\\"%s\\\" alt=\\\"%s\\\" />' % (link, title, alt)\",\n \"def create_HTML_a_img(link_url, image_url):\\n img = '<img src=\\\"' + image_url + '\\\">'\\n linked_image = create_HTML_a(link_url, img)\\n return linked_image\",\n \"def _collect_img_links(self):\\n raise NotImplementedError\",\n \"def getNewsIconURL(newsBrain):\",\n \"def correct_img_links(body_main_content, schema_name, list_name_image):\\n for name_image in list_name_image:\\n body_main_content = body_main_content.replace(\\n \\\"src=\\\\\\\"\\\" + name_image + \\\"\\\\\\\"\\\",\\n \\\"src=\\\\\\\"{% static \\\\\\\"schema_viewer/oxygen/\\\" + schema_name + \\\"/\\\" + name_image + \\\"\\\\\\\" %}\\\\\\\"\\\"\\n )\\n return body_main_content\",\n \"def image_link_collector(self, count):\\n pass\",\n \"def image(self, src, title, text):\\n src = escape_link(src)\\n text = escape(text, quote=True)\\n if title:\\n title = escape(title, quote=True)\\n html = '<img src=\\\"%s\\\" alt=\\\"%s\\\" title=\\\"%s\\\"' % (src, text, title)\\n else:\\n html = '<img src=\\\"%s\\\" alt=\\\"%s\\\"' % (src, text)\\n if self.options.get('use_xhtml'):\\n return '%s />' % html\\n return '%s>' % html\",\n \"def get_image_url():\",\n \"def MakeImageURL(fname, hyperlink='openfile', **kwargs):\\n prefix = 'cdb://image/'\\n if not _isSupportedUriPath(fname):\\n fname = 'file:///%s' % os.path.basename(fname)\\n else:\\n fname = fname.replace('\\\\\\\\', '/')\\n if hyperlink:\\n hyperlink = ' cdb:hyperlink:%s' % hyperlink\\n else:\\n hyperlink = ''\\n return '%s%s%s' % (prefix, fname, hyperlink)\",\n \"def get_image_link(self):\\n table = self.soup.find('table')\\n image_tag = table.find('img')\\n image_name = self.soup.find_all(\\\"b\\\")[1].text\\n return image_tag['src'], image_name\\n\\n # image = td.find_all('img')\\n # print(image)\\n # if image is not None:\\n # return urljoin(self.base_url, image['src'])\",\n \"def getLink(self):\",\n \"def test_image_links(self):\\r\\n print('\\\\nTest image links: ', end='', flush=True)\\r\\n driver = self.driver\\r\\n driver.get(MY_URL)\\r\\n all_images = driver.find_elements_by_tag_name('img')\\r\\n for image in all_images:\\r\\n src = image.get_attribute('src')\\r\\n alt = image.get_attribute('alt')\\r\\n r = requests.get(src)\\r\\n assert r.status_code == 200, 'Bad http status (%d) for %s' % (r.status_code, src)\\r\\n assert len(alt) > 0, 'Missing or empty alt tag for %s' % (src)\\r\\n print('.', end=\\\"\\\", flush=True)\\r\\n if DEBUG:\\r\\n print ('Src=%s' % src)\",\n \"def get_image_link():\\n image_links = set()\\n supplemented_keyword = urllib.parse.quote(\\n supplemented_keywords[random.randint(0,\\n len(supplemented_keywords) - 1)],\\n safe='')\\n main_keyword = urllib.parse.quote(\\n main_keywords[random.randint(0,\\n len(main_keywords) - 1)], safe='')\\n\\n # print('the theme of cats: ' + supplemented_keyword)\\n\\n search_query = (main_keyword + ' ' + supplemented_keyword).replace(\\n ' ', '%20')\\n url = 'https://www.google.com/search?q=' + \\\\\\n search_query + '&source=lnms&tbm=isch'\\n image_links = image_links.union(parse_page(url))\\n\\n image_link = list(image_links)[random.randint(0, len(image_links) - 1)]\\n # print('link:' + image_link)\\n\\n while 'https://' not in image_link or r'\\\\\\\\u' in image_link or '.jpg' not in image_link:\\n image_link = list(image_links)[random.randint(0, len(image_links) - 1)]\\n # print('link:' + image_link)\\n\\n return image_link\",\n \"def __init__(self, filename, hyperlink=None, width=None, height=None, kind='direct',\\r\\n mask='auto', lazy=1, hAlign='CENTER'):\\r\\n super(HyperlinkedImage, self).__init__(filename, width, height, kind, mask, lazy, hAlign=hAlign)\\r\\n self.hyperlink = hyperlink\",\n \"def image_link(self):\\r\\n\\r\\n if not self._image_link:\\r\\n warnings.warn(\\\"Seems like you are trying to pull out the image link while not having it.\\\", Warning, stacklevel=2)\\r\\n\\r\\n return self._image_link\",\n \"def GET_link_thumb(self, *a, **kw):\\r\\n return \\\"nothing to see here.\\\"\",\n \"def links_json(self, absolutize_url):\\n return [\\n {\\n \\\"href\\\": absolutize_url(\\\"v2/{0}/images/{1}\\\"\\n .format(self.tenant_id, self.image_id)),\\n \\\"rel\\\": \\\"self\\\"\\n },\\n {\\n \\\"href\\\": absolutize_url(\\\"{0}/images/{1}\\\"\\n .format(self.tenant_id, self.image_id)),\\n \\\"rel\\\": \\\"bookmark\\\"\\n },\\n {\\n \\\"href\\\": absolutize_url(\\\"/images/{0}\\\"\\n .format(self.image_id)),\\n \\\"type\\\": \\\"application/vnd.openstack.image\\\",\\n \\\"rel\\\": \\\"alternate\\\"\\n }\\n ]\",\n \"def links_json(self, absolutize_url):\\n return [\\n {\\n \\\"href\\\": absolutize_url(\\\"v2/{0}/images/{1}\\\"\\n .format(self.tenant_id, self.image_id)),\\n \\\"rel\\\": \\\"self\\\"\\n },\\n {\\n \\\"href\\\": absolutize_url(\\\"{0}/images/{1}\\\"\\n .format(self.tenant_id, self.image_id)),\\n \\\"rel\\\": \\\"bookmark\\\"\\n },\\n {\\n \\\"href\\\": absolutize_url(\\\"/images/{0}\\\"\\n .format(self.image_id)),\\n \\\"type\\\": \\\"application/vnd.openstack.image\\\",\\n \\\"rel\\\": \\\"alternate\\\"\\n }\\n ]\",\n \"def add_anchor_image(self, element, body):\\n # TODO defensive coding\\n src_url = element.attrib['src']\\n picid, picname, picdescription, width, height = self.download_image(src_url)\\n picrelid = 'rId'+str(len(self.relationships)+1)\\n self.relationships.append(['http://schemas.openxmlformats.org/officeDocument/2006/relationships/image', 'media/'+picname])\\n graphic = self.create_graphic_tag(width, height, picrelid, picid, picname, picdescription)\\n anchor = docx.makeelement('anchor', nsprefix='wp',\\n attributes={'allowOverlap':'1',\\n 'behindDoc':'0',\\n 'distB':'0',\\n 'distL':'0',\\n 'distR':'0',\\n 'distT':'0',\\n 'layoutInCell':'1',\\n 'locked':'0',\\n 'relativeHeight':'3',\\n 'simplePos':'0'})\\n anchor.append(docx.makeelement('simplePos', nsprefix='wp', attributes={'x':'0', 'y':'0'}))\\n positionH = docx.makeelement('positionH', nsprefix='wp', attributes={'relativeFrom':'column',})\\n positionH.append(docx.makeelement('posOffset', tagtext='1506220', nsprefix='wp'))\\n anchor.append(positionH)\\n positionV = docx.makeelement('positionV', nsprefix='wp', attributes={'relativeFrom':'paragraph',})\\n positionV.append(docx.makeelement('posOffset', tagtext='0', nsprefix='wp'))\\n anchor.append(positionV)\\n anchor.append(docx.makeelement('extent', nsprefix='wp', attributes={'cx':str(width), 'cy':str(height)}))\\n anchor.append(docx.makeelement('effectExtent', nsprefix='wp', attributes={'b':'0', 'l':'0', 'r':'0', 't':'0'}))\\n anchor.append(docx.makeelement('wrapNone', nsprefix='wp'))\\n anchor.append(docx.makeelement('docPr', nsprefix='wp', attributes={'id': picid, 'name': 'Picture 1', 'descr': picdescription}))\\n cNvGraphicFramePr = docx.makeelement('cNvGraphicFramePr', nsprefix='wp')\\n cNvGraphicFramePr.append(docx.makeelement('graphicFrameLocks', nsprefix='a', attributes={'noChangeAspect':'1',}))\\n anchor.append(cNvGraphicFramePr)\\n # now we can append the actual graphic\\n anchor.append(graphic)\\n drawing = docx.makeelement('drawing', nsprefix='w')\\n drawing.append(anchor)\\n r = docx.makeelement('r', nsprefix='w')\\n r.append(docx.makeelement('rPr', nsprefix='w'))\\n r.append(drawing)\\n p = docx.makeelement('p', nsprefix='w')\\n pPr = docx.makeelement('pPr', nsprefix='w')\\n pPr.append(docx.makeelement('pStyle', nsprefix='w', attributes={'val':'style0',}))\\n p.append(pPr)\\n p.append(r)\\n body.append(p)\",\n \"def get_image(result):\\n article_id = result['id']\\n id_ = article_id[14:]\\n href = article_id[:14]\\n\\n #FIXME: not working\\n image_url = \\\"http://www.jpress.nli.org.il/Olive/APA/NLI_heb/get/GetImage.ashx?kind=block&href=%s&id=%s&ext=.png\\\" %(href, id_)\\n \\n return image_url\",\n \"def hook_image_tag(self, parser, space, name):\\n link = name\\n caption = name\\n params = {}\\n\\n # Parse the inner syntax, e.g. [[Image:src|option=val|caption]]\\n separator = name.find('|')\\n items = []\\n if separator != -1:\\n items = link.split('|')\\n link = items[0]\\n # If the last item contains '=', it's not a caption\\n if items[-1].find('=') == -1:\\n caption = items[-1]\\n items = items[1:-1]\\n else:\\n caption = link\\n items = items[1:]\\n\\n # parse the relevant items\\n params = self._buildImageParams(items)\\n img_path = self._getImagePath(link)\\n\\n template = jingo.env.get_template('wikiparser/hook_image.html')\\n r_kwargs = {'img_path': img_path, 'caption': caption, 'params': params}\\n return template.render(**r_kwargs)\",\n \"def replfunc(self, match):\\n url = match.group(1)\\n imgformat = url.split('.')[-1]\\n if url.startswith('http'):\\n data = urlopen(url).read()\\n elif url.startswith('data'):\\n img = '<img src=\\\"' + url + '\\\" ' + match.group(2) + ' />'\\n return img\\n else:\\n with open(url, 'rb') as f:\\n data = f.read()\\n\\n self.log.info(\\\"embedding url: %s, format: %s\\\" % (url, imgformat))\\n b64_data = base64.b64encode(data).decode(\\\"utf-8\\\")\\n if imgformat == \\\"svg\\\":\\n img = '<img src=\\\"data:image/svg+xml;base64,' + \\\\\\n b64_data + '\\\" ' + match.group(2) + '/>'\\n elif imgformat == \\\"pdf\\\":\\n img = '<img src=\\\"data:application/pdf;base64,' + \\\\\\n b64_data + '\\\" ' + match.group(2) + '/>'\\n else:\\n img = '<img src=\\\"data:image/' + imgformat + \\\\\\n ';base64,' + b64_data + '\\\" ' + match.group(2) + ' />'\\n return img\",\n \"def get_thumbnail_url():\",\n \"def get_image_links(data):\\n painting_links = []\\n\\n print(data)\\n\\n for painting in data:\\n painting_links.append(painting['image'])\\n\\n return painting_links\",\n \"def process_image_url(value, field):\\n if field.width:\\n if not value:\\n return u\\\"无\\\"\\n return mark_safe(\\\"\\\"\\\"\\n <a href=\\\"{0}\\\" target=\\\"_blank\\\"><img src=\\\"{0}\\\" width=\\\"{1}\\\" a>\\n \\\"\\\"\\\".format(absolute_media_path(value), field.width))\\n # only show url address.\\n elif value:\\n shorten_value = ''\\n if len(value) > 20:\\n shorten_value = value[0:12] + \\\"...\\\"\\n return mark_safe(\\\"\\\"\\\"\\n <a href=\\\"{0}\\\" target=\\\"_blank\\\" title=\\\"{0}\\\" >{1}</a>\\n \\\"\\\"\\\".format(absolute_media_path(value), shorten_value if shorten_value else value))\\n else:\\n return \\\"\\\"\",\n \"def __urlImageGenerator(cls, link):\\n\\n try:\\n a = Article(url=link)\\n a.download()\\n a.parse()\\n a.fetch_images()\\n\\n for img in a.imgs:\\n yield img\\n except Exception:\\n pass\",\n \"def show_image_ref():\\n return get_image_ref()\",\n \"def link(self, obj):\\n return format_html(\\n '<a href=\\\"{url}\\\">{url}</a>',\\n url='https://sms.cam.ac.uk/media/{}'.format(obj.id)\\n )\",\n \"def generate_link_kml(self, d):\\n return \\\"\\\"\\\"\\\\\\n <NetworkLink>\\n <name>%(image_filename)s</name>\\n <Region>\\n <Lod>\\n <minLodPixels>%(minlodpixels)d</minLodPixels>\\n <maxLodPixels>-1</maxLodPixels>\\n </Lod>\\n <LatLonAltBox>\\n <north>%(north).14f</north>\\n <south>%(south).14f</south>\\n <east>%(east).14f</east>\\n <west>%(west).14f</west>\\n </LatLonAltBox>\\n </Region>\\n <Link>\\n <href>%(link_url)s</href>\\n <viewRefreshMode>onRegion</viewRefreshMode>\\n </Link>\\n </NetworkLink>\\\"\\\"\\\" % d\",\n \"def formatArrayHyperlink(txt, lnk, filename):\\n if oapackage.oahelper.oaIsBinary(filename):\\n ss = e.a(txt + e.small(\\\" (binary)\\\"), href=lnk, class_=\\\"binarylink\\\")\\n else:\\n ss = e.a(txt, href=lnk, class_=\\\"normal\\\")\\n return ss\",\n \"def image_preview(self):\\r\\n h = '<img src=\\\"%s\\\" alt=\\\"Campaign badge\\\"/>' % self.image.url\\r\\n return mark_safe(h)\",\n \"def img_url_display(self):\\n url = '%s=s%s' % (self.img_url, self.DISPLAY_SIZE_PX)\\n if self.img_rot in Plaque.ALLOWED_ROTATIONS:\\n url = \\\"%s-r%s\\\" % (url, self.img_rot)\\n return url\",\n \"def testImgAndUrlUseSameUrl(self):\\n self.assertIn(self.chart.display.Url(500, 100, use_html_entities=True),\\n self.chart.display.Img(500, 100))\",\n \"def saveImages(self):\\n if self.imageLink and not self.image:\\n f= open('imageLink.txt','wb')\\n f.write(bytes(str(self.imageLink), 'UTF-8'))\\n f.close()\\n req = urllib3.urlopen(self.imageLink, headers={'User-Agent': 'Mozilla/5.0'})\\n result = urllib3.urlopen(req)\\n self.image.save(os.path.basename(self.imageLink),ContentFile(result.read()))\\n print (\\\"Image saved\\\")\\n self.save()\",\n \"def getimgs():\",\n \"def test_class_image(self):\\n fwa = FakeWikiArchivo(\\n 'abcd <a href=\\\"/wiki/foobar\\\" class=\\\"image\\\">FooBar</a> dcba'\\n )\\n _, r = self.peishranc(fwa)\\n self.assertEqual(r, [])\",\n \"def figure_links(self):\\n dirpath = os.path.join(config[\\\"src_dir\\\"], config[\\\"figures_subdir\\\"])\\n assert os.path.exists(dirpath), f\\\"- figures subdirectory {dirpath} was not found\\\"\\n figures = [f for f in os.listdir(dirpath) if os.path.isfile(os.path.join(dirpath, f))\\n and not f.startswith('.') and not f.endswith('.tex') and not f.endswith('.pdf')]\\n figures = filter(lambda f: any([re.search(f, cell.source) for cell in self.content.cells]), figures)\\n return [(os.path.join(config[\\\"figures_subdir\\\"], figure), f\\\"{config['github_pages_url']}/figures/{figure}\\\") for figure in figures]\",\n \"def test_main():\\n parser = HTMLTagParser()\\n parser.parse('<img>some text</img><a href=\\\"www\\\"><t>,</t>linkkkk</a>')\\n for link in parser.links:\\n print(link.attributes, link.data)\\n for image in parser.images:\\n print(image.attributes, image.data)\",\n \"def link(address):\",\n \"def embed_image(self, node):\\r\\n xlink = node.get('xlink:href')\\r\\n if xlink and xlink[:5] == 'data:':\\r\\n # No need, data alread embedded\\r\\n return\\r\\n\\r\\n url = urllib.parse.urlparse(xlink)\\r\\n href = urllib.request.url2pathname(url.path)\\r\\n\\r\\n # Primary location always the filename itself.\\r\\n path = self.absolute_href(href or '')\\r\\n\\r\\n # Backup directory where we can find the image\\r\\n if not os.path.isfile(path):\\r\\n path = node.get('sodipodi:absref', path)\\r\\n\\r\\n if not os.path.isfile(path):\\r\\n inkex.errormsg('File not found \\\"{}\\\". Unable to embed image.'.format(path))\\r\\n return\\r\\n\\r\\n with open(path, \\\"rb\\\") as handle:\\r\\n # Don't read the whole file to check the header\\r\\n file_type = self.get_image_type(path, handle.read(10))\\r\\n handle.seek(0)\\r\\n\\r\\n if file_type:\\r\\n # Future: Change encodestring to encodebytes when python3 only\\r\\n node.set('xlink:href', 'data:{};base64,{}'.format(\\r\\n file_type, base64.encodebytes(handle.read()).decode('ascii')))\\r\\n node.pop('sodipodi:absref')\\r\\n else:\\r\\n inkex.errormsg(\\\"%s is not of type image/png, image/jpeg, \\\"\\r\\n \\\"image/bmp, image/gif, image/tiff, or image/x-icon\\\" % path)\",\n \"def gen_links(text):\\n return []\",\n \"def test_with_links(self):\\n self.result.figure_link = 'some_link'\\n self.result.start_figure_link = 'other_link'\\n figure_link, start_link = fitting_report.get_figure_paths(self.result)\\n self.assertEqual(figure_link, os.path.join('figures', 'some_link'))\\n self.assertEqual(start_link, os.path.join('figures', 'other_link'))\",\n \"def get_image_comic_url(session, response):\\n soup = bs(response.text, 'lxml')\\n for div in soup.find_all('div', class_=\\\"img-comic-container\\\"):\\n for a in div.find_all('a', class_=\\\"img-comic-link\\\"):\\n for img in a.find_all('img', src=True):\\n return \\\"https:\\\" + img['src']\",\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 generate_file_link_html_from_url(self, s3_public_url, file_name):\\r\\n image_link = \\\"\\\"\\\"\\r\\n <a href=\\\"{0}\\\" target=\\\"_blank\\\">{1}</a>\\r\\n \\\"\\\"\\\".format(s3_public_url, file_name)\\r\\n return image_link\",\n \"def embed_images(self):\\n for img in self.book.xpath(\\\"//img[ not(starts-with(@src, 'data:')) and @src!= '']\\\"):\\n img_src = img.attrib[\\\"src\\\"]\\n img_raw = self.get_remote_content(img_src)\\n if img_raw != None:\\n img_64 = base64.b64encode(img_raw)\\n file_info = os.path.splitext(img_src)\\n ext = file_info[1].replace(\\\".\\\", \\\"\\\")\\n ext = re.sub(\\\"\\\\?.*$\\\", \\\"\\\" , ext)\\n \\n if ext == \\\"svg\\\":\\n svg = html.fromstring(img_raw.decode(\\\"utf-8\\\"))\\n img.clear()\\n img.tag = \\\"svg\\\"\\n img[:] = [svg]\\n else:\\n img.set(\\\"src\\\", \\\"data:image/{};base64,{}\\\".format(ext, img_64.decode(\\\"utf-8\\\")))\",\n \"def create_link(self):\\n self.filename = App.get_running_app().root.ids.camera_screen.capture()\\n self.url = FileSharer(self.filename).share()\\n self.ids.label.text = self.url\",\n \"def fix_links():\\n pass\",\n \"def file_from_external_link(self, uri):\\n images = []\\n uri = uri.split('://')[1]\\n objgen = pagegenerators.LinksearchPageGenerator(uri, namespaces=[6],\\n site=self.commons)\\n for page in objgen:\\n images.append(pywikibot.FilePage(self.commons, page.title()))\\n\\n # I have no clue how the above results in duplicates, but it does so...\\n images = list(set(images))\\n\\n return images\",\n \"def make_node_urls(self, node_data):\\n node_display = node_data['display_url']\\n if node_data['__typename'] == 'GraphVideo':\\n return ['video', node_display, node_data['video_url']]\\n\\n return ['image', node_display, node_display]\",\n \"async def img(ctx, message):\\n \\\"\\\"\\\":param: ctx\\\"\\\"\\\"\\n \\\"\\\"\\\":param: message\\\"\\\"\\\"\\n \\\"\\\"\\\"return image url\\\"\\\"\\\"\\n link_list = []\\n\\n url = \\\"http://imgur.com/search?q=\\\" + message\\n response = urlopen(url)\\n html = response.read()\\n soup = BeautifulSoup(html, \\\"lxml\\\")\\n for a in soup.find_all('a', href=True):\\n if((a['href'][0:9]) == \\\"/gallery/\\\"):\\n link_list.append(\\\"https://imgur.com/\\\" + a['href'])\\n if(len(link_list) >=1):\\n random_num = random.randint(0, len(link_list) - 1)\\n await bot.say(link_list[random_num])\\n else:\\n await bot.say(\\\"there is no contente for \\\"+message)\",\n \"def _make_doi_clickable(link):\\n return f\\\"https://doi.org/{link}\\\"\",\n \"def check_link_tag(self):\\r\\n node = self.article.raw_doc\\r\\n meta = self.parser.getElementsByTag(node, tag='link', attr='rel', value='image_src')\\r\\n for item in meta:\\r\\n src = self.parser.getAttribute(item, attr='href')\\r\\n if src:\\r\\n return self.get_image(item, src, extraction_type='linktag')\\r\\n return None\",\n \"def makeLinks(self):\\n self.deleteIndexFileIfExists()\\n _fileNames = self.getHTMLFileNames()\\n _msgPart1 = \\\"<a href=\\\\\\\"\\\"\\n _msgPart2 = \\\"\\\\\\\" target=\\\\\\\"loadHTMLResults\\\\\\\">\\\"\\n _msgPart3 = \\\"</a><br>\\\"\\n _link = \\\"\\\"\\n for _fileName in _fileNames:\\n _origFileName = _fileName\\n _linkName = _fileName.split('.')[0]\\n _createAnchorTag = (_msgPart1+str(_origFileName)+_msgPart2+str(_linkName)+_msgPart3)\\n _link = _link + _createAnchorTag\\n return _link\",\n \"def replace_local_hyperlinks(\\n text,\\n base_url=\\\"https://github.com/project-rig/nengo_spinnaker/blob/master/\\\"\\n ):\\n def get_new_url(url):\\n return base_url + url[2:]\\n\\n # Deal with anonymous URLS\\n for match in re.finditer(r\\\"^__ (?P<url>\\\\./.*)\\\", text, re.MULTILINE):\\n orig_url = match.groupdict()[\\\"url\\\"]\\n url = get_new_url(orig_url)\\n\\n text = re.sub(\\\"^__ {}\\\".format(orig_url),\\n \\\"__ {}\\\".format(url), text, flags=re.MULTILINE)\\n\\n # Deal with named URLS\\n for match in re.finditer(r\\\"^\\\\.\\\\. _(?P<identifier>[^:]*): (?P<url>\\\\./.*)\\\",\\n text, re.MULTILINE):\\n identifier = match.groupdict()[\\\"identifier\\\"]\\n orig_url = match.groupdict()[\\\"url\\\"]\\n url = get_new_url(orig_url)\\n\\n text = re.sub(\\n \\\"^\\\\.\\\\. _{}: {}\\\".format(identifier, orig_url),\\n \\\".. _{}: {}\\\".format(identifier, url),\\n text, flags=re.MULTILINE)\\n\\n # Deal with image URLS\\n for match in re.finditer(r\\\"^\\\\.\\\\. image:: (?P<url>\\\\./.*)\\\",\\n text, re.MULTILINE):\\n orig_url = match.groupdict()[\\\"url\\\"]\\n url = get_new_url(orig_url)\\n\\n text = text.replace(\\\".. image:: {}\\\".format(orig_url),\\n \\\".. image:: {}\\\".format(url))\\n\\n return text\",\n \"async def olá(self):\\r\\n\\t\\tawait self.client.say('© Maddie 2017')\\r\\n\\t\\te = Embed()\\r\\n\\t\\te.set_image(url='https://cdn.discovery.pgsitecore.com/en-us/-/media/Olay_PathFinder/Images/a/OLAY%20TE%207IN1%20DEEP%20PENETRATING%20MOISTURE%20BODY%20WASH_Front.png?w=460&v=1-201705260605')\\r\\n\\t\\tawait self.client.say(embed=e)\",\n \"def fix_image_links_in_static_portlet(portal):\\n\\n def get_image_uid(image):\\n \\\"\\\"\\\"Return image UID.\\\"\\\"\\\"\\n folder = portal['imagens']\\n if image in folder:\\n return folder[image].UID()\\n\\n manager = getUtility(IPortletManager, name='plone.rightcolumn', context=portal)\\n mapping = getMultiAdapter((portal, manager), IPortletAssignmentMapping)\\n\\n assert 'midias-sociais' in mapping\\n portlet = mapping['midias-sociais']\\n images = [\\n 'ico-facebook.png', 'ico-twitter.png', 'ico-linkedin.png',\\n 'ico-youtube.png', 'ico-flickr.png'\\n ]\\n for i in images:\\n uid = 'resolveuid/' + get_image_uid(i)\\n portlet.text = portlet.text.replace(i, uid)\\n logger.debug(u'Links substituidos no portlet de midias sociais')\\n\\n assert 'banners' in mapping\\n portlet = mapping['banners']\\n image = 'acesso-a-informacao.png'\\n uid = 'resolveuid/' + get_image_uid(image) + '/image_mini'\\n portlet.text = portlet.text.replace(image, uid)\\n logger.debug(u'Link substituido no portlet de acesso a informacao')\",\n \"def getimage(self):\",\n \"def _generate_links(self):\\n index = 0\\n links = \\\"\\\"\\n for ch in self.text:\\n if ch == '[':\\n links += \\\"(^\\\"\\n elif ch == ']':\\n links += \\\")$|\\\"\\n index += 1\\n elif links[-1:] != '|' and links != \\\"\\\":\\n links += ch\\n self.links = compile(links[:-1].lower())\",\n \"def url(self):\\n\\t\\treturn self.base_url+\\\"{}/{}/{}.jpg\\\".format(self.template,self._escape(self.top_text),self._escape(self.bottom_text))+(\\\"?\\\"+\\\"&\\\".join([\\\"{}={}\\\".format(k,quote(self.kwargs[k])) for k in self.kwargs]) if self.kwargs else \\\"\\\")\",\n \"def create_link(seconds, image_name, size):\\n token = signing.dumps([str(timezone.now() + timedelta(seconds=int(seconds))), image_name, size])\\n return settings.SERVER_PATH + reverse(\\\"image:dynamic-image\\\", kwargs={\\\"token\\\": token})\",\n \"def add_image_hrefs(feed):\\n supported_image_types = ('image/jpeg', 'image/png')\\n entries = feed.get('entries', [])\\n for entry in entries:\\n if 'image' not in entry:\\n try:\\n for link in entry.get('links', []):\\n try:\\n if link.get('type') in supported_image_types:\\n entry['image'] = link.get('href')\\n break\\n except AttributeError:\\n continue\\n except (TypeError, AttributeError):\\n pass\\n\\n image_getters = (\\n lambda e: e['image'] if isinstance(e['image'], basestring) else None,\\n lambda e: e['image']['href'] if e['image'] else None,\\n lambda e: prioritize_jpeg(e['media_thumbnail']),\\n lambda e: prioritize_jpeg(e['media_content']))\\n\\n for getter in image_getters:\\n try:\\n image = getter(entry)\\n if image:\\n entry['image'] = image\\n break\\n except (KeyError, IndexError, TypeError):\\n pass\\n return feed\",\n \"def link_click(_):\\r\\n\\r\\n tag_name = about_content.tag_names(tkinter.CURRENT)[0]\\r\\n about_content.tag_config(tag_name, foreground=\\\"#551A8B\\\")\\r\\n if tag_name == 'hyper':\\r\\n webbrowser.open(\\\"https://www.facebook.com/nihal.agarwal.14\\\")\\r\\n else:\\r\\n webbrowser.open(\\\"https://github.com/NihalAgarwal/Windows-Wi-Fi-Manager\\\")\",\n \"def link(self, obj):\\n return format_html(\\n '<a href=\\\"{url}\\\">{url}</a>',\\n url='https://sms.cam.ac.uk/collection/{}'.format(obj.id)\\n )\",\n \"def link(self, link, title, text):\\n link = escape_link(link)\\n return [MdStyleInstructionLink(link)] + text\",\n \"def logosmall(self):\\n try:\\n asset = self.app.module_map.uploader.get(self.barcamp.logo)\\n except AssetNotFound:\\n asset = None\\n if not asset:\\n return u\\\"\\\"\\n v = asset.variants['medium_user']\\n url = self.app.url_for(\\\"asset\\\", asset_id = v._id)\\n return \\\"\\\"\\\"<a href=\\\"%s\\\"><img src=\\\"%s\\\" width=\\\"%s\\\" height=\\\"%s\\\"></a>\\\"\\\"\\\" %(\\n self.handler.url_for(\\\"barcamps.index\\\", slug = self.barcamp.slug),\\n url,\\n v.metadata['width'],\\n v.metadata['height'])\",\n \"def image(self, text):\\n pattern = re.compile(r\\\"\\\"\\\"\\n (?:[\\\\[{])? # pre\\n \\\\! # opening !\\n (\\\\<|\\\\=|\\\\>)? # optional alignment atts\\n (%s) # optional style,class atts\\n (?:\\\\. )? # optional dot-space\\n ([^\\\\s(!]+) # presume this is the src\\n \\\\s? # optional space\\n (?:\\\\(([^\\\\)]+)\\\\))? # optional title\\n \\\\! # closing\\n (?::(\\\\S+))? # optional href\\n (?:[\\\\]}]|(?=\\\\s|$)) # lookahead: space or end of string\\n \\\"\\\"\\\" % self.c, re.U | re.X)\\n return pattern.sub(self.fImage, text)\",\n \"def iter_links(self):\",\n \"def url_maker():\\n chars = string.ascii_lowercase + string.ascii_uppercase + string.digits\\n tempchar = [random.choice(chars) for n in range(5)]\\n return \\\"http://i.imgur.com/\\\" + \\\"\\\".join(tempchar)\",\n \"def getExpandedLinks():\",\n \"def image_reference(self, image_id):\\n info = self.image_info[image_id]\\n if info[\\\"source\\\"] == \\\"coco\\\":\\n return \\\"http://cocodataset.org/#explore?id={}\\\".format(info[\\\"id\\\"])\\n else:\\n super(CocoDataset, self).image_reference(image_id)\",\n \"def _icons(self, c_brain):\\n if c_brain.portal_type not in self.i_cache:\\n icon_link = ''\\n purl = api.portal.get_tool('portal_url')()\\n typeInfo = api.portal.get_tool('portal_types')[c_brain.portal_type]\\n if typeInfo.icon_expr:\\n # we assume that stored icon_expr is like string:${portal_url}/myContentIcon.png\\n # or like string:${portal_url}/++resource++imio.dashboard/dashboardpodtemplate.png\\n contentIcon = '/'.join(typeInfo.icon_expr.split('/')[1:])\\n title = translate(typeInfo.title, domain=typeInfo.i18n_domain, context=self.request)\\n icon_link = u\\\"<img title='%s' src='%s/%s' />\\\" % (safe_unicode(escape(title)), purl, contentIcon)\\n self.i_cache[c_brain.portal_type] = icon_link\\n return self.i_cache[c_brain.portal_type]\",\n \"def thumbnail_url(link):\\r\\n return 'http:/%s%s.png' % (s3_thumbnail_bucket, link._fullname)\",\n \"def url_for(**options):\\n\\n url_parts = get_url_parts(**options)\\n image_hash = hashlib.md5(b(options[\\\"image_url\\\"])).hexdigest()\\n url_parts.append(image_hash)\\n\\n return \\\"/\\\".join(url_parts)\",\n \"def l10n_img(ctx, url):\\n return static(l10n_img_file_name(ctx, url))\",\n \"def link(self):\\n return f\\\"[{self.numbered_title}]({self.html_url})\\\"\",\n \"def get_image_url(article):\\n get_image = article.find_all(\\\"img\\\")[0]\\n return get_image.get(\\\"src\\\").replace(\\\"../../\\\", \\\"http://books.toscrape.com/\\\")\",\n \"def create_image_caption_pairs(self):\",\n \"def get_url_image(self, obj):\\n return settings.IMAGE_HOST + obj.image.url\",\n \"def get_url_image(self, obj):\\n return settings.IMAGE_HOST + obj.image.url\",\n \"def get_url_image(self, obj):\\n return settings.IMAGE_HOST + obj.image.url\",\n \"async def link(self, ctx):\\n item_matches = self.re.findall(ctx.message.content)\\n if not item_matches:\\n return\\n tasks = []\\n print(item_matches)\\n for item in item_matches[:5]:\\n tasks.append(self.bot.loop.run_in_executor(None,\\n find_one, item.strip('[[').strip(']]'),\\n self.client, self.bot.loop))\\n results = await asyncio.gather(*tasks)\\n results = [x for x in results if x]\\n images = []\\n for result in results:\\n if result.base == \\\"Prophecy\\\":\\n flavor = 'prophecy'\\n elif 'gem' in result.tags:\\n flavor = 'gem'\\n print(result.vendors)\\n else:\\n flavor = result.rarity\\n r = utils.ItemRender(flavor)\\n images.append(r.render(result))\\n if len(images) > 1:\\n box = [0, 0]\\n for image in images:\\n box[0] = box[0] + image.size[0]\\n if image.size[1] > box[1]:\\n box[1] = image.size[1]\\n box[0] = box[0] + (2*len(images))\\n img = Image.new('RGBA', box, color='black')\\n #img.show()\\n paste_coords = [0, 0]\\n for image in images:\\n #image.show()\\n img.paste(image.convert('RGBA'), box=paste_coords[:])\\n paste_coords[0] = paste_coords[0] + image.size[0] + 2\\n else:\\n img = images[0]\\n image_fp = BytesIO()\\n img.save(image_fp, 'png')\\n image_fp.seek(0)\\n print(\\\"Image ready\\\")\\n await ctx.channel.send(file=File(image_fp, filename='image.png'))\",\n \"def cleanup_links(path, inspect_links=False):\\n with open(path) as f:\\n text = f.read()\\n\\n# if 'BokehJS does not appear to have successfully loaded' in text:\\n# for k, v in BOKEH_REPLACEMENTS.items():\\n# text = text.replace(k, v)\\n\\n text = component_links(text, path)\\n soup = BeautifulSoup(text, features=\\\"html.parser\\\")\\n for a in soup.findAll('a'):\\n href = a.get('href', '')\\n if '.ipynb' in href and 'http' not in href:\\n # for k, v in LINK_REPLACEMENTS.items():\\n # href = href.replace(k, v)\\n a['href'] = href.replace('.ipynb', '.html')\\n\\n # check to make sure that path exists, if not, try un-numbered version\\n try_path = os.path.join(os.path.dirname(path), a['href'])\\n if not os.path.exists(try_path):\\n num_name = os.path.basename(try_path)\\n name = re.split(r\\\"^\\\\d+( |-|_)\\\", num_name)[-1]\\n new_path = try_path.replace(num_name, name)\\n if os.path.exists(new_path):\\n a['href'] = os.path.relpath(new_path, os.path.dirname(path))\\n else:\\n also_tried = 'Also tried: {}'.format(name) if name != num_name else ''\\n warnings.warn('Found missing link {} in: {}. {}'.format(a['href'], path, also_tried))\\n\\n if inspect_links and 'http' in a['href']:\\n print(a['href'])\\n for img in soup.findAll('img'):\\n src = img.get('src', '')\\n if 'http' not in src and 'assets' in src:\\n try_path = os.path.join(os.path.dirname(path), src)\\n if not os.path.exists(try_path):\\n also_tried = os.path.join('..', src)\\n if os.path.exists(os.path.join(os.path.dirname(path), also_tried)):\\n img['src'] = also_tried\\n else:\\n warnings.warn('Found reference to missing image {} in: {}. Also tried: {}'.format(src, path, also_tried))\\n with open(path, 'w') as f:\\n f.write(str(soup))\",\n \"def post_line_to_list_of_local_image_links(line):\\n normal_img = '<img .*?src=\\\"([^\\\"]*?)(?:&thumb=1)?\\\".*?>'\\n md_img = '!\\\\[[^\\\\]]*\\\\]\\\\(([^)]*?)(?:&thumb=1)?\\\\)'\\n exp = re.compile(normal_img + \\\"|\\\" + md_img)\\n results = itertools.chain(*re.findall(exp, line))\\n\\n return [item for item in results if item and not item.startswith(\\\"http\\\")]\",\n \"def _getImagePath(self, link):\\n return settings.WIKI_UPLOAD_URL + urlquote(link)\",\n \"def append_links(self, lines, lang):\\n lines.append(\\\"verbatim \\\")\\n lines.append(\\\"section Links\\\")\\n lines.append(\\\"external http://polcasaglia.blogspot.com Blog\\\")\\n lines.append(\\\"external http://www.uisp-fe.it/calcio.php UISP\\\" )\\n lines.append(\\\"verbatim \\\")\\n return lines\",\n \"def image_preview(self):\\r\\n h = '<img src=\\\"%s\\\" alt=\\\"%s\\\"/>' % (self.image_resized_url, self.title)\\r\\n return mark_safe(h)\",\n \"def add_three_images(document_text, image_link_template, image_folder, images, width):\\n for idx in range(3):\\n document_text += \\\"\\\\n\\\"\\n image_info = r'<td>{0}</td>'.format(image_link_template.format(\\n os.path.join(image_folder, images[idx]), width))\\n document_text = add_document_text(document_text, image_info)\\n return document_text\",\n \"def parse_links(self, content):\\n ret = set()\\n\\n soup = BeautifulSoup(content)\\n all_a = [x['href'] for x in soup.findAll('a')]\\n all_img = [x['src'] for x in soup.findAll('img') if x['src']]\\n\\n for x in all_a:\\n # Special exception for /tracks/signup/... - that URL always redirects\\n if 'login' in x or not x.startswith('/') or x.startswith('/tracks/signup/'):\\n continue\\n\\n ret.add(x)\\n\\n return ret, all_img\",\n \"def barbican_url(self):\",\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 get_img_ref_from_attrs(attrs):\\n\\n for attr in attrs:\\n if attr[0]== 'src':\\n if isImage(attr[1]):\\n list_of_img_refs.append(attr[1])\\n\\n if attr[0] == 'href':\\n if isImage(attr[1]):\\n list_of_img_refs.append(attr[1])\",\n \"def add_link():\\n return True\",\n \"async def _misc_IMGplumbob(self, ctx):\\r\\n await self.bot.say('{}, http://i.imgur.com/q8xJsJQ.gif'.format(ctx.message.author.mention))\",\n \"def _extract_image_links(self, publication, feed_self_url):\\n self._logger.debug(\\n \\\"Started extracting image links from {0}\\\".format(\\n encode(publication.images)\\n )\\n )\\n\\n # FIXME: This code most likely will not work in general.\\n # There's no guarantee that these images have the same media type,\\n # or that the second-largest image isn't far too large to use as a thumbnail.\\n # Instead of using the second-largest image as a thumbnail,\\n # find the image that would make the best thumbnail\\n # because of its dimensions, media type, and aspect ratio:\\n # IDEAL_COVER_ASPECT_RATIO = 2.0/3\\n # IDEAL_IMAGE_HEIGHT = 240\\n # IDEAL_IMAGE_WIDTH = 160\\n\\n sorted_raw_image_links = list(\\n reversed(\\n sorted(\\n publication.images.links, key=lambda link: (link.width or 0, link.height or 0)\\n )\\n )\\n )\\n image_links = []\\n\\n if len(sorted_raw_image_links) > 0:\\n cover_link = self._extract_link(\\n sorted_raw_image_links[0],\\n feed_self_url,\\n default_link_rel=Hyperlink.IMAGE,\\n )\\n image_links.append(cover_link)\\n\\n if len(sorted_raw_image_links) > 1:\\n cover_link = self._extract_link(\\n sorted_raw_image_links[1],\\n feed_self_url,\\n default_link_rel=Hyperlink.THUMBNAIL_IMAGE,\\n )\\n image_links.append(cover_link)\\n\\n self._logger.debug(\\n \\\"Finished extracting image links from {0}: {1}\\\".format(\\n encode(publication.images), encode(image_links)\\n )\\n )\\n\\n return image_links\",\n \"def make_link_to(self, index, caption):\\n \\n # index is an int\\n return '<a href=\\\"/log/'+str(index)+'\\\"> '+caption+' '+str(index)+'</a>'\",\n \"def get_image_url(img):\\n # element['data-src'] and element.get('data-src') doesn't work\\n for k, v in img.items():\\n if k == 'data-src':\\n # https://t.nhentai.net/galleries/<gallerycode>/<page#>t.<extension>\\n # https://i.nhentai.net/galleries/<gallerycode>/<page#>.<extension>\\n return v[:8] + 'i' + v[9:32] + v[32:].replace('t.', '.', 1)\",\n \"def create_html(pic_info,sum_pic,upload_path,yun_link=('1','2')):\\n save_file=pic_info+'.txt'\\n content=\\\"\\\"\\\"\\n <p>\\n <img src=\\\"%s%s\\\" style=\\\"\\\" title=\\\"%s\\\"/>\\n </p>\\n <p>\\n <img src=\\\"%s%s\\\" style=\\\"\\\" title=\\\"%s\\\"/>\\n </p>\\n <p>\\n <img src=\\\"%s%s\\\" style=\\\"\\\" title=\\\"%s\\\"/>\\n </p>\\n <p>\\n <img src=\\\"%s%s\\\" style=\\\"\\\" title=\\\"%s\\\"/>\\n </p>\\n <p>\\n <span style=\\\"color: #FF0000; font-size: 24px;\\\">link: \\n </span>\\n <a href=\\\"%s\\\" target=\\\"_blank\\\" \\n style=\\\"font-size: 24px; text-decoration: underline;\\\">\\n <span style=\\\"font-size: 24px;\\\">%s\\n </span>\\n </a> \\n <span style=\\\"font-size: 24px;\\\">\\n <span style=\\\"color: #FF0000; font-size: 24px;\\\">code:\\n </span>\\n %s\\n </span>\\n </p>\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\\\n\\n \\\"\\\"\\\"%(upload_path,sum_pic[0],sum_pic[0],upload_path,sum_pic[1],sum_pic[1],\\n upload_path,sum_pic[2],sum_pic[2],upload_path,sum_pic[3],sum_pic[3],\\n yun_link[0],yun_link[0],yun_link[1])\\n with open(save_file, 'w') as f:\\n f.write(content)\\n f.close()\",\n \"def icon(self):\",\n \"def _do_links(self, text):\\r\\n MAX_LINK_TEXT_SENTINEL = 3000 # markdown2 issue 24\\r\\n\\r\\n # `anchor_allowed_pos` is used to support img links inside\\r\\n # anchors, but not anchors inside anchors. An anchor's start\\r\\n # pos must be `>= anchor_allowed_pos`.\\r\\n anchor_allowed_pos = 0\\r\\n\\r\\n curr_pos = 0\\r\\n while True: # Handle the next link.\\r\\n # The next '[' is the start of:\\r\\n # - an inline anchor: [text](url \\\"title\\\")\\r\\n # - a reference anchor: [text][id]\\r\\n # - an inline img: ![text](url \\\"title\\\")\\r\\n # - a reference img: ![text][id]\\r\\n # - a footnote ref: [^id]\\r\\n # (Only if 'footnotes' extra enabled)\\r\\n # - a footnote defn: [^id]: ...\\r\\n # (Only if 'footnotes' extra enabled) These have already\\r\\n # been stripped in _strip_footnote_definitions() so no\\r\\n # need to watch for them.\\r\\n # - a link definition: [id]: url \\\"title\\\"\\r\\n # These have already been stripped in\\r\\n # _strip_link_definitions() so no need to watch for them.\\r\\n # - not markup: [...anything else...\\r\\n try:\\r\\n start_idx = text.index('[', curr_pos)\\r\\n except ValueError:\\r\\n break\\r\\n text_length = len(text)\\r\\n\\r\\n # Find the matching closing ']'.\\r\\n # Markdown.pl allows *matching* brackets in link text so we\\r\\n # will here too. Markdown.pl *doesn't* currently allow\\r\\n # matching brackets in img alt text -- we'll differ in that\\r\\n # regard.\\r\\n bracket_depth = 0\\r\\n for p in range(start_idx+1, min(start_idx+MAX_LINK_TEXT_SENTINEL,\\r\\n text_length)):\\r\\n ch = text[p]\\r\\n if ch == ']':\\r\\n bracket_depth -= 1\\r\\n if bracket_depth < 0:\\r\\n break\\r\\n elif ch == '[':\\r\\n bracket_depth += 1\\r\\n else:\\r\\n # Closing bracket not found within sentinel length.\\r\\n # This isn't markup.\\r\\n curr_pos = start_idx + 1\\r\\n continue\\r\\n link_text = text[start_idx+1:p]\\r\\n\\r\\n # Possibly a footnote ref?\\r\\n if \\\"footnotes\\\" in self.extras and link_text.startswith(\\\"^\\\"):\\r\\n normed_id = re.sub(r'\\\\W', '-', link_text[1:])\\r\\n if normed_id in self.footnotes:\\r\\n self.footnote_ids.append(normed_id)\\r\\n result = '<sup class=\\\"footnote-ref\\\" id=\\\"fnref-%s\\\">' \\\\\\r\\n '<a href=\\\"#fn-%s\\\">%s</a></sup>' \\\\\\r\\n % (normed_id, normed_id, len(self.footnote_ids))\\r\\n text = text[:start_idx] + result + text[p+1:]\\r\\n else:\\r\\n # This id isn't defined, leave the markup alone.\\r\\n curr_pos = p+1\\r\\n continue\\r\\n\\r\\n # Now determine what this is by the remainder.\\r\\n p += 1\\r\\n if p == text_length:\\r\\n return text\\r\\n\\r\\n # Inline anchor or img?\\r\\n if text[p] == '(': # attempt at perf improvement\\r\\n match = self._tail_of_inline_link_re.match(text, p)\\r\\n if match:\\r\\n # Handle an inline anchor or img.\\r\\n is_img = start_idx > 0 and text[start_idx-1] == \\\"!\\\"\\r\\n if is_img:\\r\\n start_idx -= 1\\r\\n\\r\\n url, title = match.group(\\\"url\\\"), match.group(\\\"title\\\")\\r\\n if url and url[0] == '<':\\r\\n url = url[1:-1] # '<url>' -> 'url'\\r\\n # We've got to encode these to avoid conflicting\\r\\n # with italics/bold.\\r\\n url = url.replace('*', self._escape_table['*']) \\\\\\r\\n .replace('_', self._escape_table['_'])\\r\\n if title:\\r\\n title_str = ' title=\\\"%s\\\"' % (\\r\\n _xml_escape_attr(title)\\r\\n .replace('*', self._escape_table['*'])\\r\\n .replace('_', self._escape_table['_']))\\r\\n else:\\r\\n title_str = ''\\r\\n if is_img:\\r\\n result = '<img src=\\\"%s\\\" alt=\\\"%s\\\"%s%s' \\\\\\r\\n % (url.replace('\\\"', '"'),\\r\\n _xml_escape_attr(link_text),\\r\\n title_str, self.empty_element_suffix)\\r\\n if \\\"smarty-pants\\\" in self.extras:\\r\\n result = result.replace('\\\"', self._escape_table['\\\"'])\\r\\n curr_pos = start_idx + len(result)\\r\\n text = text[:start_idx] + result + text[match.end():]\\r\\n elif start_idx >= anchor_allowed_pos:\\r\\n result_head = '<a href=\\\"%s\\\"%s>' % (url, title_str)\\r\\n result = '%s%s</a>' % (result_head, link_text)\\r\\n if \\\"smarty-pants\\\" in self.extras:\\r\\n result = result.replace('\\\"', self._escape_table['\\\"'])\\r\\n # <img> allowed from curr_pos on, <a> from\\r\\n # anchor_allowed_pos on.\\r\\n curr_pos = start_idx + len(result_head)\\r\\n anchor_allowed_pos = start_idx + len(result)\\r\\n text = text[:start_idx] + result + text[match.end():]\\r\\n else:\\r\\n # Anchor not allowed here.\\r\\n curr_pos = start_idx + 1\\r\\n continue\\r\\n\\r\\n # Reference anchor or img?\\r\\n else:\\r\\n match = self._tail_of_reference_link_re.match(text, p)\\r\\n if match:\\r\\n # Handle a reference-style anchor or img.\\r\\n is_img = start_idx > 0 and text[start_idx-1] == \\\"!\\\"\\r\\n if is_img:\\r\\n start_idx -= 1\\r\\n link_id = match.group(\\\"id\\\").lower()\\r\\n if not link_id:\\r\\n link_id = link_text.lower() # for links like [this][]\\r\\n if link_id in self.urls:\\r\\n url = self.urls[link_id]\\r\\n # We've got to encode these to avoid conflicting\\r\\n # with italics/bold.\\r\\n url = url.replace('*', self._escape_table['*']) \\\\\\r\\n .replace('_', self._escape_table['_'])\\r\\n title = self.titles.get(link_id)\\r\\n if title:\\r\\n before = title\\r\\n title = _xml_escape_attr(title) \\\\\\r\\n .replace('*', self._escape_table['*']) \\\\\\r\\n .replace('_', self._escape_table['_'])\\r\\n title_str = ' title=\\\"%s\\\"' % title\\r\\n else:\\r\\n title_str = ''\\r\\n if is_img:\\r\\n result = '<img src=\\\"%s\\\" alt=\\\"%s\\\"%s%s' \\\\\\r\\n % (url.replace('\\\"', '"'),\\r\\n link_text.replace('\\\"', '"'),\\r\\n title_str, self.empty_element_suffix)\\r\\n if \\\"smarty-pants\\\" in self.extras:\\r\\n result = result.replace('\\\"', self._escape_table['\\\"'])\\r\\n curr_pos = start_idx + len(result)\\r\\n text = text[:start_idx] + result + text[match.end():]\\r\\n elif start_idx >= anchor_allowed_pos:\\r\\n result = '<a href=\\\"%s\\\"%s>%s</a>' \\\\\\r\\n % (url, title_str, link_text)\\r\\n result_head = '<a href=\\\"%s\\\"%s>' % (url, title_str)\\r\\n result = '%s%s</a>' % (result_head, link_text)\\r\\n if \\\"smarty-pants\\\" in self.extras:\\r\\n result = result.replace('\\\"', self._escape_table['\\\"'])\\r\\n # <img> allowed from curr_pos on, <a> from\\r\\n # anchor_allowed_pos on.\\r\\n curr_pos = start_idx + len(result_head)\\r\\n anchor_allowed_pos = start_idx + len(result)\\r\\n text = text[:start_idx] + result + text[match.end():]\\r\\n else:\\r\\n # Anchor not allowed here.\\r\\n curr_pos = start_idx + 1\\r\\n else:\\r\\n # This id isn't defined, leave the markup alone.\\r\\n curr_pos = match.end()\\r\\n continue\\r\\n\\r\\n # Otherwise, it isn't markup.\\r\\n curr_pos = start_idx + 1\\r\\n\\r\\n return text\",\n \"def svg(self) -> str:\\n return SPOUSE_LINK_TEMPLATE.format(**self._fields)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73077035","0.7028345","0.69006294","0.6725073","0.65269893","0.6412301","0.62754714","0.6242181","0.6159993","0.6141473","0.6111284","0.60934657","0.6057731","0.6022648","0.59900016","0.5979915","0.5953369","0.5953369","0.59277457","0.59261954","0.5877854","0.5870041","0.5869216","0.58561146","0.58545357","0.5842573","0.5821001","0.581424","0.57999074","0.57992256","0.57974845","0.57895535","0.5782306","0.57659274","0.5763755","0.57626593","0.57550085","0.5753275","0.5750355","0.5743052","0.5741372","0.5730605","0.5715451","0.56943","0.5687198","0.5661435","0.56445116","0.56272995","0.56270593","0.5597905","0.55949","0.5592195","0.559165","0.55832076","0.55787605","0.55726945","0.5567609","0.55626667","0.5553489","0.5547051","0.5532168","0.55275434","0.5525359","0.5524259","0.55238533","0.55183744","0.5514061","0.5510822","0.54958326","0.54897857","0.54855","0.54850173","0.5483755","0.5475576","0.5474998","0.54687893","0.546482","0.5461959","0.54582876","0.54582876","0.54582876","0.5430476","0.542147","0.541799","0.5417414","0.5413702","0.54124546","0.5402847","0.5399218","0.5391859","0.53801197","0.5376875","0.53751504","0.5370357","0.536946","0.53633916","0.53604674","0.5360444","0.5357701","0.5346785","0.5338167"],"string":"[\n \"0.73077035\",\n \"0.7028345\",\n \"0.69006294\",\n \"0.6725073\",\n \"0.65269893\",\n \"0.6412301\",\n \"0.62754714\",\n \"0.6242181\",\n \"0.6159993\",\n \"0.6141473\",\n \"0.6111284\",\n \"0.60934657\",\n \"0.6057731\",\n \"0.6022648\",\n \"0.59900016\",\n \"0.5979915\",\n \"0.5953369\",\n \"0.5953369\",\n \"0.59277457\",\n \"0.59261954\",\n \"0.5877854\",\n \"0.5870041\",\n \"0.5869216\",\n \"0.58561146\",\n \"0.58545357\",\n \"0.5842573\",\n \"0.5821001\",\n \"0.581424\",\n \"0.57999074\",\n \"0.57992256\",\n \"0.57974845\",\n \"0.57895535\",\n \"0.5782306\",\n \"0.57659274\",\n \"0.5763755\",\n \"0.57626593\",\n \"0.57550085\",\n \"0.5753275\",\n \"0.5750355\",\n \"0.5743052\",\n \"0.5741372\",\n \"0.5730605\",\n \"0.5715451\",\n \"0.56943\",\n \"0.5687198\",\n \"0.5661435\",\n \"0.56445116\",\n \"0.56272995\",\n \"0.56270593\",\n \"0.5597905\",\n \"0.55949\",\n \"0.5592195\",\n \"0.559165\",\n \"0.55832076\",\n \"0.55787605\",\n \"0.55726945\",\n \"0.5567609\",\n \"0.55626667\",\n \"0.5553489\",\n \"0.5547051\",\n \"0.5532168\",\n \"0.55275434\",\n \"0.5525359\",\n \"0.5524259\",\n \"0.55238533\",\n \"0.55183744\",\n \"0.5514061\",\n \"0.5510822\",\n \"0.54958326\",\n \"0.54897857\",\n \"0.54855\",\n \"0.54850173\",\n \"0.5483755\",\n \"0.5475576\",\n \"0.5474998\",\n \"0.54687893\",\n \"0.546482\",\n \"0.5461959\",\n \"0.54582876\",\n \"0.54582876\",\n \"0.54582876\",\n \"0.5430476\",\n \"0.542147\",\n \"0.541799\",\n \"0.5417414\",\n \"0.5413702\",\n \"0.54124546\",\n \"0.5402847\",\n \"0.5399218\",\n \"0.5391859\",\n \"0.53801197\",\n \"0.5376875\",\n \"0.53751504\",\n \"0.5370357\",\n \"0.536946\",\n \"0.53633916\",\n \"0.53604674\",\n \"0.5360444\",\n \"0.5357701\",\n \"0.5346785\",\n \"0.5338167\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":78798,"cells":{"query":{"kind":"string","value":"Add to the image of ."},"document":{"kind":"string","value":"def Add(self, *args):\n return _BRepAlgo.BRepAlgo_Image_Add(self, *args)"},"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 imageAdd(img, num):\n return myimg.imageAdd(img.tolist(), num)","def boutton(self,img1,x,y):\r\n self.button.append(self.creat_image(img1,x,y))","def add_image(self, id, arr):\n\t\t## remove original image and add new one\n\t\tif self.cells[id].image:\n\t\t\tself.cells[id].v.removeItem(self.cells[id].image)\n\t\t'''\n\t\timg = UiImageItem()\n\t\tself.cells[id].v.addItem(img)\n\t\timg.setImage(arr)\n\t\t## rotate the imageItem (oddly the image is rotated by default)\n\t\timg.setRotation(-90)\n\t\t'''\n\t\t## use ROI instead of imageItem\n\t\tshape = arr.shape\n\t\timg = ImageROI([0,0], [shape[0],shape[1]], movable=False, rotatable=False, sendBack=False, parent=self.cells[id].v)\n\n\t\timg.set_image(arr)\n\t\tself.cells[id].image = img\n\t\tself.cells[id].v.addItem(img)\n\t\t\n\t\t##set histo's curve color, should be called before set_image\n\t\tbuttons = self.cells[1].button_area.colorWidget.buttons\n\t\timg.set_curve_pen(buttons['color'].currentColor(), buttons['size'].value(), buttons['tense'].value()/100.)\n\n\t\t## rotate the imageItem (oddly the image is rotated by default)\n\t\t## there is a bug with the rotate method\n\t\timg.setRotation(-90)\n\n\t\t## connect images signals to slot in class ImageBar\n\t\timg.sigAddVertexRequested.connect(self.add_point)\n\t\timg.sigLoadImageRequested.connect(self.load_image_requested)\n\t\timg.sigCurveUpdated.connect(self.curve_updated)\n\t\t#img.sigDragTriggered.connect(self.cells[id].pathplot.add_draw_point)\n\t\tself.cells[id].open_action.triggered.connect(img.load_image_clicked)\n\t\t## clear existed points\n\t\tself.clear_point(id=id)\n\t\t## reset button area\n\t\tself.reset_button_area(id)\n\t\t## send signal to inform imagePanel\n\t\tself.sigImageLoaded.emit((id, arr))\n\t\t## update config file\n\t\tself.conf.configs['original_array'][id] = arr\n\n\t\tif id == 0 and id not in self.state['ready']:\n\t\t\tself.sigEnableHeatmapButton.emit(self)\n\n\t\tself.cells[id].v.setMouseEnabled(True, True)\n\t\tself.state['ready'][id] = True\n\n\t\t## just test...\n\t\t#ct = contourSelection.resize_segmentation(arr)\n\t\t#self.cells[id].contour = ct\n\t\t#print ct","def augment(self, image):\n pass","def add_image(self, image, mode='normal', state='on'):\n raise NotImplementedError","def add_image(self, file_name, content):\n self.face_fs.put(content, filename=file_name)","def imadd(img):\n\n img = img / 2 + 0.5 # unnormalize\n npimg = img\n plt.imshow(np.transpose(npimg, (1, 2, 0)))","def add_image(self, image):\n if self.temp_dir is None:\n self.temp_dir = tempfile.mkdtemp()\n if self.img_shape is None:\n self.img_shape = image.shape\n assert self.img_shape == image.shape\n filename = self.get_filename(self.current_index)\n plt.imsave(fname=filename, arr=image)\n self.current_index += 1\n return filename","def imshow(img):\n imadd(img)\n plt.ion()\n plt.show()","def on_image(self, image):","def add_image(self, image_name):\n if self.current_trip is None:\n print \"no trip to add image\"\n return\n self.current_trip.store_image(image_name)","def add_image(self, image_html, column_name, row_num):\n column_num = self.table[0].index(column_name)\n self.images[column_num, row_num + 1].append(image_html)","def insert(self, *args, **kwargs):\n return _image.image_insert(self, *args, **kwargs)","def process(self, image):","def add_image(self, tag, img_tensor, global_step=None, caption=None):\n img_tensor = make_np(img_tensor)\n self.vis.image(img_tensor, opts={'title': tag, 'caption': caption})","def add_art(self,path,size=\"500\"):\n error=False\n if path:\n print(\"processing %s to %s\" % (path,self.uid))\n f=open(path,'rb') \n filedata=f.read()\n extension=(imghdr.what('',filedata) or path.rsplit(\".\")[-1].lower()).replace('jpeg','jpg')\n if not filedata:\n error= \"NO IMAGE FOUND AT '%s'\" % path\n print(error)\n elif extension in ('bmp','png'):\n filedata=self.Image.convert(filedata)\n extension='jpg' \n elif extension not in ('gif','png','jpg','jpeg'):\n error=\"only JPEG, GIF, PNG, and BMP are supported\"\n print(error)\n if not error:\n # create a new image page\n image=self.Image.new()\n image.parent=self.uid\n image.kind='image'\n image.seq=0xFFFFFF#place at end of siblings\n # set default size \n image.stage='right full %sx%s' % (size,size) #rest of stage data will be added on the fly later by get_stage_data() \n image.set_lineage()\n image.code=\"%s.%s\" % (image.uid,extension)\n image.when=DATE()\n image.flush() #store the image page\n image.renumber_siblings_by_kind()#keep them in order\n # save the image file\n image.save_file(filedata)\n # return\n print('image \"%s\" added' % image.code)\n return image\n return None","def setImage(*args):","def add_image(self, in_image):\n image = in_image\n if not isinstance(image, Image):\n image = Image()\n image.parse_record(in_image)\n self.img_lst.append(image)","def addTextureToOcc(self):\n\t\tshas = self._getShapes()\n\t\tfname, _ = QtGui.QFileDialog.getOpenFileName(self, 'Open file ',\n\t\t\t\t\t\t\t\t\t\t\t\t\t'/home')\n\t\tif fname:\n\t\t\tfor sha in shas:\n\t\t\t\t#get texture Path\n\t\t\t\tif not sha.a.texture_Occ.exists:\n\t\t\t\t\toccText = sha.a.texture_Occ.add( dt='string' )\n\t\t\t\tsha.a.texture_Occ.v = fname","def newAvatarImage(self, imgPath, imgName): \n img = ocempgui.draw.Image.load_image(imgPath)\n if not self.images[imgName]: \n imgOcemp = guiobjects.OcempImageMapTransparent(img)\n imgOcemp.topleft = 528, 114\n self.window.add_child(imgOcemp)\n self.images[imgName] = imgOcemp\n else:\n self.images[imgName].picture = img","def update_image(self):\n self.image = Image.fromarray(self.img)","def on_draw_over_image(self):","def overlay_image(image_to_show, image_to_add, directory=None):\n \n direcx = \"/Documents/1.4.5 Images/\"#put a condition pls\n if directory == None:\n directory = os.getcwd()\n print directory\n new_image = PIL.Image.open(directory + direcx + image_to_show)\n new_imager = PIL.Image.open(directory + direcx + image_to_show)\n new_imager.show()\n new_image2 = PIL.Image.open(directory + direcx + image_to_add)\n new_image2.show()\n \n width, height = new_imager.size\n print str(width) + \" \" + str(height)\n \n new_image22 = new_image2.resize((width,height), PIL.Image.ANTIALIAS)\n new_image22.show()\n\n new_imager.paste(new_image22, (0,0), new_image22)\n new_imager.show()\n #cohrt = PIL.Image.blend(new_imager, new_image22, alpha=0.5)\n #cohrt.show() #broked","def add_image(self, image):\n if type(image) is not self.imageType:\n raise TypeError('`image` must be of type {0}'.format(self.imageType))\n\n listBinning = self.imageList[0].binning\n if image.binning != listBinning:\n raise ValueError('`image` must have binning ({0} x {1})'.format(*listBinning))\n\n self.__imageList = self.imageList + (image,)\n\n return None","def add_image(self, image_name, alpha=1):\n self.image_name = image_name\n self.image_alpha = alpha","def do_command(self, args):\n imageops = dbops.Images()\n imageops.add(args)","def add_image(name,img_array):\n\n detections, shapes, descriptors = detect_faces(person_database,img_array)\n\n if len(descriptors)==0:\n print(\"No people found.\")\n elif len(descriptors)>1:\n print(\"Multiple people detected. Picture can only contain one person.\")\n else:\n update_descriptor(person_database, name, *descriptors)\n print(\"Person successfully added.\")","def add_image_file(self, imagefilename):\n #import matplotlib.image as mpimg\n\n # set aspect to auto mode\n self.axes.set_aspect('auto')\n\n img = matplotlib.image.imread(str(imagefilename))\n # lum_img = img[:,:,0]\n # FUTURE : refactor for image size, interpolation and origin\n imgplot = self.axes.imshow(img, extent=[0, 1000, 800, 0], interpolation='none', origin='lower')\n\n # Set color bar. plt.colorbar() does not work!\n if self._colorBar is None:\n # set color map type\n imgplot.set_cmap('spectral')\n self._colorBar = self.fig.colorbar(imgplot)\n else:\n self._colorBar.update_bruteforce(imgplot)\n\n self._flush()\n\n return","def _addImage(self, image, preprocessor):\n if self.images == None:\n self.images = []\n\n processed_image = preprocessor(image,\n self.inputShape()[2],\n self.inputShape()[1])\n\n self.images.append(processed_image)","def Add(*args, **kwargs):\n return _gdi_.ImageList_Add(*args, **kwargs)","def add_image(jid, img):\n jrd.hset(_generate_job_key(jid), 'image_status', 'created')\n image_rd.hset(jid, 'image', img)","def draw(self, frame):\n frame[OFS:OFS+self.image.shape[0], OFS:OFS+self.image.shape[1]] = self.image","def addImg(in_dict):\n img = Image(name=in_dict[\"name\"],\n b64str=in_dict[\"b64str\"],\n imgsize=in_dict[\"imgsize\"],\n processed=in_dict[\"processed\"],\n timestamp=in_dict[\"timestamp\"])\n ans = img.save()\n return ans.name","def addFigure(self,fig,xl,yl,scale):\n img = py.image.load(fig)\n w,h = img.get_size()\n img = py.transform.scale(img,(int(w*scale),int(h*scale)))\n self.figures.append(img)\n self.locs.append((xl,yl))","def new_image(x, y, out, data):\n img = Image.new('RGB', (x, y))\n img.putdata(data)\n img.save(out)","def PrePush(self, image):\n pass","def overlay_image(image_to_show, image_to_add, directory=None):\n \n direcx = \"/Documents/1.4.5 Images/\"#put a condition pls\n if directory == None:\n directory = os.getcwd()\n print directory\n new_image = PIL.Image.open(directory + direcx + image_to_show)\n new_imager = PIL.Image.open(directory + direcx + image_to_show)\n new_imager.show()\n new_image2 = PIL.Image.open(directory + direcx + image_to_add)\n new_image2.show()\n width, height = new_imager.size\n print str(width) + \" \" + str(height)\n #print new_image\n #print new_image2\n #if image_to_show == \"\":\n # print_directory_list2()\n # return \"Use one of these\"\n new_image22 = new_image2.resize((width,height), PIL.Image.ANTIALIAS)\n new_image22.show()\n\n new_imager.paste(new_image22, (width, height), new_image22)\n new_imager.show()\n #cohrt = PIL.Image.blend(new_imager, new_image22, alpha=0.5)\n #cohrt.show()","def _drawimage(self, item, pos, image):\n x, y = pos\n self.cv.coords(item, (x * self.xscale, -y * self.yscale))\n self.cv.itemconfig(item, image=image)","def update_image(self, image):\n raise NotImplementedError()","def loaded_image(self, image):\r\n self.loaded_images.append(image)","def add(self, mp):\n \n self.tile_contents.append(mp)\n if(self.tile_contents[-1].raised == False):\n self.paint_blocks += 1.00","def _append_png(self, png, before_prompt=False, metadata=None):\n self._append_custom(self._insert_png, png, before_prompt, metadata=metadata)","def adjust(self, image):\n ...","def draw(self):\n self.write_image()\n self.update()","def add_image(self, image_name, version, image_hash):\n raise NotImplementedError()","def add_image(self, image_list):\n self.image_filenames_list.append(image_list)","def store_image(self, image_name):\n self.images.append(image_name)","def add(self, output_svg: Drawing) -> None:\n pass","def modify_image(self, example, target_label):\n raise NotImplementedError()","def register_collection_additional_image(self, image):\n save_path = os.path.join(self.session_dir, 'additional.jpg')\n image.save(save_path)","def add_image(self, img, input_or_output, filename, title, description=\"\"):\n if input_or_output.lower() != \"input\" and input_or_output.lower() != \"output\":\n raise Exception(\"input_or_output parameter can only contain 'input' or 'output'\")\n\n image_object = Image(self._name, img, input_or_output, self._img_folder + \"/\" + filename, title, description=\"\")\n image_object.commit()\n s = image_object.to_series()\n self._commit(s)","def add_trigger(self, img):\n img[self.trigger_loc] = 0\n poison_img = img + self.trigger_ptn\n\n return poison_img","def view(self):\n window = tk.Tk()\n label = tk.Label(window)\n label.pack()\n img = self.get_tkimage()\n label[\"image\"] = label.img = img\n window.mainloop()","def setup():\n img = Image.new('RGB', (10, 20))\n img.putpixel((5, 10), (0, 255, 0))\n img.save('green-dot.tif')\n img.save('green-dot.jpg')\n img.save('green-dot.png')","def _addClicked(self):\n volume = self.volume()\n if volume is not None:\n dataRange = volume.getDataRange()\n if dataRange is None:\n dataRange = 0., 1.\n\n volume.addIsosurface(\n numpy.mean((dataRange[0], dataRange[-1])),\n '#0000FF')","def display_image(self, img, img_pos):\n image = tk.Label(self.top, image=img)\n image.grid(row=img_pos[0], column=img_pos[1],\n columnspan=img_pos[2], rowspan=img_pos[3])","def update_image(self, data):\n self.image_data.append(data)\n if len(self.image_data) > self.image_height:\n self.image_data = self.image_data[1:]\n\n self.image_render += 1\n\n # A 200 pixel tall image squashed into the render view does not\n # appear unpleasantely jumpy when scrolled by 5\n if self.image_render % 5 != 0 and self.image_render != 1:\n return\n\n img_data = range(len(self.image_data))\n\n position = 0\n while position < len(img_data):\n img_data[position] = self.image_data[position]\n position += 1\n\n new_data = numpy.array(img_data).astype(float)\n\n mid = self.main_image_dialog\n mid.image.set_data(new_data)\n\n # If you do autoscale here, it tends to jump around in appearing\n # to stretch to the window and be in 'normal' size\n mid.get_plot().replot()","def draw(self, frame):\n xpos = OFS + self.x * TILE_SIZE\n ypos = OFS + self.y * TILE_SIZE\n frame[ypos:ypos+TILE_SIZE, xpos:xpos+TILE_SIZE] = self.image","def add_image(project, img, id, snap, parent, public):\n with BMI(_username, _password, constants.BMI_ADMIN_PROJECT) as bmi:\n ret = bmi.add_image(project, img, id, snap, parent, public)\n if ret[constants.STATUS_CODE_KEY] == 200:\n click.echo(\"Success\")\n else:\n click.echo(ret[constants.MESSAGE_KEY])","def generate_image(self):\n pass","def add_picture(self, file, left, top, width=None, height=None):\n pkg = Package.containing(self.__slide)\n image = pkg._images.add_image(file)\n rel = self.__slide._add_relationship(RT_IMAGE, image)\n pic = self.__pic(rel._rId, file, left, top, width, height)\n self.__spTree.append(pic)\n picture = Picture(pic)\n self.__shapes.append(picture)\n return picture","def botStack(self):\r\n\r\n self.z_stack=self.img.shape[0]-1\r\n #self.pixmap=QtGui.QPixmap.fromImage(ImageQt.ImageQt(misc.toimage(self.img[self.z_stack]))).scaleds(500,500)\r\n self.pixmap= self.drawPixmap(\"xy\")\r\n self.lbl.setPixmap(self.pixmap)\r\n\r\n self.pixmap2=self.writeEdge(\"xy\")\r\n self.lbl2.setPixmap(self.pixmap2)\r\n self.z_stack_lbl.setText(str(self.z_stack+1) + '/' + str(self.img.shape[0]))","def write_image(self, tag, image, step):\n\n self.writer.add_figure(tag, image, global_step=step)","def placeImage(self, img, x=0, y=0):\n if img.getSize() == self.getSize() and img.getWidth() == self.__width:\n # Same dimensions\n self._c = img._c\n\n elif x == 0 and self.__height == img.getHeight():\n # Same height, just overwrite a block\n p_start = y * self.__height\n p_end = y*self.__height + img.getSize()\n self._c[p_start:p_end] = img._c\n\n else:\n # Different dimensions\n for dx in range(min(img.getWidth(), self.getWidth() - x)):\n self.writeCol(x+dx, img.getCol(dx), y)","def _image(self):\n print(\"imaging\")\n self.images.append(self.device_control.image())\n yield","def main():\n fg = SimpleImage('image_contest/me.jpg')\n bg = SimpleImage('image_contest/house.png')\n bg.make_as_big_as(fg)\n combined_img = combine(bg, fg)\n combined_img.show()","def paintTags(self):\n imagesTagOrder = [\"gender\", \"skin\", \"head\", \"body\", \"mask\", \"hair\", \"shirt\", \"trousers\", \"skirt\", \"shoes\"]\n pos = 0\n for img in imagesTagOrder:\n self.imagesTag[img].topleft = 296, pos * 76\n self.imagesTag[img].connect_signal(ocempgui.widgets.Constants.SIG_CLICKED, self.paintCustomizeZone, img)\n self.window.add_child(self.imagesTag[img])\n pos += 1","def draw(self, color = Color.GREEN):\n self.image[self.x, self.y] = color","def add_image_to_frame_list(self,startFrame, endFrame, imageName): \n for i in range(startFrame-1, endFrame-1):\n try:\n # image = imageio.imread(imageName)\n im = Image.open(imageName)\n im = im.resize((720, 720))\n self.frame_list.append(im)\n # self.frame_list.append(im)\n\n except:\n print (imageName, \" not found.\")\n # BufferedImage bi= new BufferedImage(320,240,BufferedImage.TYPE_BYTE_GRAY);\n im=self.blank\n self.frame_list.append(im)","def add_image(self, image):\n\n # we're only for new images, no i'ds allowed\n # if u want to set an id by hand use set_image\n if image.id:\n raise o.Exception('Can not add image with id')\n\n if not image.data:\n raise o.Exception('Image must have data')\n\n if not image.source_page_url:\n raise o.Exception('Image must have source page url')\n\n # update it's stats\n image = self.populate_image_stats(image)\n\n # only add the image if we haven't seen it beforeQ\n # if we've seen it before there will be an id which\n # the set of images w/ this data and from this page share\n ids = self.rc.sinter('images:datainstance:%s' % image.shahash,\n 'images:page_ids:%s' % image.source_page_url)\n\n\n # we don't need to continue\n # we'll return back their original msg, w/o the id set\n if ids:\n print 'image already exists [%s], not setting' % ids\n return image\n\n # so the image appears to be new, good for it\n return self.set_image(image)","def display(self, image):\n raise NotImplementedError()","def image(self,v):\n self.set('heightfield.image',v)\n #assert fileExists(environment.makeFilePath(v)), \"Warning: HeightField's image file, {}, not found in images folder.\".format(v) \n return self","def main():\n space_ship = SimpleImage(\"images/MillenniumFalcon.png\")\n figure = SimpleImage(\"images/ReyGreenScreen.png\")\n result = combine(space_ship, figure)\n result.show()","def save_image(self):\n self.save()","def _build_final_image(self, image):\n raise NotImplementedError","def updateImage(self, frame, image):\n frame.imgtk = image\n frame.configure(image=image)","def update_img(self):\n self.img = np.array(self.image)","def _new_image(self, data=None, name=None, colormap=None):\n if colormap is None:\n colormap = self._label_config_center.get_first_label_config()\n self.model.new_image(data, name, None, colormap)\n self.list_view.setCurrentIndex(self.model.index(0))\n\n # change button status\n self._actions['remove_image'].setEnabled(True)\n self._actions['intersect'].setEnabled(True)\n self._actions['regular_roi'].setEnabled(True)\n self._actions['r2i'].setEnabled(True)\n self._actions['auto_label'].setEnabled(True)\n self._actions['open'].setEnabled(True)","def img_cb(self, image):\n self.last_img = image\n self.is_new_img = True","def add(self, data, action, reward, terminal):\n image = Image.fromarray(data.reshape((80, 105)))\n image = image.resize((80, 80))\n \n image = np.asarray(image)\n \n self.data.append(image.astype('uint8'))\n self.actions.append(action)\n self.rewards.append(reward)\n self.terminal.append(terminal)\n\n if len(self.data) > self.history_size:\n self.data.pop(0)\n self.actions.pop(0)\n self.rewards.pop(0)\n self.terminal.pop(0)","def integrateObservation(self, img,action):\n self.States.append(img)\n self.Actions.append(action) \n #self.printLevelScene()","def getimage(self):","def _append_jpg(self, jpg, before_prompt=False, metadata=None):\n self._append_custom(self._insert_jpg, jpg, before_prompt, metadata=metadata)","def AddScale(img,barLen =2, scale = 34.5, px=0.02,py=0.96, color = 255,thick=5,lw=1,stroke=1):\n h,w=img.shape\n w_scale=int(scale*barLen)\n x1=int(w*px)\n y1=int(h*py)\n x2=x1+w_scale\n y2=y1+thick\n \n bcolor=255-color\n \n \n \n \n text = str(barLen)+' nm'\n font = cv2.FONT_HERSHEY_SIMPLEX#CV_FONT_HERSHEY_SIMPLEX normal size sans-serif font\n if stroke == 1:\n cv2.putText(img,text,(x1,y1-8), font, 1, bcolor, 3, cv2.LINE_AA) #Stroke \n cv2.rectangle(img,(x1,y1),(x2,y2),bcolor,2)#boarder color\n\n \n cv2.rectangle(img,(x1,y1),(x2,y2),color,-1)\n \n cv2.putText(img,text,(x1,y1-8), font, 1, color, 2, cv2.LINE_AA)","def add_image_to_html(self, image_path):\r\n file_object = open(self.file_name, 'a+')\r\n html_content = f'<div><img src={image_path} width=\"500\" height=\"300\"></div>'\r\n file_object.write(html_content)","def _add_image(self, image):\n document = self._control.document()\n name = str(image.cacheKey())\n document.addResource(QtGui.QTextDocument.ImageResource,\n QtCore.QUrl(name), image)\n format = QtGui.QTextImageFormat()\n format.setName(name)\n return format","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 display(self):\n display(self.image)","def build_filler_images(self):","def display(self, color = (190,205,205), add = False): \r\n s += pgl.Shape(pgl.FaceSet( [[0,0,0],[1,0,0],[1,1,0],[0,1,0]], [[0,1,2,3]]) , pgl.Material((0,100,0)))","def update(self):\n if self.value:\n self.image = self.rect2 \n else:\n self.image = self.rect1","def set_image(self, image):\n self.data['image'] = image","def add_drawable(self, gameObject):\r\n if not self.sprite_group.has(gameObject):\r\n self.sprite_group.add(gameObject)","def extend_image(self):\n IJ.run(self.image, 'Select All', '')\n IJ.run(self.image, 'Copy', '')\n width = self.image.getWidth()\n height = int(self.image.getHeight() + self.extend_full)\n new_image = IJ.createImage(\n IMP.getTitle(), '32-bit black', width, height, 1)\n new_image.setRoi(0, 0, self.image.getWidth(), self.image.getHeight())\n IJ.run(new_image, 'Paste', '')\n IJ.run(new_image, 'Enhance Contrast', 'saturated=0.35')\n IJ.run(new_image, 'Select None', '')\n cal = Calibration(self.image)\n cal.pixelWidth = self.dispersion\n cal.xOrigin = self.offset\n new_image.setCalibration(cal)\n self.image = new_image\n return new_image","def add_photo(self, new_photo, i):\r\n self.__photos[i] = new_photo","def __init__(self, image):\n self.image = image","def add_image(self, f_name,file,new_id):\r\n folder=tempfile.mktemp()\r\n os.mkdir(folder)\r\n datei=open(folder+'/'+f_name,'w+')\r\n datei.write(file.read())\r\n datei.close()\r\n val='' \r\n liste_ext=liste_val\r\n if(self.toolbox.hasProperty('eigene_formate')):\r\n self_val=self.toolbox.getProperty('eigene_formate').split(',')\r\n liste_ext=[]\r\n for x in self_val:\r\n liste_ext.append('_'+x+'.jpeg')\r\n for extension in liste_ext:\r\n #cmd='/usr/bin/convert '+folder+'/'+f_name+' -resize '+extension[1:-4]+'x'+extension[1:-4]+' '+folder+'/'+new_id+extension\r\n cmd='/usr/bin/convert '+folder+'/'+f_name+' -resize '+extension[1:-4]+' '+folder+'/'+new_id+extension\r\n order=os.popen(cmd).read()\r\n kurz_name='_'+str(f_name.split('.')[0])\r\n kurz_name=kurz_name.replace(' ','_')\r\n val=val+self.manage_addImage(id=new_id+kurz_name+extension,file=open(folder+'/'+new_id+extension),title=f_name, precondition='', content_type='',REQUEST=None)+' ' \r\n os.remove(folder+'/'+new_id+extension)\r\n os.remove(folder+'/'+f_name)\r\n os.rmdir(folder)\r\n txt=\"Datei Hochgeladen!<br>\"\r\n #my_root=self.toolbox\r\n #txt+=my_root.id+\"<br>\"\r\n #if(my_root.hasProperty('eigene_formate')):\r\n # txt+=my_root.getProperty('eigene_formate')+\"<br>\"\r\n return txt","def setIconImage(*args):","def update_image(self):\n if self.filenames:\n pos = self.slider.value()\n proj, flat, dark, theta = dx.read_aps_32id(self.filenames, proj=(pos, pos+1))\n if self.ffc_correction:\n image = proj[0,:,:].astype(np.float)/flat[0,:,:].astype(np.float)\n else:\n image = proj[0,:,:].astype(np.float)\n self.image_item.setImage(image)","def add_sample(self, img, action, reward, terminal):\n self.imgs[:, :, self.top] = img\n self.actions[self.top] = action\n self.rewards[self.top] = reward\n self.terminal[self.top] = terminal\n\n if self.size == self.max_steps:\n self.bottom = (self.bottom + 1) % self.max_steps\n else:\n self.size += 1\n\n self.top = (self.top + 1) % self.max_steps"],"string":"[\n \"def imageAdd(img, num):\\n return myimg.imageAdd(img.tolist(), num)\",\n \"def boutton(self,img1,x,y):\\r\\n self.button.append(self.creat_image(img1,x,y))\",\n \"def add_image(self, id, arr):\\n\\t\\t## remove original image and add new one\\n\\t\\tif self.cells[id].image:\\n\\t\\t\\tself.cells[id].v.removeItem(self.cells[id].image)\\n\\t\\t'''\\n\\t\\timg = UiImageItem()\\n\\t\\tself.cells[id].v.addItem(img)\\n\\t\\timg.setImage(arr)\\n\\t\\t## rotate the imageItem (oddly the image is rotated by default)\\n\\t\\timg.setRotation(-90)\\n\\t\\t'''\\n\\t\\t## use ROI instead of imageItem\\n\\t\\tshape = arr.shape\\n\\t\\timg = ImageROI([0,0], [shape[0],shape[1]], movable=False, rotatable=False, sendBack=False, parent=self.cells[id].v)\\n\\n\\t\\timg.set_image(arr)\\n\\t\\tself.cells[id].image = img\\n\\t\\tself.cells[id].v.addItem(img)\\n\\t\\t\\n\\t\\t##set histo's curve color, should be called before set_image\\n\\t\\tbuttons = self.cells[1].button_area.colorWidget.buttons\\n\\t\\timg.set_curve_pen(buttons['color'].currentColor(), buttons['size'].value(), buttons['tense'].value()/100.)\\n\\n\\t\\t## rotate the imageItem (oddly the image is rotated by default)\\n\\t\\t## there is a bug with the rotate method\\n\\t\\timg.setRotation(-90)\\n\\n\\t\\t## connect images signals to slot in class ImageBar\\n\\t\\timg.sigAddVertexRequested.connect(self.add_point)\\n\\t\\timg.sigLoadImageRequested.connect(self.load_image_requested)\\n\\t\\timg.sigCurveUpdated.connect(self.curve_updated)\\n\\t\\t#img.sigDragTriggered.connect(self.cells[id].pathplot.add_draw_point)\\n\\t\\tself.cells[id].open_action.triggered.connect(img.load_image_clicked)\\n\\t\\t## clear existed points\\n\\t\\tself.clear_point(id=id)\\n\\t\\t## reset button area\\n\\t\\tself.reset_button_area(id)\\n\\t\\t## send signal to inform imagePanel\\n\\t\\tself.sigImageLoaded.emit((id, arr))\\n\\t\\t## update config file\\n\\t\\tself.conf.configs['original_array'][id] = arr\\n\\n\\t\\tif id == 0 and id not in self.state['ready']:\\n\\t\\t\\tself.sigEnableHeatmapButton.emit(self)\\n\\n\\t\\tself.cells[id].v.setMouseEnabled(True, True)\\n\\t\\tself.state['ready'][id] = True\\n\\n\\t\\t## just test...\\n\\t\\t#ct = contourSelection.resize_segmentation(arr)\\n\\t\\t#self.cells[id].contour = ct\\n\\t\\t#print ct\",\n \"def augment(self, image):\\n pass\",\n \"def add_image(self, image, mode='normal', state='on'):\\n raise NotImplementedError\",\n \"def add_image(self, file_name, content):\\n self.face_fs.put(content, filename=file_name)\",\n \"def imadd(img):\\n\\n img = img / 2 + 0.5 # unnormalize\\n npimg = img\\n plt.imshow(np.transpose(npimg, (1, 2, 0)))\",\n \"def add_image(self, image):\\n if self.temp_dir is None:\\n self.temp_dir = tempfile.mkdtemp()\\n if self.img_shape is None:\\n self.img_shape = image.shape\\n assert self.img_shape == image.shape\\n filename = self.get_filename(self.current_index)\\n plt.imsave(fname=filename, arr=image)\\n self.current_index += 1\\n return filename\",\n \"def imshow(img):\\n imadd(img)\\n plt.ion()\\n plt.show()\",\n \"def on_image(self, image):\",\n \"def add_image(self, image_name):\\n if self.current_trip is None:\\n print \\\"no trip to add image\\\"\\n return\\n self.current_trip.store_image(image_name)\",\n \"def add_image(self, image_html, column_name, row_num):\\n column_num = self.table[0].index(column_name)\\n self.images[column_num, row_num + 1].append(image_html)\",\n \"def insert(self, *args, **kwargs):\\n return _image.image_insert(self, *args, **kwargs)\",\n \"def process(self, image):\",\n \"def add_image(self, tag, img_tensor, global_step=None, caption=None):\\n img_tensor = make_np(img_tensor)\\n self.vis.image(img_tensor, opts={'title': tag, 'caption': caption})\",\n \"def add_art(self,path,size=\\\"500\\\"):\\n error=False\\n if path:\\n print(\\\"processing %s to %s\\\" % (path,self.uid))\\n f=open(path,'rb') \\n filedata=f.read()\\n extension=(imghdr.what('',filedata) or path.rsplit(\\\".\\\")[-1].lower()).replace('jpeg','jpg')\\n if not filedata:\\n error= \\\"NO IMAGE FOUND AT '%s'\\\" % path\\n print(error)\\n elif extension in ('bmp','png'):\\n filedata=self.Image.convert(filedata)\\n extension='jpg' \\n elif extension not in ('gif','png','jpg','jpeg'):\\n error=\\\"only JPEG, GIF, PNG, and BMP are supported\\\"\\n print(error)\\n if not error:\\n # create a new image page\\n image=self.Image.new()\\n image.parent=self.uid\\n image.kind='image'\\n image.seq=0xFFFFFF#place at end of siblings\\n # set default size \\n image.stage='right full %sx%s' % (size,size) #rest of stage data will be added on the fly later by get_stage_data() \\n image.set_lineage()\\n image.code=\\\"%s.%s\\\" % (image.uid,extension)\\n image.when=DATE()\\n image.flush() #store the image page\\n image.renumber_siblings_by_kind()#keep them in order\\n # save the image file\\n image.save_file(filedata)\\n # return\\n print('image \\\"%s\\\" added' % image.code)\\n return image\\n return None\",\n \"def setImage(*args):\",\n \"def add_image(self, in_image):\\n image = in_image\\n if not isinstance(image, Image):\\n image = Image()\\n image.parse_record(in_image)\\n self.img_lst.append(image)\",\n \"def addTextureToOcc(self):\\n\\t\\tshas = self._getShapes()\\n\\t\\tfname, _ = QtGui.QFileDialog.getOpenFileName(self, 'Open file ',\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'/home')\\n\\t\\tif fname:\\n\\t\\t\\tfor sha in shas:\\n\\t\\t\\t\\t#get texture Path\\n\\t\\t\\t\\tif not sha.a.texture_Occ.exists:\\n\\t\\t\\t\\t\\toccText = sha.a.texture_Occ.add( dt='string' )\\n\\t\\t\\t\\tsha.a.texture_Occ.v = fname\",\n \"def newAvatarImage(self, imgPath, imgName): \\n img = ocempgui.draw.Image.load_image(imgPath)\\n if not self.images[imgName]: \\n imgOcemp = guiobjects.OcempImageMapTransparent(img)\\n imgOcemp.topleft = 528, 114\\n self.window.add_child(imgOcemp)\\n self.images[imgName] = imgOcemp\\n else:\\n self.images[imgName].picture = img\",\n \"def update_image(self):\\n self.image = Image.fromarray(self.img)\",\n \"def on_draw_over_image(self):\",\n \"def overlay_image(image_to_show, image_to_add, directory=None):\\n \\n direcx = \\\"/Documents/1.4.5 Images/\\\"#put a condition pls\\n if directory == None:\\n directory = os.getcwd()\\n print directory\\n new_image = PIL.Image.open(directory + direcx + image_to_show)\\n new_imager = PIL.Image.open(directory + direcx + image_to_show)\\n new_imager.show()\\n new_image2 = PIL.Image.open(directory + direcx + image_to_add)\\n new_image2.show()\\n \\n width, height = new_imager.size\\n print str(width) + \\\" \\\" + str(height)\\n \\n new_image22 = new_image2.resize((width,height), PIL.Image.ANTIALIAS)\\n new_image22.show()\\n\\n new_imager.paste(new_image22, (0,0), new_image22)\\n new_imager.show()\\n #cohrt = PIL.Image.blend(new_imager, new_image22, alpha=0.5)\\n #cohrt.show() #broked\",\n \"def add_image(self, image):\\n if type(image) is not self.imageType:\\n raise TypeError('`image` must be of type {0}'.format(self.imageType))\\n\\n listBinning = self.imageList[0].binning\\n if image.binning != listBinning:\\n raise ValueError('`image` must have binning ({0} x {1})'.format(*listBinning))\\n\\n self.__imageList = self.imageList + (image,)\\n\\n return None\",\n \"def add_image(self, image_name, alpha=1):\\n self.image_name = image_name\\n self.image_alpha = alpha\",\n \"def do_command(self, args):\\n imageops = dbops.Images()\\n imageops.add(args)\",\n \"def add_image(name,img_array):\\n\\n detections, shapes, descriptors = detect_faces(person_database,img_array)\\n\\n if len(descriptors)==0:\\n print(\\\"No people found.\\\")\\n elif len(descriptors)>1:\\n print(\\\"Multiple people detected. Picture can only contain one person.\\\")\\n else:\\n update_descriptor(person_database, name, *descriptors)\\n print(\\\"Person successfully added.\\\")\",\n \"def add_image_file(self, imagefilename):\\n #import matplotlib.image as mpimg\\n\\n # set aspect to auto mode\\n self.axes.set_aspect('auto')\\n\\n img = matplotlib.image.imread(str(imagefilename))\\n # lum_img = img[:,:,0]\\n # FUTURE : refactor for image size, interpolation and origin\\n imgplot = self.axes.imshow(img, extent=[0, 1000, 800, 0], interpolation='none', origin='lower')\\n\\n # Set color bar. plt.colorbar() does not work!\\n if self._colorBar is None:\\n # set color map type\\n imgplot.set_cmap('spectral')\\n self._colorBar = self.fig.colorbar(imgplot)\\n else:\\n self._colorBar.update_bruteforce(imgplot)\\n\\n self._flush()\\n\\n return\",\n \"def _addImage(self, image, preprocessor):\\n if self.images == None:\\n self.images = []\\n\\n processed_image = preprocessor(image,\\n self.inputShape()[2],\\n self.inputShape()[1])\\n\\n self.images.append(processed_image)\",\n \"def Add(*args, **kwargs):\\n return _gdi_.ImageList_Add(*args, **kwargs)\",\n \"def add_image(jid, img):\\n jrd.hset(_generate_job_key(jid), 'image_status', 'created')\\n image_rd.hset(jid, 'image', img)\",\n \"def draw(self, frame):\\n frame[OFS:OFS+self.image.shape[0], OFS:OFS+self.image.shape[1]] = self.image\",\n \"def addImg(in_dict):\\n img = Image(name=in_dict[\\\"name\\\"],\\n b64str=in_dict[\\\"b64str\\\"],\\n imgsize=in_dict[\\\"imgsize\\\"],\\n processed=in_dict[\\\"processed\\\"],\\n timestamp=in_dict[\\\"timestamp\\\"])\\n ans = img.save()\\n return ans.name\",\n \"def addFigure(self,fig,xl,yl,scale):\\n img = py.image.load(fig)\\n w,h = img.get_size()\\n img = py.transform.scale(img,(int(w*scale),int(h*scale)))\\n self.figures.append(img)\\n self.locs.append((xl,yl))\",\n \"def new_image(x, y, out, data):\\n img = Image.new('RGB', (x, y))\\n img.putdata(data)\\n img.save(out)\",\n \"def PrePush(self, image):\\n pass\",\n \"def overlay_image(image_to_show, image_to_add, directory=None):\\n \\n direcx = \\\"/Documents/1.4.5 Images/\\\"#put a condition pls\\n if directory == None:\\n directory = os.getcwd()\\n print directory\\n new_image = PIL.Image.open(directory + direcx + image_to_show)\\n new_imager = PIL.Image.open(directory + direcx + image_to_show)\\n new_imager.show()\\n new_image2 = PIL.Image.open(directory + direcx + image_to_add)\\n new_image2.show()\\n width, height = new_imager.size\\n print str(width) + \\\" \\\" + str(height)\\n #print new_image\\n #print new_image2\\n #if image_to_show == \\\"\\\":\\n # print_directory_list2()\\n # return \\\"Use one of these\\\"\\n new_image22 = new_image2.resize((width,height), PIL.Image.ANTIALIAS)\\n new_image22.show()\\n\\n new_imager.paste(new_image22, (width, height), new_image22)\\n new_imager.show()\\n #cohrt = PIL.Image.blend(new_imager, new_image22, alpha=0.5)\\n #cohrt.show()\",\n \"def _drawimage(self, item, pos, image):\\n x, y = pos\\n self.cv.coords(item, (x * self.xscale, -y * self.yscale))\\n self.cv.itemconfig(item, image=image)\",\n \"def update_image(self, image):\\n raise NotImplementedError()\",\n \"def loaded_image(self, image):\\r\\n self.loaded_images.append(image)\",\n \"def add(self, mp):\\n \\n self.tile_contents.append(mp)\\n if(self.tile_contents[-1].raised == False):\\n self.paint_blocks += 1.00\",\n \"def _append_png(self, png, before_prompt=False, metadata=None):\\n self._append_custom(self._insert_png, png, before_prompt, metadata=metadata)\",\n \"def adjust(self, image):\\n ...\",\n \"def draw(self):\\n self.write_image()\\n self.update()\",\n \"def add_image(self, image_name, version, image_hash):\\n raise NotImplementedError()\",\n \"def add_image(self, image_list):\\n self.image_filenames_list.append(image_list)\",\n \"def store_image(self, image_name):\\n self.images.append(image_name)\",\n \"def add(self, output_svg: Drawing) -> None:\\n pass\",\n \"def modify_image(self, example, target_label):\\n raise NotImplementedError()\",\n \"def register_collection_additional_image(self, image):\\n save_path = os.path.join(self.session_dir, 'additional.jpg')\\n image.save(save_path)\",\n \"def add_image(self, img, input_or_output, filename, title, description=\\\"\\\"):\\n if input_or_output.lower() != \\\"input\\\" and input_or_output.lower() != \\\"output\\\":\\n raise Exception(\\\"input_or_output parameter can only contain 'input' or 'output'\\\")\\n\\n image_object = Image(self._name, img, input_or_output, self._img_folder + \\\"/\\\" + filename, title, description=\\\"\\\")\\n image_object.commit()\\n s = image_object.to_series()\\n self._commit(s)\",\n \"def add_trigger(self, img):\\n img[self.trigger_loc] = 0\\n poison_img = img + self.trigger_ptn\\n\\n return poison_img\",\n \"def view(self):\\n window = tk.Tk()\\n label = tk.Label(window)\\n label.pack()\\n img = self.get_tkimage()\\n label[\\\"image\\\"] = label.img = img\\n window.mainloop()\",\n \"def setup():\\n img = Image.new('RGB', (10, 20))\\n img.putpixel((5, 10), (0, 255, 0))\\n img.save('green-dot.tif')\\n img.save('green-dot.jpg')\\n img.save('green-dot.png')\",\n \"def _addClicked(self):\\n volume = self.volume()\\n if volume is not None:\\n dataRange = volume.getDataRange()\\n if dataRange is None:\\n dataRange = 0., 1.\\n\\n volume.addIsosurface(\\n numpy.mean((dataRange[0], dataRange[-1])),\\n '#0000FF')\",\n \"def display_image(self, img, img_pos):\\n image = tk.Label(self.top, image=img)\\n image.grid(row=img_pos[0], column=img_pos[1],\\n columnspan=img_pos[2], rowspan=img_pos[3])\",\n \"def update_image(self, data):\\n self.image_data.append(data)\\n if len(self.image_data) > self.image_height:\\n self.image_data = self.image_data[1:]\\n\\n self.image_render += 1\\n\\n # A 200 pixel tall image squashed into the render view does not\\n # appear unpleasantely jumpy when scrolled by 5\\n if self.image_render % 5 != 0 and self.image_render != 1:\\n return\\n\\n img_data = range(len(self.image_data))\\n\\n position = 0\\n while position < len(img_data):\\n img_data[position] = self.image_data[position]\\n position += 1\\n\\n new_data = numpy.array(img_data).astype(float)\\n\\n mid = self.main_image_dialog\\n mid.image.set_data(new_data)\\n\\n # If you do autoscale here, it tends to jump around in appearing\\n # to stretch to the window and be in 'normal' size\\n mid.get_plot().replot()\",\n \"def draw(self, frame):\\n xpos = OFS + self.x * TILE_SIZE\\n ypos = OFS + self.y * TILE_SIZE\\n frame[ypos:ypos+TILE_SIZE, xpos:xpos+TILE_SIZE] = self.image\",\n \"def add_image(project, img, id, snap, parent, public):\\n with BMI(_username, _password, constants.BMI_ADMIN_PROJECT) as bmi:\\n ret = bmi.add_image(project, img, id, snap, parent, public)\\n if ret[constants.STATUS_CODE_KEY] == 200:\\n click.echo(\\\"Success\\\")\\n else:\\n click.echo(ret[constants.MESSAGE_KEY])\",\n \"def generate_image(self):\\n pass\",\n \"def add_picture(self, file, left, top, width=None, height=None):\\n pkg = Package.containing(self.__slide)\\n image = pkg._images.add_image(file)\\n rel = self.__slide._add_relationship(RT_IMAGE, image)\\n pic = self.__pic(rel._rId, file, left, top, width, height)\\n self.__spTree.append(pic)\\n picture = Picture(pic)\\n self.__shapes.append(picture)\\n return picture\",\n \"def botStack(self):\\r\\n\\r\\n self.z_stack=self.img.shape[0]-1\\r\\n #self.pixmap=QtGui.QPixmap.fromImage(ImageQt.ImageQt(misc.toimage(self.img[self.z_stack]))).scaleds(500,500)\\r\\n self.pixmap= self.drawPixmap(\\\"xy\\\")\\r\\n self.lbl.setPixmap(self.pixmap)\\r\\n\\r\\n self.pixmap2=self.writeEdge(\\\"xy\\\")\\r\\n self.lbl2.setPixmap(self.pixmap2)\\r\\n self.z_stack_lbl.setText(str(self.z_stack+1) + '/' + str(self.img.shape[0]))\",\n \"def write_image(self, tag, image, step):\\n\\n self.writer.add_figure(tag, image, global_step=step)\",\n \"def placeImage(self, img, x=0, y=0):\\n if img.getSize() == self.getSize() and img.getWidth() == self.__width:\\n # Same dimensions\\n self._c = img._c\\n\\n elif x == 0 and self.__height == img.getHeight():\\n # Same height, just overwrite a block\\n p_start = y * self.__height\\n p_end = y*self.__height + img.getSize()\\n self._c[p_start:p_end] = img._c\\n\\n else:\\n # Different dimensions\\n for dx in range(min(img.getWidth(), self.getWidth() - x)):\\n self.writeCol(x+dx, img.getCol(dx), y)\",\n \"def _image(self):\\n print(\\\"imaging\\\")\\n self.images.append(self.device_control.image())\\n yield\",\n \"def main():\\n fg = SimpleImage('image_contest/me.jpg')\\n bg = SimpleImage('image_contest/house.png')\\n bg.make_as_big_as(fg)\\n combined_img = combine(bg, fg)\\n combined_img.show()\",\n \"def paintTags(self):\\n imagesTagOrder = [\\\"gender\\\", \\\"skin\\\", \\\"head\\\", \\\"body\\\", \\\"mask\\\", \\\"hair\\\", \\\"shirt\\\", \\\"trousers\\\", \\\"skirt\\\", \\\"shoes\\\"]\\n pos = 0\\n for img in imagesTagOrder:\\n self.imagesTag[img].topleft = 296, pos * 76\\n self.imagesTag[img].connect_signal(ocempgui.widgets.Constants.SIG_CLICKED, self.paintCustomizeZone, img)\\n self.window.add_child(self.imagesTag[img])\\n pos += 1\",\n \"def draw(self, color = Color.GREEN):\\n self.image[self.x, self.y] = color\",\n \"def add_image_to_frame_list(self,startFrame, endFrame, imageName): \\n for i in range(startFrame-1, endFrame-1):\\n try:\\n # image = imageio.imread(imageName)\\n im = Image.open(imageName)\\n im = im.resize((720, 720))\\n self.frame_list.append(im)\\n # self.frame_list.append(im)\\n\\n except:\\n print (imageName, \\\" not found.\\\")\\n # BufferedImage bi= new BufferedImage(320,240,BufferedImage.TYPE_BYTE_GRAY);\\n im=self.blank\\n self.frame_list.append(im)\",\n \"def add_image(self, image):\\n\\n # we're only for new images, no i'ds allowed\\n # if u want to set an id by hand use set_image\\n if image.id:\\n raise o.Exception('Can not add image with id')\\n\\n if not image.data:\\n raise o.Exception('Image must have data')\\n\\n if not image.source_page_url:\\n raise o.Exception('Image must have source page url')\\n\\n # update it's stats\\n image = self.populate_image_stats(image)\\n\\n # only add the image if we haven't seen it beforeQ\\n # if we've seen it before there will be an id which\\n # the set of images w/ this data and from this page share\\n ids = self.rc.sinter('images:datainstance:%s' % image.shahash,\\n 'images:page_ids:%s' % image.source_page_url)\\n\\n\\n # we don't need to continue\\n # we'll return back their original msg, w/o the id set\\n if ids:\\n print 'image already exists [%s], not setting' % ids\\n return image\\n\\n # so the image appears to be new, good for it\\n return self.set_image(image)\",\n \"def display(self, image):\\n raise NotImplementedError()\",\n \"def image(self,v):\\n self.set('heightfield.image',v)\\n #assert fileExists(environment.makeFilePath(v)), \\\"Warning: HeightField's image file, {}, not found in images folder.\\\".format(v) \\n return self\",\n \"def main():\\n space_ship = SimpleImage(\\\"images/MillenniumFalcon.png\\\")\\n figure = SimpleImage(\\\"images/ReyGreenScreen.png\\\")\\n result = combine(space_ship, figure)\\n result.show()\",\n \"def save_image(self):\\n self.save()\",\n \"def _build_final_image(self, image):\\n raise NotImplementedError\",\n \"def updateImage(self, frame, image):\\n frame.imgtk = image\\n frame.configure(image=image)\",\n \"def update_img(self):\\n self.img = np.array(self.image)\",\n \"def _new_image(self, data=None, name=None, colormap=None):\\n if colormap is None:\\n colormap = self._label_config_center.get_first_label_config()\\n self.model.new_image(data, name, None, colormap)\\n self.list_view.setCurrentIndex(self.model.index(0))\\n\\n # change button status\\n self._actions['remove_image'].setEnabled(True)\\n self._actions['intersect'].setEnabled(True)\\n self._actions['regular_roi'].setEnabled(True)\\n self._actions['r2i'].setEnabled(True)\\n self._actions['auto_label'].setEnabled(True)\\n self._actions['open'].setEnabled(True)\",\n \"def img_cb(self, image):\\n self.last_img = image\\n self.is_new_img = True\",\n \"def add(self, data, action, reward, terminal):\\n image = Image.fromarray(data.reshape((80, 105)))\\n image = image.resize((80, 80))\\n \\n image = np.asarray(image)\\n \\n self.data.append(image.astype('uint8'))\\n self.actions.append(action)\\n self.rewards.append(reward)\\n self.terminal.append(terminal)\\n\\n if len(self.data) > self.history_size:\\n self.data.pop(0)\\n self.actions.pop(0)\\n self.rewards.pop(0)\\n self.terminal.pop(0)\",\n \"def integrateObservation(self, img,action):\\n self.States.append(img)\\n self.Actions.append(action) \\n #self.printLevelScene()\",\n \"def getimage(self):\",\n \"def _append_jpg(self, jpg, before_prompt=False, metadata=None):\\n self._append_custom(self._insert_jpg, jpg, before_prompt, metadata=metadata)\",\n \"def AddScale(img,barLen =2, scale = 34.5, px=0.02,py=0.96, color = 255,thick=5,lw=1,stroke=1):\\n h,w=img.shape\\n w_scale=int(scale*barLen)\\n x1=int(w*px)\\n y1=int(h*py)\\n x2=x1+w_scale\\n y2=y1+thick\\n \\n bcolor=255-color\\n \\n \\n \\n \\n text = str(barLen)+' nm'\\n font = cv2.FONT_HERSHEY_SIMPLEX#CV_FONT_HERSHEY_SIMPLEX normal size sans-serif font\\n if stroke == 1:\\n cv2.putText(img,text,(x1,y1-8), font, 1, bcolor, 3, cv2.LINE_AA) #Stroke \\n cv2.rectangle(img,(x1,y1),(x2,y2),bcolor,2)#boarder color\\n\\n \\n cv2.rectangle(img,(x1,y1),(x2,y2),color,-1)\\n \\n cv2.putText(img,text,(x1,y1-8), font, 1, color, 2, cv2.LINE_AA)\",\n \"def add_image_to_html(self, image_path):\\r\\n file_object = open(self.file_name, 'a+')\\r\\n html_content = f'<div><img src={image_path} width=\\\"500\\\" height=\\\"300\\\"></div>'\\r\\n file_object.write(html_content)\",\n \"def _add_image(self, image):\\n document = self._control.document()\\n name = str(image.cacheKey())\\n document.addResource(QtGui.QTextDocument.ImageResource,\\n QtCore.QUrl(name), image)\\n format = QtGui.QTextImageFormat()\\n format.setName(name)\\n return format\",\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 display(self):\\n display(self.image)\",\n \"def build_filler_images(self):\",\n \"def display(self, color = (190,205,205), add = False): \\r\\n s += pgl.Shape(pgl.FaceSet( [[0,0,0],[1,0,0],[1,1,0],[0,1,0]], [[0,1,2,3]]) , pgl.Material((0,100,0)))\",\n \"def update(self):\\n if self.value:\\n self.image = self.rect2 \\n else:\\n self.image = self.rect1\",\n \"def set_image(self, image):\\n self.data['image'] = image\",\n \"def add_drawable(self, gameObject):\\r\\n if not self.sprite_group.has(gameObject):\\r\\n self.sprite_group.add(gameObject)\",\n \"def extend_image(self):\\n IJ.run(self.image, 'Select All', '')\\n IJ.run(self.image, 'Copy', '')\\n width = self.image.getWidth()\\n height = int(self.image.getHeight() + self.extend_full)\\n new_image = IJ.createImage(\\n IMP.getTitle(), '32-bit black', width, height, 1)\\n new_image.setRoi(0, 0, self.image.getWidth(), self.image.getHeight())\\n IJ.run(new_image, 'Paste', '')\\n IJ.run(new_image, 'Enhance Contrast', 'saturated=0.35')\\n IJ.run(new_image, 'Select None', '')\\n cal = Calibration(self.image)\\n cal.pixelWidth = self.dispersion\\n cal.xOrigin = self.offset\\n new_image.setCalibration(cal)\\n self.image = new_image\\n return new_image\",\n \"def add_photo(self, new_photo, i):\\r\\n self.__photos[i] = new_photo\",\n \"def __init__(self, image):\\n self.image = image\",\n \"def add_image(self, f_name,file,new_id):\\r\\n folder=tempfile.mktemp()\\r\\n os.mkdir(folder)\\r\\n datei=open(folder+'/'+f_name,'w+')\\r\\n datei.write(file.read())\\r\\n datei.close()\\r\\n val='' \\r\\n liste_ext=liste_val\\r\\n if(self.toolbox.hasProperty('eigene_formate')):\\r\\n self_val=self.toolbox.getProperty('eigene_formate').split(',')\\r\\n liste_ext=[]\\r\\n for x in self_val:\\r\\n liste_ext.append('_'+x+'.jpeg')\\r\\n for extension in liste_ext:\\r\\n #cmd='/usr/bin/convert '+folder+'/'+f_name+' -resize '+extension[1:-4]+'x'+extension[1:-4]+' '+folder+'/'+new_id+extension\\r\\n cmd='/usr/bin/convert '+folder+'/'+f_name+' -resize '+extension[1:-4]+' '+folder+'/'+new_id+extension\\r\\n order=os.popen(cmd).read()\\r\\n kurz_name='_'+str(f_name.split('.')[0])\\r\\n kurz_name=kurz_name.replace(' ','_')\\r\\n val=val+self.manage_addImage(id=new_id+kurz_name+extension,file=open(folder+'/'+new_id+extension),title=f_name, precondition='', content_type='',REQUEST=None)+' ' \\r\\n os.remove(folder+'/'+new_id+extension)\\r\\n os.remove(folder+'/'+f_name)\\r\\n os.rmdir(folder)\\r\\n txt=\\\"Datei Hochgeladen!<br>\\\"\\r\\n #my_root=self.toolbox\\r\\n #txt+=my_root.id+\\\"<br>\\\"\\r\\n #if(my_root.hasProperty('eigene_formate')):\\r\\n # txt+=my_root.getProperty('eigene_formate')+\\\"<br>\\\"\\r\\n return txt\",\n \"def setIconImage(*args):\",\n \"def update_image(self):\\n if self.filenames:\\n pos = self.slider.value()\\n proj, flat, dark, theta = dx.read_aps_32id(self.filenames, proj=(pos, pos+1))\\n if self.ffc_correction:\\n image = proj[0,:,:].astype(np.float)/flat[0,:,:].astype(np.float)\\n else:\\n image = proj[0,:,:].astype(np.float)\\n self.image_item.setImage(image)\",\n \"def add_sample(self, img, action, reward, terminal):\\n self.imgs[:, :, self.top] = img\\n self.actions[self.top] = action\\n self.rewards[self.top] = reward\\n self.terminal[self.top] = terminal\\n\\n if self.size == self.max_steps:\\n self.bottom = (self.bottom + 1) % self.max_steps\\n else:\\n self.size += 1\\n\\n self.top = (self.top + 1) % self.max_steps\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71930027","0.7081216","0.6968564","0.6821934","0.6807955","0.6542881","0.6534922","0.6530329","0.648896","0.6469324","0.6455258","0.64521104","0.6431994","0.6423373","0.6371444","0.6369241","0.63576514","0.63544565","0.6354122","0.6349464","0.63464147","0.63364327","0.63351697","0.633037","0.6315666","0.6311231","0.62845767","0.62818086","0.6261919","0.62207377","0.6213396","0.6195025","0.6175233","0.6169233","0.6160607","0.61468154","0.61376405","0.6118433","0.6118213","0.6113562","0.60924494","0.60835737","0.60762393","0.60685897","0.60461205","0.60438216","0.6040712","0.6036545","0.60315347","0.6029797","0.60159844","0.60102266","0.60049194","0.5991476","0.5976356","0.59552133","0.5918959","0.5918593","0.59181947","0.5917047","0.59160155","0.5883647","0.5880813","0.5880601","0.5875848","0.5875815","0.58727586","0.58669585","0.5866428","0.58591807","0.5855978","0.58533597","0.5853108","0.5841864","0.5837895","0.5829847","0.5821546","0.5820039","0.581908","0.5817821","0.5816532","0.581557","0.5813022","0.5811178","0.5810703","0.5796619","0.5794181","0.5793743","0.57935035","0.57889944","0.5787767","0.5782915","0.5778302","0.5774121","0.57693064","0.5766662","0.5763204","0.5762425","0.5757021","0.57560086"],"string":"[\n \"0.71930027\",\n \"0.7081216\",\n \"0.6968564\",\n \"0.6821934\",\n \"0.6807955\",\n \"0.6542881\",\n \"0.6534922\",\n \"0.6530329\",\n \"0.648896\",\n \"0.6469324\",\n \"0.6455258\",\n \"0.64521104\",\n \"0.6431994\",\n \"0.6423373\",\n \"0.6371444\",\n \"0.6369241\",\n \"0.63576514\",\n \"0.63544565\",\n \"0.6354122\",\n \"0.6349464\",\n \"0.63464147\",\n \"0.63364327\",\n \"0.63351697\",\n \"0.633037\",\n \"0.6315666\",\n \"0.6311231\",\n \"0.62845767\",\n \"0.62818086\",\n \"0.6261919\",\n \"0.62207377\",\n \"0.6213396\",\n \"0.6195025\",\n \"0.6175233\",\n \"0.6169233\",\n \"0.6160607\",\n \"0.61468154\",\n \"0.61376405\",\n \"0.6118433\",\n \"0.6118213\",\n \"0.6113562\",\n \"0.60924494\",\n \"0.60835737\",\n \"0.60762393\",\n \"0.60685897\",\n \"0.60461205\",\n \"0.60438216\",\n \"0.6040712\",\n \"0.6036545\",\n \"0.60315347\",\n \"0.6029797\",\n \"0.60159844\",\n \"0.60102266\",\n \"0.60049194\",\n \"0.5991476\",\n \"0.5976356\",\n \"0.59552133\",\n \"0.5918959\",\n \"0.5918593\",\n \"0.59181947\",\n \"0.5917047\",\n \"0.59160155\",\n \"0.5883647\",\n \"0.5880813\",\n \"0.5880601\",\n \"0.5875848\",\n \"0.5875815\",\n \"0.58727586\",\n \"0.58669585\",\n \"0.5866428\",\n \"0.58591807\",\n \"0.5855978\",\n \"0.58533597\",\n \"0.5853108\",\n \"0.5841864\",\n \"0.5837895\",\n \"0.5829847\",\n \"0.5821546\",\n \"0.5820039\",\n \"0.581908\",\n \"0.5817821\",\n \"0.5816532\",\n \"0.581557\",\n \"0.5813022\",\n \"0.5811178\",\n \"0.5810703\",\n \"0.5796619\",\n \"0.5794181\",\n \"0.5793743\",\n \"0.57935035\",\n \"0.57889944\",\n \"0.5787767\",\n \"0.5782915\",\n \"0.5778302\",\n \"0.5774121\",\n \"0.57693064\",\n \"0.5766662\",\n \"0.5763204\",\n \"0.5762425\",\n \"0.5757021\",\n \"0.57560086\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69936126"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":78799,"cells":{"query":{"kind":"string","value":"Remove to set of images."},"document":{"kind":"string","value":"def Remove(self, *args):\n return _BRepAlgo.BRepAlgo_Image_Remove(self, *args)"},"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 remove_images(self):\n hardware_components.log_method(self, \"remove_images\")\n communication_object = self._get_control_software().connection\n communication_object.remove_all()","def remove(self, done=False, verbose=True):\n return _image.image_remove(self, done, verbose)","def delete_AllImgs(self):\n self.listImages.remove_all_imgs()","def remove():","def del_image(self, name):\r\n if self.images is None or name not in self.images:\r\n return\r\n l = self.images\r\n self.images = None\r\n l.setdefault('/empties/', [])\r\n # push the number on the empties list\r\n l['/empties/'].append(l[name])\r\n del l[name]\r\n self.images = l","def Remove(*args, **kwargs):\n return _gdi_.ImageList_Remove(*args, **kwargs)","def clean(self):\n tags = self.get_tags()\n for tag in tags:\n image_name = self.build_image_name(tag)\n try:\n self.client.images.remove(image_name, force=True)\n except Exception as ex:\n print('Cannot remove {}: {}'.format(tag, str(ex)))","def remove_images(self, images):\n url = (\"https://api.imgur.com/3/album/{0}/\"\n \"remove_images\".format(self._delete_or_id_hash))\n # NOTE: Returns True and everything seem to be as it should in testing.\n # Seems most likely to be upstream bug.\n params = {'ids': images}\n return self._imgur._send_request(url, params=params, method=\"DELETE\")","def remove_pixels(self, pixel_set):\n for pixel in pixel_set:\n self.remove_pixel(pixel)","def removeTextureToOcc(self):\n\t\tshas = self._getShapes()\n\t\tfor sha in shas:\n\t\t\tif sha.a.texture_Occ.exists:\n\t\t\t\tsha.a.texture_Occ.delete()","def remove(self):","def cleanup_images(self, remove_old=False, raise_on_error=False):\n used_images = set(self.inspect_container(container['Id'])['Image']\n for container in self.containers(all=True))\n image_dependencies = ((image['Id'], image['ParentId']) for image in self.images(all=True))\n resolver = ContainerImageResolver(used_images, image_dependencies)\n tag_check = is_latest_image if remove_old else is_repo_image\n unused_images = set(image['Id'] for image in self.images()\n if not tag_check(image) and not resolver.get_dependencies(image['Id']))\n\n for iid in unused_images:\n try:\n self.remove_image(iid)\n except APIError as e:\n import sys\n exc_info = sys.exc_info()\n if e.response.status_code != 404:\n self.push_log(\"Could not remove image '%s': %s\", logging.ERROR, iid, e.explanation)\n if raise_on_error:\n raise exc_info[0], exc_info[1], exc_info[2]","def cmd_album_remove_images(client, args):\n remove_images = client.album_remove_images(args.album_id, args.ids)\n generate_output({'remove_images': remove_images})","def remove(self):\n pass","def remove(self):\n pass","def remove(self):\n pass","def remove():\n pass","def delAvatarImage(self, imgName = None): \n if imgName:\n self.window.remove_child(self.images[imgName])\n self.images[imgName].destroy()\n self.images[imgName] = None\n else:\n for key in self.images:\n if self.images[key]:\n self.window.remove_child(self.images[key])\n self.images[key].destroy()\n self.images[key] = None","def _remove(self):\n pass","def remove(self):\n raise NotImplementedError","def remove(self):\n raise NotImplementedError","def del_imgs(path):\n files = os.listdir(path)\n for file in files:\n if file.endswith(\".jpg\"):\n os.remove(os.path.join(path, file))","def delete_all_images(self, index):\n self.__accessed_image[:] = False\n self.__check_delete_images()","def remove_ssm(self, ssm_image):\n pass","def removeIrisToOcc(self):\n\t\tshas = self._getShapes()\n\t\tfor sha in shas:\n\t\t\tif sha.a.iris_Occ.exists:\n\t\t\t\tsha.a.iris_Occ.delete()","def delete(log, session, args):\n log('imageset id: {highlight}{id}{reset}',\n highlight=Fore.GREEN,\n id=args.id,\n reset=Style.RESET_ALL)\n log.warn('delete imageset command coming soon.')","def delete_any_image(self, index):\n self.__accessed_image[index] = False\n self.__check_delete_images()","def remove_image(self, imagename, del_img=False):\n os.system('rm -r {}.model'.format(imagename))\n os.system('rm -r {}.flux'.format(imagename))\n os.system('rm -r {}.psf'.format(imagename))\n os.system('rm -r {}.residual'.format(imagename))\n if del_img:\n os.system('rm -r {}.image'.format(imagename))","def remove_bad_images(path_images):\n images = sorted(os.listdir(path_images))\n for k in range(len(images)):\n os.remove(path_images + images[k])","def remove_extra_images(path_to_images: str, number_of_images: int) -> None:\n last_image = 'image' + str(number_of_images) + '.jpg'\n while last_image in listdir(path_to_images):\n last_image_path = path.join(path_to_images, last_image)\n remove(last_image_path)\n print(f\"remove {last_image}\")\n number_of_images += 1\n last_image = 'image' + str(number_of_images) + '.jpg'","def cleanup_old_images(self):\n \n logging.debug(\"%s cleanup_old_images entered\" % self.footprint_name)\n active_imgs = self.images.values()\n old_images = self.old_images[:]\n for img_id in old_images:\n logging.info(\"Deleting image %s from footprint %s\" % (img_id, self.footprint_name))\n if img_id not in active_imgs:\n notify(\"Deleting image %s from footprint %s\" % (img_id, self.footprint_name))\n img = cs.images.get(img_id)\n if img:\n try:\n img.delete()\n except novaclient.exceptions.NotFound:\n notify(\"Couldn't find image %s\" % img_id)\n self.old_images.remove(img_id)\n else:\n notify(\"Not deleting active image %s\" % img_id)\n # save changes\n self.save()","def remove_image(image_path):\n\n os.remove(image_path)\n images_in_directory.remove(image_path)\n\n print(f'removed {image_path} from directory')\n\n pass","def _remove_wall_pic(self):\n # Retrieve the item that was selected\n key = self._listbox.get(ACTIVE)\n # Post a delete notice to the manager\n self._remove(key)","def remove_from_sprite_lists(self):\n super().remove_from_sprite_lists()\n\n # It is very important to call this to prevent potential\n # issues such as crashes or excess memory use from failed\n # garbage collection.\n pyglet.clock.unschedule(self.update)","def __on_delete(self):\n self.image.delete()","def __on_delete(self):\n self.image.delete()","def removeScene(self):\n del self.scene, self.imgPixmapItem","def clear_images(self):\r\n\r\n # audio = self.MutagenType(self['filename'])\r\n self.audio.pop(\"metadata_block_picture\", None)\r\n self.audio.pop(\"coverart\", None)\r\n self.audio.pop(\"coverartmime\", None)\r\n self.audio.save()","def destroy(self):\n url = \"/images/%s/destroy\" % (str(self.id))\n\n data = self._conn.request(url)\n\n log.debug(data)","def remove(self, pset):\n self._sets.remove(pset)","def delete(self):\n\t\tif self.hasUdim:\n\t\t\tfor a in self.udimPaths:\n\t\t\t\ta.delete()\n\t\telse:\n\t\t\tsuper( textureFile, self ).delete()","def remove(self):\r\n\t\tself._delete()","def clearImage(self):\n if self.hasImage():\n self.scene.removeItem(self._image)\n self._image = None","def remove(self):\n for artist in self._artists:\n artist.remove()","def remove_data(writer: UFOWriter, filename: str) -> None:\n writer.removeImage(filename)","def delete_image(self):\n Image.objects.get(id = self.id).delete()","def delete(self, *args, **kwargs):\n\t\tself.emo_img.delete(False)\n\t\tsuper(Emotion, self).delete(*args, **kwargs)","def remove(self, *args):\n pass","def remove(self, *args):\n self.__execute(self.pkgin_bin, \"remove\", *args)","def __del__(self):\n\t\tos.remove(self.imgpath)\n\t\tfor b in self.__class__.__bases__:\n\t\t\tb.__del__(self)","def remove_from_hand(self):\n pass","def reset(self, i):\n self.img_collection[i] = []","def clear(self):\n [roi.clear() for roi in self.rois]","def delete_image(Name=None):\n pass","def removeInputCopies(self):\n for p in self.assoc.parlist:\n if int(p['group']) == 1:\n _img = p['image'].datafile\n shutil.move(p['orig_filename'],_img)","def delete(self, *args, **kwargs):\n super(Image, self).delete(*args, **kwargs)","def remove(self, items, relative=True):\n if relative: items = self.items[items]\n self.items = np.setdiff1d(self.items, items)","def delTags(self):\r\n for tag in self.tags:\r\n self.canvasCirkt.delete(tag)\r\n self.canvasCirkt.update()","def _remove_texture(self):\n # Retrieve the item that was selected\n key = self._listbox.get(ACTIVE)\n # Post a delete notice to the manager\n self._remove(key)","def remove(self):\n self.remove_file()","def remove_images_without_label(path_folder):\n\n\n #labels = os.listdir(path_folder + \"labels/val/\")\n labels = os.listdir(path_folder + \"labels/val/\")\n images = os.listdir(path_folder + \"images/val/\")\n for i in images:\n name_i = i.split(\".\")\n if name_i[0] + '.xml' not in labels:\n os.remove(path_folder + \"images/val/\" + i)","def space_cleaning():\n for file in os.listdir(\".\"):\n if file.endswith(\".png\"):\n os.remove(file)","def remove_unactionable_images(data):\n os.makedirs(os.path.join(data, 'removed'), exist_ok=True)\n for product in os.listdir(data):\n if product.startswith('product') is False:\n continue\n path = os.path.join(data, product)\n if os.path.isdir(path) is False:\n continue\n if is_useful(path, 0.5) is False:\n print('\\tRemoving ' + path)\n shutil.copy(os.path.join(path, 'TCI.tiff'),\n os.path.join(data, 'removed', product + '.tiff'))\n shutil.rmtree(path)\n else:\n shutil.copy(os.path.join(path, 'TCI.tiff'),\n os.path.join(data, product + '.tiff'))","def remove_image(project, img):\n data = {constants.PROJECT_PARAMETER: project,\n constants.IMAGE_NAME_PARAMETER: img}\n res = requests.delete(_url + \"remove_image/\", data=data, auth=(\n _username, _password))\n click.echo(res.content)","def do_command(self, args):\n imageops = dbops.Images()\n imageops.delete(args)","def clear_space():\r\n global images_a, images_b, images_total\r\n images_a = []\r\n images_b = []\r\n images_total = []","def withdraw(self):\n files = self._file_list\n for f in files:\n remove(str(f))\n self._file_list = []\n self._filename = \"\"","async def remove(self, container, uids):","def __check_delete_images(self):\n for i, (ctr, usingproperty) in enumerate(zip(self.__using_image_counter, self.__accessed_image)):\n if not ctr and not usingproperty:\n self.__images_cache[i] = None","def remove_from_gallery(self):\n url = \"https://api.imgur.com/3/gallery/{0}\".format(self.id)\n self._imgur._send_request(url, needs_auth=True, method='DELETE')\n if isinstance(self, Image):\n item = self._imgur.get_image(self.id)\n else:\n item = self._imgur.get_album(self.id)\n _change_object(self, item)\n return self","def handle_remove(self):\r\n self.del_common()","def remove(self, container):\n pass","def delImg(img_name):\n img = Image.objects.raw({\"_id\": img_name}).first()\n img.delete()\n return","def clear_thumbnails(self):","def removefile(self, file):\n return _image.image_removefile(self, file)","async def remove_img(self, ctx: BBContext, url: str):\n\n con = await ctx.get_connection()\n query = f'DELETE FROM {TABLE_ARTS} WHERE url = $1'\n\n await con.execute(query, url)\n await ctx.tick(True)","def delete(self, *args, **kwargs):\n self.image.delete()\n super(Recipe, self).delete(*args, **kwargs)","def remove_image_file(sender, instance, **kwargs):\n # Pass false so ImageField doesn't save the model.\n instance.image.delete(False)","def delete_leftovers(self):\n for each_file, artist in self.past_songs_db_data:\n if os.path.isfile(each_file): \n os.remove(each_file)\n print \"Deleted \" + each_file\n\n for each_file in os.listdir(\".\"):\n if each_file.endswith(\".jpg\"):\n os.remove(each_file)","def remove(self, packages):\n raise NotImplementedError()","def remove_gif(self, url: Text) -> None:\r\n matches = [e for e in self.elements\r\n if e.url == url]\r\n if not matches:\r\n return\r\n self.elements = [e for e in self.elements if e.url != url]\r\n # Update the tags\r\n match_tags = [t for t_ in matches\r\n for t in t_.tags]\r\n for tag in match_tags:\r\n self.tags[tag] -= 1\r\n if self.tags[tag] == 0:\r\n del self.tags[tag]","def remove(self) -> None:\n self.map.cameras.remove(self)\n if self.is_active():\n self.set_inactive_all()","def remove(self):\n self.inp.inputs.discard(self)\n self.out.outputs.discard(self)","def remove(self):\r\n game_ref.remove(self)","def clean(self):\n if self.image:\n self.glance.images.delete(self.image['id'])\n\n if self.image_file:\n shutil.rmtree(self.download_path)","def remove_all_rasters():\n for fname in g.list_grouped(['raster'])['PERMANENT']:\n g.run_command('g.remove', flags='f', type='raster',\n name=fname)","def remove_night_images(path_labels):\n labels = sorted(os.listdir(path_labels))\n for k in range(len(labels)):\n content = open(path_labels + labels[k]).read()\n if 'night' in content:\n os.remove(path_labels + labels[k])","def clear_images(self):\r\n\r\n with translate_errors():\r\n self.audio.clear_pictures()\r\n self.audio.save()\r\n\r\n super().clear_images()","def delete(self):\n # Get all images\n images = self.get_images(\"Deleted\")\n self._app[\"mark\"].marked = []\n # Delete all images remembering possible errors\n message = \"\"\n for im in images:\n if not os.path.exists(im):\n message += \"Image %s does not exist.\" % (im)\n elif os.path.isdir(im):\n message += \"Deleting directory %s is not supported.\" % (im)\n else:\n self.trash_manager.delete(im)\n if message:\n self._app[\"statusbar\"].message(message, \"error\")\n\n self._app.emit(\"paths-changed\", self)","def remove_animal(self, i):\n self.__list_animaux.pop(i)","def __del__(self):\n for filename in self.files:\n unlink(filename)","def clearImage(self):\n if self.hasImage():\n self.scene.removeItem(self._pixmapHandle)\n self._pixmapHandle = None\n self.zoom=-1\n self.scene.clear()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()"],"string":"[\n \"def remove_images(self):\\n hardware_components.log_method(self, \\\"remove_images\\\")\\n communication_object = self._get_control_software().connection\\n communication_object.remove_all()\",\n \"def remove(self, done=False, verbose=True):\\n return _image.image_remove(self, done, verbose)\",\n \"def delete_AllImgs(self):\\n self.listImages.remove_all_imgs()\",\n \"def remove():\",\n \"def del_image(self, name):\\r\\n if self.images is None or name not in self.images:\\r\\n return\\r\\n l = self.images\\r\\n self.images = None\\r\\n l.setdefault('/empties/', [])\\r\\n # push the number on the empties list\\r\\n l['/empties/'].append(l[name])\\r\\n del l[name]\\r\\n self.images = l\",\n \"def Remove(*args, **kwargs):\\n return _gdi_.ImageList_Remove(*args, **kwargs)\",\n \"def clean(self):\\n tags = self.get_tags()\\n for tag in tags:\\n image_name = self.build_image_name(tag)\\n try:\\n self.client.images.remove(image_name, force=True)\\n except Exception as ex:\\n print('Cannot remove {}: {}'.format(tag, str(ex)))\",\n \"def remove_images(self, images):\\n url = (\\\"https://api.imgur.com/3/album/{0}/\\\"\\n \\\"remove_images\\\".format(self._delete_or_id_hash))\\n # NOTE: Returns True and everything seem to be as it should in testing.\\n # Seems most likely to be upstream bug.\\n params = {'ids': images}\\n return self._imgur._send_request(url, params=params, method=\\\"DELETE\\\")\",\n \"def remove_pixels(self, pixel_set):\\n for pixel in pixel_set:\\n self.remove_pixel(pixel)\",\n \"def removeTextureToOcc(self):\\n\\t\\tshas = self._getShapes()\\n\\t\\tfor sha in shas:\\n\\t\\t\\tif sha.a.texture_Occ.exists:\\n\\t\\t\\t\\tsha.a.texture_Occ.delete()\",\n \"def remove(self):\",\n \"def cleanup_images(self, remove_old=False, raise_on_error=False):\\n used_images = set(self.inspect_container(container['Id'])['Image']\\n for container in self.containers(all=True))\\n image_dependencies = ((image['Id'], image['ParentId']) for image in self.images(all=True))\\n resolver = ContainerImageResolver(used_images, image_dependencies)\\n tag_check = is_latest_image if remove_old else is_repo_image\\n unused_images = set(image['Id'] for image in self.images()\\n if not tag_check(image) and not resolver.get_dependencies(image['Id']))\\n\\n for iid in unused_images:\\n try:\\n self.remove_image(iid)\\n except APIError as e:\\n import sys\\n exc_info = sys.exc_info()\\n if e.response.status_code != 404:\\n self.push_log(\\\"Could not remove image '%s': %s\\\", logging.ERROR, iid, e.explanation)\\n if raise_on_error:\\n raise exc_info[0], exc_info[1], exc_info[2]\",\n \"def cmd_album_remove_images(client, args):\\n remove_images = client.album_remove_images(args.album_id, args.ids)\\n generate_output({'remove_images': remove_images})\",\n \"def remove(self):\\n pass\",\n \"def remove(self):\\n pass\",\n \"def remove(self):\\n pass\",\n \"def remove():\\n pass\",\n \"def delAvatarImage(self, imgName = None): \\n if imgName:\\n self.window.remove_child(self.images[imgName])\\n self.images[imgName].destroy()\\n self.images[imgName] = None\\n else:\\n for key in self.images:\\n if self.images[key]:\\n self.window.remove_child(self.images[key])\\n self.images[key].destroy()\\n self.images[key] = None\",\n \"def _remove(self):\\n pass\",\n \"def remove(self):\\n raise NotImplementedError\",\n \"def remove(self):\\n raise NotImplementedError\",\n \"def del_imgs(path):\\n files = os.listdir(path)\\n for file in files:\\n if file.endswith(\\\".jpg\\\"):\\n os.remove(os.path.join(path, file))\",\n \"def delete_all_images(self, index):\\n self.__accessed_image[:] = False\\n self.__check_delete_images()\",\n \"def remove_ssm(self, ssm_image):\\n pass\",\n \"def removeIrisToOcc(self):\\n\\t\\tshas = self._getShapes()\\n\\t\\tfor sha in shas:\\n\\t\\t\\tif sha.a.iris_Occ.exists:\\n\\t\\t\\t\\tsha.a.iris_Occ.delete()\",\n \"def delete(log, session, args):\\n log('imageset id: {highlight}{id}{reset}',\\n highlight=Fore.GREEN,\\n id=args.id,\\n reset=Style.RESET_ALL)\\n log.warn('delete imageset command coming soon.')\",\n \"def delete_any_image(self, index):\\n self.__accessed_image[index] = False\\n self.__check_delete_images()\",\n \"def remove_image(self, imagename, del_img=False):\\n os.system('rm -r {}.model'.format(imagename))\\n os.system('rm -r {}.flux'.format(imagename))\\n os.system('rm -r {}.psf'.format(imagename))\\n os.system('rm -r {}.residual'.format(imagename))\\n if del_img:\\n os.system('rm -r {}.image'.format(imagename))\",\n \"def remove_bad_images(path_images):\\n images = sorted(os.listdir(path_images))\\n for k in range(len(images)):\\n os.remove(path_images + images[k])\",\n \"def remove_extra_images(path_to_images: str, number_of_images: int) -> None:\\n last_image = 'image' + str(number_of_images) + '.jpg'\\n while last_image in listdir(path_to_images):\\n last_image_path = path.join(path_to_images, last_image)\\n remove(last_image_path)\\n print(f\\\"remove {last_image}\\\")\\n number_of_images += 1\\n last_image = 'image' + str(number_of_images) + '.jpg'\",\n \"def cleanup_old_images(self):\\n \\n logging.debug(\\\"%s cleanup_old_images entered\\\" % self.footprint_name)\\n active_imgs = self.images.values()\\n old_images = self.old_images[:]\\n for img_id in old_images:\\n logging.info(\\\"Deleting image %s from footprint %s\\\" % (img_id, self.footprint_name))\\n if img_id not in active_imgs:\\n notify(\\\"Deleting image %s from footprint %s\\\" % (img_id, self.footprint_name))\\n img = cs.images.get(img_id)\\n if img:\\n try:\\n img.delete()\\n except novaclient.exceptions.NotFound:\\n notify(\\\"Couldn't find image %s\\\" % img_id)\\n self.old_images.remove(img_id)\\n else:\\n notify(\\\"Not deleting active image %s\\\" % img_id)\\n # save changes\\n self.save()\",\n \"def remove_image(image_path):\\n\\n os.remove(image_path)\\n images_in_directory.remove(image_path)\\n\\n print(f'removed {image_path} from directory')\\n\\n pass\",\n \"def _remove_wall_pic(self):\\n # Retrieve the item that was selected\\n key = self._listbox.get(ACTIVE)\\n # Post a delete notice to the manager\\n self._remove(key)\",\n \"def remove_from_sprite_lists(self):\\n super().remove_from_sprite_lists()\\n\\n # It is very important to call this to prevent potential\\n # issues such as crashes or excess memory use from failed\\n # garbage collection.\\n pyglet.clock.unschedule(self.update)\",\n \"def __on_delete(self):\\n self.image.delete()\",\n \"def __on_delete(self):\\n self.image.delete()\",\n \"def removeScene(self):\\n del self.scene, self.imgPixmapItem\",\n \"def clear_images(self):\\r\\n\\r\\n # audio = self.MutagenType(self['filename'])\\r\\n self.audio.pop(\\\"metadata_block_picture\\\", None)\\r\\n self.audio.pop(\\\"coverart\\\", None)\\r\\n self.audio.pop(\\\"coverartmime\\\", None)\\r\\n self.audio.save()\",\n \"def destroy(self):\\n url = \\\"/images/%s/destroy\\\" % (str(self.id))\\n\\n data = self._conn.request(url)\\n\\n log.debug(data)\",\n \"def remove(self, pset):\\n self._sets.remove(pset)\",\n \"def delete(self):\\n\\t\\tif self.hasUdim:\\n\\t\\t\\tfor a in self.udimPaths:\\n\\t\\t\\t\\ta.delete()\\n\\t\\telse:\\n\\t\\t\\tsuper( textureFile, self ).delete()\",\n \"def remove(self):\\r\\n\\t\\tself._delete()\",\n \"def clearImage(self):\\n if self.hasImage():\\n self.scene.removeItem(self._image)\\n self._image = None\",\n \"def remove(self):\\n for artist in self._artists:\\n artist.remove()\",\n \"def remove_data(writer: UFOWriter, filename: str) -> None:\\n writer.removeImage(filename)\",\n \"def delete_image(self):\\n Image.objects.get(id = self.id).delete()\",\n \"def delete(self, *args, **kwargs):\\n\\t\\tself.emo_img.delete(False)\\n\\t\\tsuper(Emotion, self).delete(*args, **kwargs)\",\n \"def remove(self, *args):\\n pass\",\n \"def remove(self, *args):\\n self.__execute(self.pkgin_bin, \\\"remove\\\", *args)\",\n \"def __del__(self):\\n\\t\\tos.remove(self.imgpath)\\n\\t\\tfor b in self.__class__.__bases__:\\n\\t\\t\\tb.__del__(self)\",\n \"def remove_from_hand(self):\\n pass\",\n \"def reset(self, i):\\n self.img_collection[i] = []\",\n \"def clear(self):\\n [roi.clear() for roi in self.rois]\",\n \"def delete_image(Name=None):\\n pass\",\n \"def removeInputCopies(self):\\n for p in self.assoc.parlist:\\n if int(p['group']) == 1:\\n _img = p['image'].datafile\\n shutil.move(p['orig_filename'],_img)\",\n \"def delete(self, *args, **kwargs):\\n super(Image, self).delete(*args, **kwargs)\",\n \"def remove(self, items, relative=True):\\n if relative: items = self.items[items]\\n self.items = np.setdiff1d(self.items, items)\",\n \"def delTags(self):\\r\\n for tag in self.tags:\\r\\n self.canvasCirkt.delete(tag)\\r\\n self.canvasCirkt.update()\",\n \"def _remove_texture(self):\\n # Retrieve the item that was selected\\n key = self._listbox.get(ACTIVE)\\n # Post a delete notice to the manager\\n self._remove(key)\",\n \"def remove(self):\\n self.remove_file()\",\n \"def remove_images_without_label(path_folder):\\n\\n\\n #labels = os.listdir(path_folder + \\\"labels/val/\\\")\\n labels = os.listdir(path_folder + \\\"labels/val/\\\")\\n images = os.listdir(path_folder + \\\"images/val/\\\")\\n for i in images:\\n name_i = i.split(\\\".\\\")\\n if name_i[0] + '.xml' not in labels:\\n os.remove(path_folder + \\\"images/val/\\\" + i)\",\n \"def space_cleaning():\\n for file in os.listdir(\\\".\\\"):\\n if file.endswith(\\\".png\\\"):\\n os.remove(file)\",\n \"def remove_unactionable_images(data):\\n os.makedirs(os.path.join(data, 'removed'), exist_ok=True)\\n for product in os.listdir(data):\\n if product.startswith('product') is False:\\n continue\\n path = os.path.join(data, product)\\n if os.path.isdir(path) is False:\\n continue\\n if is_useful(path, 0.5) is False:\\n print('\\\\tRemoving ' + path)\\n shutil.copy(os.path.join(path, 'TCI.tiff'),\\n os.path.join(data, 'removed', product + '.tiff'))\\n shutil.rmtree(path)\\n else:\\n shutil.copy(os.path.join(path, 'TCI.tiff'),\\n os.path.join(data, product + '.tiff'))\",\n \"def remove_image(project, img):\\n data = {constants.PROJECT_PARAMETER: project,\\n constants.IMAGE_NAME_PARAMETER: img}\\n res = requests.delete(_url + \\\"remove_image/\\\", data=data, auth=(\\n _username, _password))\\n click.echo(res.content)\",\n \"def do_command(self, args):\\n imageops = dbops.Images()\\n imageops.delete(args)\",\n \"def clear_space():\\r\\n global images_a, images_b, images_total\\r\\n images_a = []\\r\\n images_b = []\\r\\n images_total = []\",\n \"def withdraw(self):\\n files = self._file_list\\n for f in files:\\n remove(str(f))\\n self._file_list = []\\n self._filename = \\\"\\\"\",\n \"async def remove(self, container, uids):\",\n \"def __check_delete_images(self):\\n for i, (ctr, usingproperty) in enumerate(zip(self.__using_image_counter, self.__accessed_image)):\\n if not ctr and not usingproperty:\\n self.__images_cache[i] = None\",\n \"def remove_from_gallery(self):\\n url = \\\"https://api.imgur.com/3/gallery/{0}\\\".format(self.id)\\n self._imgur._send_request(url, needs_auth=True, method='DELETE')\\n if isinstance(self, Image):\\n item = self._imgur.get_image(self.id)\\n else:\\n item = self._imgur.get_album(self.id)\\n _change_object(self, item)\\n return self\",\n \"def handle_remove(self):\\r\\n self.del_common()\",\n \"def remove(self, container):\\n pass\",\n \"def delImg(img_name):\\n img = Image.objects.raw({\\\"_id\\\": img_name}).first()\\n img.delete()\\n return\",\n \"def clear_thumbnails(self):\",\n \"def removefile(self, file):\\n return _image.image_removefile(self, file)\",\n \"async def remove_img(self, ctx: BBContext, url: str):\\n\\n con = await ctx.get_connection()\\n query = f'DELETE FROM {TABLE_ARTS} WHERE url = $1'\\n\\n await con.execute(query, url)\\n await ctx.tick(True)\",\n \"def delete(self, *args, **kwargs):\\n self.image.delete()\\n super(Recipe, self).delete(*args, **kwargs)\",\n \"def remove_image_file(sender, instance, **kwargs):\\n # Pass false so ImageField doesn't save the model.\\n instance.image.delete(False)\",\n \"def delete_leftovers(self):\\n for each_file, artist in self.past_songs_db_data:\\n if os.path.isfile(each_file): \\n os.remove(each_file)\\n print \\\"Deleted \\\" + each_file\\n\\n for each_file in os.listdir(\\\".\\\"):\\n if each_file.endswith(\\\".jpg\\\"):\\n os.remove(each_file)\",\n \"def remove(self, packages):\\n raise NotImplementedError()\",\n \"def remove_gif(self, url: Text) -> None:\\r\\n matches = [e for e in self.elements\\r\\n if e.url == url]\\r\\n if not matches:\\r\\n return\\r\\n self.elements = [e for e in self.elements if e.url != url]\\r\\n # Update the tags\\r\\n match_tags = [t for t_ in matches\\r\\n for t in t_.tags]\\r\\n for tag in match_tags:\\r\\n self.tags[tag] -= 1\\r\\n if self.tags[tag] == 0:\\r\\n del self.tags[tag]\",\n \"def remove(self) -> None:\\n self.map.cameras.remove(self)\\n if self.is_active():\\n self.set_inactive_all()\",\n \"def remove(self):\\n self.inp.inputs.discard(self)\\n self.out.outputs.discard(self)\",\n \"def remove(self):\\r\\n game_ref.remove(self)\",\n \"def clean(self):\\n if self.image:\\n self.glance.images.delete(self.image['id'])\\n\\n if self.image_file:\\n shutil.rmtree(self.download_path)\",\n \"def remove_all_rasters():\\n for fname in g.list_grouped(['raster'])['PERMANENT']:\\n g.run_command('g.remove', flags='f', type='raster',\\n name=fname)\",\n \"def remove_night_images(path_labels):\\n labels = sorted(os.listdir(path_labels))\\n for k in range(len(labels)):\\n content = open(path_labels + labels[k]).read()\\n if 'night' in content:\\n os.remove(path_labels + labels[k])\",\n \"def clear_images(self):\\r\\n\\r\\n with translate_errors():\\r\\n self.audio.clear_pictures()\\r\\n self.audio.save()\\r\\n\\r\\n super().clear_images()\",\n \"def delete(self):\\n # Get all images\\n images = self.get_images(\\\"Deleted\\\")\\n self._app[\\\"mark\\\"].marked = []\\n # Delete all images remembering possible errors\\n message = \\\"\\\"\\n for im in images:\\n if not os.path.exists(im):\\n message += \\\"Image %s does not exist.\\\" % (im)\\n elif os.path.isdir(im):\\n message += \\\"Deleting directory %s is not supported.\\\" % (im)\\n else:\\n self.trash_manager.delete(im)\\n if message:\\n self._app[\\\"statusbar\\\"].message(message, \\\"error\\\")\\n\\n self._app.emit(\\\"paths-changed\\\", self)\",\n \"def remove_animal(self, i):\\n self.__list_animaux.pop(i)\",\n \"def __del__(self):\\n for filename in self.files:\\n unlink(filename)\",\n \"def clearImage(self):\\n if self.hasImage():\\n self.scene.removeItem(self._pixmapHandle)\\n self._pixmapHandle = None\\n self.zoom=-1\\n self.scene.clear()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75192356","0.73298836","0.7317633","0.72680634","0.70345575","0.70180535","0.6974491","0.694794","0.6942505","0.6920568","0.6883206","0.6673236","0.6662014","0.66038215","0.66038215","0.66038215","0.65617543","0.6498469","0.6489149","0.64788216","0.64788216","0.6440581","0.64166725","0.6398696","0.63885313","0.6387467","0.63822013","0.6365928","0.63658774","0.6351343","0.63091695","0.6302999","0.6296248","0.62861943","0.62678045","0.62678045","0.6266213","0.6256419","0.62398857","0.6239134","0.6231312","0.62218606","0.621588","0.6213998","0.62033874","0.6185583","0.6162997","0.6139573","0.6138615","0.6128981","0.6126547","0.6116847","0.6108286","0.60872793","0.60808694","0.6080498","0.6074055","0.6068943","0.60627604","0.6053015","0.6043032","0.60381454","0.60276574","0.6026092","0.60251933","0.60168463","0.600821","0.60062134","0.60049593","0.60029507","0.59940785","0.5981042","0.5980679","0.597951","0.59794015","0.5978965","0.59774715","0.596551","0.5961506","0.59590346","0.5956739","0.59520864","0.5940149","0.593624","0.59336954","0.5933004","0.59271055","0.5924844","0.5924499","0.59237283","0.59226114","0.59210855","0.59196615","0.59196615","0.59196615","0.59196615","0.59196615","0.59196615","0.59196615","0.59196615"],"string":"[\n \"0.75192356\",\n \"0.73298836\",\n \"0.7317633\",\n \"0.72680634\",\n \"0.70345575\",\n \"0.70180535\",\n \"0.6974491\",\n \"0.694794\",\n \"0.6942505\",\n \"0.6920568\",\n \"0.6883206\",\n \"0.6673236\",\n \"0.6662014\",\n \"0.66038215\",\n \"0.66038215\",\n \"0.66038215\",\n \"0.65617543\",\n \"0.6498469\",\n \"0.6489149\",\n \"0.64788216\",\n \"0.64788216\",\n \"0.6440581\",\n \"0.64166725\",\n \"0.6398696\",\n \"0.63885313\",\n \"0.6387467\",\n \"0.63822013\",\n \"0.6365928\",\n \"0.63658774\",\n \"0.6351343\",\n \"0.63091695\",\n \"0.6302999\",\n \"0.6296248\",\n \"0.62861943\",\n \"0.62678045\",\n \"0.62678045\",\n \"0.6266213\",\n \"0.6256419\",\n \"0.62398857\",\n \"0.6239134\",\n \"0.6231312\",\n \"0.62218606\",\n \"0.621588\",\n \"0.6213998\",\n \"0.62033874\",\n \"0.6185583\",\n \"0.6162997\",\n \"0.6139573\",\n \"0.6138615\",\n \"0.6128981\",\n \"0.6126547\",\n \"0.6116847\",\n \"0.6108286\",\n \"0.60872793\",\n \"0.60808694\",\n \"0.6080498\",\n \"0.6074055\",\n \"0.6068943\",\n \"0.60627604\",\n \"0.6053015\",\n \"0.6043032\",\n \"0.60381454\",\n \"0.60276574\",\n \"0.6026092\",\n \"0.60251933\",\n \"0.60168463\",\n \"0.600821\",\n \"0.60062134\",\n \"0.60049593\",\n \"0.60029507\",\n \"0.59940785\",\n \"0.5981042\",\n \"0.5980679\",\n \"0.597951\",\n \"0.59794015\",\n \"0.5978965\",\n \"0.59774715\",\n \"0.596551\",\n \"0.5961506\",\n \"0.59590346\",\n \"0.5956739\",\n \"0.59520864\",\n \"0.5940149\",\n \"0.593624\",\n \"0.59336954\",\n \"0.5933004\",\n \"0.59271055\",\n \"0.5924844\",\n \"0.5924499\",\n \"0.59237283\",\n \"0.59226114\",\n \"0.59210855\",\n \"0.59196615\",\n \"0.59196615\",\n \"0.59196615\",\n \"0.59196615\",\n \"0.59196615\",\n \"0.59196615\",\n \"0.59196615\",\n \"0.59196615\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7645537"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":787,"numItemsPerPage":100,"numTotalItems":95772,"offset":78700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMwMTc3MiwianRpIjoiNTg3NjJjZDItNTg4Ni00ZDIzLTk1MGUtZjcwMDAyMjcwOWNmIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMDUzNzIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.3nCpKqzYuBegk_8MNpWrCz2bSnAMaVXBZ0F18n5myRCMMwaGQEIzgvmf3WorIQYaHh0_KMURQERGHqcyroIgBA","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 |
|---|---|---|---|---|---|---|
Verify that the k8s job succeeded | def _ensure_successful_job(k8s_ctx: str, k8s_job_file: pathlib.Path, dry_run: bool = False) -> None:
if not k8s_job_file.exists():
raise FileNotFoundError(str(k8s_job_file))
cmd = f'kubectl --context={k8s_ctx} get -f {k8s_job_file} -o json'
if dry_run:
logging.info(cmd)
return
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _job_succeeded(k8s_ctx: str, k8s_job_file: pathlib.Path, dry_run: bool = False) -> bool:\n if not k8s_job_file.exists():\n raise FileNotFoundError(str(k8s_job_file))\n\n cmd = f'kubectl --context={k8s_ctx} get -f {k8s_job_file} -o json'\n\n if dry_run:\n logging.info(cmd)\n return... | [
"0.7243436",
"0.6838614",
"0.6621957",
"0.661534",
"0.6345359",
"0.6335698",
"0.6323335",
"0.6229853",
"0.62206024",
"0.61564785",
"0.6155526",
"0.6098027",
"0.6045814",
"0.6034818",
"0.6030602",
"0.60113835",
"0.6005282",
"0.59931767",
"0.5990048",
"0.59655994",
"0.59544134"... | 0.71603185 | 1 |
Check whether persistent volume snapshot is ready | def _snapshot_ready(k8s_ctx: str, k8s_spec_file: pathlib.Path, dry_run: bool = False) -> bool:
if not k8s_spec_file.exists():
raise FileNotFoundError(str(k8s_spec_file))
cmd = f'kubectl --context={k8s_ctx} get -f {k8s_spec_file} -o json'
if dry_run:
logging.info(cmd)
return True
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def snapshot_volumes(self) -> bool:\n return pulumi.get(self, \"snapshot_volumes\")",
"def _IsReady(self):\n return self._GetPod()['status']['phase'] != 'Pending'",
"def _wait_until_volume_available(self, volume, maybe_in_use=False):\n ok_states = [\"creating\"] # it's ok to wait if the volum... | [
"0.6778808",
"0.6521101",
"0.63207036",
"0.6315146",
"0.6265592",
"0.622958",
"0.61976886",
"0.61875296",
"0.6180802",
"0.6176623",
"0.61693776",
"0.61398023",
"0.6051415",
"0.6027882",
"0.60233265",
"0.60011977",
"0.5982842",
"0.5962757",
"0.5861081",
"0.5847211",
"0.5834819... | 0.68950456 | 0 |
Wait for the PVC snapshot to be ready or raise a TimeoutError after specified number of attempts. | def _wait_for_snapshot(k8s_ctx: str, spec_file: pathlib.Path, attempts: int = 30, secs2wait: int = 20, dry_run: bool = False) -> None:
for counter in range(attempts):
if _snapshot_ready(k8s_ctx, spec_file, dry_run):
break
time.sleep(secs2wait)
else:
raise TimeoutError(f'{spec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait_for_pvc(k8s_ctx: str, pvc_name: str, attempts: int = 30, secs2wait: int = 20, dry_run: bool = False) -> None:\n for counter in range(attempts):\n if _pvc_bound(k8s_ctx, pvc_name, dry_run):\n break\n time.sleep(secs2wait)\n else:\n raise TimeoutError(f'Waiting for PVC ... | [
"0.68641895",
"0.65287995",
"0.6082232",
"0.60197186",
"0.6005225",
"0.59622586",
"0.5947616",
"0.5915617",
"0.58709437",
"0.57942975",
"0.57836044",
"0.57385135",
"0.5725081",
"0.5724657",
"0.56830114",
"0.5620255",
"0.5616016",
"0.55936587",
"0.5574639",
"0.5546054",
"0.552... | 0.76268655 | 0 |
Check whether a persistent volume claim is bound to a kubernetes node | def _pvc_bound(k8s_ctx: str, pvc_name: str, dry_run: bool = False) -> bool:
cmd = f'kubectl --context={k8s_ctx} get pvc {pvc_name} -o json'
if dry_run:
logging.info(cmd)
return True
p = safe_exec(cmd)
if not p.stdout:
return False
json_output = json.loads(p.stdout.decode(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_booted_from_volume(self, instance, disk_mapping=None):\n return not bool(instance.get('image_ref'))",
"def can_handle(self, rsm_ctx):\n return rsm_ctx.instance.type == NODE_TYPE_QUOTA",
"def can_reach_metadata_server():\n try:\n http_client = _obtain_http_client(hostname=_METADA... | [
"0.57044387",
"0.55365884",
"0.551062",
"0.54884076",
"0.5434074",
"0.54069275",
"0.5402176",
"0.5394375",
"0.53685576",
"0.5321871",
"0.5291866",
"0.5244603",
"0.52340746",
"0.52208585",
"0.52021044",
"0.5195634",
"0.5176338",
"0.5152459",
"0.50973433",
"0.50880367",
"0.5085... | 0.63240516 | 0 |
Wait for the persistent volume claim to be bound to an instance. A bound PVC means that a persistent disk has been created. | def wait_for_pvc(k8s_ctx: str, pvc_name: str, attempts: int = 30, secs2wait: int = 20, dry_run: bool = False) -> None:
for counter in range(attempts):
if _pvc_bound(k8s_ctx, pvc_name, dry_run):
break
time.sleep(secs2wait)
else:
raise TimeoutError(f'Waiting for PVC {pvc_name} ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _wait_until_volume_available(self, volume, maybe_in_use=False):\n ok_states = [\"creating\"] # it's ok to wait if the volume is in this\n tries = 0\n if maybe_in_use:\n ok_states.append(\"in_use\")\n logger.info(\"Volume: %s is in state: %s\", volume.name, volume.state)\... | [
"0.5896992",
"0.5781035",
"0.5712666",
"0.56834656",
"0.56729543",
"0.56464386",
"0.5645018",
"0.5619778",
"0.55979586",
"0.55502456",
"0.53824466",
"0.5378539",
"0.5355347",
"0.5350618",
"0.53472906",
"0.5329603",
"0.53034407",
"0.5259739",
"0.5248038",
"0.5234132",
"0.52156... | 0.630798 | 0 |
Initialize storage for ElasticBLAST cluster | def initialize_storage(cfg: ElasticBlastConfig, query_files: List[str] = [], wait=ElbExecutionMode.WAIT) -> None:
use_local_ssd = cfg.cluster.use_local_ssd
if use_local_ssd:
initialize_local_ssd(cfg, query_files, wait)
else:
initialize_persistent_disk(cfg, query_files, wait) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_beeswax_db(cls):\n global _INITIALIZED\n if _INITIALIZED:\n return\n\n make_query(cls.client, 'CREATE DATABASE IF NOT EXISTS %(db)s' % {'db': cls.db_name}, wait=True)\n make_query(cls.client, 'CREATE DATABASE IF NOT EXISTS %(db)s_other' % {'db': cls.db_name}, wait=True)\n\n if cls.load... | [
"0.61822534",
"0.61604846",
"0.61142486",
"0.61103785",
"0.6019239",
"0.600666",
"0.59842885",
"0.59343857",
"0.57664347",
"0.5744994",
"0.57356334",
"0.5724775",
"0.57101536",
"0.57081795",
"0.5696668",
"0.56931335",
"0.5670077",
"0.56564623",
"0.5631872",
"0.5608877",
"0.56... | 0.74047345 | 0 |
Initialize local SSDs for ElasticBLAST cluster | def initialize_local_ssd(cfg: ElasticBlastConfig, query_files: List[str] = [], wait=ElbExecutionMode.WAIT) -> None:
db, db_path, _ = get_blastdb_info(cfg.blast.db, cfg.gcp.get_project_for_gcs_downloads())
if not db:
raise ValueError("Config parameter 'db' can't be empty")
dry_run = cfg.cluster.dry_r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_storage(cfg: ElasticBlastConfig, query_files: List[str] = [], wait=ElbExecutionMode.WAIT) -> None:\n use_local_ssd = cfg.cluster.use_local_ssd\n if use_local_ssd:\n initialize_local_ssd(cfg, query_files, wait)\n else:\n initialize_persistent_disk(cfg, query_files, wait)",
"d... | [
"0.66219467",
"0.6232512",
"0.59862846",
"0.5774646",
"0.57388014",
"0.5706254",
"0.5698521",
"0.5565083",
"0.5551789",
"0.5548251",
"0.5548236",
"0.5532527",
"0.55006236",
"0.54399735",
"0.5400785",
"0.5354679",
"0.533072",
"0.532619",
"0.5325551",
"0.5290499",
"0.5258854",
... | 0.60757315 | 2 |
Initialize Persistent Disk for ElasticBLAST execution | def initialize_persistent_disk(cfg: ElasticBlastConfig, query_files: List[str] = [], wait=ElbExecutionMode.WAIT) -> None:
# ${LOGDATETIME} setup_pd start >>${ELB_LOGFILE}
db, db_path, _ = get_blastdb_info(cfg.blast.db,
cfg.gcp.get_project_for_gcs_downloads())
if not db... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_storage(cfg: ElasticBlastConfig, query_files: List[str] = [], wait=ElbExecutionMode.WAIT) -> None:\n use_local_ssd = cfg.cluster.use_local_ssd\n if use_local_ssd:\n initialize_local_ssd(cfg, query_files, wait)\n else:\n initialize_persistent_disk(cfg, query_files, wait)",
"d... | [
"0.69325453",
"0.6751443",
"0.6751443",
"0.6653742",
"0.6350506",
"0.63132924",
"0.5965553",
"0.5893428",
"0.588529",
"0.58253783",
"0.58102304",
"0.5791366",
"0.57175225",
"0.5694924",
"0.5682932",
"0.56052977",
"0.5575009",
"0.5567323",
"0.5530617",
"0.54932505",
"0.5454839... | 0.71941566 | 0 |
Label disk with given claim with standard labels | def label_persistent_disk(cfg: ElasticBlastConfig, pv_claim: str) -> None:
use_local_ssd = cfg.cluster.use_local_ssd
if use_local_ssd:
return
dry_run = cfg.cluster.dry_run
cluster_name = cfg.cluster.name
labels = cfg.cluster.labels
get_pv_cmd = f'kubectl --context={cfg.appstate.k8s_ctx}... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_base_image_labels(driver, user_disk, img_name, branch, target):\n\n dashes = [i for i, c in enumerate(img_name) if c=='-']\n cf_version = img_name[dashes[0]+1:dashes[3]]\n build_id = img_name[dashes[-1]+1:]\n\n driver.ex_set_volume_labels(user_disk,\n {'cf_version': cf_version, 'branch':... | [
"0.5758011",
"0.56702936",
"0.5651301",
"0.54146427",
"0.5399197",
"0.53988075",
"0.5323684",
"0.52344555",
"0.5222524",
"0.52210075",
"0.51896286",
"0.51797324",
"0.515616",
"0.51407397",
"0.5139695",
"0.51392925",
"0.5135739",
"0.5114927",
"0.50736207",
"0.50625324",
"0.505... | 0.6934975 | 0 |
Check that server set after gcp.get_gke_credentials is alive | def check_server(k8s_ctx: str, dry_run: bool = False):
cmd = f'kubectl --context={k8s_ctx} version --short'
if dry_run:
logging.info(cmd)
else:
safe_exec(cmd) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ft_credential_server():\n ensure_credential_server_running( run_once=True, foreground=True )",
"def check_server():\n\n url='{url}/auth'.format(url=config.SERVER_URL)\n while True:\n\n try:\n res=request.urlopen(url,timeout=5).read()\n res=str(res,encoding='utf8')\n ... | [
"0.6182946",
"0.6138832",
"0.5968581",
"0.5966169",
"0.59497523",
"0.5877434",
"0.5827503",
"0.58103245",
"0.57660997",
"0.5742771",
"0.5707626",
"0.5705608",
"0.565789",
"0.5629737",
"0.56063974",
"0.5598198",
"0.5525763",
"0.5518381",
"0.5509588",
"0.548903",
"0.54651225",
... | 0.0 | -1 |
Collect logs from Kubernetes. | def get_logs(k8s_ctx: str, label: str, containers: List[str], dry_run: bool = False):
for c in containers:
cmd = f'kubectl --context={k8s_ctx} logs -l {label} -c {c} --timestamps --since=24h --tail=-1'
if dry_run:
logging.info(cmd)
else:
try:
# kubectl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_k8s_logs(cfg: ElasticBlastConfig):\n dry_run = cfg.cluster.dry_run\n k8s_ctx = cfg.appstate.k8s_ctx\n if not k8s_ctx:\n raise RuntimeError(f'kubernetes context is missing for {cfg.cluster.name}')\n # TODO use named constants for labels and containers\n # also modify corresponding ... | [
"0.7308022",
"0.7177128",
"0.70522076",
"0.64065844",
"0.6268711",
"0.6268711",
"0.61853147",
"0.61756486",
"0.6170662",
"0.6147985",
"0.60778475",
"0.6039634",
"0.60380864",
"0.6027567",
"0.5917655",
"0.58830225",
"0.5881376",
"0.583538",
"0.5802469",
"0.5768473",
"0.5762911... | 0.6624328 | 3 |
Collect logs from Kubernetes logs for several label/container combinations. | def collect_k8s_logs(cfg: ElasticBlastConfig):
dry_run = cfg.cluster.dry_run
k8s_ctx = cfg.appstate.k8s_ctx
if not k8s_ctx:
raise RuntimeError(f'kubernetes context is missing for {cfg.cluster.name}')
# TODO use named constants for labels and containers
# also modify corresponding YAML templa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_logs_from_pod(namespace, pod, logs_dir, k8s_cli):\n containers = get_list_of_containers_from_pod(namespace, pod, k8s_cli)\n init_containers = get_list_of_init_containers_from_pod(namespace, pod, k8s_cli)\n containers.extend(init_containers)\n if containers is None:\n logger.warning(\... | [
"0.7182909",
"0.71400505",
"0.6958383",
"0.6778838",
"0.6523679",
"0.6264228",
"0.622623",
"0.61939454",
"0.59845686",
"0.5965813",
"0.59611726",
"0.59611726",
"0.5935786",
"0.59302646",
"0.5916675",
"0.5870155",
"0.58109695",
"0.5809834",
"0.57496893",
"0.5732803",
"0.562136... | 0.6977004 | 2 |
Assign default service account cluster admin priveleges. Necessary for proper functioning of janitor and cloud submit jobs | def enable_service_account(cfg: ElasticBlastConfig):
dry_run = cfg.cluster.dry_run
logging.debug(f"Enabling service account")
with TemporaryDirectory() as d:
set_extraction_path(d)
rbac_yaml = resource_filename('elastic_blast', 'templates/elb-janitor-rbac.yaml')
cmd = f"kubectl --con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _ensure_initial_admin(config):\n if get_api_version() > 2:\n manager = get_manager()\n default_domain_id = create_or_show_domain(DEFAULT_DOMAIN)\n leader_set({'default_domain_id': default_domain_id})\n admin_domain_id = create_or_show_domain(ADMIN_DOMAIN)\n ... | [
"0.58965456",
"0.5454678",
"0.5446887",
"0.5400099",
"0.53879905",
"0.5352295",
"0.53448015",
"0.5342162",
"0.5328383",
"0.52938116",
"0.526896",
"0.5231793",
"0.51919377",
"0.51914835",
"0.51685226",
"0.51562625",
"0.5155733",
"0.51304394",
"0.5110545",
"0.51001656",
"0.5099... | 0.5189528 | 14 |
Creates a k8s cronjob to delete GCP cluster once the jobs are done | def submit_janitor_cronjob(cfg: ElasticBlastConfig):
dry_run = cfg.cluster.dry_run
janitor_schedule = ELB_DFLT_JANITOR_SCHEDULE_GCP
if ELB_JANITOR_SCHEDULE in os.environ:
janitor_schedule = os.environ[ELB_JANITOR_SCHEDULE]
logging.debug(f'Overriding janitor schedule to "{janitor_schedule}"'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_job_schedule(self):\n job_schedule_delete = netapp_utils.zapi\\\n .NaElement.create_node_with_children(\n 'job-schedule-cron-destroy',\n **{'job-schedule-name': self.name})\n try:\n self.server.invoke_successfully(job_schedule_delete,\n ... | [
"0.6107607",
"0.6002564",
"0.59531444",
"0.5917263",
"0.5882619",
"0.58595407",
"0.5802002",
"0.5662835",
"0.55701196",
"0.5563007",
"0.5515092",
"0.54493976",
"0.54372144",
"0.5400792",
"0.5393199",
"0.5387648",
"0.5379455",
"0.53551286",
"0.5343901",
"0.53183055",
"0.531234... | 0.5830477 | 6 |
Creates a k8s job to submit BLAST jobs | def submit_job_submission_job(cfg: ElasticBlastConfig):
dry_run = cfg.cluster.dry_run
subs = {
'K8S_JOB_SUBMIT_JOBS' : K8S_JOB_SUBMIT_JOBS,
'ELB_DOCKER_IMAGE' : ELB_CJS_DOCKER_IMAGE_GCP,
'ELB_GCP_PROJECT' : cfg.gcp.project,
'ELB_GCP_ZONE' : cfg.gcp.zone,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_job(api_instance, job):\n api_response = api_instance.create_namespaced_job(\n body=job, namespace=\"default\", pretty=True\n )\n logger.info(\"Job created with status='%s'\" % str(api_response.status))\n return api_response",
"def _create_job(self,\n name,\n ... | [
"0.65601635",
"0.6456106",
"0.64101607",
"0.62889904",
"0.60392916",
"0.5989142",
"0.59834176",
"0.59480613",
"0.59373564",
"0.5935629",
"0.5929065",
"0.58854586",
"0.58693117",
"0.5855808",
"0.5849256",
"0.579629",
"0.5764425",
"0.5734367",
"0.5733252",
"0.5725296",
"0.57196... | 0.67617774 | 0 |
Compute balanced seed loss | def __init__(self, eps: float=1e-5):
self.eps = eps | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dice_crossentropy_loss():\n assert dice_dice_crossentropy_loss() == expected_dice_crossentropy_loss",
"def compute_loss(self):\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.data.test_labels, logits=self.test_logits)\n ... | [
"0.6412278",
"0.62036204",
"0.6196435",
"0.6195581",
"0.61794907",
"0.61794907",
"0.6134663",
"0.6116744",
"0.60979277",
"0.60830367",
"0.6067807",
"0.6030138",
"0.6020347",
"0.59942544",
"0.5973485",
"0.5926284",
"0.5905612",
"0.5888543",
"0.5878932",
"0.5864883",
"0.584793"... | 0.0 | -1 |
Compute balanced seed loss | def __call__(self, score_map, one_hot_label) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
assert not one_hot_label.requires_grad
pi = one_hot_label.to(torch.float)
assert not torch.any(torch.isinf(score_map))
assert not torch.any(torch.isnan(score_map))
log_qi = torch.lo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dice_crossentropy_loss():\n assert dice_dice_crossentropy_loss() == expected_dice_crossentropy_loss",
"def compute_loss(self):\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.data.test_labels, logits=self.test_logits)\n ... | [
"0.6412278",
"0.62036204",
"0.6196435",
"0.6195581",
"0.61794907",
"0.61794907",
"0.6134663",
"0.6116744",
"0.60979277",
"0.60830367",
"0.6067807",
"0.6030138",
"0.6020347",
"0.59942544",
"0.5973485",
"0.5926284",
"0.5905612",
"0.5888543",
"0.5878932",
"0.5864883",
"0.584793"... | 0.0 | -1 |
Create a new product for the scenario It would be deleted at the tearDown | def setUp(self):
super().setUp()
list_of_product_types = [
'default_product_variant',
'multiple_product_variants',
'ceo_title'
]
self.new_product = eval(f"get_new_product_with_" \
f"{list_of_product_types[randint(0, len(list_of_product_t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_01_product_create(self):\n # Create new product with a replacement product\n product = self.create_product()\n\n # Check recently was created product with default 'In Development'\n # value state and that the replacement was assigned. This case also\n # check the read te... | [
"0.7601618",
"0.752833",
"0.7353155",
"0.72841406",
"0.7263181",
"0.7074391",
"0.7024802",
"0.699035",
"0.69720995",
"0.69443333",
"0.6904304",
"0.684024",
"0.6830409",
"0.6829515",
"0.68056715",
"0.68019325",
"0.6705739",
"0.6702876",
"0.66581947",
"0.6651187",
"0.66456455",... | 0.75885576 | 1 |
Create a new product and buy it along with existing one | def test_buy_now(self):
catalog_page = CatalogPage(self.driver)
product_page = ProductPage(self.driver)
payment_page = PaymentPage(self.driver)
payment_review_page = PaymentReviewPage(self.driver)
payment_info_page = PaymentInfoPage(self.driver)
success_page = SuccessPage... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def buy(self, product_id: int):\n ee = self.request.request(\n url=f'https://economy.roblox.com/v2/user-products/{product_id}/purchase',\n method='post')\n return ee",
"def add_product(self):\n self.owner.new_product(self.barcode, self.description, self.price, sel... | [
"0.735359",
"0.71443206",
"0.71084017",
"0.7047093",
"0.7040663",
"0.7022442",
"0.69806325",
"0.6965997",
"0.6953303",
"0.6949329",
"0.6932501",
"0.6912224",
"0.6905006",
"0.68999946",
"0.68712866",
"0.6832764",
"0.6787224",
"0.67799085",
"0.67761487",
"0.6768781",
"0.6768526... | 0.62568086 | 59 |
in addition to default tearDown delete new product that was created in setUp | def tearDown(self):
ProcessRequest(f"products/{self.product_id}.json").send_request(
'DELETE', continue_on_error=True)
super().tearDown() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tearDownClass(self):\n self.product_id = None",
"def tearDown(self):\n del self.new",
"def tearDown(self):\n util.delete_mocks()",
"def tearDown(self):\n util.delete_mocks()",
"def tearDown(self):\n util.delete_mocks()",
"def tearDown(self):\n util.delete_moc... | [
"0.7673542",
"0.76476455",
"0.7402727",
"0.7402727",
"0.7402727",
"0.7402727",
"0.7402727",
"0.7402727",
"0.7268774",
"0.7223385",
"0.72121155",
"0.7198862",
"0.7184747",
"0.7164011",
"0.7163723",
"0.7111245",
"0.71104",
"0.71104",
"0.71104",
"0.70951384",
"0.7086183",
"0.7... | 0.7786658 | 0 |
Tests the performance of the agent | def evaluate(self, runs = 5, use_gui = False):
self.env.render(use_gui)
evaluation_results = {
"runs" : runs,
"unfinished_runs" : 0,
"average_delay" : [],
"episode_mean_delays" : [],
"episode_delay_lists" : []
}
for i in range... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_agent(AgentFactory, steps, envs, percepts):\n print ('RUN TEST AGENT')\n envs.add_thing(AgentFactory)\n #envs.run(steps)\n \n agent = AgentFactory\n agent.program(percept)\n #envs.run(steps)\n envs.runPLWumpus(agent, steps)\n #envs.runPLWumpus(steps)\n print(' ------------PLW... | [
"0.6791763",
"0.6692284",
"0.6472564",
"0.6311555",
"0.63058454",
"0.6276679",
"0.6257189",
"0.62086666",
"0.62048584",
"0.61926913",
"0.6175451",
"0.61510926",
"0.6126369",
"0.61106914",
"0.60962504",
"0.60887414",
"0.6077805",
"0.6060409",
"0.6053641",
"0.60355383",
"0.6023... | 0.0 | -1 |
Incrementar ciclo de la simulacion | def OnNuevoCiclo(self, event):
if self.clipsFile != "":
clips.Assert("(Seguir S)")
clips.Run()
self.office.updatePeopleLocation()
self.Refresh()
error = clips.ErrorStream.Read()
if error != None:
print(error)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def increment_counter(self) -> None:",
"def increase_counter(self):\n self.values = self.values + 1",
"def increment_number(self):\n # self.number += 1\n print('fuckwit')\n # print(self.number)",
"def increment(self):\r\n return self.add(1)",
"def increment(self) -> global___... | [
"0.7661288",
"0.7241211",
"0.723567",
"0.71288633",
"0.7114365",
"0.7087606",
"0.70840394",
"0.70431554",
"0.7006013",
"0.6944731",
"0.693673",
"0.6839732",
"0.68132",
"0.67405885",
"0.668815",
"0.66852885",
"0.66219515",
"0.66219515",
"0.65973246",
"0.65261966",
"0.6499437",... | 0.0 | -1 |
Lanzar toda la simulacion | def OnLanzarSimulacion(self, event):
if self.clipsFile != "":
clips.Assert("(Seguir S)")
clips.Run()
self.office.updatePeopleLocation()
self.Refresh()
else:
dlg = wx.MessageDialog(self, "No se ha cargado fichero .clp", "Error en ASSERT", wx.OK)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exo2():",
"def mezclar_bolsa(self):",
"def substantiate():",
"def falcon():",
"def sth():",
"def simple():",
"def simple():",
"def regular(self):",
"def _regr_basic():",
"def g():",
"def result(self):",
"def result(self):",
"def exercise_b2_53():\r\n pass",
"def exercise_b2_113():\... | [
"0.69584775",
"0.6749619",
"0.6713742",
"0.64656717",
"0.6359033",
"0.6328706",
"0.6328706",
"0.62757856",
"0.6218919",
"0.61349535",
"0.5964754",
"0.5964754",
"0.59394264",
"0.5912193",
"0.5887806",
"0.58347887",
"0.5828976",
"0.5822087",
"0.5822087",
"0.5822087",
"0.5822087... | 0.0 | -1 |
Takes the original JSON data structure and generates a stream of data items as dictionaries made of key/value pairs. | def load_input(raw):
columns = [(column, column['dataTypeName'] == 'text')
for column in raw['meta']['view']['columns']]
print('')
print("[COLUMNS]")
for column, selected in columns:
if selected:
try:
description = column['description'].strip()[:50]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json2dict(data):\n sub_all = data.get(\"values\")\n keys = data.get(\"fields\")\n dic_all = []\n for sub in sub_all:\n x = dict(zip(keys, sub))\n if not x['datastring'] is None:\n x['datastring'] = json.loads(x.get('datastring'))\n dic_all.append(x)\n return dic_a... | [
"0.65098023",
"0.62888145",
"0.6237558",
"0.6040369",
"0.6006107",
"0.5962079",
"0.5920561",
"0.59005207",
"0.581828",
"0.57504183",
"0.5685113",
"0.561694",
"0.55845666",
"0.55844814",
"0.5577096",
"0.5543952",
"0.5540783",
"0.5534506",
"0.5531823",
"0.54926765",
"0.5492299"... | 0.0 | -1 |
It rakes an input file with the source data and converts it to a stream of JSON documents. | def main(arguments):
# The input file can be optionally encoded with gzip format:
input_file = arguments.input_file[0]
assert isinstance(input_file, str)
if input_file.endswith(".gz"):
_open = gzip.open
else:
_open = open
with _open(input_file, "rt",
encoding='utf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_file(input_file_path: str, output_file_path: str):\n\n # Open json\n with open(input_file_path, mode=\"r\") as in_file:\n input_data = json.load(in_file)\n\n # Transform and write\n with jsonlines.open(output_file_path, mode=\"w\", compact=True) as out_file:\n for item in in... | [
"0.6293595",
"0.6250602",
"0.62383056",
"0.62383056",
"0.6183641",
"0.6183641",
"0.6145613",
"0.60405284",
"0.59711635",
"0.59660596",
"0.5911783",
"0.59033376",
"0.58587277",
"0.5830733",
"0.5830733",
"0.5815685",
"0.5783476",
"0.5749292",
"0.5749292",
"0.5746732",
"0.554991... | 0.5998158 | 8 |
Function that reads an image file and convert it into a given representation | def read_image(filename, representation):
color_flag = True #if RGB image
image = imread(filename)
float_image = image.astype(np.float64)
if not np.all(image <= 1):
float_image /= NORMALIZE #Normalized to range [0,1]
if len(float_image.shape) != 3 : #Checks if RGB or Grayscale
co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_image(filename, representation):\n image = imread(filename)\n new_image = image.astype(np.float64)\n new_image /= 255\n if representation == 1:\n new_image = rgb2gray(new_image)\n return new_image",
"def read_image(filename, representation):\n img = imread(filename)\n img = i... | [
"0.7449107",
"0.72581416",
"0.7177248",
"0.7115413",
"0.7029074",
"0.70162386",
"0.6951657",
"0.69001406",
"0.689829",
"0.68941265",
"0.6855205",
"0.67252743",
"0.665023",
"0.66493964",
"0.66025174",
"0.657016",
"0.6519702",
"0.6510978",
"0.64749444",
"0.6460991",
"0.64137334... | 0.7181966 | 2 |
That function displays an image in a given representation | def imdisplay(filename, representation):
image = read_image(filename, representation)
plt.imshow(image, cmap="gray")
plt.show() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display(self, image):\n raise NotImplementedError()",
"def display(self):\n display(self.image)",
"def display_image(mat):\n\timg = Image.fromarray(mat)\n\timg.show()",
"def showimage(image):\n mplt.figure()\n mplt.imshow(image)\n mplt.show()",
"def display_image ( X ):\r\n\t# on... | [
"0.7702066",
"0.7678106",
"0.7630015",
"0.7384051",
"0.72779155",
"0.72562844",
"0.725237",
"0.72513103",
"0.7247135",
"0.7241654",
"0.7196195",
"0.7185689",
"0.71471035",
"0.70569164",
"0.7045489",
"0.7034913",
"0.70256436",
"0.70256436",
"0.6965478",
"0.6949715",
"0.6930488... | 0.73751575 | 4 |
This function transforms an RGB image to the YIQ color space | def rgb2yiq(imRGB):
return np.dot(imRGB, np.array(MATRIX).T) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transformYIQ2RGB(imgYIQ: np.ndarray) -> np.ndarray:\r\n yiq_from_rgb = np.array([[0.299, 0.587, 0.114],\r\n [0.59590059, -0.27455667, -0.32134392],\r\n [0.21153661, -0.52273617, 0.31119955]])\r\n rgb_from_yiq = np.linalg.inv(yiq_from_rgb)\r\n\r\n ... | [
"0.8075077",
"0.7972723",
"0.78853625",
"0.7761124",
"0.7719949",
"0.768193",
"0.7594159",
"0.7592578",
"0.7579149",
"0.7546962",
"0.75089204",
"0.7505258",
"0.70519155",
"0.69547826",
"0.6946691",
"0.69057375",
"0.6859484",
"0.679065",
"0.65877485",
"0.630929",
"0.6295286",
... | 0.7133341 | 12 |
This function transforms an YIQ color space to a RGB image | def yiq2rgb(imYIQ):
return np.dot(imYIQ, np.linalg.inv(np.array(MATRIX).T)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transformYIQ2RGB(imgYIQ: np.ndarray) -> np.ndarray:\r\n yiq_from_rgb = np.array([[0.299, 0.587, 0.114],\r\n [0.59590059, -0.27455667, -0.32134392],\r\n [0.21153661, -0.52273617, 0.31119955]])\r\n rgb_from_yiq = np.linalg.inv(yiq_from_rgb)\r\n\r\n ... | [
"0.80520254",
"0.8039881",
"0.7962519",
"0.7937877",
"0.7900755",
"0.73019373",
"0.730139",
"0.7127854",
"0.71096927",
"0.6935564",
"0.6876887",
"0.68677354",
"0.68543035",
"0.67816305",
"0.672084",
"0.6647167",
"0.66198665",
"0.6539262",
"0.65241694",
"0.64449745",
"0.634743... | 0.76489943 | 5 |
This function performs an histogram equalization of a given image | def histogram_equalize(im_orig):
color_flag = False
image = im_orig
if len(im_orig.shape) == 3: #RGB image
color_flag = True
y_im = rgb2yiq(im_orig)
image = y_im[:, :, 0]
image *= NORMALIZE
hist_orig, bins = np.histogram(image, range(BINS))
hist_cum = np.cumsum(hist_o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def equalise_hist(image, bin_count=256):\n # TODO: your histogram equalization code\n #define arrays\n image = img_as_ubyte(image)\n row,col = image.shape\n new_image = np.zeros((row,col),dtype='uint8') \n\n # compute the value of each grayscale,and save in image_hist \n image_hist = np.bincount(image.flatt... | [
"0.81590986",
"0.8098537",
"0.8089895",
"0.79471034",
"0.7874277",
"0.7826743",
"0.7749235",
"0.769595",
"0.76528543",
"0.7423789",
"0.7374871",
"0.7359829",
"0.735687",
"0.7356559",
"0.73502856",
"0.73391485",
"0.7225304",
"0.722211",
"0.72127074",
"0.7191898",
"0.7184982",
... | 0.81297153 | 1 |
This function performs optimal quantization of a given grayscale or RGB image | def quantize(im_orig, n_quant, n_iter):
color_flag = False
image = im_orig
error = list()
if len(im_orig.shape) == 3: #RGB image
color_flag = True
y_im = rgb2yiq(im_orig)
image = y_im[:, :, 0]
if np.all(image <= 1):
image *= NORMALIZE
my_hist, bins = np.histog... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quantize(im_orig, n_quant, n_iter):\n shape_len = len(im_orig.shape)\n if shape_len == 2: # grayscale\n return quantization_helper(im_orig, n_quant, n_iter)\n\n elif shape_len == 3: # rgb\n im_yiq = rgb2yiq(im_orig)\n y = im_yiq[:, :, 0]\n y_quant, error = quantization_hel... | [
"0.67629147",
"0.67326945",
"0.64545953",
"0.6432401",
"0.63289773",
"0.60762316",
"0.60647696",
"0.5980381",
"0.5804083",
"0.5782493",
"0.5782493",
"0.5782493",
"0.57392335",
"0.5699688",
"0.56758535",
"0.561525",
"0.55881965",
"0.5586545",
"0.5531348",
"0.5517089",
"0.55085... | 0.641383 | 4 |
Determines if natural number N is prime by trial division. | def trial_div(n: int) -> bool:
if n == 1:
return False
i = 2
while i**2 <= n:
if n % i == 0:
return False
i += 1
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isprime(n):\r\n\treturn is_prime(n)",
"def prime_t(n: int) -> bool:\n tests = set(range(2, int(math.sqrt(n) + 1)))\n non_factors = set(takewhile(lambda i: n % i != 0, tests))\n return tests == non_factors",
"def prime_t(n: int) -> bool:\n tests = set(range(2, int(math.sqrt(n) + 1)))\n non_fa... | [
"0.75904524",
"0.7572783",
"0.7572783",
"0.7533633",
"0.75022924",
"0.74241966",
"0.73947245",
"0.73647577",
"0.73487324",
"0.7345413",
"0.7342212",
"0.72686034",
"0.7251062",
"0.72339666",
"0.7232719",
"0.72271216",
"0.72271216",
"0.7186987",
"0.71865153",
"0.7166788",
"0.71... | 0.7699925 | 0 |
Generates the LucasLehmer sequence. | def lucas_lehmer() -> Generator[int, None, None]:
seed = 4
while True:
yield seed
seed = seed**2 - 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Lucas(input) :\n\n # if input == 0 :\n\n # return 2\n # elif input == 1 :\n\n # return 1\n\n # else :\n\n # return Lucas(input-1) + Lucas(input-2)\n\n\n return sum_series(input,2,1)",
"def generate_random_MT_Lune_samp():\n # 1. Get randomly varied Lune parameters (g... | [
"0.5769175",
"0.57630914",
"0.5601627",
"0.55063254",
"0.5457792",
"0.54477936",
"0.53614664",
"0.5287758",
"0.5262873",
"0.52039135",
"0.5178368",
"0.51434594",
"0.5132669",
"0.51296896",
"0.508006",
"0.50615644",
"0.50557595",
"0.50262654",
"0.5007828",
"0.5002165",
"0.4987... | 0.68218356 | 0 |
Determines if Mersenne number 2^N 1 is prime via the LucasLehmer primality test. | def ll_primality(n: int) -> bool:
if n <= 2 or not trial_div(n):
return False
luc_leh = lucas_lehmer()
for _ in range(n - 1):
ll = next(luc_leh)
return ll % (2**n - 1) == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_prime(n):\n return mr_prime(n)",
"def test_prime(n):\n if SIEVE[n]:\n return True\n else:\n return False",
"def isprime(n):\r\n\treturn is_prime(n)",
"def isprime(n=936):\n if n < 3: return False\n for i in range(2, n):\n if n % i == 0:\n return False\n ... | [
"0.7239062",
"0.7073942",
"0.7019739",
"0.70070904",
"0.7005515",
"0.6946308",
"0.6864864",
"0.68361056",
"0.678722",
"0.6734504",
"0.6730105",
"0.6687569",
"0.66823626",
"0.667622",
"0.6668467",
"0.6650945",
"0.6643008",
"0.6626922",
"0.661976",
"0.66106534",
"0.6610468",
... | 0.7341868 | 0 |
Yields all primes below N using the Sieve of Eratosthenes. | def sieve(n: int) -> Generator[int, None, None]:
primes, p = [i for i in range(2, n + 1)], 2
while p**2 < n:
for i in primes:
if i % p == 0 and i != p:
primes.remove(i)
p += 1
yield from primes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def primes(n):\n\tsieve = [True] * n\n\tyield 2\n\tfor i in xrange(3,int(n**0.5)+1,2):\n\t\tif sieve[i]:\n\t\t\tyield i\n\t\t\tsieve[i*i::2*i] = [False]*((n-i*i-1)/(2*i)+1)\n\tfor i in xrange(i+2,n,2):\n\t\tif sieve[i]: yield i",
"def primes(n):\n sieve = [True]*n\n for p in range(2, n):\n if sieve[... | [
"0.8024125",
"0.8002254",
"0.7932262",
"0.7904185",
"0.78591853",
"0.7638811",
"0.75153947",
"0.75153947",
"0.75134873",
"0.7506634",
"0.7475689",
"0.74711454",
"0.74352396",
"0.74297386",
"0.7427221",
"0.74193126",
"0.74012053",
"0.7400942",
"0.74002695",
"0.7398897",
"0.733... | 0.77653205 | 5 |
calculates a gradient step with a CNN | def NN_gradienten_step(LEP,model):
original_mesh = LEP.mesh # backup current mesh
LEP.updateMesh(targetmesh) # project current solution on reference mesh
# get phi and u as arrays ([:-1] because of lambda in the last coordinate)
phi_val = LEP.phi_n.vector()[:]
phi_coor = LEP.F.tabulate_dof_coordina... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gd(x0,gradient,learning_rate=1.0,min_step=1e-16,max_iters=1000,**kwargs):\n x = x0; i = 0; step_size = np.Inf\n while step_size > min_step and i < max_iters:\n x0 = x\n grad = gradient(x0)\n x = x0 - learning_rate*grad\n step_size = np.linalg.norm(x-x0)\n i += 1\n\n ... | [
"0.6585613",
"0.653625",
"0.65349156",
"0.6519607",
"0.6512883",
"0.65008676",
"0.6488376",
"0.648457",
"0.6452228",
"0.6450012",
"0.6432286",
"0.6313621",
"0.6273695",
"0.62098813",
"0.6192474",
"0.61888814",
"0.6185899",
"0.6185899",
"0.6180109",
"0.61712617",
"0.61653495",... | 0.0 | -1 |
Deterministic solvemethod for an Linear Elasticity Problem | def deterministic_NN_solve(LEP,model):
# solve state equation
SE = LEP.SE(LEP.u, LEP.phi_n[0], LEP.v_u, LEP.g)
solve(lhs(SE) == rhs(SE), LEP.u_n, bcs=LEP.bcSE, solver_parameters={"linear_solver": "umfpack", "preconditioner": "default"}, form_compiler_parameters=None)
# solve adjoint equation
LEP.p_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):",
"def get_sol(self):",
"def solve(self):\n ...",
"def solve(self):\n \n raise NotImplementedError(\"not implemented!\")",
"def solve(self):\n pass",
"def solve(self):\n pass",
"def solve_elas(self,x,E_p=None):\n \n if x['Crystal_Structu... | [
"0.7224722",
"0.69912314",
"0.6899648",
"0.66831875",
"0.6625148",
"0.6625148",
"0.6569677",
"0.65169144",
"0.64995986",
"0.64433146",
"0.6418878",
"0.64093494",
"0.6375208",
"0.6360713",
"0.6352544",
"0.6352544",
"0.63449115",
"0.6279814",
"0.61759114",
"0.61729276",
"0.6145... | 0.6131261 | 23 |
Deterministic solvemethod for an Linear Elasticity Problem | def deterministic_solve(LEP):
# solve state equation
SE = LEP.SE(LEP.u, LEP.phi_n[0], LEP.v_u, LEP.g)
solve(lhs(SE) == rhs(SE), LEP.u_n, bcs=LEP.bcSE, solver_parameters={"linear_solver": "umfpack", "preconditioner": "default"}, form_compiler_parameters=None)
# solve adjoint equation
LEP.p_n.assign(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):",
"def get_sol(self):",
"def solve(self):\n ...",
"def solve(self):\n \n raise NotImplementedError(\"not implemented!\")",
"def solve(self):\n pass",
"def solve(self):\n pass",
"def solve_elas(self,x,E_p=None):\n \n if x['Crystal_Structu... | [
"0.7224722",
"0.69912314",
"0.6899648",
"0.66831875",
"0.6625148",
"0.6625148",
"0.6569677",
"0.65169144",
"0.64995986",
"0.64433146",
"0.6418878",
"0.64093494",
"0.6375208",
"0.6360713",
"0.6352544",
"0.6352544",
"0.63449115",
"0.6279814",
"0.61759114",
"0.61729276",
"0.6145... | 0.5781621 | 66 |
Converts a NumPy image to a tf.Summary.Value object. | def image_to_tf_summary_value(image, tag):
curr_image = np.asarray(image, dtype=np.uint8)
height, width, n_channels = curr_image.shape
# If monochrome image, then reshape to [height, width]
if n_channels == 1:
curr_image = np.reshape(curr_image, [height, width])
s = io.BytesIO()
matplotlib_pyplot().imsa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def array_to_image_summary(array, format=\"png\"):\n height, width, channels = array.shape\n image = Image.fromarray(array)\n\n with io.BytesIO() as memf:\n image.save(memf, format=format)\n image_string = memf.getvalue()\n return tf.Summary.Image(\n height=height,\n width=w... | [
"0.6867479",
"0.65719885",
"0.64364594",
"0.6324988",
"0.6231608",
"0.6231608",
"0.6148279",
"0.6141953",
"0.6138373",
"0.61298656",
"0.6080713",
"0.6017898",
"0.60149074",
"0.60149074",
"0.60149074",
"0.60122037",
"0.59977126",
"0.5987593",
"0.59382886",
"0.5902842",
"0.5889... | 0.8311787 | 0 |
Optionally converts images from hooks_args to image summaries. | def convert_predictions_to_image_summaries(hook_args):
decode_hparams = hook_args.decode_hparams
if not decode_hparams.display_decoded_images:
return []
predictions = hook_args.predictions[0]
# Display ten random inputs and outputs so that tensorboard does not hang.
all_summaries = []
rand_predictions ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_stage(self, images):\n\n for i, image in enumerate(images):\n pass\n # logging_tags = logs.image_config_to_tags(image, self.group_by_keywords)",
"def multi_run_wrapper(args):\n\treturn img_preprocessing(*args)",
"def __call__(self, images, targets):\n pass",
"def pr... | [
"0.57442975",
"0.57011163",
"0.5521036",
"0.53856045",
"0.5378818",
"0.5378818",
"0.5353799",
"0.531765",
"0.52791244",
"0.52719086",
"0.5230224",
"0.52281237",
"0.52281237",
"0.5207086",
"0.5201962",
"0.5174777",
"0.51720655",
"0.51613",
"0.5155435",
"0.51528734",
"0.5152154... | 0.69051784 | 0 |
image resize function used by quite a few image problems. | def resize_by_area(img, size):
return tf.to_int64(
tf.image.resize_images(img, [size, size], tf.image.ResizeMethod.AREA)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_image(image):\n image = resize(image)\n return image",
"def FlyResize( image, log_mess, nimages, method = Image.ANTIALIAS ):\n oldw, oldh = image.size\n resl = [8, 10, 14, 16, 20, 22, 24, 32, 40, 48, 64, 96, 128, 256]\n \n if oldw > 256 or oldh > 256:\... | [
"0.7521358",
"0.74610686",
"0.7421938",
"0.73141485",
"0.7142209",
"0.7142209",
"0.71145546",
"0.71056485",
"0.7080996",
"0.7078732",
"0.7073116",
"0.7058495",
"0.6986709",
"0.69650143",
"0.6933278",
"0.6913644",
"0.69086534",
"0.690373",
"0.6900538",
"0.6889671",
"0.68864405... | 0.0 | -1 |
Returns list of scaled images, one for each resolution. | def make_multiscale(image, resolutions,
resize_method=tf.image.ResizeMethod.BICUBIC,
num_channels=3):
scaled_images = []
for height in resolutions:
scaled_image = tf.image.resize_images(
image,
size=[height, height], # assuming that height = width
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scales(self):\n scales = queryMultiAdapter((self, self.request), name=\"images\")\n return scales",
"def scale(img, scales):\n outputs = []\n for sc in scales:\n outputs.append(\n cv2.resize(img, None, fx=sc, fy=sc, interpolation=cv2.INTER_CUBIC)\n )\n return o... | [
"0.7400567",
"0.6925044",
"0.68059033",
"0.6721329",
"0.66487384",
"0.6625194",
"0.6619865",
"0.6577308",
"0.6562258",
"0.6527271",
"0.6507845",
"0.6345303",
"0.6319713",
"0.63128996",
"0.6248099",
"0.6236228",
"0.61226034",
"0.61199546",
"0.6042438",
"0.6025261",
"0.5975142"... | 0.67498195 | 3 |
Returns list of scaled images, one for each resolution. Resizes by skipping every nth pixel. | def make_multiscale_dilated(image, resolutions, num_channels=3):
image_height = common_layers.shape_list(image)[0]
scaled_images = []
for height in resolutions:
dilation_rate = image_height // height # assuming height = width
scaled_image = image[::dilation_rate, ::dilation_rate]
scaled_image = tf.to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resize_images(self, images):\n \n img_list = []\n \n for img in images:\n \n yield np.resize(img, (64, 64, 3))",
"def resize_images(imgs, size=(720, 720)):\n res = []\n for img in imgs:\n\n factor = max(1, size[0]/float(img.shape[0]), size[1]/float(img.shape... | [
"0.6965899",
"0.6890647",
"0.6819921",
"0.6661743",
"0.6544926",
"0.6532967",
"0.6431577",
"0.64254856",
"0.6387828",
"0.6340229",
"0.6289193",
"0.62139636",
"0.61322016",
"0.61032397",
"0.60858595",
"0.6070303",
"0.6048841",
"0.6043469",
"0.6002986",
"0.5975552",
"0.59419584... | 0.6684896 | 3 |
Number of color channels. | def num_channels(self):
return 3 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_of_channels(self) -> int:\n return len(self.non_zero_channels())",
"def n_channels(self):\n return len(self.channels)",
"def n_channels(self):\n return self._n_channels",
"def channels(self) -> int:\n return len(self._channel_arrays)",
"def queryNumberOfColors(self):\n ... | [
"0.79698837",
"0.7782575",
"0.77616227",
"0.74364847",
"0.7303962",
"0.72801465",
"0.7276568",
"0.7234011",
"0.71893704",
"0.7163125",
"0.7106633",
"0.71035886",
"0.70540285",
"0.7002933",
"0.6996827",
"0.6929145",
"0.69025093",
"0.68789124",
"0.68253195",
"0.6736472",
"0.671... | 0.75154245 | 3 |
Number of pixel values. | def vocab_size(self):
return 256 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def numPixels(self):\n self._logger.debug(\"numPixels\")\n return self.count",
"def numPixels(self):\n\t\treturn self.size",
"def numPixels(self):\n\t\treturn self.size",
"def count(self):\n \n return len(self.img_lst)",
"def get_num_of_images(self):",
"def GetNumberOfComponen... | [
"0.86553746",
"0.86169404",
"0.86169404",
"0.73817253",
"0.73454994",
"0.7130761",
"0.71236366",
"0.7103836",
"0.70961624",
"0.70860696",
"0.70763683",
"0.70628375",
"0.70424324",
"0.7030204",
"0.7015081",
"0.7007118",
"0.6998215",
"0.69781816",
"0.69707894",
"0.6957646",
"0.... | 0.0 | -1 |
Yield images encoded as pngs. | def encode_images_as_png(images):
if tf.executing_eagerly():
for image in images:
yield tf.image.encode_png(image).numpy()
else:
(height, width, channels) = images[0].shape
with tf.Graph().as_default():
image_t = tf.placeholder(dtype=tf.uint8, shape=(height, width, channels))
encoded_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _iter_images(self):\n for image in self._images:\n yield np.array(image.convert('RGB'))",
"def _iter_images(self):\n for image in self._images:\n yield image",
"def _iter_images(self):\n raise NotImplementedError",
"def image_generator(images, labels):\n if not... | [
"0.74284726",
"0.7120368",
"0.70620733",
"0.7001267",
"0.6647991",
"0.6641262",
"0.65364003",
"0.644897",
"0.63591933",
"0.6352729",
"0.63406384",
"0.63015574",
"0.62920284",
"0.62758785",
"0.62565166",
"0.6213246",
"0.6183164",
"0.615228",
"0.6151142",
"0.6129787",
"0.612291... | 0.64094543 | 8 |
Generator for images that takes image and labels lists and creates pngs. | def image_generator(images, labels):
if not images:
raise ValueError("Must provide some images for the generator.")
width, height, _ = images[0].shape
for (enc_image, label) in zip(encode_images_as_png(images), labels):
yield {
"image/encoded": [enc_image],
"image/format": ["png"],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image_generator(img_list):\n while True:\n img = random.choice(img_list)\n label = os.path.basename(os.path.dirname(img)) # add label function according to the dataset tree\n img = preprocess_image(img)\n yield img, label",
"def batch(img_path, gt_path,img_list, batch, total_s... | [
"0.8013157",
"0.7169892",
"0.71564656",
"0.702399",
"0.68695503",
"0.6713235",
"0.6668822",
"0.66558856",
"0.6632258",
"0.65799594",
"0.65589684",
"0.6515779",
"0.65155697",
"0.65101016",
"0.64978045",
"0.6496326",
"0.64884",
"0.6485673",
"0.64815027",
"0.6465144",
"0.6454243... | 0.80332494 | 0 |
Image augmentation suitable for CIFAR10/100. | def cifar_image_augmentation(images):
images = tf.image.resize_image_with_crop_or_pad(images, 40, 40)
images = tf.random_crop(images, [32, 32, 3])
images = tf.image.random_flip_left_right(images)
return images | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_augmentation_sequence():\n # Macro to apply something with 50% chance\n sometimes = lambda aug: iaa.Sometimes(0.5, aug) # 50%\n rarely = lambda aug: iaa.Sometimes(0.1, aug) # 10%\n\n # Augmentation applied to every image\n # Augmentors sampled one value per channel\n aug_sequence = iaa.Se... | [
"0.7163005",
"0.7071261",
"0.7014249",
"0.7005597",
"0.6739197",
"0.6528979",
"0.6500406",
"0.63945806",
"0.63873875",
"0.635612",
"0.628733",
"0.6277283",
"0.62339985",
"0.61770326",
"0.61731637",
"0.616266",
"0.6130412",
"0.61154556",
"0.6099443",
"0.6072942",
"0.60591555",... | 0.6585125 | 5 |
Apply random horizontal and vertical shift to images. This is the default dataaugmentation strategy used on CIFAR in Glow. | def random_shift(image, wsr=0.1, hsr=0.1):
height, width, _ = common_layers.shape_list(image)
width_range, height_range = wsr*width, hsr*height
height_translations = tf.random_uniform((1,), -height_range, height_range)
width_translations = tf.random_uniform((1,), -width_range, width_range)
translations = tf.c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shift_augmentation():\n shift = np.random.randint(-200, 201, size=2)\n return lambda image: shift_with_extension(image, shift)",
"def random_shifts(self, image, label, h_shift, v_shift):\n\n rows = image.shape[0]\n cols = image.shape[1]\n\n horizontal = uniform(- h_shift / ... | [
"0.7565832",
"0.68828964",
"0.6849282",
"0.67500216",
"0.66608775",
"0.6658838",
"0.6638471",
"0.65298706",
"0.6441347",
"0.6437689",
"0.64301574",
"0.6396851",
"0.63864475",
"0.63639367",
"0.63604707",
"0.6309984",
"0.6303468",
"0.62520194",
"0.62459886",
"0.61901236",
"0.61... | 0.6359114 | 15 |
Inserts the handle into the base object to prevent memory corruption in certain cases | def register_handle(handle, base_object):
try:
if base_object.IsKind("Standard_Transient"):
base_object.thisHandle = handle
base_object.thisown = False
except:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_handle(self):\n\n raise NotImplementedError('new_handle')",
"def appendPhandle(self, obj):\n # Create a bogus state because we only need the Phandle dictionary\n state = FdtState(addr_cells=1, size_cells=1, cpu_cells=1)\n\n phandle = state.phandle(obj)\n self.append(Fdt... | [
"0.6344074",
"0.6075597",
"0.58665854",
"0.5793248",
"0.5771051",
"0.5582377",
"0.5384124",
"0.531869",
"0.52723384",
"0.52723384",
"0.52723384",
"0.52709585",
"0.52696466",
"0.5216243",
"0.5204256",
"0.5171028",
"0.51665926",
"0.515439",
"0.51379216",
"0.5128355",
"0.5126797... | 0.66234106 | 6 |
this method makes a wire whose edges are C1 from a Wire whose edges could be G1. It removes a vertex between G1 edges. Option can be G1 or C1. | def ConcatenateWire(*args):
return _BRepAlgo.brepalgo_ConcatenateWire(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_graph2(self, g1):\n g2 = g1.copy()\n for source, target, weight in self._remaining_edges:\n if weight == -1:\n self._gt_edges.append((source, target))\n if g2.has_edge(source, target):\n g2.remove_edge(source, target)\n ret... | [
"0.548062",
"0.54205805",
"0.5287949",
"0.51086205",
"0.48842067",
"0.48342565",
"0.4824531",
"0.48094237",
"0.47528753",
"0.47327384",
"0.472759",
"0.47229192",
"0.47211432",
"0.4712262",
"0.47049093",
"0.46987176",
"0.4694659",
"0.4678394",
"0.4678394",
"0.4674186",
"0.4642... | 0.0 | -1 |
this method makes an edge from a wire. Junction points between edges of wire may be sharp, resulting curve of the resulting edge may be C0. | def ConcatenateWireC0(*args):
return _BRepAlgo.brepalgo_ConcatenateWireC0(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_edge(self, a, b):\n try: e = self.G.new_edge(a, b)\n except: return self.G.new_edge(a,b)\n\n try: self.G.set_edge_attribute(e, \"arrow\", \"true\")\n except: return self.G.new_edge(a,b)\n\n try: self.G.set_edge_attribute(e, \"spline\", \"false\")\n except: return ... | [
"0.61174107",
"0.60685146",
"0.57434285",
"0.56741333",
"0.5600909",
"0.5600067",
"0.5582746",
"0.5530568",
"0.5528883",
"0.54733944",
"0.54462737",
"0.54074967",
"0.53542346",
"0.5343363",
"0.5315694",
"0.5315531",
"0.52983046",
"0.52760667",
"0.5260912",
"0.5250793",
"0.523... | 0.0 | -1 |
Checks if the shape is 'correct'. If not, returns , else returns . | def IsValid(*args):
return _BRepAlgo.brepalgo_IsValid(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_shape(placeholder_shape, data_shape):\n\n return True",
"def _check_shape(shape):\n if type(shape) == int:\n shape = (shape, shape)\n check_odd(shape, 'psf shape')\n return shape",
"def _check_shape(input_shape):\n msg = ('Input to SpatialExpansion must be 4D with dimension... | [
"0.6993668",
"0.66536385",
"0.65772355",
"0.64655465",
"0.64077026",
"0.6379204",
"0.6362978",
"0.62955195",
"0.62610215",
"0.6260291",
"0.6246603",
"0.62193215",
"0.6180648",
"0.61409706",
"0.6115868",
"0.60293645",
"0.601427",
"0.5950285",
"0.59175324",
"0.5911704",
"0.5911... | 0.0 | -1 |
Checks if the shape is 'correct'. If not, returns , else returns . This method differs from the previous one in the fact that no geometric contols (intersection of wires, pcurve validity) are performed. | def IsTopologicallyValid(*args):
return _BRepAlgo.brepalgo_IsTopologicallyValid(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isValidPcbShape(g):\n return g.GetShape() != pcbnew.S_SEGMENT or g.GetLength() > 0",
"def is_valid(self):\n if len(self.exterior) < 3:\n return False\n return self.to_shapely_polygon().is_valid",
"def _check_curve(layer: ogr.Layer) -> None:\n # Check if the feature geomet... | [
"0.65879864",
"0.6473084",
"0.60748625",
"0.5991389",
"0.5924151",
"0.5896834",
"0.5865766",
"0.5848998",
"0.583442",
"0.580154",
"0.57394546",
"0.5724047",
"0.57233506",
"0.57214564",
"0.5621533",
"0.56186867",
"0.5612514",
"0.559289",
"0.55808973",
"0.5569833",
"0.55482334"... | 0.0 | -1 |
this method makes a wire whose edges are C1 from a Wire whose edges could be G1. It removes a vertex between G1 edges. Option can be G1 or C1. | def brepalgo_ConcatenateWire(*args):
return _BRepAlgo.brepalgo_ConcatenateWire(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_graph2(self, g1):\n g2 = g1.copy()\n for source, target, weight in self._remaining_edges:\n if weight == -1:\n self._gt_edges.append((source, target))\n if g2.has_edge(source, target):\n g2.remove_edge(source, target)\n ret... | [
"0.548062",
"0.54205805",
"0.5287949",
"0.51086205",
"0.48842067",
"0.48342565",
"0.4824531",
"0.48094237",
"0.47528753",
"0.47327384",
"0.472759",
"0.47229192",
"0.47211432",
"0.4712262",
"0.47049093",
"0.46987176",
"0.4694659",
"0.4678394",
"0.4678394",
"0.4674186",
"0.4642... | 0.0 | -1 |
this method makes an edge from a wire. Junction points between edges of wire may be sharp, resulting curve of the resulting edge may be C0. | def brepalgo_ConcatenateWireC0(*args):
return _BRepAlgo.brepalgo_ConcatenateWireC0(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_edge(self, a, b):\n try: e = self.G.new_edge(a, b)\n except: return self.G.new_edge(a,b)\n\n try: self.G.set_edge_attribute(e, \"arrow\", \"true\")\n except: return self.G.new_edge(a,b)\n\n try: self.G.set_edge_attribute(e, \"spline\", \"false\")\n except: return ... | [
"0.61174107",
"0.60685146",
"0.57434285",
"0.56741333",
"0.5600909",
"0.5600067",
"0.5582746",
"0.5530568",
"0.5528883",
"0.54733944",
"0.54462737",
"0.54074967",
"0.53542346",
"0.5343363",
"0.5315694",
"0.5315531",
"0.52983046",
"0.52760667",
"0.5260912",
"0.5250793",
"0.523... | 0.0 | -1 |
Checks if the shape is 'correct'. If not, returns , else returns . | def brepalgo_IsValid(*args):
return _BRepAlgo.brepalgo_IsValid(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_shape(placeholder_shape, data_shape):\n\n return True",
"def _check_shape(shape):\n if type(shape) == int:\n shape = (shape, shape)\n check_odd(shape, 'psf shape')\n return shape",
"def _check_shape(input_shape):\n msg = ('Input to SpatialExpansion must be 4D with dimension... | [
"0.6993668",
"0.66536385",
"0.65772355",
"0.64655465",
"0.64077026",
"0.6379204",
"0.6362978",
"0.62955195",
"0.62610215",
"0.6260291",
"0.6246603",
"0.62193215",
"0.6180648",
"0.61409706",
"0.6115868",
"0.60293645",
"0.601427",
"0.5950285",
"0.59175324",
"0.5911704",
"0.5911... | 0.0 | -1 |
Checks if the shape is 'correct'. If not, returns , else returns . This method differs from the previous one in the fact that no geometric contols (intersection of wires, pcurve validity) are performed. | def brepalgo_IsTopologicallyValid(*args):
return _BRepAlgo.brepalgo_IsTopologicallyValid(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isValidPcbShape(g):\n return g.GetShape() != pcbnew.S_SEGMENT or g.GetLength() > 0",
"def is_valid(self):\n if len(self.exterior) < 3:\n return False\n return self.to_shapely_polygon().is_valid",
"def _check_curve(layer: ogr.Layer) -> None:\n # Check if the feature geomet... | [
"0.65879864",
"0.6473084",
"0.60748625",
"0.5991389",
"0.5924151",
"0.5896834",
"0.5865766",
"0.5848998",
"0.583442",
"0.580154",
"0.57394546",
"0.5724047",
"0.57233506",
"0.57214564",
"0.5621533",
"0.56186867",
"0.5612514",
"0.559289",
"0.55808973",
"0.5569833",
"0.55482334"... | 0.0 | -1 |
Creates an empty AsDes. | def __init__(self, *args):
_BRepAlgo.BRepAlgo_AsDes_swiginit(self,_BRepAlgo.new_BRepAlgo_AsDes(*args)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_empty_trace(self):\n self.data = np.zeros(0, dtype=np.float32)\n self.header = SEGYTraceHeader(header=None, endian=self.endian)",
"def _create_empty_segy_file_object(self):\n self.textual_file_header = b''\n self.binary_file_header = None\n self.traces = []",
"def... | [
"0.5758801",
"0.5586419",
"0.5519884",
"0.5494886",
"0.5454309",
"0.54006606",
"0.53879",
"0.5323445",
"0.52917165",
"0.528022",
"0.5211821",
"0.51626563",
"0.5152615",
"0.51504207",
"0.51392835",
"0.5120089",
"0.5102294",
"0.5096787",
"0.5087933",
"0.5048822",
"0.5039879",
... | 0.5758028 | 1 |
Stores as a futur subshape of . | def Add(self, *args):
return _BRepAlgo.BRepAlgo_AsDes_Add(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape(self):",
"def shape(self):",
"def _settle_shape(self, shape):\n if shape:\n for block in shape.blocks:\n self.array[block.row_position][block.column_position] = block\n self.remove_completed_lines()",
"def predataShape(self):\n self._predatashape['name... | [
"0.6075055",
"0.6075055",
"0.59390676",
"0.59037286",
"0.58740383",
"0.57528335",
"0.5671366",
"0.56450456",
"0.53267777",
"0.5302478",
"0.5295207",
"0.5285361",
"0.5209979",
"0.5204615",
"0.51952237",
"0.5167934",
"0.51644427",
"0.51629305",
"0.51255596",
"0.51195276",
"0.51... | 0.0 | -1 |
Returns the Shape containing . | def Ascendant(self, *args):
return _BRepAlgo.BRepAlgo_AsDes_Ascendant(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape(self) -> Shape:",
"def locate_shape(shape):",
"def shape(self):",
"def shape(self):",
"def shape(self):\n return self._shape",
"def shape(self):\n return None",
"def interior(self):\n return Shape(self - self.edge('inner'))",
"def shape(self) -> str:\n return \"box\"... | [
"0.7659576",
"0.7153201",
"0.71205145",
"0.71205145",
"0.68296224",
"0.67433995",
"0.66680634",
"0.6657945",
"0.6656064",
"0.6634446",
"0.661535",
"0.64803284",
"0.64801484",
"0.6447151",
"0.6447151",
"0.6438147",
"0.64115214",
"0.62910223",
"0.62553567",
"0.62410337",
"0.622... | 0.0 | -1 |
Returns futur subhapes of . | def Descendant(self, *args):
return _BRepAlgo.BRepAlgo_AsDes_Descendant(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def XCAFDoc_ShapeTool_GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)",
"def GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)",
"def reshape(x, shape):\n return Reshape(shape)(x)",
"def sliceshape(slicetuple, totshape):\n res = []\n fo... | [
"0.57035416",
"0.56229824",
"0.5592263",
"0.55720997",
"0.55593735",
"0.5515692",
"0.54992557",
"0.54937744",
"0.5476747",
"0.5476747",
"0.54289174",
"0.54163265",
"0.5404519",
"0.54007506",
"0.53987753",
"0.53804696",
"0.53761375",
"0.53140134",
"0.53051925",
"0.5304505",
"0... | 0.0 | -1 |
Returns futur subhapes of . | def ChangeDescendant(self, *args):
return _BRepAlgo.BRepAlgo_AsDes_ChangeDescendant(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def XCAFDoc_ShapeTool_GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)",
"def GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)",
"def reshape(x, shape):\n return Reshape(shape)(x)",
"def sliceshape(slicetuple, totshape):\n res = []\n fo... | [
"0.57035416",
"0.56229824",
"0.5592263",
"0.55720997",
"0.55593735",
"0.5515692",
"0.54992557",
"0.54937744",
"0.5476747",
"0.5476747",
"0.54289174",
"0.54163265",
"0.5404519",
"0.54007506",
"0.53987753",
"0.53804696",
"0.53761375",
"0.53140134",
"0.53051925",
"0.5304505",
"0... | 0.0 | -1 |
Replace by . disapear from . | def Replace(self, *args):
return _BRepAlgo.BRepAlgo_AsDes_Replace(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_dot(data):\n data = re.sub(\"[.]\", \" . \", data)\n return data",
"def rm_dot(item):\n if len(str(item).split('.')) > 2:\n return item.replace('.', '', 1)\n else:\n return item",
"def _remove_dot_from_extension(\n extensions\n):\n if isinstance(extensions, str):\n ... | [
"0.694087",
"0.6739121",
"0.6405482",
"0.63316286",
"0.6185834",
"0.617668",
"0.617281",
"0.61466223",
"0.6135448",
"0.6116209",
"0.60985905",
"0.6085858",
"0.6023782",
"0.59829724",
"0.59341085",
"0.5888144",
"0.58224416",
"0.5703905",
"0.5689685",
"0.5688758",
"0.5656561",
... | 0.0 | -1 |
Returns True if (S1> and has common Descendants. Stores in the Commons Descendants. | def HasCommonDescendant(self, *args):
return _BRepAlgo.BRepAlgo_AsDes_HasCommonDescendant(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isAllIncluded(S1, S2):\n return False if len(set(S1).intersection(S2)) != len(set(S1)) else True",
"def is_found_in_parents(mcs, name, parents):\n for parent in parents:\n\n for cls in reversed(parent.__mro__):\n\n if hasattr(cls, name):\n return True\n\... | [
"0.58216304",
"0.57693666",
"0.56457704",
"0.54126",
"0.53150624",
"0.53035873",
"0.5301044",
"0.5265569",
"0.5263396",
"0.5238863",
"0.52369124",
"0.5216553",
"0.5201471",
"0.51886964",
"0.5182887",
"0.5174848",
"0.5164969",
"0.5162364",
"0.5154515",
"0.5146251",
"0.5138688"... | 0.5984507 | 0 |
Returns the first shape involved in this Boolean operation. | def Shape1(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperation_Shape1(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ShapeFrom(self, *args):\n return _BRepAlgo.BRepAlgo_BooleanOperations_ShapeFrom(self, *args)",
"def shape(self):\n return self.active.shape",
"def Shape(self, *args):\n return _BRepAlgo.BRepAlgo_BooleanOperations_Shape(self, *args)",
"def get_output_shape(self):\n return self.... | [
"0.69976586",
"0.67969745",
"0.6770878",
"0.6766901",
"0.6766901",
"0.6725859",
"0.67074716",
"0.67057925",
"0.66768235",
"0.6671902",
"0.6587406",
"0.6587406",
"0.65293986",
"0.65240335",
"0.64601064",
"0.6452454",
"0.6452454",
"0.6452454",
"0.64200085",
"0.6357087",
"0.6352... | 0.6905269 | 1 |
Returns the second shape involved in this Boolean operation. | def Shape2(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperation_Shape2(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ShapeFrom(self, *args):\n return _BRepAlgo.BRepAlgo_BooleanOperations_ShapeFrom(self, *args)",
"def Shape(self, *args):\n return _BRepAlgo.BRepAlgo_BooleanOperations_Shape(self, *args)",
"def Shape1(self, *args):\n return _BRepAlgo.BRepAlgo_BooleanOperation_Shape1(self, *args)",
"def... | [
"0.7164068",
"0.70292205",
"0.696538",
"0.6760701",
"0.6375149",
"0.6258295",
"0.6258295",
"0.6172665",
"0.61283445",
"0.6042824",
"0.60409766",
"0.60409766",
"0.60409766",
"0.60370505",
"0.6007792",
"0.6001082",
"0.5968415",
"0.59486276",
"0.59486276",
"0.5940918",
"0.588824... | 0.7778657 | 0 |
S1 is a Shell with ALL faces supported by the SAME S2 is an Edge INCLUDED in that surface with pcurve. this avoids a timeconsuming 3D operation, compared to Shapes. | def Shapes2d(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_Shapes2d(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CreateCurve1DMeshfrom2DMesh(self):\n\n self.__do_memebers_exist__()\n\n p = self.InferPolynomialDegree()\n mm = Mesh()\n unique_edges, inv_edges = np.unique(self.edges,return_inverse=True)\n mm.points = self.points[unique_edges,:]\n mm.nnode = mm.points.shape[0]\n ... | [
"0.58741635",
"0.5715788",
"0.5693927",
"0.56503993",
"0.56048983",
"0.5515899",
"0.55102676",
"0.54814833",
"0.54200506",
"0.5375164",
"0.53727293",
"0.53232086",
"0.5315329",
"0.5283123",
"0.5282904",
"0.52738345",
"0.5272365",
"0.5220711",
"0.5219027",
"0.52072",
"0.519925... | 0.0 | -1 |
returns the common part of the shapes. | def Common(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_Common(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commonbeam(self):\n return _image.image_commonbeam(self)",
"def common(self):\n return self._common",
"def common(self):",
"def common(self, other):\n last = None\n for x, y in zip(self.parts(), other.parts()):\n if x != y:\n return last\n ... | [
"0.6230063",
"0.6022561",
"0.6008241",
"0.5993487",
"0.59818494",
"0.5967463",
"0.59326553",
"0.5864632",
"0.58553815",
"0.58179706",
"0.58179706",
"0.57640815",
"0.57613176",
"0.5748849",
"0.57426405",
"0.57311636",
"0.5704641",
"0.5704629",
"0.56948143",
"0.568224",
"0.5669... | 0.0 | -1 |
returns the fuse part of the shapes. | def Fus(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_Fus(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fuse(self):\n # TODO: Don't fuse unless they have None as the end slants?\n i = 0\n while i < len(self.segments) - 1:\n left = self.segments[i]\n right = self.segments[i + 1]\n if (\n isinstance(left, LineSegment)\n and isinsta... | [
"0.5748058",
"0.55704474",
"0.55694354",
"0.5541534",
"0.54904336",
"0.54904336",
"0.54525256",
"0.5400547",
"0.539064",
"0.53859663",
"0.5384255",
"0.53695667",
"0.5342205",
"0.5335079",
"0.525432",
"0.5212678",
"0.5192541",
"0.5192125",
"0.5191531",
"0.518714",
"0.518714",
... | 0.0 | -1 |
returns the cut part of the shapes. | def Cut(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_Cut(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cuts(self) -> list[list[int]]:\n if self._cuts is not None:\n return self._cuts\n width = self.width\n height = self.height\n screen_region = Region(0, 0, width, height)\n cuts_sets = [{0, width} for _ in range(height)]\n\n if self.map is not None:\n ... | [
"0.6406902",
"0.6294918",
"0.6268585",
"0.62640405",
"0.61140466",
"0.60826236",
"0.5990929",
"0.5919687",
"0.588759",
"0.5864538",
"0.5862589",
"0.5862589",
"0.58487844",
"0.5839845",
"0.5816513",
"0.5800285",
"0.5751268",
"0.5747535",
"0.5705699",
"0.5686229",
"0.56849027",... | 0.52482724 | 82 |
returns the intersection of the shapes. | def Section(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_Section(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection(self, other):\n return self._geomgen(capi.geom_intersection, other)",
"def intersection(self, other):\n \n self_corners = self.corners\n\n other_corners = get_2d_false_corners(other)\n\n #shell()\n\n return planar_intersection_polygon(self_corners,other_... | [
"0.7315705",
"0.7097444",
"0.70627666",
"0.7027862",
"0.69971836",
"0.68884236",
"0.67736405",
"0.6743636",
"0.6635209",
"0.66342473",
"0.6617631",
"0.65977013",
"0.657614",
"0.6560498",
"0.65414494",
"0.6511421",
"0.64712614",
"0.6467776",
"0.64660656",
"0.64551896",
"0.6419... | 0.0 | -1 |
returns the result of the boolean operation. | def Shape(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_Shape(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __bool__(self):\n return bool(self.get_value())",
"def get_bool2(self):\n pass",
"def __bool__(self):\n return bool(self._value)",
"def __bool__(self):\n return self is TRUE",
"def bool(self):\n return bool(self.int(2))",
"def _true(*args):\n # pylint:disable=unu... | [
"0.7540962",
"0.73034054",
"0.7231144",
"0.722943",
"0.7205474",
"0.71799725",
"0.71602803",
"0.7127289",
"0.7101453",
"0.70738816",
"0.7039228",
"0.703541",
"0.6967901",
"0.6967901",
"0.6967901",
"0.69588107",
"0.69455975",
"0.69328094",
"0.691385",
"0.6885347",
"0.68823045"... | 0.0 | -1 |
Returns the shape(s) resulting of the boolean operation issued from the shape . | def ShapeFrom(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_ShapeFrom(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Shape(self, *args):\n return _BRepAlgo.BRepAlgo_BooleanOperations_Shape(self, *args)",
"def _check_shape(placeholder_shape, data_shape):\n\n return True",
"def shape(self):\n\n result = list(self.data.shape)\n included = np.count_nonzero(self.mask.to_array(dtype=bool))\n #it... | [
"0.6819105",
"0.67962897",
"0.67651623",
"0.66086906",
"0.660517",
"0.65323514",
"0.6515616",
"0.6495337",
"0.6495337",
"0.64884543",
"0.64880997",
"0.6476348",
"0.6467666",
"0.6467654",
"0.64491105",
"0.6449074",
"0.63928175",
"0.6381001",
"0.6355569",
"0.6325708",
"0.632415... | 0.65076053 | 7 |
Returns the list of the descendant shapes of the shape . | def Modified(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_Modified(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shapes(self):\n return [load_node(item) for item in self.get_attribute('shapes')]",
"def shapes(self):\n return self.container['shapes']",
"def XCAFDoc_ShapeTool_GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)",
"def type_shapes(self):\n return self._type_sh... | [
"0.7335689",
"0.7056765",
"0.6670955",
"0.6620322",
"0.65096456",
"0.6487307",
"0.6474483",
"0.6366075",
"0.63453704",
"0.6228035",
"0.61771905",
"0.61771905",
"0.6141498",
"0.6123635",
"0.6072071",
"0.6023066",
"0.60074574",
"0.5974856",
"0.59430003",
"0.5921462",
"0.5908138... | 0.0 | -1 |
Returns the fact that the shape has been deleted or not by the boolean operation. | def IsDeleted(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_IsDeleted(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isSetDeletion(self):\n return _libsbml.ReplacedElement_isSetDeletion(self)",
"def is_deleted(self):\n if self.deleted:\n return True\n return False",
"def deleted(self) -> bool:\n return pulumi.get(self, \"deleted\")",
"def checkTrueArrayIsDeleted(node):\n if (no... | [
"0.6678011",
"0.65664494",
"0.6531786",
"0.64280504",
"0.6359463",
"0.6359463",
"0.62985015",
"0.62773854",
"0.62599415",
"0.62015194",
"0.6054305",
"0.59900373",
"0.5980353",
"0.586673",
"0.5838913",
"0.583038",
"0.5804918",
"0.5689249",
"0.5687188",
"0.5682833",
"0.5672811"... | 0.6039284 | 11 |
returns the member myDSA. It is useful to then access the method GetSectionEdgeSet (wich is a member of DSAccess) | def DataStructureAccess(self, *args):
return _BRepAlgo.BRepAlgo_BooleanOperations_DataStructureAccess(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dsa_key(self,private_key):\n numbers = private_key.private_numbers()\n content = WriteMessage()\n content.write_string('ssh-dss')\n content.write_mpint(numbers.public_numbers.parameter_numbers.p)\n content.write_mpint(numbers.public_numbers.parameter_numbers.q)\n cont... | [
"0.56260055",
"0.5464349",
"0.5435241",
"0.53704",
"0.5287761",
"0.5128341",
"0.5128341",
"0.51013947",
"0.5087422",
"0.50863296",
"0.50863296",
"0.50863296",
"0.50863296",
"0.50863296",
"0.50863296",
"0.5081519",
"0.50691783",
"0.5043424",
"0.504146",
"0.5022155",
"0.5000575... | 0.0 | -1 |
Clears the internal data structure, including the | def Init(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_Init(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear(self) -> None:\n self.data = {} # defaultdict fails (T282865)\n self.size = 0",
"def clear(self):\n self._data = []",
"def clear(self):\n self._data = []",
"def clear(self):\n for key in self.__data.keys():\n del self.__data[key]",
"def clear(self):\... | [
"0.87491065",
"0.84816325",
"0.84816325",
"0.84703386",
"0.8418484",
"0.826198",
"0.82451874",
"0.8211007",
"0.8152963",
"0.81437767",
"0.81424785",
"0.81424785",
"0.81424785",
"0.8130953",
"0.8130953",
"0.8130953",
"0.8130953",
"0.8130953",
"0.8130953",
"0.8130953",
"0.81195... | 0.0 | -1 |
Loads the shape in DS. | def Load(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_Load(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load(self, pkgpart, part_dict):\n # call parent to do generic aspects of load\n super(BaseSlide, self)._load(pkgpart, part_dict)\n # unmarshal shapes\n self._shapes = ShapeCollection(self._element.cSld.spTree, self)\n # return self-reference to allow generative calling\n ... | [
"0.66357905",
"0.64954376",
"0.63588953",
"0.6266509",
"0.6103227",
"0.60606235",
"0.6031602",
"0.59880817",
"0.59817374",
"0.59817374",
"0.59817374",
"0.59817374",
"0.59773034",
"0.5931885",
"0.5918622",
"0.5911345",
"0.5911345",
"0.5896537",
"0.5884401",
"0.58312875",
"0.58... | 0.0 | -1 |
Intersects two shapes at input and loads the DS with their intersection. Clears the TopOpeBRepBuild_HBuilder if necessary | def Intersect(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_Intersect(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mergePolyShapefiles(input1Filename, input2Filename, mergedFilename,field_names = [cc.DEV_LAYER_ATTRIBUTE_NAME,]):\n\n input1Ds = ogr.Open(input1Filename)\n if not input1Ds:\n sys.exit(\"Unable to open input file '{0}'\".format(input1Filename))\n input1lyr = input1Ds.GetLayer()\n inp1SRS = in... | [
"0.54987395",
"0.5441911",
"0.5406553",
"0.5404014",
"0.53096396",
"0.51874185",
"0.5181753",
"0.517855",
"0.51533735",
"0.515292",
"0.5128276",
"0.5125197",
"0.51138943",
"0.5113446",
"0.5102353",
"0.5057921",
"0.5054311",
"0.5013443",
"0.4999361",
"0.4991658",
"0.49792105",... | 0.0 | -1 |
This method does the same thing as the previous, but faster. There is no intersection face/face 3D. The faces have the same support(surface). No test of tangency (that is why it is faster). Intersects in 2d the faces tangent F1 anf F2. | def SameDomain(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_SameDomain(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_x_intersection_2d(self):\n\n f_1 = np.array([[0, 2], [1, 1]])\n f_2 = np.array([[1, 1], [0, 2]])\n\n f_set = [f_1, f_2]\n nx = [3, 3]\n\n grids = meshing.cart_grid(f_set, nx, physdims=nx)\n\n # 2D grid:\n g_2d = grids.grids_of_dimension(2)[0]\n\n f_t... | [
"0.66358507",
"0.6470757",
"0.5942164",
"0.5913264",
"0.5904449",
"0.5815683",
"0.5782105",
"0.5723379",
"0.57060015",
"0.5683652",
"0.56676096",
"0.5646296",
"0.5637886",
"0.5632924",
"0.56150067",
"0.55646557",
"0.5564056",
"0.5550254",
"0.55085504",
"0.55046755",
"0.550392... | 0.0 | -1 |
returns compounds of Edge connected with section, which contains sections between faces contained in S1 and S2. returns an empty list of Shape if S1 or S2 do not contain face. calls GetSectionEdgeSet() if it has not already been done | def GetSectionEdgeSet(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_GetSectionEdgeSet(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shared_edges(self, face_selector1: _face_selector_types,\n face_selector2: _face_selector_types) -> Sequence[Edge]:\n other_faces = self.find_faces(face_selector2)\n\n result_edges = []\n for face in self.find_faces(face_selector1):\n for edge in face.edges:\... | [
"0.6410287",
"0.55884326",
"0.55351377",
"0.5522345",
"0.55068785",
"0.5343045",
"0.5311352",
"0.53073007",
"0.5303514",
"0.5291458",
"0.52785116",
"0.52631366",
"0.52371",
"0.5231882",
"0.5201273",
"0.51927465",
"0.51717657",
"0.5161595",
"0.512026",
"0.51042163",
"0.5084441... | 0.56942534 | 1 |
NYI returns the vertex of section, which contains the section between face S1 and edge S2 (returns an empty Shape if S1 is not a face or if S2 is not an edge) | def SectionVertex(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_SectionVertex(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def interior(self):\n return Shape(self - self.edge('inner'))",
"def edge(self, which='inner'):\n def edge_shape(site):\n def in_shape(x): return self.shape(Site(site.family, site.tag + x))\n sites = [in_shape(x) for x in self._directions]\n if which == 'inner':\n ... | [
"0.5541395",
"0.5489833",
"0.5383749",
"0.5357461",
"0.5332824",
"0.5327966",
"0.5252265",
"0.5224318",
"0.5198802",
"0.5197832",
"0.5191145",
"0.5147392",
"0.51444155",
"0.5139365",
"0.51293975",
"0.512021",
"0.5118103",
"0.51166993",
"0.511586",
"0.51152444",
"0.5114294",
... | 0.5469 | 2 |
Invalidates a complete line of section. All Edges connected by Vertex or a Wire. Can be a group of connected Edges, which do not form a standard Wire. | def SuppressEdgeSet(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_SuppressEdgeSet(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def repair_lines(self) -> None:\n if len(self.lines) == 0:\n self.create_lines()\n else:\n for line in self.lines:\n connection = line.connection\n start_component = self.components[connection.start_entity]\n end_component = self.comp... | [
"0.5473867",
"0.5382009",
"0.5166588",
"0.50958604",
"0.5034876",
"0.4909096",
"0.48637462",
"0.48626918",
"0.48165956",
"0.4806414",
"0.4795987",
"0.4752227",
"0.47336608",
"0.47117722",
"0.47117722",
"0.46954763",
"0.4666305",
"0.46530327",
"0.4650531",
"0.46436208",
"0.463... | 0.0 | -1 |
Modifies a line of section. should be a Group of Edges connected by Vertex. Can be a Wire. Can be a group of connected Edges that do not form a standard Wire. should be subgroupn of | def ChangeEdgeSet(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_ChangeEdgeSet(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, line):",
"def _write_line(\n self,\n shape: LineString,\n emission: float,\n info: EmissionInfo,\n source_group: int,\n ):\n # split the line string in single lines\n previous_coord = shape.coords[0]\n\n lines = [LineString([previous_coo... | [
"0.6074737",
"0.5583487",
"0.55022883",
"0.5488069",
"0.54185945",
"0.5411359",
"0.5380621",
"0.5375459",
"0.5367733",
"0.5354074",
"0.5351168",
"0.5344226",
"0.53420377",
"0.5332318",
"0.5319096",
"0.52651125",
"0.5257836",
"0.5232933",
"0.521354",
"0.521354",
"0.521354",
... | 0.0 | -1 |
NYI Make invalid a Vertex of section. The Vertex shoud be reconstructed from a point. | def SuppressSectionVertex(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_SuppressSectionVertex(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_vertex(self): \n return False",
"def _validateVertex(self, v):\n if v < 0 or v >= self._V:\n raise Exception(\"vertex {} is not between 0 and {}\".format(v, (self._V-1)))",
"def agregar_vertice(self, v):\n if not v in self.vertices.keys():\n self.vertices[v] = {}"... | [
"0.59776235",
"0.591074",
"0.56486434",
"0.562389",
"0.5610807",
"0.5493077",
"0.5428685",
"0.54126817",
"0.5402887",
"0.53902274",
"0.53565663",
"0.5349987",
"0.53480065",
"0.53480065",
"0.5347004",
"0.53421235",
"0.5341217",
"0.53389066",
"0.53311205",
"0.53235525",
"0.5322... | 0.57575715 | 2 |
SectionShape est soit un Vertex de section(NYI), soit une Edge de section. Propagation des shapes de section en partant de SectionShape. return un Compound de section. | def PropagateFromSection(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_PropagateFromSection(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_compound_stiffened_isection():\n uc = steel_sections.i_section(d=400, b=400, t_f=25, t_w=25, r=30, n_r=8)\n plate1 = (\n sections.rectangular_section(b=500, d=10).align_center(uc).align_to(uc, \"top\")\n )\n plate2 = (\n sections.rectangular_section(b=500, d=10)\n .align_c... | [
"0.57629484",
"0.57139105",
"0.55810535",
"0.53494585",
"0.5339676",
"0.53303343",
"0.5307979",
"0.52796847",
"0.5153275",
"0.5118574",
"0.50900316",
"0.50871176",
"0.50563085",
"0.5051936",
"0.5004477",
"0.5000257",
"0.5000257",
"0.49977192",
"0.49440226",
"0.49164158",
"0.4... | 0.0 | -1 |
Returns the list of the descendant shapes of the shape . | def Modified(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_Modified(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shapes(self):\n return [load_node(item) for item in self.get_attribute('shapes')]",
"def shapes(self):\n return self.container['shapes']",
"def XCAFDoc_ShapeTool_GetSubShapes(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetSubShapes(*args)",
"def type_shapes(self):\n return self._type_sh... | [
"0.73384356",
"0.7060281",
"0.6672472",
"0.662404",
"0.65109956",
"0.64910746",
"0.6474879",
"0.63651323",
"0.6347653",
"0.6231355",
"0.618104",
"0.618104",
"0.6144639",
"0.6126819",
"0.6074737",
"0.6026544",
"0.6010485",
"0.59775174",
"0.59462196",
"0.59245396",
"0.5912519",... | 0.0 | -1 |
NYI coherence of the internal Data Structure. | def Check(self, *args):
return _BRepAlgo.BRepAlgo_DSAccess_Check(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nits(self):",
"def __init__(self):\n # set of lists of nodal differences\n self.di = {}\n # self of upper boudns\n self.i = {}",
"def n_cs(self):\n pass",
"def COMBI(self):\n\n self.FB()\n self.LAT()\n self.ROT()",
"def CL(self):",
"def centrali... | [
"0.63208634",
"0.6317959",
"0.5812783",
"0.57412237",
"0.5726633",
"0.5572401",
"0.5542451",
"0.5523592",
"0.5466767",
"0.5457007",
"0.54446673",
"0.54446673",
"0.5427072",
"0.5396151",
"0.538998",
"0.5379538",
"0.5379538",
"0.5344213",
"0.5321583",
"0.5319438",
"0.53033674",... | 0.0 | -1 |
GetValue(BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean self) > Standard_Boolean | def GetValue(self):
return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_GetValue(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __bool__(self):\n return bool(self.get_value())",
"def __bool__(self):\n raise RuntimeError(\"Cannot evaluate CrypTensors to boolean values\")",
"def __bool__(self):\n raise RuntimeError(\"Cannot evaluate BinarySharedTensors to boolean values\")",
"def SetValue(self, *args):\n ... | [
"0.6632537",
"0.65650076",
"0.6527329",
"0.64361316",
"0.6419467",
"0.6400087",
"0.6373707",
"0.637024",
"0.6366055",
"0.63470244",
"0.6285019",
"0.62832886",
"0.62286204",
"0.62076914",
"0.62011594",
"0.6153996",
"0.6111137",
"0.6075253",
"0.60686135",
"0.60634077",
"0.60227... | 0.7905299 | 0 |
SetValue(BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean self, Standard_Boolean value) | def SetValue(self, *args):
return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_SetValue(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetValue(self):\n return _BRepAlgo.BRepAlgo_DataMapNodeOfDataMapOfShapeBoolean_GetValue(self)",
"def test_setitem_bool(self):\n random.seed(12345)\n nside_coverage = 32\n nside_map = 128\n pxnums = np.arange(0, 2000)\n pxvalues = np.ones(pxnums.size, dtype=bool)\n ... | [
"0.74341255",
"0.67324233",
"0.668604",
"0.63878953",
"0.63041806",
"0.63035727",
"0.62389475",
"0.62142",
"0.619102",
"0.61905813",
"0.6144637",
"0.60952264",
"0.6080537",
"0.6070081",
"0.60686034",
"0.59739524",
"0.59568506",
"0.59503865",
"0.59209836",
"0.5920271",
"0.5913... | 0.8526055 | 0 |
returns a list of wire non standard | def MakeBlock(self, *args):
return _BRepAlgo.BRepAlgo_EdgeConnector_MakeBlock(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def non_zero_components(self) :\n return list(self.parent().characters())",
"def test_show_all_wires_false(self):\n\n ops = [qml.PauliX(\"a\"), qml.PauliY(\"c\")]\n wire_order = [\"a\", \"b\", \"c\", \"d\"]\n\n wire_map = convert_wire_order(ops, wire_order, show_all_wires=False)\n ... | [
"0.6052848",
"0.5989274",
"0.5908896",
"0.59033775",
"0.58206475",
"0.5755208",
"0.5742159",
"0.5671657",
"0.56207526",
"0.5596734",
"0.5553147",
"0.5512436",
"0.5506076",
"0.5496295",
"0.54956263",
"0.54736805",
"0.54546434",
"0.5410878",
"0.5403076",
"0.5399878",
"0.5390138... | 0.0 | -1 |
NYI returns true if proceeded to MakeBlock() | def IsDone(self, *args):
return _BRepAlgo.BRepAlgo_EdgeConnector_IsDone(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_block(self, block):\n pass",
"def test_34(self):\n assert 'False' == Api.requestBlock('test-34')",
"def test_13(self):\n assert 'False' == Api.requestBlock('test-13')",
"def test_03(self):\n assert 'False' == Api.requestBlock('test-03')",
"def test_33(self):\n a... | [
"0.7251698",
"0.7021523",
"0.70073795",
"0.6960257",
"0.6946966",
"0.69168705",
"0.6913372",
"0.6911039",
"0.69050634",
"0.69032633",
"0.68848264",
"0.68548423",
"0.6844301",
"0.6840599",
"0.68374604",
"0.6833395",
"0.68182987",
"0.6814433",
"0.6800926",
"0.67845434",
"0.6770... | 0.0 | -1 |
NYI returns true if W is a Wire standard. W must belong to the list returned by MakeBlock. | def IsWire(self, *args):
return _BRepAlgo.BRepAlgo_EdgeConnector_IsWire(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isWatt(self):\n return _libsbml.Unit_isWatt(self)",
"def test_wireable_object(self):\n result = attributeAsLDIF(\"dn\", WireableObject())\n self.assertEqual(result, b\"dn: wire\\n\")",
"def wwn(self) -> SmartSsdWwn:\n return self._wwn",
"def CanBalanceWithWater(self):\n ... | [
"0.5597362",
"0.55873543",
"0.5548783",
"0.55013156",
"0.54576916",
"0.53746676",
"0.5354919",
"0.5347618",
"0.52789843",
"0.5266089",
"0.51734984",
"0.51449096",
"0.513721",
"0.50930214",
"0.50891733",
"0.5074785",
"0.5068847",
"0.50615853",
"0.5049344",
"0.50426847",
"0.504... | 0.6148025 | 0 |
the surface of will be the the surface of each new faces built. is used to update pcurves on edges if necessary. See Add(). | def Init(self, *args):
return _BRepAlgo.BRepAlgo_FaceRestrictor_Init(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, initial_surfaces):\n\n nsurf = len(initial_surfaces)\n nvert, nedge, ngroup, \\\n surf_ptrs, edge_ptrs, \\\n surf_group, edge_group \\\n = self._compute_topology(initial_surfaces)\n\n self._num = {\n 'surf': len(initial_surfaces),\... | [
"0.6337671",
"0.62322086",
"0.6138106",
"0.60926324",
"0.60289365",
"0.6019346",
"0.59726006",
"0.58784676",
"0.58642536",
"0.5785459",
"0.5726048",
"0.5694008",
"0.5689473",
"0.568601",
"0.56728286",
"0.56689453",
"0.56689453",
"0.56234235",
"0.56112266",
"0.5610793",
"0.560... | 0.0 | -1 |
Removes all the Wires | def Clear(self, *args):
return _BRepAlgo.BRepAlgo_FaceRestrictor_Clear(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_all_wells(self):\n self.wells = []",
"def remove_all(self):\n # Post a delete all notice to the manager\n self._remove_all()",
"def remove_all(self):\n # Post a delete all notice to the manager\n self._remove_all()",
"def deleteAll(self):\n for tlight in s... | [
"0.6894521",
"0.68552023",
"0.68552023",
"0.67969257",
"0.6740532",
"0.6709369",
"0.66663945",
"0.66131437",
"0.65450144",
"0.6478279",
"0.64725685",
"0.6429976",
"0.64166206",
"0.63693064",
"0.63480186",
"0.6325027",
"0.63126177",
"0.63076156",
"0.63052785",
"0.6294209",
"0.... | 0.0 | -1 |
Evaluate all the faces limited by the set of Wires. | def Perform(self, *args):
return _BRepAlgo.BRepAlgo_FaceRestrictor_Perform(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def WiresToFaces(self, *args):\n return _BRepAlgo.BRepAlgo_Loop_WiresToFaces(self, *args)",
"def findFaces(self):\n\t\trects = self.detectAll()\n\t\tif len(rects)==0:\n\t\t\trects = []\n\t\telse:\n\t\t\trects[:, 2:] += rects[:, :2]\n\t\tself.analyzeFrame(rects)",
"def get_filtered_faces(self, faces):\n ... | [
"0.6536707",
"0.5573983",
"0.54805946",
"0.54441386",
"0.54284626",
"0.53461635",
"0.5334527",
"0.53106356",
"0.530548",
"0.5246779",
"0.51937175",
"0.516544",
"0.516158",
"0.5131471",
"0.51164645",
"0.51044893",
"0.5103975",
"0.5064539",
"0.5041223",
"0.50377566",
"0.5032868... | 0.5327577 | 7 |
Links as image of . | def Bind(self, *args):
return _BRepAlgo.BRepAlgo_Image_Bind(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image(self, link, title, alt):\n if not link.startswith(('http://', 'https://')):\n source_dir = os.path.dirname(self.source_path)\n link = os.path.abspath(os.path.join(source_dir, link))\n return '<img src=\"%s\" title=\"%s\" alt=\"%s\" />' % (link, title, alt)",
"def cre... | [
"0.73077035",
"0.7028345",
"0.69006294",
"0.6725073",
"0.65269893",
"0.6412301",
"0.62754714",
"0.6242181",
"0.6159993",
"0.6141473",
"0.6111284",
"0.60934657",
"0.6057731",
"0.6022648",
"0.59900016",
"0.5979915",
"0.5953369",
"0.5953369",
"0.59277457",
"0.59261954",
"0.58778... | 0.0 | -1 |
Add to the image of . | def Add(self, *args):
return _BRepAlgo.BRepAlgo_Image_Add(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def imageAdd(img, num):\n return myimg.imageAdd(img.tolist(), num)",
"def boutton(self,img1,x,y):\r\n self.button.append(self.creat_image(img1,x,y))",
"def add_image(self, id, arr):\n\t\t## remove original image and add new one\n\t\tif self.cells[id].image:\n\t\t\tself.cells[id].v.removeItem(self.cel... | [
"0.71930027",
"0.7081216",
"0.6968564",
"0.6821934",
"0.6807955",
"0.6542881",
"0.6534922",
"0.6530329",
"0.648896",
"0.6469324",
"0.6455258",
"0.64521104",
"0.6431994",
"0.6423373",
"0.6371444",
"0.6369241",
"0.63576514",
"0.63544565",
"0.6354122",
"0.6349464",
"0.63464147",... | 0.69936126 | 2 |
Remove to set of images. | def Remove(self, *args):
return _BRepAlgo.BRepAlgo_Image_Remove(self, *args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_images(self):\n hardware_components.log_method(self, \"remove_images\")\n communication_object = self._get_control_software().connection\n communication_object.remove_all()",
"def remove(self, done=False, verbose=True):\n return _image.image_remove(self, done, verbose)",
... | [
"0.75192356",
"0.73298836",
"0.7317633",
"0.72680634",
"0.70345575",
"0.70180535",
"0.6974491",
"0.694794",
"0.6942505",
"0.6920568",
"0.6883206",
"0.6673236",
"0.6662014",
"0.66038215",
"0.66038215",
"0.66038215",
"0.65617543",
"0.6498469",
"0.6489149",
"0.64788216",
"0.6478... | 0.7645537 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.