def main(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() prefix = Name("/icear-server/result/example-data/2/deeplab") prefixNamespace = Namespace(prefix) prefixNamespace.setFace(face) enabled = [True] img = [None] def onGeneralizedObject(contentMetaInfo, obj): data = obj.toBytes() dump("Got generalized object, content-type", contentMetaInfo.getContentType(), ":", repr(data)) print(len(data)) enabled[0] = False img[0] = data goh = GeneralizedObjectHandler(onGeneralizedObject) prefixNamespace.setHandler(goh).objectNeeded() # Loop calling processEvents until a callback sets enabled[0] = False. while enabled[0]: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01) image = Image.open(io.BytesIO(img[0])) image.show()
def fetch_data(self, prefix, start_frame, end_frame): # type: (Name, int, int) -> None for frame_id in range(start_frame, end_frame + 1): name = Name(prefix).append(str(frame_id)) # Feed server with existing data if self.storage.exists(name): self.on_payload(name) # Fetching new data logging.info("Fetching: %s", name.toUri()) # TODO: Namespace will put everything into memory frame_namespace = Namespace(name) frame_namespace.setFace(self.face) frame_namespace.setHandler( GeneralizedObjectHandler(partial(self.on_generalized_obj, name))).objectNeeded()
def main(args): face = Face() prefix = Namespace(args['<prefix>']) prefix.setFace(face) enabled = [True] # This is called to print the content after it is re-assembled from segments. def onGeneralizedObject(contentMetaInfo, objectNamespace): if args['--verbose']: print(objectNamespace.getName()) print(str(objectNamespace.obj)) enabled[0] = False handler = GeneralizedObjectHandler(onGeneralizedObject) handler.setNComponentsAfterObjectNamespace(1) prefix.setHandler(handler).objectNeeded(True) # Loop calling processEvents until a callback sets enabled[0] = False. while enabled[0]: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01)
def main(index_f, weight_f, config_f, consumerMode, th, fetchPrefix, publishPrefix): # The default Face will connect using a Unix socket, or to "localhost". instance_prefix = fetchPrefix.split("/")[-1] sl = SegmentLabel(index_f, weight_f, instance_prefix, th) if config_f != "": sl.readConfig(config_f) face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) #stream_annConsumer_test = Namespace("/ndn/eb/stream/run/28/annotations") #stream_annConsumer_test.setFace(face) print(' > Will fetch from ' + str(fetchPrefix)) stream_annConsumer_show = Namespace(fetchPrefix) stream_annConsumer_show.setFace(face) log_f = open(str("seglab_log") + ".txt", "w") log_f.close() stream_segProducer = Namespace( Name(publishPrefix).append(Name(fetchPrefix)[-1]), keyChain) print(' > Will publish segments under ' + str(stream_segProducer.getName())) publish_handler = GeneralizedObjectStreamHandler() # publish_handler.setLatestPacketFreshnessPeriod(30) stream_segProducer.setHandler(publish_handler) stream_segProducer.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName), lambda prefixName, whatever: dump("Register success for prefix", prefixName)) def onNewAnnotation(sequenceNumber, contentMetaInfo, objectNamespace): ann = str(objectNamespace.obj) segment_result = [] jsonAnn = json.loads(ann) # print(jsonAnn["frameName"]) if not "error" in ann: jsonAnn = json.loads(ann) # print(jsonAnn["frameName"]) segment_result = sl.sceneDetection(jsonAnn) if segment_result and len(segment_result) > 0: print(segment_result) #dump("Got generalized object, sequenceNumber", sequenceNumber, # ", content-type", contentMetaInfo.getContentType(), ":", # str(jsonAnn["frameName"]), 'at', str(time.time())) publish_handler.addObject(Blob(json.dumps(segment_result)), "application/json") print(" > PUBLISHED SCENE " + str(publish_handler.getProducedSequenceNumber())) # # logging the result # if segment_result: with open(str("seglab_log") + ".txt", "w+") as f: f.write("PUBLISHED SCENE: %s" % str(publish_handler.getProducedSequenceNumber())) f.write("%s\r\n" % segment_result) pipelineSize = 0 #if consumerMode == 'default': # stream_annConsumer_default.setHandler( # GeneralizedObjectStreamHandler(pipelineSize, onNewAnnotation)).objectNeeded() stream_annConsumer_show.setHandler( GeneralizedObjectStreamHandler(pipelineSize, onNewAnnotation)).objectNeeded() #stream_annConsumer_test.setHandler( # GeneralizedObjectStreamHandler(pipelineSize, onNewAnnotation)).objectNeeded() while True: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01)
def main(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() # Create an in-memory key chain with default keys. # keyChain = KeyChain("pib-memory:", "tpm-memory:") # keyChain.importSafeBag(SafeBag # (Name("/testname/KEY/123"), # Blob(DEFAULT_RSA_PRIVATE_KEY_DER, False), # Blob(DEFAULT_RSA_PUBLIC_KEY_DER, False))) # face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) # Use default keys keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) publishIntervalMs = 1000.0 / 10 stream = Namespace("/ndn/eb/stream/run/28/annotations", keyChain) handler = GeneralizedObjectStreamHandler() stream.setHandler(handler) dump("Register prefix", stream.name) # Set the face and register to receive Interests. stream.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName)) # Loop, producing a new object every previousPublishMs milliseconds (and # also calling processEvents()). previousPublishMs = 0 # test with publishing existing jason file by json string input jsonString = "data/faith.json" curr = [] for line in open(jsonString, 'r'): curr.append(json.loads(line)) # curr_list = [] # for ann in curr: # temp = [] # frameName = ann['frameName'] # for k in ann["annotations"]: # # temp.append({"label": ''.join([i for i in k["label"] if not i.isdigit()]), "prob": k["prob"]}) # temp.append({"label": ''.join([i for i in k["label"] if not i.isdigit()]), "ytop": k["ytop"], # "ybottom": k["ybottom"], "xleft": k["xleft"], "xright": k["xright"], "prob": k["prob"], # "frameName": frameName}) # # curr_list.append(temp) total_cnt = len(curr) cnt = 0 while cnt < total_cnt: now = Common.getNowMilliseconds() if now >= previousPublishMs + publishIntervalMs: dump("Preparing data for sequence", handler.getProducedSequenceNumber() + 1) print(curr[cnt]) handler.addObject(Blob(json.dumps(curr[cnt])), "application/json") # handler.addObject( # Blob(json.dumps() + str(handler.getProducedSequenceNumber() + 1)), # "application/json") cnt += 1 if cnt == total_cnt: cnt = 0 previousPublishMs = now face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01)
def main(index_f, weight_f, consumerMode, k, query_interval, fetchPrefix, publishPrefix): # The default Face will connect using a Unix socket, or to "localhost". instance_prefix = fetchPrefix.split("/")[-1] pd = PlayDetect(index_f, weight_f, instance_prefix, k, query_interval) face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) # sceneConsumer = Namespace("/ndn/eb/stream/run/28/annotation") engine = str(Name(fetchPrefix)[-1]) sceneFetchPrefix = Name('/eb/seglab').append(engine) print(' > Will fetch annotations from ' + fetchPrefix) print(' > Will fetch scenes from ' + sceneFetchPrefix.toUri()) sceneConsumer = Namespace(sceneFetchPrefix) sceneConsumer.setFace(face) annotationsConsumer = Namespace(fetchPrefix) #if consumerMode == "test": # annotationsConsumer = Namespace("/ndn/eb/stream/run/28/annotations") #elif consumerMode == "default": # annotationsConsumer = Namespace('/eb/proto/test/ml_processing/yolo_default') annotationsConsumer.setFace(face) log_f = open(str("playdetect_log") + ".txt", "w") log_f.close() playdetectProducer = Namespace( Name(publishPrefix).append(engine), keyChain) print(' > Will publish playdetect data under ' + playdetectProducer.getName().toUri()) playdSegmentsHandler = GeneralizedObjectStreamHandler() # set freshness to 30 # playdSegmentsHandler.setLatestPacketFreshnessPeriod(30) playdetectProducer.setHandler(playdSegmentsHandler) playdetectProducer.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName), lambda prefixName, whatever: dump("Register success for prefix", prefixName)) def onNewScene(sequenceNumber, contentMetaInfo, objectNamespace): dump("Got scene (segment) :", str(objectNamespace.getName())) if str(objectNamespace.obj): # Store scene segment AND scene segment NAME into a database sceneSegmentName = objectNamespace.getName() sceneSegment = json.loads(str(objectNamespace.obj)) pd.storeToDatabase(sceneSegmentName, sceneSegment) def onNewAnnotation(sequenceNumber, contentMetaInfo, objectNamespace): # dump("Got new annotation") stringObj = str(objectNamespace.obj) # print(stringObj) now = Common.getNowMilliseconds() if stringObj and pd.itIsTimeToQueryDatabase(): # TBD # query interval configurable itIsTimeToQueryDatabase = True if itIsTimeToQueryDatabase: # TBD # run query against the databse, using recevied annotation # the result should be a list that contains scene segment names (see above) # FOR NOW: let's have startFrame end endFrame in the results # most likely -- parameterize query, i.e. give argument maxResultNum result = pd.pickTops(json.loads(stringObj), k) if result: playdSegmentsHandler.addObject(Blob(json.dumps(result)), "application/json") print( "PUBLISH SIMILAR SCENES: %s" % str(playdSegmentsHandler.getProducedSequenceNumber())) #logging the result with open(str("playdetect_log") + ".txt", "w+") as f: f.write("PUBLISHED SCENE: %s" % str( playdSegmentsHandler.getProducedSequenceNumber())) f.write("%s\r\n" % result) pipelineSize_segConsume = 3 sceneConsumer.setHandler( GeneralizedObjectStreamHandler(pipelineSize_segConsume, onNewScene)).objectNeeded() pipelineSize_annoConsume = 3 annotationsConsumer.setHandler( GeneralizedObjectStreamHandler(pipelineSize_annoConsume, onNewAnnotation)).objectNeeded() while True: face.processEvents() # We need to sleep for a few milliseconds so we don't use 100% of the CPU. time.sleep(0.01)