def compute_lane_from_candidates(line_candidates, img_shape): """ Compute lines that approximate the position of both road lanes. :param line_candidates: lines from hough transform :param img_shape: shape of image to which hough transform was applied :return: lines that approximate left and right lane position """ # separate candidate lines according to their slope pos_lines = [l for l in line_candidates if l.slope > 0] neg_lines = [l for l in line_candidates if l.slope < 0] # interpolate biases and slopes to compute equation of line that approximates left lane # median is employed to filter outliers neg_bias = np.median([l.bias for l in neg_lines]).astype(int) neg_slope = np.median([l.slope for l in neg_lines]) x1, y1 = 0, neg_bias x2, y2 = -np.int32(np.round(neg_bias / neg_slope)), 0 left_lane = Line(x1, y1, x2, y2) # interpolate biases and slopes to compute equation of line that approximates right lane # median is employed to filter outliers lane_right_bias = np.median([l.bias for l in pos_lines]).astype(int) lane_right_slope = np.median([l.slope for l in pos_lines]) x1, y1 = 0, lane_right_bias x2, y2 = np.int32( np.round( (img_shape[0] - lane_right_bias) / lane_right_slope)), img_shape[0] right_lane = Line(x1, y1, x2, y2) return left_lane, right_lane
def createLinevertical(): length = int(w.lenlineEntry.get()) function = w.functionEntry.get() line_type = w.linetypeEntry.get() rotate_type = w.rotatetypeEntry.get() degree_rote = w.degreeroteEntry.get() speed_max = w.speedmaxEntry.get() wait_time = w.waittimeEntry.get() f = Frame(w.mapFrame, height=length * LineVertical['height'], width=LineVertical['width'], bg="black") labelsLine.append( Line(f, length, function, line_type, rotate_type, degree_rote, speed_max, wait_time)) labelsLinevertical.append( Line(f, length, function, line_type, rotate_type, degree_rote, speed_max, wait_time)) f.pack_propagate(0) # don't shrink f.place(x=0, y=0) f.bind("<Button-1>", drag_start) f.bind("<B1-Motion>", drag_motion) f.bind("<ButtonRelease-1>", drop_motionVertical) f.bind("<Button-3>", popup) f.bind("<Enter>", information)
def render(SceneLoaded, Scale, Light, CamDist, Fdist): Scene = SceneLoaded Screen = [] projection_plane = Plane(Vector(0, CamDist, 0), Vector(1, 0, 0), Vector(0, 0, 1)) focalPoint = Vector(0, CamDist + Fdist, 0) #Sort by Y value all triangles (oclusion) Scene.sort(key=lambda tri: tri.centre.y) for triangle in Scene: triangle.shade(Light) triangle.v1 = triangle.v1 * Scale triangle.v2 = triangle.v2 * Scale triangle.v3 = triangle.v3 * Scale for triangle in Scene: try: V1 = Line(triangle.v1, focalPoint - triangle.v1).plane_intersect( projection_plane) # Three lines from the vertices to the plane V2 = Line(triangle.v2, focalPoint - triangle.v2).plane_intersect( projection_plane) # V3 = Line(triangle.v3, focalPoint - triangle.v3).plane_intersect( projection_plane) # Screen.append(Triangle(V1, V2, V3, color=triangle.color)) except: pass draw(Screen)
def intersect(self, polyline): interPoints = [] for j in range(len(polyline.points)-1): for i in range(len(self.points)-1): ls1 = Line(self.points[i].x, self.points[i].y, self.points[i+1].x, self.points[i+1].y) ls2 = Line(polyline.points[j].x, polyline.points[j].y, polyline.points[j+1].x, polyline.points[j+1].y) interp = ls1.intersect(ls2) if interp: interPoints.append(Point(int(interp.x), int(interp.y))) # if self.points[i].x > self.points[i+1].x: # minx = self.points[i+1].x # maxx = self.points[i].x # else: # minx = self.points[i].x # maxx = self.points[i+1].x # # if self.points[i].y > self.points[i+1].y: # miny = self.points[i+1].y # maxy = self.points[i].y # else: # miny = self.points[i].y # maxy = self.points[i+1].y # # if (polyline.points[j].x>=minx and polyline.points[j].x<=maxx) or (polyline.points[j].y>=miny and polyline.points[j].y<=maxy): # ls1 = LineSeg(self.points[i].x, self.points[i].y, self.points[i+1].x, self.points[i+1].y) # ls2 = LineSeg(polyline.points[j].x, polyline.points[j].y, polyline.points[j+1].x, polyline.points[j+1].y) # interp = ls1.intersect(ls2) # if interp: # interPoints.append(Point(int(interp.x), int(interp.y))) return interPoints
def draw(self): for x in range(self.gridSize, self.width, self.gridSize): Line(self.x1 + x, self.y1, self.x1 + x, self.y1 + self.height, [0, 1, 0], 0.0).draw() for y in range(self.gridSize, self.height, self.gridSize): Line(self.x1, self.y1 + y, self.x1 + self.width, self.y1 + y, [0, 1, 0], 0.0).draw()
def findKeyRanges(self, key, requireSymbol=None): """ Return the ndex of start and end lines matching the key given, if any. Used to find well-formed embedded blocks. As there may be more than one embedded, result is a list. Illformed embedded blocks will cause an early exit, warnings, status, {index1, index2, ...} = findKeyRanges... status == 0 --> ok; status != 0 --> result is error string instead of list. """ # state is 0 if outside keyblock and 1 if inside state=0 index = 0 result = [] for s in self.data: if Line.keyBegins(key,s) and (not requireSymbol or Line.symbolOf(s) == requireSymbol): if not state: result.append(index) state = 1 else: return (1, "begin encountered twice without end for key " + key + " at line " + str(index)) if Line.keyEnds(key,s) and (not requireSymbol or Line.symbolOf(s) == requireSymbol): if state: result.append(index) state = 0 else: return (1, "end encountered without begin for key " + key + " at line " + str(index)) index += 1 return( 0, result )
def order(plane1, plane2): '''returns True if plane1 should be in front of plane2''' front = True pointList1 = plane1.getPointPositionsOnScreen() pointList2 = plane2.getPointPositionsOnScreen() rawPointList = plane1.getPoints() pointList = [] planeCoordinates = plane1.getCoordinates() for i in range(0, len(rawPointList)): pointList.append([]) for j in range(0, 3): pointList[i].append(rawPointList[i].getPosition()[j] + planeCoordinates[j]) lineList = [] #creating lines between the points of plane2 for i in range(0, len(pointList2)): if i == len(pointList2) - 1: lineList.append(Line.Line(pointList2[i], pointList2[0])) else: lineList.append(Line.Line(pointList2[i], pointList2[i + 1])) #cycling through all of plane1 points, seeing if any are behind plane2 for i in range(0, len(pointList1)): count = 0 ray = Line.Line([0, pointList1[i][1]], pointList1[i]) vectorToEye = Line.Vector([center[0], 0, center[1]], [pointList[i][0] - center[0], pointList[i][1], pointList[i][2] - center[1]]) for j in range(0, len(lineList)): if Line.intersect(ray, lineList[j]): count += 1 if count % 2 == 1 and plane1.getDepth(i) > getIntersection(plane2, vectorToEye)[1]: front = False break return front
def main(): """ all the test of the class Line """ #Header print("*******************") print(" Line module test") print("*******************") #creation of 5 stations A = Station("A", [1., 0.]) B = Station("B", [2., 0.]) C = Station("C", [3., 0.]) D = Station("D", [4., 0.]) E = Station("E", [5., 0.]) Line_1 = Line([A, B, C, D, E], "underground", "Line_1") ############################################################################ # Declaration TEST # ############################################################################ assert Line_1.station == [A, B, C, D, E] print("self.station OK") assert Line_1.mode == "underground" print("self.mode OK") assert Line_1.name == "Line_1" print("self.name OK") ############################################################################ # Message end # ############################################################################ print("Line is OK") print("*******************") print(Line_1._repr_())
def __generateChildren(self): self.__population = self.__population[0:20] parents = list(self.__population) while len(parents) > 0: father = random.choice(parents) parents.remove(father) father = father.combinaison mother = random.choice(parents) parents.remove(mother) mother = mother.combinaison splitid = random.choice(range(self.nbcolor)) children1 = Line.Line() children2 = Line.Line() for id in range(self.nbcolor): if id < splitid: children1.addcolor(father.getcolor(id)) children2.addcolor(mother.getcolor(-id)) else: children1.addcolor(mother.getcolor(id)) children2.addcolor(father.getcolor(-id)) result1 = children1.compareto(self.__answer) essai1 = Essai(result1.getCorrect(), result1.getRigthColor(), 10*result1.getCorrect()+result1.getRigthColor(), children1) result2 = children2.compareto(self.__answer) essai2 = Essai(result2.getCorrect(), result2.getRigthColor(), 10*result2.getCorrect()+result2.getRigthColor(), children2) if self.__population.count(essai1) == 0: self.__population.append(essai1) if self.__population.count(essai2) == 0: self.__population.append(essai2) self.__population.sort(key=lambda x: x.score, reverse=True)
def __init__(self, filename): self.filename = filename self.file = [[]] self.longest = 0 try: f = open(filename) except FileNotFoundError: print("File cannot be opened.") sys.exit(1) in_function = False i = 1 for line in f: if line.startswith("import"): pass elif line.startswith("from"): pass elif line.strip().startswith("#"): pass elif line == '\n': if in_function: in_function = False self.file[-1].append(Line.Line(line, "#", i)) elif line.strip().startswith("def"): in_function = True self.file.append([Line.Line(line, "#", i)]) else: self.file[-1].append(Line.Line(line, "#", i)) i += 1 f.close()
def load_image(image_name, camimgs, cam, invmask, hgback, hgmax, hgqual, hgmind, hgminf, scale, sigma): try: camimgs += image_name # Set up Homography object homog = Velocity.Homography(camimgs, cam, invmask, calibFlag=True, band='L', equal=True) # Calculate homography hg = homog.calcHomographyPairs(hgback, hgmax, hgqual, hgmind, hgminf) homogmatrix = [item[0] for item in hg] new_terminus = Line(camimgs, cam, homogmatrix) current_imgset = new_terminus._imageSet imn = new_terminus.getImageNames() cameraMatrix = cam.getCamMatrixCV2() distortP = cam.getDistortCoeffsCV2() # Create New Snake image = current_imgset[0].getImageCorr(cameraMatrix, distortP) processed_image = setup_image(image, scale, sigma) return processed_image except: return [[False]]
def crossroadLine(): length = int(w.lenlineEntry.get()) function = w.functionEntry.get() line_type = w.linetypeEntry.get() rotate_type = w.rotatetypeEntry.get() degree_rote = w.degreeroteEntry.get() speed_max = w.speedmaxEntry.get() wait_time = w.waittimeEntry.get() f = Frame(w.mapFrame, height=grid_size * 2, width=grid_size * 2, bg="#d9d9d9") k = Frame(f, height=LineVertical['height'], width=LineVertical['width'], bg="black") j = Frame(f, height=LineHorizal['height'], width=LineHorizal['width'], bg="black") k.place(x=grid_size / 2 + 4, y=0) j.place(y=grid_size / 2 + 4, x=0) f.pack_propagate(0) # don't shrink f.place(x=0, y=0) labelsLine.append( Line(f, length, function, line_type, rotate_type, degree_rote, speed_max, wait_time)) labelsLinecross.append( Line(f, length, function, line_type, rotate_type, degree_rote, speed_max, wait_time)) f.bind("<Button-1>", drag_start) f.bind("<B1-Motion>", drag_motion) f.bind("<ButtonRelease-1>", drop_motion) f.bind("<Button-3>", popup) f.bind("<Enter>", information)
def BinOpNode_compile(self, node: BinOpNode): if (node.op == ':='): self.__codeGen(node.arg2) self.lines.append(Line('STORE', node.arg1.name)) else: self.__codeGen(node.arg1) self.__codeGen(node.arg2) self.lines.append(Line(op_cmd[node.op.value]))
def minute(self): if self.minutes < MATCH_GLOBALS["TOTAL_TURNS"]: self.home.update_skill_tactic() self.away.update_skill_tactic() self.minutes += 1 self.events = {"Home Possession": False, "Goal": False} home_tactic_inf = [(self.home.tactic[0] - self.away.tactic[2]) * MATCH_GLOBALS["TACTIC_INFLUENCE"], (self.home.tactic[1] - self.away.tactic[1]) * MATCH_GLOBALS["TACTIC_INFLUENCE"], (self.home.tactic[2] - self.away.tactic[0]) * MATCH_GLOBALS["TACTIC_INFLUENCE"]] home_concedes_rat = (self.home.skill[0] - self.away.skill[2]) / float(PLAYER_GLOBALS["MAX_SKILL"]) + home_tactic_inf[0] home_possession_rat = (self.home.skill[1] - self.away.skill[1]) / float(PLAYER_GLOBALS["MAX_SKILL"]) + home_tactic_inf[1] home_scores_rat = (self.home.skill[2] - self.away.skill[0]) / float(PLAYER_GLOBALS["MAX_SKILL"]) + home_tactic_inf[2] home_scores_prob = Line.Line(((-1, MATCH_GLOBALS["MIN_GOAL_PER_POSS"]), (1, MATCH_GLOBALS["MAX_GOAL_PER_POSS"]))).solve_for_y(home_scores_rat) home_possession_prob = Line.Line(((-1, 1 - MATCH_GLOBALS["MAX_POSSESSION"]),(1, MATCH_GLOBALS["MAX_POSSESSION"]))).solve_for_y(home_possession_rat) home_concedes_prob = Line.Line(((-1, MATCH_GLOBALS["MAX_GOAL_PER_POSS"]), (1, MATCH_GLOBALS["MIN_GOAL_PER_POSS"]))).solve_for_y(home_concedes_rat) poss_rand = random.uniform(0, 1) goal_rand = random.uniform(0, 1) #ANTI GOLEADAS: if self.result[0] >= 3 + self.result[1]: home_scores_prob = home_scores_prob * MATCH_GLOBALS["ANTI_GOLEADAS"] elif self.result[1] >= 3 + self.result[0]: home_concedes_prob = home_concedes_prob * MATCH_GLOBALS["ANTI_GOLEADAS"] #PROBABILIDADE HUMANA DE MARCAR NO FINAL min_norm = HelperMethods.normalize(self.minutes, 0, MATCH_GLOBALS["TOTAL_TURNS"]) if min_norm <= 0.2: if self.away.manager.human: home_scores_prob = home_scores_prob * MATCH_GLOBALS["GOAL_BEGINNING_END_MULTI"] if self.home.manager.human: home_concedes_prob = home_concedes_prob * MATCH_GLOBALS["GOAL_BEGINNING_END_MULTI"] if min_norm >= 0.8: if self.home.manager.human: home_scores_prob = home_scores_prob * MATCH_GLOBALS["GOAL_BEGINNING_END_MULTI"] if self.away.manager.human: home_concedes_prob = home_concedes_prob * MATCH_GLOBALS["GOAL_BEGINNING_END_MULTI"] if poss_rand <= home_possession_prob: self.events["Home Possession"] = True self.possession[0] += 1 if goal_rand <= home_scores_prob: self.result[0] += 1 self.events["Goal"] = True self.set_goalscorer(True) else: self.events["Home Possession"] = False self.possession[1] += 1 if goal_rand <= home_concedes_prob: self.result[1] += 1 self.events["Goal"] = True self.set_goalscorer(False) return True else: return False
def reset(self): self.left_fit = [] self.right_fit = [] ret,dist_coeffs,cam_matrix,rvecs,tvecs = calibrate_camera('camera_cal','calibration*.jpg',(9,6),(720,1280)) self.c_matrix = cam_matrix self.dist_coeffs = dist_coeffs self.left_line = Line() self.right_line = Line() self.search_by_histogram = True
def drawEdges(screen, edgeMatrix, color): for i in range(0, len(edgeMatrix[0]) - 1, 2): Line.drawLine( screen, [int(round(edgeMatrix[0][i])), int(round(edgeMatrix[1][i]))], [ int(round(edgeMatrix[0][i + 1])), int(round(edgeMatrix[1][i + 1])) ], color)
def __init__(self, cameraCalibration, root_folder, output_folder): self.root_folder = root_folder self.output_folder = output_folder self.cameraCalibration = cameraCalibration self.frame_count = 0 self.nframes_left_line = Line() self.nframes_right_line = Line() self.prev_left_fit = [] self.prev_right_fit = []
def pipeline(self): image = gradWarpPipeline.gradWarpPipeline()(self.image) # Histogram of the bottom half of the image histogram = np.sum(image[self.height // 2:, :], axis=0) # To find the peaks of the histogram. These peaks tell us where the lane edges are midpoint = np.int(histogram.shape[0] / 2) left_x = np.argmax(histogram[:midpoint]) right_x = np.argmax(histogram[midpoint:]) + midpoint left_lane_indices = [] right_lane_indices = [] # Get nonzero pixels in the image. The nonzero() return a tuple of x, y points # that have nonzero value nonzero = image.nonzero() nonzeroy = nonzero[0] nonzerox = nonzero[1] # Stepping through the windows one by one for window in range(self.num_windows): # Identify window boundaries in x and y (and right and left) win_y_low = image.shape[0] - (window + 1) * self.window_height win_y_high = image.shape[0] - window * self.window_height left_window = laneTracker.window(left_x, win_y_low, win_y_high) right_window = laneTracker.window(right_x, win_y_low, win_y_high) # A list consisting of window objects self.left_lane_windows.append(left_window) self.right_lane_windows.append(right_window) # Get nonzero pixel indices within the window left_nonzero_indices = left_window.find_pixel_indices(nonzero) right_nonzero_indices = right_window.find_pixel_indices(nonzero) # Append the window nonzero pixel indices to the lists left_lane_indices.append(left_nonzero_indices) right_lane_indices.append(right_nonzero_indices) left_x = left_window.xMid right_x = right_window.xMid # Concatenate all the windows nonzero pixel indices left_lane_indices = np.concatenate(left_lane_indices) right_lane_indices = np.concatenate(right_lane_indices) self.left_lane = Line.Line(nonzerox[left_lane_indices], nonzeroy[left_lane_indices], self.height, self.width) self.right_lane = Line.Line(nonzerox[right_lane_indices], nonzeroy[right_lane_indices], self.height, self.width)
def test_toHTML(): print("--- test_toHTML") filename = "../testData/monkeyAndThunder/AYA1_MonkeyandThunder.eaf" doc = etree.parse(filename) lineCount = len(doc.findall("TIER/ANNOTATION/ALIGNABLE_ANNOTATION")) line = Line(doc, 6) html = line.toHtml()
def dev(): filename = "../testData/LOKONO_IJAL_2.eaf" doc = etree.parse(filename) line0 = Line(doc, 0) tbl = line0.getTable() childIDs = tbl.loc[tbl["ANNOTATION_REF"] == "a23", "ANNOTATION_ID"].tolist() childText = tbl.loc[tbl["ANNOTATION_REF"] == "a23", "TEXT"].tolist() textLength = [len(t) for t in tbl["TEXT"].tolist()]
def callAll(): fl = [] with open('aist.csv', newline='') as f: reader = csv.reader(f, delimiter=',') for row in reader: fl.append(row) for row in fl: if (row[3] == 'manga') and checkConn(): Ms.runn(row[0], row[1], int(row[2])) if (row[3] == 'webtoon') and checkConn(): Line.runn(row[0], row[1], int(row[2]))
def __init__(self, mtx, dist): self.mtx = mtx self.dist = dist self.sobelKernel = 3 self.LeftLine = Line.Line() self.RightLine = Line.Line() self.confidence = 0 #calculate perspective transformation matrix and inverse self.M = cv2.getPerspectiveTransform(src, dst) self.Minv = cv2.getPerspectiveTransform(dst, src)
class Borde: line = Line(0, 0, 0, 0) especularidad = False def __init__(self, x1, y1, x2, y2, _especularidad): self.line = Line(x1, y1, x2, y2) self.especularidad = _especularidad def draw(self, surface): self.line.draw(surface)
def __init__(self): self.left_line = Line() self.right_line = Line() self.mtx = None self.dist = None self.sobel_kernel_size = 3 self.x_grad_threshold = (30, 150) self.hls_s_channel_threshold = (125, 255) self.perspective_M = None self.perspective_Minv = None # Reset the line detection after too many bad curvature transform self.reset_lane_detect = True
def test_getTable_from_LOKONO(): print("--- test_getTable_from_LOKONO") pd.set_option('display.width', 1000) filename = "../testData/LOKONO_IJAL_2.eaf" doc = etree.parse(filename) x3 = Line(doc, 3) tbl3 = x3.getTable() assert (x3.classifyTier(0) == "spokenText") assert (x3.classifyTier(1) == "nativeGlossOrFreeTranslation") assert (x3.classifyTier(2) == "nativeMorpheme")
def smoothen_over_time(lane_lines): """ Smooth the lane line inference over a window of frames and returns the average lines. """ avg_line_lt = np.zeros((len(lane_lines), 4)) avg_line_rt = np.zeros((len(lane_lines), 4)) for t in range(0, len(lane_lines)): avg_line_lt[t] += lane_lines[t][0].get_coords() avg_line_rt[t] += lane_lines[t][1].get_coords() return Line(*np.mean(avg_line_lt, axis=0)), Line( *np.mean(avg_line_rt, axis=0))
def test_recognizeDegenerateLine(): """ MonkeyAndThunder starts off with a few introductory lines in Spanish, with English translation. No words, no glosses, just a line with time slots, and one child """ print("--- test_recognizeDegenerateLine") filename = "../testData/monkeyAndThunder/AYA1_MonkeyandThunder.eaf" xmlDoc = etree.parse(filename) x0 = Line(xmlDoc, 0) assert(x0.getTierCount() == 2) classifier = LineClassifier(x0.getTable()) assert(classifier.run() == "DegenerateLine")
def test_LOKONO_allLinesRecognized(): print("--- test_LOKONO_allLinesRecognized") filename = "../testData/LOKONO_IJAL_2.eaf" xmlDoc = etree.parse(filename) lineCount = len(xmlDoc.findall("TIER/ANNOTATION/ALIGNABLE_ANNOTATION")) assert(lineCount == 344) for i in range(lineCount): x = Line(xmlDoc, i) classifier = LineClassifier(x.getTable()) classification = classifier.run() #print("%d: %s" % (i, classification)) assert(classification in ["WordsAsElementsLine"])
def test_MonkeyAndThunder_allLinesRecognized(): print("--- test_MonkeyAndThunder_allLinesRecognized") filename = "../testData/monkeyAndThunder/AYA1_MonkeyandThunder.eaf" xmlDoc = etree.parse(filename) lineCount = len(xmlDoc.findall("TIER/ANNOTATION/ALIGNABLE_ANNOTATION")) assert(lineCount == 41) for i in range(lineCount): x = Line(xmlDoc, i) classifier = LineClassifier(x.getTable()) classification = classifier.run() #print("%d: %s" % (i, classification)) assert(classification in ["DegenerateLine", "CanonicalLine"])
def test_recognizeCanonicalLine(): """ MonkeyAndThunder line 6 fits the canonical form: 1) a time line """ print("--- test_recognizeCanonicalLine") filename = "../testData/monkeyAndThunder/AYA1_MonkeyandThunder.eaf" xmlDoc = etree.parse(filename) x = Line(xmlDoc, 6) assert(x.getTierCount() == 4) classifier = LineClassifier(x.getTable()) assert(classifier.run() == "CanonicalLine")
def get_thread(self): """ get thread """ print(self.thread) print("=====body=====\n\n") seed = requests.get(self.thread) soup = BeautifulSoup(seed.content, "html.parser") # body = soup.find_all("span") body = soup.find_all("span", class_="cntd") print(body) # del body[0:4] # body.pop() # body.pop() # body.pop() print("-----after body -----\n\n") print(body) end = body[0].text end = end.replace(u"頃消えます", "") if len(end) > 5: end = end[(len(end) - 5):] gabage = '"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" %s' browser = webbrowser.get(gabage) browser.open(self.thread) noti = "'display notification " " with title \"Get Deresute Thread!!!\"'" os.system("osascript -e" + noti) Line(self.thread).notify_line() Output("g", end, "Get Thread!!!").call_result()
def test_recognizeWordsAsElementsLine(): """ LOKONO has the canonical spokenText tier, its translation, but each word in the spokenText is its own element, each with two children: morpheme and gloss """ print("--- test_recognizeWordsAsElementsLine") filename = "../testData/LOKONO_IJAL_2.eaf" xmlDoc = etree.parse(filename) x = Line(xmlDoc, 1) # print(x.getTable()) assert(x.getTierCount() == 20) classifier = LineClassifier(x.getTable()) assert(classifier.run() == "WordsAsElementsLine")
def updateAfterCount(self, opts, symbol): if not Line.matchedSymbolTail(symbol, opts.matchSyms): # here we assume the real symbol block comes last. works for uses in f90 return 0 if opts.language in ['cxx','python','f77','f90','java']: if (opts.linesAfter < 1): return 1 if opts.language in ['c']: if (opts.linesAfter < 2): return 2 return opts.linesAfter
def writeString(self, outFileName, verbose=False, rejectSave=True, rejectFileName="", rejectLines =[]): """return string representation of file for other's to output. outFileName is used to write rejects if specified or to issue error messages. @return (status, resultString) where if status is True, string will be valid and if false, the input source was apparently empty.""" fname = outFileName writeRejects = (rejectSave and rejectLines != None) if writeRejects: rname = fname + ".rej" if len(rejectFileName) > 0: rname = rejectFileName if self.nsplices < 1: if verbose: print "Nothing new to write to ", fname if self.num < 1: print "Nothing old to copy to ", fname print "Reading ", self.fin, " failed?" return (False, "") if verbose: if writeRejects: print "Writing rejects to ", rname print "Writing to string for ", fname if True: outlist = [] if writeRejects: try: rejfile = fileManager.open(rname,"w") except: err('splicer could not open rejects file for writing: ' + rname) for i in self.sections: isProtected = False for s in self.protectedSymbols: if i == self.getProtectedBlock(s): isProtected = True break if isProtected: continue lines = i.getLines() for p in lines: outlist.append( p.strip("\n") ) stringified = "\n".join(outlist) if writeRejects: date = Line.stringdate() print >> rejfile, "#FROM %s on %s" % (fname, date) for p in rejectLines: print >> rejfile , p.strip("\n") if verbose: if writeRejects: print " Finished ", rname print " Finished ", fname return (True, stringified) else: print "Error writing for "+ fname return (False, "")
def endChunk(self, key, blockStart, lineList, line, inputfilename, subsymbols=[], protected=False): """ finish recording a chunk and save data. string key, int blockStart, reference linelist """ symbol = "null" if key != "null": symbol = Line.symbolOf(line) if not protected and symbol in self.symbols: print "Warning: duplicate block for symbol ", symbol, " ignored at line ", str(blockStart) return elif protected and symbol in self.protectedSymbols: print "Warning: duplicate block for protected symbol ",symbol,"ignored at line ", str(blockStart) return if not protected: self.symbolIndex[symbol] = len(self.sections) self.symbols.append(symbol) else: self.protectedSymbolIndex[symbol] = len(self.sections) self.protectedSymbols.append(symbol) block = Block.Block() block.init(key, lineList, inputfilename, blockStart, subsymbols) self.sections.append(block)
def loadList(self, input, key, lines, warn=True, preserveProtected=False): """Load a list of lines as a source. Either this or load may be called once per SourceFile object. input is an identifier string, normally a filename, that might be useful in error messages. key is the splicing generic prefix tag (not per-sidl-symbol), and lines is the data.""" chunk = [] protectedChunk = [] # protected blocks need a separate chunk subsymbols = [] # Symbols designating substitution blocks nokey = "null" protectedKey = "bocca.protected" message = "Block still unended at end of file." self.num = 0 blockStart = 1 protectedBlockStart = 0 seek_begin = True # true while not in key'd block protected_block = False # true while in bocca.protected for line in lines: self.num += 1 if seek_begin: if Line.keyEnds(key, line): seek_begin = False message = "Block end found before beginning." break # outside a key block, start block, or append old. if Line.keyBegins(key, line): seek_begin = False self.endChunk( nokey, blockStart, chunk, line, input, protected=False) # save old if any blockStart = self.num self.beginChunk( chunk) # start new if any chunk.append(line) else: chunk.append(line) elif protected_block: # inside a protected block if Line.keyBegins(protectedKey, line) or Line.keyBegins(key, line): message = "Block begin found inside bocca.protected" break if Line.keyEnds(protectedKey, line): protectedChunk.append(line) chunk.append(line) self.endChunk( protectedKey, protectedBlockStart, protectedChunk, line, input, protected=True) subsymbols.append(Line.symbolOf(line)) protected_block = False; else: # Chunk contains content of subblocks; will be replaced/stubbed if necessary when # performing substitution protectedChunk.append(line) chunk.append(line) else: # inside a key block if Line.keyBegins(key,line): # warn unended block message = "Block begin found inside another." break if Line.keyEnds(key,line): seek_begin = True chunk.append(line) self.endChunk( key, blockStart, chunk, line, input, subsymbols, protected=False) # save key block subsymbols = [] blockStart = self.num+1 # start new block self.beginChunk( chunk) elif preserveProtected and Line.keyBegins(protectedKey, line): # Begin the protected block protectedBlockStart = self.num self.beginChunk(protectedChunk) protectedChunk.append(line) chunk.append(line) protected_block = True; else: chunk.append(line) # end else # end for if not seek_begin: print "In ", input, ":", message, " at line ", self.num if len(chunk) > 0: print "Current block started at line ", blockStart, ":" print "\t", chunk[0] return (1, message) if len(chunk) > 0: self.endChunk( nokey, blockStart, chunk, line, input) if len(self.symbolIndex) < 1 and warn: print "Warning: no blocks in ", input, " for key ", key return (0, "ok")
def writeBlock(self, before, fs, after, opts, append): """process a block with -B -A or --signature options. # return 0 if ok, nonzero otherwise # @param before the block ahead of this one or none if this is first. # @param fs the current block to print. # @param after the block after this one or none if this is last. # @param opts handling flags for lines. # @param append[0] an in-out integer array with one element. it tracks # how many blocks have been written in the single file case. """ lines = fs.getLines() pos = 0 symbol = Line.symbolOf(lines[pos]) if symbol == "null": return 1 if not Line.matchedSymbol(symbol, opts.matchSyms): return 0 # compute before lines pre = opts.linesBefore post = opts.linesAfter if (opts.signatures or opts.method) and before != None: post = self.updateAfterCount(opts, symbol) pre = before.computeSignature( symbol, opts.language, opts.sourceKey, opts.methodcomment) outlines = [] if pre > 0 and before != None: blines = before.getLines() blen = len(blines) while blen > 0 and pre > 0: outlines.append(blines[blen-1]) blen -= 1 pre -= 1 outlines.reverse() # copy main segment if opts.genLines: endtag="" if opts.method: endtag="/* This line not in actual source */" Line.addLineNumber(fs.start(), outlines, fs.source(), opts.language, endtag ) while pos < len(lines): outlines.append(lines[pos]) pos += 1 pos = 0 # compute after if post > 0 and after != None: alines = after.getLines() n = 0 while n < len(alines) and post > 0: outlines.append(alines[n]) n += 1 post -= 1 # write if len(outlines) < 1: return 1 flags = "w" if opts.singleFile: if append[0]: flags= "a" if len(opts.outputFile): fname = os.path.join(opts.outputDir, opts.outputFile) else: fname = os.path.join(opts.outputDir, opts.inputFile) fname += ".splice" else: fname = os.path.join(opts.outputDir, opts.blockFilePrefix) # print "Writing block for ", symbol, fname fname = fname + symbol + opts.blockFileSuffix # print "Writing block for ", symbol, fname try: outfile = open(fname,flags) if opts.singleFile and append[0] and len(opts.spliceHeader) > 0 and (not opts.method): w = 0 delta = len(opts.spliceHeader) while w < 72: outfile.write("%s" % opts.spliceHeader) w += delta outfile.write("\n") j = 0 while j < len(outlines): if opts.keepLines or opts.genLines or outlines[j][0:5] != "#line": print >> outfile, outlines[j].strip("\n") j+= 1 append[0] += 1 return 0 except: print "Error writing block for ", symbol return 1
def computeSignature(self, symbol, language, sourcekey, withcomment=False): """return attempted guess at the number of lines at the end of the block that constitute a babel impl method signature. The block being checked is the block before the block with the symbol code body. @param language one of python, java, c, cxx, f77, f90. @param sourceKey the key, not symbol, of interest. @param withcomment try to include the comment block if any. """ result = 0 lines = self.getLines() p = len(lines)-1 if p < 1: return 0 line = lines[p] if language == "python": while p >= 0 and line[0:4] != "####" and line[0:6] != " def " and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): # break on 2 blank lines if len(line) == 0: q = p -1 if q >= 0 and len(lines[q]) == 0: break # else keep line, move on to next result += 1 p -= 1 line = lines[p] result += 1 ; # include ' def ' line. # python comment blocks are embedded, not extra. if language == "java": while p > 0 and len(line) != 0 and \ line[0:6] != "import" and \ line[0:8] != " public" and \ line[0:4] != "////" and \ line[0:3] != "/**" and \ line[0:5] != " */" and \ line[0:8] != " static" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): result += 1 p -= 1 line = lines[p] result += 1 ; # include ' public' line. if withcomment: while p > 0 and len(line) != 0 and \ line[0:5] != " /**" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): result +=1 p -= 1 line = lines[p] if language == "c" or language == "cxx": while p > 0 and \ not Line.cppDirective(line) and \ line[0:15] != "// user defined" and \ line[0:15] != "// static class" and \ line[0:3] != "/**" and \ line[0:3] != " */" and \ line[0:5] != " */" and \ line[0:22] != "// special constructor" and \ line[0:22] != "// speical constructor" and \ line[0:1] != "}" and \ line[0:8] != "////////" and \ line[0:8] != "/**//**/" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): # two blank lines, or 1 if _tail symbol if len(line) == 0: mname = Line.methodName(symbol) if mname[0] == "_": break q = p-1 if q >= 0 and len(lines[q]) == 0: break # else keep line and move on result += 1 p -= 1 line = lines[p] if withcomment: while p > 0 and len(line) != 0 and \ line[0:5] != " /**" and \ line[0:2] != "/*" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): result +=1 p -= 1 line = lines[p] result += 1 ; # include '( )/*(*)' line. if language == "f77" or language == "f77_31": while p > 0 and \ line[0:19] != " subroutine " and \ line[0:4] != "CCCC" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): # break on 2 blank lines if len(line) == 0: q = p -1 if q >= 0 and len(lines[q]) == 0: break # else keep line and move on result += 1 p -= 1 line = lines[p] result += 1 ; # include subroutine if withcomment: while p > 0 and len(line) != 0 and \ line[0:15] != "C Method:" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): result +=1 p -= 1 line = lines[p] if language == "f90": while p > 0 and \ line[0:21] != "recursive subroutine " and \ line[0:5] != "!!!!" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): # break on 2 blank lines if len(line) == 0: q = p -1 if q >= 0 and len(lines[q]) == 0: break # else keep line and move on result += 1 p -= 1 line = lines[p] result += 1 ; # include subroutine if withcomment: while p > 0 and len(line) != 0 and \ line[0:9] != "! Method:" and \ not Line.keyEnds(sourcekey, line) and \ not Line.keyBegins(sourcekey,line): result +=1 p -= 1 line = lines[p] return result
def copy_line(self, line, x, y): new_line = Line(x, y) new_line.copy(line) self.model.add_line(new_line) self.drag_line(new_line, x, y)
def add_line(self,ion,idx): lnow = Line(ion,idx,self.model_name,self.galaxy,self.radii) lnow.total_probability() self.lines = np.append(self.lines,lnow) self.nlines = self.nlines + 1 return
def intersects(self, a,b,x,i): #if self.intersecting[a][b][x][i] == None: #self.intersecting[a][b][x][i]=Line.linesIntersect(self.cords[i],self.cords[x],self.cords[a],self.cords[b]) #return self.intersecting[a][b][x][i] return Line.linesIntersect(self.cords[i],self.cords[x],self.cords[a],self.cords[b])
if len(rejectLines) == 0: print "No rejection information to put into " + rejectFileName return False if dryrun: print "Dry run: Not writing to " + rejectFileName # For a dry run, don't do anything return True if verbose: print "Writing rejects to: " + rejectFileName outfile = None try: outfile = fileManager.open(rejectFileName,'w') except IOError, e: err('splicer could not open reject file %s for writing: %s' % (rejectFileName, str(e))) if len(originalFile) > 0: date = Line.stringdate() print >> outfile, "# Rejects FROM %s on %s" % (originalFile, date) for p in rejectLines: print >> outfile, p.strip("\n") if verbose: print "Finished writing rejects: " + rejectFileName return True # end writeRejects # private use def updateAfterCount(self, opts, symbol): if not Line.matchedSymbolTail(symbol, opts.matchSyms): # here we assume the real symbol block comes last. works for uses in f90 return 0 if opts.language in ['cxx','python','f77','f90','java']:
def isCommon(sym, commonSuppressions): """returns True if symbol matches commonSuppressions entry.""" method = Line.methodName(sym) if method in commonSuppressions: return True return False