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 main(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() # Use the system default key chain and certificate name to sign. keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) objectPrefix = Namespace("/ndn/eb/run/28/description", keyChain) dump("Register prefix", objectPrefix.name) # Set the face and register to receive Interests. objectPrefix.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName)) dump("Preparing data for", objectPrefix.name) GeneralizedObjectHandler().setObject(objectPrefix, Blob("EB run #28. Ham and oats"), "text/html") 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(): # Silence the warning from Interest wire encode. Interest.setDefaultCanBePrefix(True) # The default Face will connect using a Unix socket, or to "localhost". face = Face() memberName = Name("/first/user") memberKeyName = Name(memberName).append(Name("/KEY/%0C%87%EB%E6U%27B%D6")) memberKeyChain = KeyChain("pib-memory:", "tpm-memory:") memberKeyChain.importSafeBag(SafeBag (memberKeyName, Blob(MEMBER_PRIVATE_KEY, False), Blob(MEMBER_PUBLIC_KEY, False))) # TODO: Use a real Validator. decryptor = DecryptorV2( memberKeyChain.getPib().getIdentity(memberName).getDefaultKey(), ValidatorNull(), memberKeyChain, face) contentPrefix = Name("/testname/content") contentNamespace = Namespace(contentPrefix) contentNamespace.setFace(face) contentNamespace.setDecryptor(decryptor) enabled = [True] def onSegmentedObject(objectNamespace): dump("Got segmented content", objectNamespace.obj.toRawStr()) enabled[0] = False SegmentedObjectHandler(contentNamespace, onSegmentedObject).objectNeeded() 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(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() # Use the system default key chain and certificate name to sign. keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) publishIntervalMs = 1000.0 stream = Namespace("/ndn/eb/stream/run/28/annotations", keyChain) handler = GeneralizedObjectStreamHandler(stream) 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 publishIntervalMs milliseconds (and # also calling processEvents()). previousPublishMs = 0 while True: now = Common.getNowMilliseconds() if now >= previousPublishMs + publishIntervalMs: dump("Preparing data for sequence", handler.getProducedSequenceNumber() + 1) handler.addObject( Blob("Payload " + str(handler.getProducedSequenceNumber() + 1)), "application/json") 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(): # Silence the warning from Interest wire encode. Interest.setDefaultCanBePrefix(True) if sys.version_info[0] <= 2: userName = raw_input("Enter your user name (e.g. \"a\" or \"b\"): ") else: userName = input("Enter your user name (e.g. \"a\" or \"b\"): ") if userName == "": dump("You must enter a user name") return # The default Face will connect using a Unix socket, or to "localhost". face = Face() # Use the system default key chain and certificate name to sign. keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) applicationPrefix = Namespace(Name("/test/app"), keyChain) applicationPrefix.setFace(face, lambda prefix: dump("Register failed for prefix", prefix)) applicationPrefix.enableSync() userPrefix = applicationPrefix[Name.Component(userName)] def onStateChanged(nameSpace, changedNamespace, state, callbackId): if (state == NamespaceState.NAME_EXISTS and not userPrefix.name.isPrefixOf(changedNamespace.name)): dump("Received", changedNamespace.name.toUri()) applicationPrefix.addOnStateChanged(onStateChanged) publishIntervalMs = 1000.0 component = Name("/%00").get(0) # Loop, producing a new name every publishIntervalMs milliseconds (and also # calling processEvents()). previousPublishMs = 0.0 while True: now = Common.getNowMilliseconds() if now >= previousPublishMs + publishIntervalMs: # If userName is "a", this makes /test/app/a/%00, /test/app/a/%01, etc. newNamespace = userPrefix[component] dump("Publish", newNamespace.name.toUri()) component = component.getSuccessor() 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(): # 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() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) streamNamespace = Namespace(Name("/example-data"), keyChain) dump("Register prefix", streamNamespace.name) # Set the face and register to receive Interests. streamNamespace.setFace(face, lambda prefixName: dump("Register failed for prefix", prefixName)) # /example-data/2~3 for sequenceNumber in range(2, 4): sequenceNamespace = streamNamespace[str(sequenceNumber)] dump("Preparing data for", sequenceNamespace.name) # Prepare the _meta packet. contentMetaInfo = ContentMetaInfo() contentMetaInfo.setContentType("jpeg") contentMetaInfo.setTimestamp(Common.getNowMilliseconds()) contentMetaInfo.setHasSegments(True) sequenceNamespace["_meta"].serializeObject(contentMetaInfo.wireEncode()) # Read jpeg file img_path = os.path.join(root_path, "sample420x236.jpg") with open(img_path, "rb") as f: data = f.read() segment_size = face.getMaxNdnPacketSize() // 2 segment_cnt = (len(data) + segment_size - 1) // segment_size # We know the content has two segments. metaInfo = MetaInfo() metaInfo.setFinalBlockId(Name().appendSegment(segment_cnt - 1)[0]) sequenceNamespace.setNewDataMetaInfo(metaInfo) for i in range(segment_cnt): start_offset = i * segment_size end_offset = start_offset + segment_size sequenceNamespace[Name.Component.fromSegment(i)].serializeObject( Blob(bytearray(data[start_offset:end_offset]))) 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 process(): # while True: # Set timeout to 0 for an immediate check. isReady, _, _ = select.select([sys.stdin], [], [], 0) if len(isReady) != 0: input = promptAndInput("") if input == "exit": stopGui() # We will send the leave message below. # break # before producer has namespace.publish call, we manually call onNameAdded as a hack to publish namesync.onNameAdded(None, Namespace(Name(input)), 0, True) face.processEvents() if root: root.after(100, process)
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(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() # Use the system default key chain and certificate name to sign. keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) prefix = Namespace("/ndn/test/status", keyChain) dump("Register prefix", prefix.name) # Set the face and register to receive Interests. prefix.setFace(face, lambda prefixName: dump("Register failed for prefix", prefixName)) handler = GeneralizedObjectHandler() # Each generalized object will have a 1000 millisecond freshness period. metaInfo = MetaInfo() metaInfo.setFreshnessPeriod(1000.0) # This is called when the library receives an Interest which is not # satisfied by Data already in the Namespace tree. def onObjectNeeded(namespace, neededNamespace, callbackId): if not (neededNamespace is prefix): # This is not the expected Namespace. return False # Make a version from the current time. versionNamespace = prefix[ Name.Component.fromVersion(Common.getNowMilliseconds())] # The metaInfo has the freshness period. versionNamespace.setNewDataMetaInfo(metaInfo) dump("Producing the generalized object for", versionNamespace.name) handler.setObject( versionNamespace, Blob("Status as of " + str(datetime.datetime.now())), "text/html") return True prefix.addOnObjectNeeded(onObjectNeeded) 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(): # Silence the warning from Interest wire encode. Interest.setDefaultCanBePrefix(True) face = Face("memoria.ndn.ucla.edu") page = Namespace("/ndn/edu/ucla/remap/demo/ndn-js-test/named-data.net/project/ndn-ar2011.html/%FDT%F7n%9E") page.setFace(face) enabled = [True] def onSegmentedObject(objectNamespace): dump("Got segmented object size", objectNamespace.obj.size()) enabled[0] = False SegmentedObjectHandler(page, onSegmentedObject).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)
def main(): # The default Face will connect using a Unix socket, or to "localhost". face = Face() groupName = Name("/Prefix/READ") userName = Name("/U") userKeyName = Name("/U/Key") contentPrefix = Name("/Prefix/SAMPLE") contentName = Name(contentPrefix).append("Content") keyChain = createVerifyKeyChain() # Imitate test_consumer from the PyNDN integration tests. databaseFilePath = "test.db" try: os.remove(databaseFilePath) except OSError: pass namespace = Namespace(contentName) namespace.setFace(face) handler = NacConsumerHandler(namespace, keyChain, groupName, userName, Sqlite3ConsumerDb(databaseFilePath)) fixtureUserDKeyBlob = Blob(FIXTURE_USER_D_KEY) handler.addDecryptionKey(userKeyName, fixtureUserDKeyBlob) enabled = [True] def onContentSet(namespace, contentNamespace, callbackId): if contentNamespace == namespace: dump("Got segmented content", contentNamespace.content.toRawStr()) enabled[0] = False namespace.addOnContentSet(onContentSet) SegmentedContent(namespace).start() 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(args): face = Face() keyChain = KeyChain() face.setCommandSigningInfo(keyChain, keyChain.getDefaultCertificateName()) gobj = Namespace(args['<prefix>'], keyChain) gobj.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName)) handler = GeneralizedObjectHandler() metaInfo = MetaInfo() if args['--freshness']: metaInfo.setFreshnessPeriod(float(args['--freshness'])) else: metaInfo.setFreshnessPeriod(1000.0) def onObjectNeeded(namespace, neededNamespace, callbackId): if not (neededNamespace is gobj): # This is not the expected Namespace. return False # Make a version from the current time. versionNamespace = gobj[Name.Component.fromVersion( Common.getNowMilliseconds())] # The metaInfo has the freshness period. versionNamespace.setNewDataMetaInfo(metaInfo) with open(args['<file>'], 'r') as f: handler.setObject(versionNamespace, Blob(f.read()), "text/html") return True gobj.addOnObjectNeeded(onObjectNeeded) while True: face.processEvents() time.sleep(0.01)
def main(): face = Face("memoria.ndn.ucla.edu") page = Namespace( "/ndn/edu/ucla/remap/demo/ndn-js-test/named-data.net/project/ndn-ar2011.html/%FDX%DC5B" ) page.setFace(face) enabled = [True] def onContentSet(namespace, contentNamespace, callbackId): if contentNamespace == namespace: dump("Got segmented content size", contentNamespace.content.size()) enabled[0] = False page.addOnContentSet(onContentSet) SegmentedContent(page).start() # 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(): # Silence the warning from Interest wire encode. Interest.setDefaultCanBePrefix(True) # The default Face will connect using a Unix socket, or to "localhost". face = Face() stream = Namespace("/ndn/eb/stream/run/28/annotations") stream.setFace(face) def onNewObject(sequenceNumber, contentMetaInfo, objectNamespace): dump("Got generalized object, sequenceNumber", sequenceNumber, ", content-type", contentMetaInfo.contentType, ":", str(objectNamespace.obj)) pipelineSize = 10 GeneralizedObjectStreamHandler(stream, pipelineSize, onNewObject).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(): # Silence the warning from Interest wire encode. Interest.setDefaultCanBePrefix(True) # The default Face will connect using a Unix socket, or to "localhost". face = Face() objectPrefix = Namespace("/ndn/eb/run/28/description") objectPrefix.setFace(face) enabled = [True] def onGeneralizedObject(contentMetaInfo, objectNamespace): dump("Got generalized object, content-type", contentMetaInfo.contentType, ":", str(objectNamespace.obj)) enabled[0] = False GeneralizedObjectHandler(objectPrefix, onGeneralizedObject).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)
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(): # 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(): # 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()) # Enable Interest loopback so that the EncryptorV2 can fetch Data packets # from the AccessManagerV2. face.setInterestLoopbackEnabled(True) contentPrefix = Name("/testname/content") contentNamespace = Namespace(contentPrefix, keyChain) # We know the content has two segments. metaInfo = MetaInfo() metaInfo.setFinalBlockId(Name().appendSegment(1)[0]) contentNamespace.setNewDataMetaInfo(metaInfo) ckPrefix = Name("/some/ck/prefix") encryptor = prepareData(ckPrefix, keyChain, face) # Make the callback to produce a Data packet for a content segment. def onObjectNeeded(namespace, neededNamespace, id): if not (len(neededNamespace.name) == len(contentPrefix) + 1 and contentPrefix.isPrefixOf(neededNamespace.name) and neededNamespace.name[-1].isSegment()): # Not a content segment, ignore. return False # Get the segment number. segment = neededNamespace.name[-1].toSegment() if not (segment >= 0 and segment <= 1): # An invalid segment was requested. return False segmentContent = ("This test message was decrypted" if segment == 0 else " from segments.") # Now call serializeObject which will answer the pending incoming Interest. dump("Producing Data", neededNamespace.name) neededNamespace.serializeObject( encryptor.encrypt(Blob(segmentContent)).wireEncodeV2()) return True contentNamespace.addOnObjectNeeded(onObjectNeeded) dump("Register prefix", contentNamespace.name) # Set the face and register to receive Interests. contentNamespace.setFace( face, lambda prefixName: dump("Register failed for prefix", prefixName)) 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(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(): # Uncomment these lines to print ChronoSync debug messages. # logging.getLogger('').addHandler(logging.StreamHandler(sys.stdout)) # logging.getLogger('').setLevel(logging.INFO) defaultUserPrefix = "com/newspaper/USER/bob" userPrefix = promptAndInput("Enter user prefix: [" + defaultUserPrefix + "]") if userPrefix == "": userPrefix = defaultUserPrefix defaultNamespacePrefix = "/ndn/hackathon/cnl-demo/slides" #"com/newspaper" namespacePrefix = promptAndInput("Enter namespace prefix [" + defaultNamespacePrefix + "]: ") if namespacePrefix == "": namespacePrefix = defaultNamespacePrefix host = "localhost" #"memoria.ndn.ucla.edu" print("Connecting to " + host) print("") # Set up the key chain. face = Face(host) identityStorage = MemoryIdentityStorage() privateKeyStorage = MemoryPrivateKeyStorage() keyChain = KeyChain(IdentityManager(identityStorage, privateKeyStorage), NoVerifyPolicyManager()) keyChain.setFace(face) keyName = Name("/testname/DSK-123") certificateName = keyName.getSubName(0, keyName.size() - 1).append( "KEY").append(keyName[-1]).append("ID-CERT").append("0") identityStorage.addKey(keyName, KeyType.RSA, Blob(DEFAULT_RSA_PUBLIC_KEY_DER)) privateKeyStorage.setKeyPairForKeyName( keyName, KeyType.RSA, DEFAULT_RSA_PUBLIC_KEY_DER, DEFAULT_RSA_PRIVATE_KEY_DER) face.setCommandSigningInfo(keyChain, certificateName) newspaper = Namespace(namespacePrefix) def onContentSet(namespace, contentNamespace, callbackId): global currentSlideName if contentNamespace == namespace: print("content size "+str(contentNamespace.content.size())) currentSlideName = contentNamespace.getName() displayImage(contentNamespace.content.toRawStr(), contentNamespace.getName().toUri()) # dump("Got segmented content ", contentNamespace.content.toRawStr()) def onNewName(namespace, addedNamespace, callbackId): print("namespace ("+addedNamespace.getName().toUri()+") added to "+namespace.getName().toUri()) if addedNamespace.getName().get(-1).isSegment() and addedNamespace.getName().get(-1).toSegment() == 0: addedNamespace.getParent().addOnContentSet(onContentSet) SegmentedContent(addedNamespace.getParent()).start() newspaper.addOnNameAdded(onNewName) newspaper.setFace(face) namesync = NameSyncHandler(newspaper, userPrefix, keyChain, certificateName) # The main loop to process Chat while checking stdin to send a message. print("Enter your namespace update. To quit, enter \"exit\".") def process(): # while True: # Set timeout to 0 for an immediate check. isReady, _, _ = select.select([sys.stdin], [], [], 0) if len(isReady) != 0: input = promptAndInput("") if input == "exit": stopGui() # We will send the leave message below. # break # before producer has namespace.publish call, we manually call onNameAdded as a hack to publish namesync.onNameAdded(None, Namespace(Name(input)), 0, True) face.processEvents() if root: root.after(100, process) def leftKey(event): global currentSlideName allVersions = newspaper.getChildComponents() currentVersion = currentSlideName[-1] selected = allVersions[0] for c in allVersions: print(str(c.toVersion())) if c.toVersion() == currentVersion.toVersion(): break selected = c currentSlideName = Name(newspaper.getName()).append(selected) displayImage(newspaper.getChild(selected).content.toRawStr(), currentSlideName.toUri()) def rightKey(event): global currentSlideName allVersions = newspaper.getChildComponents() currentVersion = currentSlideName[-1] selected = None for c in allVersions[::-1]: if c.toVersion() == currentVersion.toVersion(): break selected = c if selected: currentSlideName = Name(newspaper.getName()).append(selected) displayImage(newspaper.getChild(selected).content.toRawStr(), currentSlideName.toUri()) else: print("no slides to show") runGui(process, leftKey, rightKey)
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)