def project_save1(tree): f = open('resar.xml', 'w') w = XMLWriter(f) html = w.start("data") w.element("empresa", '"' + tree.GetItemText(tree.GetRootItem(), 0) + '"') w.start('items') def printChildren(tree, treeItem): subItem = tree.GetFirstChild(treeItem)[0] name = tree.GetItemText(treeItem, 1) index = tree.GetItemText(treeItem, 0) try: parent = tree.GetItemText(tree.GetItemParent(treeItem), 1) except Exception: parent = 'root' if not subItem.IsOk(): w.element("item", nombre=name, indice=index, parent=parent) else: w.element("item", nombre=name, indice=index, parent='root') while subItem.IsOk(): printChildren(tree, subItem) subItem = tree.GetNextSibling(subItem) printChildren(tree, tree.GetRootItem()) w.end('items') w.close(html) f.close()
def persist(self): # Create an xml outs = cStringIO.StringIO() w = XMLWriter(outs) root = w.start("parsedlog", submitter=self.__submitter) #self.parser.asXml(w) self.loot.asXml(w) self.attendance.asXml(w) self.kills.asXml(w) w.close(root) # Stuff the xml into an http post headers = {"Content-type": "application/xml", "Accept": "text/plain"} #conn = httplib.HTTPConnection('beauty.quonic.net') #conn.request("POST", "/~erik/eqlogdb/submit.psp", outs.getvalue()) conn = httplib.HTTPConnection('beauty.quonic.net') conn.request("POST", "/~erik/eqlogdb/submit.psp", outs.getvalue()) response = conn.getresponse() if response.status == 200: self.loot.clear() self.attendance.clear() self.kills.clear() print response.read() conn.close()
def asXml(self): outs = cStringIO.StringIO() w = XMLWriter(outs) root = w.start("parsedlog", submitter=self.myname) self.fights.asXml(w) self.loot.asXml(w) self.attendance.asXml(w) self.kills.asXml(w) w.close(root) return str(outs.getvalue())
def main(): dimension = sys.argv[1] min_count = int(sys.argv[2]) engine_response = _json_post('%s/ws/query' % (ENGINE_URL), ENGINE_QUERY % {'dimension':dimension, 'min_count': min_count}) facets = engine_response['facets'][dimension]['childIds'] w = XMLWriter(sys.stdout) w.start("dimension", {'id': dimension, 'type': 'tree'}) for facet in facets: w.start('element', {'id': facet, '_count':str(engine_response['facets'][dimension]['data'][facet]['count'])}) w.end('element') w.end('dimension')
def tagcloudxml(request): xml = cStringIO.StringIO() w = XMLWriter(xml) tags = w.start("tags") for tag in tagcloud(): w.element("a", text=tag['tag'], attrs={'href': "http://www.bhamtechevents.org/browse_events/%s".format(tag['tag']), 'title': "%s topics".format(tag["count"]), 'rel': "tag", 'style': "font-size: %s".format(tag["size"])} ) w.end() w.close(tags) w.flush() return HttpResponse(xml.read())
def __init__(self, filename): BaseReporter.__init__(self) from cStringIO import StringIO self._sio = StringIO() from elementtree.SimpleXMLWriter import XMLWriter self.writer = XMLWriter(self._sio, "utf-8") self.filename = filename self.test_starts = {}
def main(): genre_objects = json.load(sys.stdin) registry = {} for obj in genre_objects: registry[obj['id']] = obj _validate_parent_child_relationships(registry) top_level = [obj for obj in genre_objects if len(obj['_parent_ids']) == 0] touched = set() paths = set() w = XMLWriter(sys.stdout) w.start("dimension", {'id':'genre', 'type':'tree'}) for obj in top_level: process_genre(w, obj, '', registry, touched, paths) w.end('dimension') _assert_all_visited(registry, touched)
def __init__(self): BaseReporter.__init__(self) from cStringIO import StringIO self._sio = StringIO() try: from elementtree.SimpleXMLWriter import XMLWriter except ImportError: from testoob.compatibility.SimpleXMLWriter import XMLWriter self.writer = XMLWriter(self._sio, "utf-8") self.test_starts = {}
def __call__(self,options): """Make .tex file for JOB""" ret,jlist,base,jobspecfile,order,jjspec = e4t.cli.select_jobs_from_jobfile(options.jobfile) def xmloutjobs(w,name,*args,**kw): (datareqs,processors,outputs) = e4t.cli.get_elem_configs(*args,**kw) cfg = e4t.cli._read_cfgfile(kw,'OUTPUT',name) _cfgs = (kw, cfg) if cfg: # pprint(cfg) cfg = udict(cfg) cfg.remove('^__.*') cfg = ldict([ (k.replace(' ','_'),v) for k,v in cfg.items()]) w.start("job",name=name,**ldict(cfg)) w.end("job") formats = options.options.xget('FORMAT','XML') from elementtree.SimpleXMLWriter import XMLWriter from StringIO import StringIO myxml = StringIO() w = XMLWriter(myxml) for part,jobs in jlist.items(): w.start('index', name=part ) for j,k in jobs: if k['kind'] in ('table','figure'): xmloutjobs(w,j,**k) w.end('index') ret = myxml.getvalue() xmls = dom.parseString(ret) # or xml.dom.minidom.parseString(xml_string) pp = Postprocessor(options=options) pp.output(False,xmls.toprettyxml(),'%s.xml'% part)
def main(sysargs): # settings args = EasyArgs(sysargs) cfg = EasyConfig(args.config, group="trainer") max_clicks = args.clicks or cfg.default_clicks window_name = "EagleEye Trainer" if "help" in args: usage() return 0 # grab marks from args if len(args) > 5: mark_in = args[4] mark_out = args[5] # test integer-ness try: int(mark_in) and int(mark_out) except: usage() return 1 elif len(args) > 3: ret, mark_in, mark_out = marker_tool(args[1], cfg.buffer_size, window_name) if not ret: print "Not processing - exiting." return 1 else: usage() return 1 ## clicking time! cropped_total = mark_out - mark_in print "video cropped at:", mark_in, "to", mark_out, "- ({} frames)".format(cropped_total) # clicking function def on_mouse(event, x, y, flags, params): # left click to mark if event == cv2.EVENT_LBUTTONDOWN: params['pos'] = (x, y) params['status'] = Status.record # right click to skip elif event == cv2.EVENT_RBUTTONDOWN: params['status'] = Status.skip # working variables params = {'status': Status.wait, 'pos': None} write_xml = False textstatus = "" dataQuality = 0 # 0 = good, >0 = bad/potentially bad # default right side (buttonside) if cfg.dual_mode: lens = Theta.Right trainer_points = {Theta.Right:{}, Theta.Left:{}} else: # both sides otherwise lens = Theta.Both trainer_points = {Theta.Both:{}} print "Minimum reflectors: {} | Ignore Negative xyz: {}".format(cfg.min_reflectors, cfg.check_negatives) # load video (again) in_vid = BuffSplitCap(args[1], crop=(0,0,0,0), rotate=BuffSplitCap.r0, buff_max=cfg.buffer_size) in_vid.restrict(mark_in, mark_out) # load csv (with appropriate ratio) in_csv = Memset(args[2]) in_csv.restrict() in_csv.setRatio(cropped_total) # test for marker data if len(in_csv.row()) < 10: print "This CSV contains no marker data!\nAborting." return 1 # status print "" print "Writing to:", args[3] print "Number of clicks at:", max_clicks print "" cv2.namedWindow(window_name) cv2.setMouseCallback(window_name, on_mouse, params) # grab clicks (Process 2) while in_vid.isOpened(): frame = in_vid.frame(side=lens) sys.stdout.write(in_vid.status() + " | Clicks {} / {}\r".format( len(trainer_points[lens]), max_clicks)) sys.stdout.flush() # prepare CSV data, click data tx = float(in_csv.row()[2]) ty = float(in_csv.row()[3]) tz = float(in_csv.row()[4]) rx = float(in_csv.row()[5]) ry = float(in_csv.row()[6]) rz = float(in_csv.row()[7]) # data quality status visible = int(in_csv.row()[9]) max_visible = int(in_csv.row()[8]) # status text to write textrow = "VICON - x: {:.4f} y: {:.4f} z: {:.4f} | rx: {:.4f} ry: {:.4f} rz: {:.4f}".format(tx, ty, tz, rx, ry, rz) textquality = "Visible: {} , Max Visible: {}".format(visible, max_visible) textstatus = "{} | {}/{} clicks".format(in_vid.status(), len(trainer_points[lens]), max_clicks) if lens == Theta.Left: textstatus += " - back side" elif lens == Theta.Right: textstatus += " - button side" #else none, no lens split # if data is qualified bad, reduce timeout by one if dataQuality > 0: dataQuality -= 1 if dataQuality == 0: dataStatus = " - Good data!!" dataStatus_colour = (0, 255, 0) # green else: dataStatus = " - Potentially bad data (wait {})".format(dataQuality) dataStatus_colour = (0, 255, 255) # yellow # Data tests # values must be above 0 and minimum reflectors if (cfg.check_negatives and (tx <= 0 or ty <= 0 or tz <= 0)) \ or visible < cfg.min_reflectors: dataStatus = " - Bad data!!" dataStatus_colour = (0, 0, 255) # red if cfg.ignore_baddata: dataStatus += " Ignored." dataQuality = 1 + cfg.quality_delay # draw the trainer dot (if applicable) if in_vid.at() in trainer_points[lens]: cv2.circle(frame, trainer_points[lens][in_vid.at()][0], 1, cfg.dot_colour, 2) cv2.circle(frame, trainer_points[lens][in_vid.at()][0], 15, cfg.dot_colour, 1) # draw text and show displayText(frame, textrow, top=True) displayText(frame, textquality) displayText(frame, textstatus) displayText(frame, dataStatus, endl=True, colour=dataStatus_colour) cv2.imshow(window_name, frame) # pause for input while params['status'] == Status.wait: key = cv2.waitKey(10) if key == Key.esc: params['status'] = Status.stop elif key == Key.enter: write_xml = True params['status'] = Status.stop elif key == Key.right: params['status'] = Status.skip elif key == Key.left: params['status'] = Status.back elif key == Key.backspace: params['status'] = Status.remove elif Key.char(key, '1') and cfg.dual_mode: params['status'] = Status.still lens = Theta.Left elif Key.char(key, '2') and cfg.dual_mode: params['status'] = Status.still lens = Theta.Right # catch exit status if params['status'] == Status.stop: print "\nprocess aborted!" break # write data if params['status'] == Status.record \ and len(trainer_points[lens]) != max_clicks: # TODO: does this disable recording clicks on the last frame if dataQuality == 0: trainer_points[lens][in_vid.at()] = (params['pos'], in_csv.row()[2:5], in_csv.row()[8:10]) params['status'] = Status.skip # or remove it elif params['status'] == Status.remove \ and in_vid.at() in trainer_points[lens]: del trainer_points[lens][in_vid.at()] print "\nremoved dot" # load next csv frame if params['status'] == Status.skip: if in_vid.next(): in_csv.next() else: write_xml = True print "\nend of video: {}/{}".format(in_vid.at() -1, mark_out -1) break # or load previous csv frame elif params['status'] == Status.back: if in_vid.back(): in_csv.back() # reset status params['status'] = Status.wait # clean up cv2.destroyAllWindows() ## write xml if write_xml: out_xml = XMLWriter(args[3]) out_xml.declaration() doc = out_xml.start("TrainingSet") # source information out_xml.start("video", mark_in=str(mark_in), mark_out=str(mark_out)) out_xml.data(os.path.basename(args[1])) out_xml.end() out_xml.element("csv", os.path.basename(args[2])) # training point data for lens in trainer_points: if lens == Theta.Right: out_xml.start("buttonside", points=str(len(trainer_points[lens]))) elif lens == Theta.Left: out_xml.start("backside", points=str(len(trainer_points[lens]))) else: # non dualmode out_xml.start("frames", points=str(len(trainer_points[lens]))) for i in trainer_points[lens]: pos, row, markers = trainer_points[lens][i] x, y = pos out_xml.start("frame", num=str(i)) out_xml.element("plane", x=str(x), y=str(y)) out_xml.element("vicon", x=str(row[0]), y=str(row[1]), z=str(row[2])) out_xml.element("visibility", visibleMax=str(markers[0]), visible=str(markers[1])) out_xml.end() out_xml.end() # frames # clean up out_xml.close(doc) print "Data was written." else: print "No data was written" print "\nDone." return 0
def createMetadata(item_ID): # get number of files images = os.listdir("/processing/"+item_ID+"/images") leaf_count = len(images) - 1 #accounts for /thumbs directory in there # get dimensions of cover and create cover image cover_path = Template('/processing/$item_ID/images/$item_ID').substitute(item_ID=item_ID) + "00001.jpg" im = Image.open(cover_path) width, height = im.size #returns tuple # generate cover thumbnail max_cover_width = 200 max_cover_height = 200 im.thumbnail((max_cover_width, max_cover_height), Image.ANTIALIAS) im.save(Template('/processing/$item_ID/$item_ID').substitute(item_ID=item_ID) + "_cover.jpg") print "Cover created for",item_ID # write to xml fhand = Template("/processing/$item_ID/$item_ID$suffix.xml").substitute(item_ID=item_ID, suffix="_metadata") w = XMLWriter(fhand, "utf-8") metadata = w.start("add") w.start("doc") w.element("field", Template("meta:$item_ID").substitute(item_ID=item_ID), name="id") w.element("field", Template("$item_ID").substitute(item_ID=item_ID), name="ItemID") #no underscore for solr index in "ItemID" #creats overall ratio - height / width w.element("field", str(height), name="pheight") w.element("field", str(width), name="pwidth") w.element("field", str(leaf_count), name="leafs") w.element("field", Template("$item_ID").substitute(item_ID=item_ID), name="item_title") #how will we generate this? ItemID for now... w.end() #closes <doc> w.close(metadata)
def __init__(self, filename, encoding="utf-8", x=XmlFormat): self.xmlfile = open(filename, "w") self.writer = XMLWriter(self.xmlfile, encoding) self.x = x self.doc = self.writer.start(self.x.HEAD)
class TaraxuDjangoWriter: def __init__(self, filename, encoding="utf-8", x=XmlFormat): self.xmlfile = open(filename, "w") self.writer = XMLWriter(self.xmlfile, encoding) self.x = x self.doc = self.writer.start(self.x.HEAD) def close(self): self.writer.close(self.doc) self.xmlfile.close() def start_task(self, task): # detect what type of task this is and remember it for encapsulated elements self.ttype = type(task).__name__ # start task and remember it so that we can close self.task = self.writer.start( self.x.TASK[self.ttype], id=task.corpus.custom_id, sourcelanguage=task.corpus.language.name ) def end_task(self, task): self.writer.close(self.task) def add_result(self, result): label = self.x.ITEM[self.ttype] # pythonic way to get to the particular type of the result try: result = result.rankingresult except: pass else: self.writer.start( label, id=result.item.source_sentence.custom_id.strip(), duration=str(result.duration), user=result.user.username, ) ranks = _RankingRank.objects.filter(result=result) self.writer.element(self.x.SOURCE, result.item.source_sentence.text) for rank in ranks: self.writer.element( self.x.TRANSLATION, rank.translation.text, system=rank.translation.document.translateddocument.translation_system.name, rank=str(rank.rank), ) self.writer.end() try: result = result.selectandposteditresult except: pass else: self.writer.start( label, id=result.item.source_sentence.custom_id.strip(), duration=str(result.duration), user=result.user.username, ) self.writer.element(self.x.SOURCE, result.item.source_sentence.text) try: translation = Translation.objects.get( source_sentence=result.item.source_sentence, document__translateddocument__translation_system=result.system, ) self.writer.element(self.x.TRANSLATION, translation.text) except: pass try: self.writer.element( self.x.POSTEDIT, result.sentence, system=result.system.name, fromscratch=str(result.fromScratch) ) except: self.writer.element(self.x.POSTEDIT, result.sentence, system="?", fromscratch=str(result.fromScratch)) self.writer.end()
def write_graph_xml(g, output_file='transit_graph.xml'): from elementtree.SimpleXMLWriter import XMLWriter #w = XMLWriter(sys.stdout)#output_file) w = XMLWriter(output_file) data = w.start("data") gx = w.start("gtfs") sx = w.start("stops") for s in g.stops: w.element("stop", id=str(s), name=str(g.stops[s].name), desc=str(g.stops[s].desc), lat=str(g.stops[s].lat), lng=str(g.stops[s].lng), url=str(g.stops[s].url), location_type=str(g.stops[s].location_type), parent_station=str(g.stops[s].parent_station) ) w.end() # stops w.start("stop_times") for st in g.stop_times: w.element("stop_time", id=str(st), stop_id=str(g.stop_times[st].stop_id), trip_id=str(g.stop_times[st].trip_id), stop_sequence=str(g.stop_times[st].stop_sequence), pickup_type=str(g.stop_times[st].pickup_type), dropoff_type=str(g.stop_times[st].dropoff_type), arrival_time_s=str(g.stop_times[st].arrival_time_s), departure_time_s=str(g.stop_times[st].departure_time_s), arrival_time=str(g.stop_times[st].arrival_time), departure_time=str(g.stop_times[st].departure_time) ) w.end() # stoptimes w.start("trips") for t in g.trips: w.element("trip", id=str(g.trips[t].id), route_id=str(g.trips[t].route_id), service_id=str(g.trips[t].service_id), trip_headsign=str(g.trips[t].trip_headsign), block_id=str(g.trips[t].block_id) ) w.end() # trips w.start("routes") for r in g.routes: w.element("route", id=str(g.routes[r].id), short_name=str(g.routes[r].short_name), long_name=str(g.routes[r].long_name), desc=str(g.routes[r].desc), type=str(g.routes[r].type) ) w.end() # routes w.end() # gtfs w.start("graph") # write nodes w.start("nodes") for n in g: w.element("node", id=str(n), stop_id=str(g[n].stop_id), stop_time_id=str(g[n].stop_time_id), arrival_time=str(g[n].arrival_time), departure_time=str(g[n].departure_time) ) w.end() # nodes # write arcs w.start("arcs") for n in g: w.start("node", id=str(n)) for arc in g[n]: w.element("arc", id=str(arc), weight=str(g[n][arc]), type=str(g[n][arc].type) ) w.end() # arc-node w.end() # arcs w.end() # graph w.close(data)
def writeXML(frames, path, args): out_xml = XMLWriter(path) out_xml.declaration() doc = out_xml.start("AnnotationEvaluation") # source information out_xml.element("video", mark_in=str(args[4]), mark_out=str(args[5])) out_xml.element("mapper", os.path.basename(args[1])) out_xml.element("annotation", os.path.basename(args[2])) out_xml.element("comparison", mean_err=str(calMean(frames))) # compared points out_xml.start("frames", total=str((args[5]-1) - (args[4]+1)+1), compared=str(len(frames))) for f in frames.keys(): out_xml.start("frame", num=str(f)) for key in frames[f]: out_xml.start("object", lens=Theta.name(frames[f][key]["lens"]), name=key, err=str(frames[f][key]["err"])) out_xml.element("annotatedCentroid", x=str(frames[f][key]["ann_x"]), y=str(frames[f][key]["ann_y"])) out_xml.element("mappedCentroid", x=str(frames[f][key]["map_x"]), y=str(frames[f][key]["map_y"])) out_xml.end() # object out_xml.end() # frames # clean up out_xml.close(doc)
#Write datastreams manifest to XML #example datastream chunk ''' <foxml:datastream CONTROL_GROUP="M" ID="ORIGINAL" STATE="A"> <foxml:datastreamVersion ID="ORIGINAL.0" MIMETYPE="image/jpeg" LABEL="Page#"> <foxml:contentLocation TYPE="URL"> <xsl:attribute name="REF">http://image.url/Sketches_and_scraps0000#.jpg</xsl:attribute> </foxml:contentLocation> </foxml:datastreamVersion> </foxml:datastream> ''' fhand = item_path + "/" + item_ID + "_FOXML.xml" w = XMLWriter(fhand, encoding="utf-8") w.declaration() #namespace dictionary namespace={} namespace['xmlns:foxml'] = "info:fedora/fedora-system:def/foxml#" namespace['xmlns:xsi']="http://www.w3.org/2001/XMLSchema-instance" manifest = w.start("ebook_item", namespace) # iterate through parent collections and create <collection> elements for each for collection_name in collections: w.element("collection", Template("$collection_name").substitute(collection_name=collection_name)) w.element("PID_prefix", Template("$PID_prefix").substitute(PID_prefix=PID_prefix)) w.element("book_title", Template("$item_ID").substitute(item_ID=item_ID))
else: return 'N/A' urls = get_news_urls() for u in urls: title = get_articles_title(u) article_content = get_articles_content(u) author = get_subnews_author(u) subnews = get_subnews_titles(u) subnews_content = get_subnews_content(u) date = get_articles_dates(u) iso = date.split(' ')[0] filename = 'nl_' + iso + '_' + title.replace(' ','_').lower() + '.xml' w = XMLWriter(filename, encoding='utf-8') html = w.start("broadcast") content = ' '.join(article_content) w.element("title", title) w.element("meta", name="author", value=author) w.element("meta", name="published", value=date) w.element("meta", name="corpus", value=filename) w.element("meta", name="source", value=u) w.element("meta", name="generator", value="https://github.com/caio1982/Nuntii-Latini") w.start("headline") w.element("title", title) w.element("content", content) w.end("headline")
def intWriter(path, buttonside=None, backside=None): try: status = "" print 'Generating Intrinsic Parameters to:', path, '...' with open(path, 'w') as int_xml: w = XMLWriter(int_xml) w.declaration() # Camera Intrinsic (Root) root = w.start('dual_intrinsic') num_sides = range(0, 2) #num_sides = range(0, 1) if buttonside is None or backside is None else range(0, 2) for i in num_sides: w.start("Buttonside" if i == 0 else "Backside") if i == 0 and buttonside[0].size > 0 and buttonside[1].size > 0: status += 'Buttonside' camMat = buttonside[0] distCoe = buttonside[1] calibError = buttonside[2] elif i == 1 and backside[0].size > 0 and backside[1].size > 0: if status == "": status += 'Backside' else: status += ' & Backside' camMat = backside[0] distCoe = backside[1] calibError = backside[2] else: w.end() continue # Camera Matrix w.element('CamMat', fx=str(camMat[0][0]), fy=str(camMat[1][1]), cx=str(camMat[0][2]), cy=str(camMat[1][2])) # Distortion Coefficients if (len(distCoe[0]) == 8): # 8 coefficients Rational Model, k4 k5 k6 enabled w.element('DistCoe', k1=str(distCoe[0][0]), k2=str(distCoe[0][1]), p1=str(distCoe[0][2]), p2=str(distCoe[0][3]), k3=str(distCoe[0][4]), k4=str(distCoe[0][5]), k5=str(distCoe[0][6]), k6=str(distCoe[0][7])) elif (len(distCoe[0]) == 12): # 12 coefficients Prism Model, c1, c2, c3, c4 enabled, new in OpenCV 3.0.0 w.element('DistCoe', k1=str(distCoe[0][0]), k2=str(distCoe[0][1]), p1=str(distCoe[0][2]), p2=str(distCoe[0][3]), k3=str(distCoe[0][4]), k4=str(distCoe[0][5]), k5=str(distCoe[0][6]), k6=str(distCoe[0][7]), c1=str(distCoe[0][8]), c2=str(distCoe[0][9]), c3=str(distCoe[0][10]),c4=str(distCoe[0][11])) else: w.element('DistCoe', k1=str(distCoe[0][0]), k2=str(distCoe[0][1]), p1=str(distCoe[0][2]), p2=str(distCoe[0][3]), k3=str(distCoe[0][4])) # Error values if len(calibError) > 0: w.element('Error', rms=str(calibError['rms']), total=str(calibError['tot_err']), arth=str(calibError['arth_err'])) w.end() #buttonside/backside w.close(root) print status, 'Intrinsic calibration has been generated successfully.' except Exception as e: # keep it bubbling up, to catch in main() raise Exception("{}: {}\n'ERROR: occurred in writing intrinsic XML file.'".format(type(e), e.message))
class MusicXMLWriter: song = None #Core.MusicData.Song writer = None #elementtree.SimpleXMLWriter.XMLWriter currentBeat = 0 divisions = 2 #Hmm currentMeasureIndex = -1 def __init__(self, song): self.song = song def write(self, fileName): file = open(fileName, "w") file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n") self.writer = XMLWriter(file) structure = self.writer.start("score-partwise", {"version": "3.0"}) self.writer.start("part-list") self.writer.start("score-part", {"id": "P1"}) self.writer.element("part-name", "Music") self.writer.end("score-part") self.writer.end("part-list") self.writer.start("part", {"id": "P1"}) for index, measure in enumerate(self.song.get_measures()): #raw_input() self.currentMeasureIndex = index self.currentBeat = 0 self.writer.start("measure", {"number": str(index + 1)}) self.writer.start("attributes") self.writer.element("divisions", str(self.divisions)) if (index == 0): self.writer.start("key") self.writer.element( "fifths", str(KeySignature.key_sig_values[self.song.key.value])) self.writer.element("mode", "major") self.writer.end("key") self.writer.start("time") self.writer.element("beats", str(measure.duration)) self.writer.element("beat-type", "4") self.writer.end("time") self.writer.element("staves", "2") self.writer.start("clef", {"number": "1"}) self.writer.element("sign", "G") self.writer.element("line", "2") self.writer.end("clef") self.writer.start("clef", {"number": "2"}) self.writer.element("sign", "F") self.writer.element("line", "4") self.writer.end("clef") self.writer.end("attributes") self.writeChordSymbol(measure.chords[0]) for note in measure._notes: if note.duration == 1.5 and self.currentBeat % 1 == 0.5: splitNotes = self.splitDottedHalf(note) #for x in splitNotes: #print str(x.pitch)+", "+str(x.duration) self.writeNoteXML(splitNotes[0], 1, "start") self.writeNoteXML(splitNotes[1], 1, "stop") else: if len(measure.harmonies) == 1: if self.currentBeat == measure.harmonies[0][0]: #print "harmony found: "+str(index+1) self.writeNoteXML([note, measure.harmonies[0][1]], 1) else: self.writeNoteXML(note, 1) else: self.writeNoteXML(note, 1) self.writer.start("backup") self.writer.element("duration", str(measure.duration * self.divisions)) self.writer.end("backup") ### OLD #c = measure.chords[0].get_random_voicing(measure.duration) #self.writeNoteXML(c,2) ### NEW newThing = make_chord_measure(measure.chords[0], measure.duration) for note_tuple in newThing: self.writeNoteXML(note_tuple, 2) #### self.writer.end("measure") self.writer.end("part") self.writer.end(structure) def writeNoteXML(self, note_s, staffNumber, tied=None): """ This can output XML for either a note or a chord. """ if isinstance(note_s, Note): note_s = [note_s] elif not isinstance(note_s, list): raise ValueError("WTF IS GOING ON") for i, n in enumerate(note_s): self.writer.start("note") self.writer.start("pitch") self.writer.element("step", n.pitch.letter[:1]) if (n.pitch.sharp_or_flat != 0): self.writer.element("alter", str(n.pitch.sharp_or_flat)) if n.pitch.letter == 'Cb': self.writer.element("octave", str(n.pitch.octave + 1)) else: self.writer.element("octave", str(n.pitch.octave)) self.writer.end("pitch") self.writer.element("duration", str(n.duration * self.divisions)) if (tied == "start" or n.tie == "start"): self.writer.start("notations") self.writer.element("tied", None, {"type": "start"}) self.writer.end("notations") elif (tied == "stop" or n.tie == "stop"): self.writer.start("notations") self.writer.element("tied", None, {"type": "stop"}) self.writer.end("notations") nextNote = self.song.get_measure_at_index( self.currentMeasureIndex).get_note_at_beat(self.currentBeat + n.duration) last_note_measure_change = int( math.floor((self.currentBeat - 0.25) / 4)) last_beat = (self.song.beats_per_measure + self.currentBeat - 0.25) % self.song.beats_per_measure lastNote = self.song.get_measure_at_index( last_note_measure_change).get_note_at_beat( last_beat) #I think this works... #The conditionals below are only self detecting for eighth notes, if parameter "beam" is None if n is None: brk = 0 """ if n.type == "eighth" and self.currentBeat % 1 == 0 and nextNote is not None and tied is None: if nextNote.type == "eighth": self.writer.element("beam","begin") elif n.type == "eighth" and self.currentBeat % 1 == 0.5 and lastNote.type == "eighth" and tied is None: #lastNote NULL??? self.writer.element("beam","end") """ self.writer.element("type", n.type) if (n.dot): self.writer.element("dot") self.writer.element("staff", str(staffNumber)) if (i > 0): self.writer.element("chord") self.writer.end("note") self.currentBeat += note_s[0].duration def writeChordSymbol(self, chord): self.writer.start("harmony") self.writer.start("root") root = self.song.key.scale[chord.step - 1] self.writer.element("root-step", root[0]) if (len(root) > 1): alter = 1 if root[1] == '#' else -1 self.writer.element("root-alter", str(alter)) self.writer.end("root") typeText = "" if chord.chord_type == "maj" else "m" self.writer.element("kind", "none", {"text": typeText}) self.writer.end("harmony") def splitDottedHalf(self, note): firstEighth = Note(Pitch(note.pitch.value, self.song.key), 0.5) secondQuarter = Note(Pitch(note.pitch.value, self.song.key), note.duration - 0.5) return [firstEighth, secondQuarter]
class OldHTMLReporter(BaseReporter): "Direct HTML reporting. Deprecated in favor of XSLT reporting" def __init__(self, filename): BaseReporter.__init__(self) from cStringIO import StringIO self._sio = StringIO() from elementtree.SimpleXMLWriter import XMLWriter self.writer = XMLWriter(self._sio, "utf-8") self.filename = filename self.test_starts = {} def start(self): BaseReporter.start(self) self._writeHeader() def _writeHeader(self): self.writer.start("html") self.writer.start("head") self.writer.element("title", "TESTOOB unit-test report") self.writer.end("head") self.writer.start("body") self.writer.start("table", border="1") self.writer.start("tr") self.writer.element("td", "Test Name") self.writer.element("td", "Time") self.writer.element("td", "Result") self.writer.element("td", "More info") self.writer.end("tr") def done(self): BaseReporter.done(self) self.writer.end("table") self.writer.element("p", "Total time: %.4f"%self.total_time) self.writer.end("body") self.writer.end("html") #assert len(self.test_starts) == 0 f = file(self.filename, "w") try: f.write(self._getHtml()) finally: f.close() def _getHtml(self): return self._sio.getvalue() def _encodeException(self, str): import re str = re.sub(r'File "(.+)",', r'<a href="file:///\1"> File "\1",</a>', str) return str.replace("\n","<br>") def startTest(self, test_info): BaseReporter.startTest(self, test_info) self.test_starts[test_info] = _time.time() def addError(self, test_info, err_info): BaseReporter.addError(self, test_info, err_info) self._add_unsuccessful_testcase("error", test_info, err_info) def addFailure(self, test_info, err_info): BaseReporter.addFailure(self, test_info, err_info) self._add_unsuccessful_testcase("failure", test_info, err_info) _SuccessTemplate='<tr><td>%s</td><td>%s</td><td><font color="green">success</font></td></tr>' def addSuccess(self, test_info): BaseReporter.addSuccess(self, test_info) self._sio.write(HTMLReporter._SuccessTemplate%(str(test_info), self._test_time(test_info))) _SkipTemplate='<tr><td>%s</td><td>%s</td><td><font color="blue">skipped</font></td><td>%s</td></tr>' def addSkip(self, test_info, err_info, isRegistered=True): BaseReporter.addSkip(self, test_info, err_info, isRegistered) self._sio.write(HTMLReporter._SkipTemplate%(str(test_info), self._test_time(test_info), str(err_info.exception_value()))) _FailTemplate=""" <tr><td>%s</td><td>%s</td><td><font color="red">%s</font></td> <td>%s</td></tr> """ def _add_unsuccessful_testcase(self, failure_type, test_info, err_info): self._sio.write(HTMLReporter._FailTemplate%(str(test_info), self._test_time(test_info), failure_type, self._encodeException(str(err_info)))) def _test_time(self, test_info): result = _time.time() - self.test_starts[test_info] del self.test_starts[test_info] return "%.4f" % result
def installerLog(package_details): ''' This module writes the required fields of a package to a temporary XML file which is then appended to the list of installedLog.xml. Right now - only name and version written to the installedLog.xml. ''' #package_details contain all the info about the package w = XMLWriter('tempholder.xml') xml = w.start("xml") w.start("Package") w.element("name", package_details[0]) w.element("version", package_details[1]) #w.element("architecture", package_details[2]) #w.element("short-description",package_details[3]) #w.element("installed",package_details[4]) #w.element("long-description",package_details[4]) #-----^basic logging data above^------ #w.element("section",package_details[5]) #w.element("installed-size",package_details[6]) #w.element("maintainer",package_details[7]) #w.element("original-maintainer",package_details[8]) #w.element("replaces",package_details[9]) #w.element("provides",package_details[10]) #w.element("pre-depends",package_details[11]) #w.element("depends",package_details[5]) #w.element("recomends",package_details[13]) #w.element("suggests",package_details[14]) #w.element("conflicts",package_details[15]) #w.element("filename",package_details[16]) #w.element("size",package_details[17]) #w.element("md5sum",package_details[18]) #w.element("homepage",package_details[19]) w.end() w.close(xml)
def main(sysargs): args = EasyArgs(sysargs) cfg = EasyConfig(args.config, group="mapper") if "help" in args: usage() return 0 if ["calib", "trainer", "output"] not in args: print "Must specify: -calib, -trainer, -output files" usage() return 1 if len(args) == 1: print "Not enough input CSV files" usage() return 1 if len(args) > 2 and args.map_trainer_mode: print "Too many CSV for trainer-mapping mode" usage() return 1 if "force_side" in args: side = Theta.resolve(args.force_side) if side == Theta.NonDual: print "Invalid force_side argument:", args.force_side usage() return 1 # set side overrides force_button = (side == Theta.Buttonside) force_back = not force_button else: force_button = force_back = False # working vars csvs = {} frame_num = 0 # open source CSV datasets for i in range(1, len(args)): print args[i] csvs[i] = Memset(args[i]) # reel all the files up to their first flash for i in csvs: csvs[i].restrict() if len(csvs[i].row()) < 10: print "CSV file:", args[i], "contains no marker data!\nAborting." return 1 # override csv name if args.map_trainer_mode: csvs[1]._name = cfg.trainer_target # open calib files try: buttonside = Mapper(args.calib, args.trainer, cfg, Theta.Buttonside) backside = Mapper(args.calib, args.trainer, cfg, Theta.Backside) except Exception as e: print e.message return 1 count = {'bts':0, 'bks':0, 'rej':0} # open destination XML with open(args.output, "w") as xmlfile: w = XMLWriter(xmlfile) w.declaration() xmlfile.write("<!DOCTYPE dataset SYSTEM \"http://storage.gwillz.com.au/eagleeye_v2.dtd\">") doc = w.start("dataset") # main loop while True: w.start("frameInformation") w.element("frame", number=str(frame_num)) for i in csvs: c = csvs[i] # determine marker quality try: max_reflectors = int(c.row()[8]) visible_reflectors = int(c.row()[9]) except: print "Error in reading quality at row {}".format(i) return 1 try: # read VICON data x = float(c.row()[2]) y = float(c.row()[3]) z = float(c.row()[4]) # TODO: is this necessary? We never use the object's rotation rx = float(c.row()[5]) ry = float(c.row()[6]) rz = float(c.row()[7]) except: print "Error occurred when converting VICON data at row {}".format(i) return 1 # run projection/mapping on VICON data if backside.isVisible((x,y,z)): points = backside.reprojpts((x, y, z)) side = 'backside' count['bks'] += 1 elif buttonside.isVisible((x,y,z)): points = buttonside.reprojpts((x, y, z)) points[0] += 960 # add 960 to x for rightside points side = 'buttonside' count['bts'] += 1 # TODO don't write non visible dots? else: points = [0.,0.] count['rej'] += 1 # TODO: Change DTD and double check with Manjung w.start("object", id=str(i), name=c.name(), lens=Theta.name(side)) w.element("boxinfo", height="99", width="99", x=str(points[0]-50), y=str(points[1]-50)) w.element("centroid", x=str(points[0]), y=str(points[1]), rx=str(rx), ry=str(ry), rz=str(rz)) w.element("visibility", visible=str(visible_reflectors), visibleMax=str(max_reflectors)) w.end() w.end() # test end of files eofs = 0 for i in csvs: if csvs[i].eof(): eofs += 1 if len(csvs) == eofs: print "end of all datasets" break # load next frame frame_num += 1 for i in csvs: csvs[i].next() w.close(doc) print "\nbuttonside", count['bts'] print "backside", count['bks'] print "rejected", count['rej'] return 0
def main(): fout_name = os.path.join(data_dir, "geo_coordinates.xml") fout = open(fout_name, "w") w = XMLWriter(fout) w.start("root") f_name = os.path.join(data_dir, "crime_geo_coordinates.txt") with open(f_name) as f: for line in f: lat = str(line.split(",")[0]) lng = str(line.split(",")[1]) w.start('dataelement') w.element('text', "") w.start("geodata") w.element("latitude", lat) w.element("longitude", lng) w.end("geodata") w.end("dataelement") w.end("root")
def write_keymap(keymap, filename): contexts = list(set([ c for c,a,k in keymap ])) actions = list(set([ a for c,a,k in keymap ])) w = XMLWriter(filename, "utf-8") doc = w.start("keymap") for context in contexts: w.start(context) w.start("keyboard") for c,a,k in keymap: if c==context: w.element("key", a, id=k) w.end() w.end() w.end() w.close(doc)
correction = tokens[2].split("||")[0] correction = ' '.join(nltk.word_tokenize(correction)) required = tokens[3] annotator = int(tokens[5]) annotators[s].add(annotator) if c_start == -1 and c_end == -1 and etype.lower() == "noop": # Noop --> empty set of edits (source is right) pass else: ref_annot[s].append([c_start, c_end, etype, correction, annotator]) f_in.close() # Create the output XML if not out_file: out_file = in_file + ".ieval.xml" f_out = XMLWriter(out_file, "UTF-8") f_out.declaration() f_out.start("scripts") f_out.start("script", id="1") # Assume only one script # Do clustering for s in xrange(len(ref_annot)): sys.stdout.write("\rSentence %s..." % (s+1)) sys.stdout.flush() clusters = [] # Sort edits from longest to shortest range ref_annot[s].sort(key=lambda x: x[0] - x[1]) for e in ref_annot[s]: # Go through each edit merge = False for c in clusters:
# convert to lat/lon if('X' in huisnr_fields): coordinates = projection.to_wgs84(huisnr_fields['X'], huisnr_fields['Y']) huisnr_fields['LAT'] = coordinates[0] huisnr_fields['LON'] = coordinates[1] else: huisnr_fields['LAT'] = '' huisnr_fields['LON'] = '' fields = [ 'COMMUNE_NL', 'COMMUNE_FR', 'COMMUNE_DE', 'PKANCODE', 'STREET_NL', 'STREET_FR', 'STREET_DE', 'HUISNR', 'LAT', 'LON'] output = open(args.output_csv, 'w') if(len(args.output_osm) > 0): w = XMLWriter(args.OUTFILE) w.start("osm", {"generator": "crab-tools" + str(__version__), "version": API_VERSION, "upload": "false"}) rec_str = '' for field in fields: rec_str += field + ',' output.write(rec_str[:-1] + "\n") for (huisnr_id, huisnr_fields) in huisnr_dic.items(): rec_str = '' for field in fields: value = '' if(field in huisnr_fields): rec_str += str(huisnr_fields[field]) + ',' else: rec_str += ',' output.write(rec_str[:-1] + "\n")
parser = argparse.ArgumentParser(description='Convert a ESRI Shapefile (POINT only) to .OSM') parser.add_argument('INFILE', help='The path to the input ESRI shapefile, will append .shp if omitted') parser.add_argument('OUTFILE', type=argparse.FileType('w'), default='out.osm', help='The path to the output OSM XML file') parser.add_argument('--quiet', action='store_true', default=False) args = parser.parse_args() osm_id = 0 dt = datetime.now() sf = shapefile.Reader(args.INFILE) f = sf.fields l = len(sf.shapes()) if not args.quiet: p = ProgressBar(l) w = XMLWriter(args.OUTFILE) w.start("osm", {"generator": "shape2osm " + str(__version__), "version": API_VERSION, "upload": "false"}) for shape in sf.shapeRecords(): osm_id -= 1 (x,y) = shape.shape.points[0] w.start("node", {"id": str(osm_id), "timestamp": dt.isoformat(), "version": "1", "visible": "true", "lon": str(x), "lat": str(y)}) for i in range(1,len(f)): w.element("tag", "", {"k": str(f[i][0]), "v": str(shape.record[i-1])}) w.end() if not args.quiet: p.update_time(l - (l + osm_id)) print "{0}\r".format(p), w.end() if not args.quiet: print "\nfinished."
#Get either every dimension or a single dimension val1s = parser.getProperties() val2s = parser.getProperties() # Values that we've found through previous executions of this grid-search printFound = True found = {} #found[('Release Year','Width (mm)')] = {'C':1000,'gamma':0.1} prefix = "gridoutput/" if not os.path.exists(prefix): os.makedirs(prefix) t = time.localtime(time.time()) logfn = os.path.join(prefix,"gridlog_"+str(t[0])+'.'+str(t[1])+'.'+str(t[2])+'_'+str(t[3])+'.'+str(t[4])+'.'+str(t[5])+".xml") with open(logfn,'w') as f: writer = XMLWriter(f) rootnode = writer.start("root") for val1 in val1s: for val2 in val2s: if val1 is not val2: start_time = time.time() print "Modelling",val1,"(independent) against",val2,"(dependent)." ed = None if (val1,val2) not in found.keys(): writer.start("model",ind=val1,dep=val2) ods = [] weights = [0.4,0.3,0.2] for w in weights: ods.append(ObservedDistribution(parser, val1, contours, val2, w, retrain=True)) #[0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100] #[0.01, 0.033, 0.1, 0.33, 1, 3, 10, 33, 100]
def _record_key(): dialog = KeyListener() dialog.doModal() key = dialog.key del dialog w = XMLWriter(twitter_file, "utf-8") doc = w.start("keymap") w.start("global") w.start("keyboard") w.element("key", "addon.opensettings(script.service.twitter)", id=str(key)) w.end() w.end() w.start("fullscreenvideo") w.start("keyboard") w.element("key", "addon.opensettings(script.service.twitter)", id=str(key)) w.end() w.end() w.end() w.close(doc)
def process(self, args): # Perform any base class processing. if not super(NfoProcess, self).process(args): return # If we don't have an output parameter, we figure it out from # the input filename. output = args.output if not output: output = os.path.splitext(args.tmdb)[0] + ".nfo" # Check to see if the file exists. if os.path.isfile(output) and not args.force: print "Cannot overwrite file: " + output return False # Open up the output file. xml = open(output, 'w') xml.write("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n") w = XMLWriter(xml, 'utf-8') tag = w.start("movie", ThumbGen="1") w.element("hasrighttoleftdirection", "false") w.element("title", self.movie['title']) w.element("originaltitle", self.movie['original_title']) w.element("filename", os.path.splitext(args.tmdb)[0] + ".mp4") w.element("tagline", self.movie['tagline']) w.element("releasedate", self.movie['release_date']) w.element("id", self.movie['imdb_id']) w.element("runtime", format(self.movie['runtime'])) w.element("plot", self.movie['overview']) # Write out the genres. w.start("genre") for genre in self.movie['genres']: w.element("name", genre['name']) w.end() # Media information w.start("mediainfo") w.start("Resolution") w.element("Flag", "Resolution_480p") w.end() w.element("resolution", "480P") w.end() # Finish up the document. w.end() w.close(tag) xml.close() # Report that we created the file. self.log.info("Created " + output)
class XMLReporter(BaseReporter): """Reports test results in XML, in a format resembling Ant's JUnit xml formatting output.""" def __init__(self): BaseReporter.__init__(self) from cStringIO import StringIO self._sio = StringIO() try: from elementtree.SimpleXMLWriter import XMLWriter except ImportError: from testoob.compatibility.SimpleXMLWriter import XMLWriter self.writer = XMLWriter(self._sio, "utf-8") self.test_starts = {} def start(self): BaseReporter.start(self) self.writer.start("results") self.writer.start("testsuites") def done(self): BaseReporter.done(self) self.writer.element("total_time", value="%.4f"%self.total_time) self.writer.end("testsuites") if self.cover_amount is not None and self.cover_amount == "xml": self._write_coverage(self.coverage) self.writer.end("results") def get_xml(self): return self._sio.getvalue() def startTest(self, test_info): BaseReporter.startTest(self, test_info) self.test_starts[test_info] = time.time() def addError(self, test_info, err_info): BaseReporter.addError(self, test_info, err_info) self._add_unsuccessful_testcase("error", test_info, err_info) def addFailure(self, test_info, err_info): BaseReporter.addFailure(self, test_info, err_info) self._add_unsuccessful_testcase("failure", test_info, err_info) def _add_testcase_element(self, test_info, result, add_elements = lambda:None): self._start_testcase_tag(test_info) self.writer.element("result", result) add_elements() self.writer.end("testcase") def addSuccess(self, test_info): BaseReporter.addSuccess(self, test_info) self._add_testcase_element(test_info, "success") def addSkip(self, test_info, err_info, isRegistered=True): BaseReporter.addSkip(self, test_info, err_info, isRegistered) def add_elements(): self.writer.element( "reason", err_info.exception_value() ) self._add_testcase_element(test_info, "skip") def _add_unsuccessful_testcase(self, failure_type, test_info, err_info): def add_elements(): "Additional elements specific for failures and errors" self.writer.element(failure_type, str(err_info), type=err_info.exception_type(), message=err_info.exception_value()) self._add_testcase_element(test_info, failure_type, add_elements) def _start_testcase_tag(self, test_info): self.writer.start("testcase", name=str(test_info), time=self._test_time(test_info)) def _test_time(self, test_info): result = time.time() - self.test_starts[test_info] return "%.4f" % result def _write_coverage(self, coverage): self.writer.start("coverage") for filename, stats in coverage.getstatistics().items(): # TODO: can probably extract loop body to a method self.writer.start("sourcefile", name=filename, statements=str(stats["lines"]), executed=str(stats["covered"]), percent=str(stats["percent"])) lines, covered = coverage.coverage[filename].values() missing = [line for line in covered if line not in lines] self.writer.data(str(missing)[1:-1].replace(" ", "")) self.writer.end("sourcefile") self.writer.end("coverage")
def write_graph_xml(graph, output_file='street_graph.xml'): w = XMLWriter(output_file) graph_e = w.start("graph") # write nodes w.start("nodes") for n in graph: w.element("node", id=str(n), lat=str(graph[n].lat), lon=str(graph[n].lng)) w.end() # write arcs w.start("arcs") for n in graph: w.start("node", id=str(n)) for arc in graph[n]: w.element("arc", ref=str(arc), weight=str(graph[n][arc])) #print arc, graph[n][arc] w.end() w.end() w.close(graph_e)
def main(sysargs): # settings args = EasyArgs(sysargs) cfg = EasyConfig(args.config, group="trainer") max_clicks = args.clicks or cfg.default_clicks window_name = "EagleEye Trainer" if "help" in args: usage() return 0 # grab video flash marks from args if len(args) > 5: mark_in = args[4] mark_out = args[5] # test integer-ness try: int(mark_in) and int(mark_out) except: usage() return 1 elif len(args) > 3: ret, mark_in, mark_out = marker_tool(args[1], cfg.buffer_size, window_name) if not ret: print "Not processing - exiting." return 1 else: usage() return 1 #How many frames between flashes? cropped_total = mark_out - mark_in print "video cropped at:", mark_in, "to", mark_out, "- ({} frames)".format(cropped_total) # clicking function def on_mouse(event, x, y, flags, params): # left click to mark if event == cv2.EVENT_LBUTTONDOWN: params['pos'] = (x, y) params['status'] = Status.record # right click to skip elif event == cv2.EVENT_RBUTTONDOWN: params['status'] = Status.skip # working variables params = {'status': Status.wait, 'pos': None} write_xml = False textstatus = "" dataQuality = 0 # 0 = good, >0 = bad/potentially bad # default right side (buttonside) if cfg.dual_mode: lens = Theta.Right trainer_points = {Theta.Right:{}, Theta.Left:{}} else: # both sides otherwise lens = Theta.Both trainer_points = {Theta.Both:{}} print "Minimum reflectors: {} | Ignore Negative xyz: {}".format(cfg.min_reflectors, cfg.check_negatives) # load video (again) in_vid = BuffSplitCap(args[1], crop=(0,0,0,0), rotate=BuffSplitCap.r0, buff_max=cfg.buffer_size) in_vid.restrict(mark_in, mark_out) #reels up to flash sync # load csv (with appropriate ratio) in_csv = Memset(args[2]) in_csv.restrict() #reels up to flash sync #since Vicon records at higher "framerate" than camera, in_csv.next() jumps forwards by <vicon frame count>/<cam frame count> rows. #TODO: what about variable (vicon) framerate? No average of all within timstamp range? in_csv.setRatio(cropped_total) # test for marker data if len(in_csv.row()) < 10: print "This CSV contains no marker data!\nAborting." return 1 # status print "" print "Writing to:", args[3] print "Number of clicks at:", max_clicks print "" cv2.namedWindow(window_name) cv2.setMouseCallback(window_name, on_mouse, params) # grab clicks (Process 2) while in_vid.isOpened(): frame = in_vid.frame(side=lens) sys.stdout.write(in_vid.status() + " | Clicks {} / {}\r".format( len(trainer_points[lens]), max_clicks)) sys.stdout.flush() # prepare CSV data, click data tx = float(in_csv.row()[2]) ty = float(in_csv.row()[3]) tz = float(in_csv.row()[4]) rx = float(in_csv.row()[5]) ry = float(in_csv.row()[6]) rz = float(in_csv.row()[7]) # data quality status visible = int(in_csv.row()[9]) max_visible = int(in_csv.row()[8]) # status text to write textrow = "VICON - x: {:.4f} y: {:.4f} z: {:.4f} | rx: {:.4f} ry: {:.4f} rz: {:.4f}".format(tx, ty, tz, rx, ry, rz) textquality = "Visible: {} , Max Visible: {}".format(visible, max_visible) textstatus = "{} | {}/{} clicks".format(in_vid.status(), len(trainer_points[lens]), max_clicks) if lens == Theta.Left: textstatus += " - back side" elif lens == Theta.Right: textstatus += " - button side" #else none, no lens split # if data is qualified bad, reduce timeout by one if dataQuality > 0: dataQuality -= 1 if dataQuality == 0: dataStatus = " - Good data!!" dataStatus_colour = (0, 255, 0) # green else: dataStatus = " - Potentially bad data (wait {})".format(dataQuality) dataStatus_colour = (0, 255, 255) # yellow # Data tests # values must be above 0 and minimum reflectors if (cfg.check_negatives and (tx <= 0 or ty <= 0 or tz <= 0)) \ or visible < cfg.min_reflectors: dataStatus = " - Bad data!!" dataStatus_colour = (0, 0, 255) # red if cfg.ignore_baddata: dataStatus += " Ignored." dataQuality = 1 + cfg.quality_delay #default quality_delay=2 # draw the trainer dot (if applicable) if in_vid.at() in trainer_points[lens]: cv2.circle(frame, trainer_points[lens][in_vid.at()][0], 1, cfg.dot_colour, 2) cv2.circle(frame, trainer_points[lens][in_vid.at()][0], 15, cfg.dot_colour, 1) # draw text and show displayText(frame, textrow, top=True) displayText(frame, textquality) displayText(frame, textstatus) displayText(frame, dataStatus, endl=True, colour=dataStatus_colour) cv2.imshow(window_name, frame) # pause for input while params['status'] == Status.wait: key = cv2.waitKey(10) if key == Key.esc: #don't write anything, exit params['status'] = Status.stop elif key == Key.enter: #write groundtruth correspondences xml, exit write_xml = True params['status'] = Status.stop elif key == Key.right: #next frame params['status'] = Status.skip elif key == Key.left: #previous frame params['status'] = Status.back elif key == Key.backspace: #remove click point in current frame params['status'] = Status.remove elif Key.char(key, '1') and cfg.dual_mode: params['status'] = Status.still #swap lens lens = Theta.Left elif Key.char(key, '2') and cfg.dual_mode: params['status'] = Status.still #swap lens lens = Theta.Right # catch exit status if params['status'] == Status.stop: print "\nprocess aborted!" break # write data if params['status'] == Status.record \ and len(trainer_points[lens]) != max_clicks: # TODO: does this disable recording clicks on the last frame if dataQuality == 0: trainer_points[lens][in_vid.at()] = (params['pos'], in_csv.row()[2:5], in_csv.row()[8:10]) params['status'] = Status.skip # or remove it elif params['status'] == Status.remove \ and in_vid.at() in trainer_points[lens]: del trainer_points[lens][in_vid.at()] print "\nremoved dot" # load next csv frame if params['status'] == Status.skip: if in_vid.next(): in_csv.next() else: write_xml = True print "\nend of video: {}/{}".format(in_vid.at() -1, mark_out -1) break # or load previous csv frame elif params['status'] == Status.back: if in_vid.back(): in_csv.back() # reset status params['status'] = Status.wait # clean up cv2.destroyAllWindows() ## write xml if write_xml: out_xml = XMLWriter(args[3]) out_xml.declaration() doc = out_xml.start("TrainingSet") # source information out_xml.start("video", mark_in=str(mark_in), mark_out=str(mark_out)) out_xml.data(os.path.basename(args[1])) out_xml.end() out_xml.element("csv", os.path.basename(args[2])) # training point data for lens in trainer_points: if lens == Theta.Right: out_xml.start("buttonside", points=str(len(trainer_points[lens]))) elif lens == Theta.Left: out_xml.start("backside", points=str(len(trainer_points[lens]))) else: # non dualmode out_xml.start("frames", points=str(len(trainer_points[lens]))) for i in trainer_points[lens]: pos, row, markers = trainer_points[lens][i] x, y = pos out_xml.start("frame", num=str(i)) out_xml.element("plane", x=str(x), y=str(y)) out_xml.element("vicon", x=str(row[0]), y=str(row[1]), z=str(row[2])) out_xml.element("visibility", visibleMax=str(markers[0]), visible=str(markers[1])) out_xml.end() out_xml.end() # frames # clean up out_xml.close(doc) print "Data was written." else: print "No data was written" print "\nDone." return 0