1. (Re)Start Docker
2. Start Object Detection pepper_tensorflow/pepper_tensorflow/object_detection.py
3. Start This script!
"""
class BroaderMindApp(
AbstractApplication,
StatisticsComponent, # Show Performance Statistics in Terminal
DisplayComponent, # Display what Robot (or Computer) sees in browser
SceneComponent, # Scene (dependency of DisplayComponent)
ContextComponent, # Context (dependency of DisplayComponent)
ObjectDetectionComponent, # Object Detection (dependency of DisplayComponent)
FaceRecognitionComponent, # Face Recognition (dependency of DisplayComponent)
SpeechRecognitionComponent, # Speech Recognition Component (dependency)
TextToSpeechComponent): # Text to Speech (dependency)
def __init__(self, backend):
super(BroaderMindApp, self).__init__(backend)
self.context.start_chat("Human")
def on_chat_turn(self, utterance):
# TODO: Change animation to preferred animation
self.say('hello! ... ...', animation=animations.AFFIRMATIVE)
if __name__ == '__main__':
BroaderMindApp(config.get_backend()).run()
from pepper.framework import *
from pepper.knowledge.wikipedia import Wikipedia
from pepper import config
class WikipediaApp(AbstractApplication,
StatisticsComponent,
StreamingSpeechRecognitionComponent,
TextToSpeechComponent):
def on_transcript(self, hypotheses, audio):
question = hypotheses[0].transcript
print(question)
self.respond_wikipedia(question)
def respond_wikipedia(self, question):
answer = Wikipedia().query(question)
if answer:
answer = answer.split('. ')[0]
self.say(answer)
return answer
if __name__ == "__main__":
WikipediaApp(config.get_backend()).run()
from pepper.framework import *
from pepper import config
class TrackApp(AbstractApplication, TrackComponent, DisplayComponent,
ObjectDetectionComponent, FaceDetectionComponent):
def __init__(self, backend):
super(TrackApp, self).__init__(backend)
if __name__ == '__main__':
TrackApp(config.get_backend()).run()
# Query Wikipedia for Answer to Question
result = Wikipedia.query(question)
if result:
answer, url = result
# Limit Answer to a single sentence
answer = answer.split('.')[0]
# Tell Answer to Human
self.say(answer)
else:
# Tell Human you don't know
self.say("I don't know!")
if __name__ == "__main__":
# Get Backend from Global Configuration File
backend = config.get_backend()
# Create Application with given Backend
application = WikipediaApplication(backend)
# Run Application
application.run()
from pepper.framework import *
from pepper import config
class ObjPosApp(AbstractApplication,
DisplayComponent, SceneComponent,
ExploreComponent, ContextComponent,
ObjectDetectionComponent, SpeechRecognitionComponent, FaceRecognitionComponent, TextToSpeechComponent):
def __init__(self, backend):
super(ObjPosApp, self).__init__(backend)
if __name__ == '__main__':
ObjPosApp(config.get_backend()).run()
# Check whether speaking is appropriate
if self.is_object_recognition_appropriate(obj.name):
# Then tell human what you saw
self.say("I see a {}".format(obj.name))
def is_object_recognition_appropriate(self, name):
"""Returns True if telling about objects is appropriate and updates Object Time"""
# Appropriateness arises when
# 1. object hasn't been seen before, or
# 2. enough time has passed since last sighting
if name not in self.object_time or (time() - self.object_time[name] >
self.OBJECT_TIMEOUT):
# Store last seen time (right now) in object_time dictionary
self.object_time[name] = time()
# Return "Appropriate"
return True
# Return "Not Appropriate"
return False
if __name__ == "__main__":
# Run ObjectApplication using Backend Configured in Global Configuration File
ObjectApplication(config.get_backend()).run()
from pepper.framework import *
from pepper import config
class DisplayApp(AbstractApplication, StatisticsComponent, DisplayComponent,
ObjectDetectionComponent, FaceDetectionComponent,
SpeechRecognitionComponent):
pass
if __name__ == '__main__':
DisplayApp(config.get_backend()).run()
from pepper.framework import *
from pepper import config
class VerboseApp(AbstractApplication, StatisticsComponent,
SpeechRecognitionComponent, ObjectDetectionComponent,
FaceDetectionComponent):
def on_image(self, image):
self.log.info("on_image: {}".format(image.shape))
def on_object(self, image, objects):
self.log.info("on_object: {} {}".format(image.shape, objects))
def on_face_known(self, faces):
self.log.info("on_face: {}".format(faces))
def on_face(self, faces):
self.log.info("on_person: {}".format(faces))
def on_face_new(self, faces):
self.log.info("on_new_person: {}".format(faces))
def on_transcript(self, hypotheses, audio):
self.log.info("on_transcript: {}".format(hypotheses, audio.shape))
if __name__ == '__main__':
VerboseApp(config.get_backend()).run()
"bye bye", "bye", "goodbye", "see you"
]:
# Respond Goodbye, <speaker>!
self.say("Goodbye, {}!".format(self._speaker))
# Sleep 5 seconds (else human would be instantly greeted again)
sleep(5)
# Switch Back to Idle Intention
IdleIntention(self.application)
return
else:
# If Human doesn't end the conversation,
# act as if you understand what he/she is saying :)
self.say("How interesting!")
if __name__ == '__main__':
# Initialize Application
application = MyApplication(config.get_backend())
# Initialize (Idle) Intention
IdleIntention(application)
# Run Application
application.run()
def _is_name_statement(self, hypotheses):
for hypothesis in hypotheses:
for cue in self.CUES:
if cue in hypothesis.transcript.lower():
return True
return False
def _save(self):
name, features = self._current_name, np.concatenate(
self.face_vectors).reshape(-1, OpenFace.FEATURE_DIM)
if name != "NEW": # Prevent Overwrite of NEW.bin
self.face_classifier.add(name, features)
features.tofile(
os.path.join(config.PEOPLE_NEW_ROOT, "{}.bin".format(name)))
if __name__ == '__main__':
while True:
# Boot Application
application = ResponderApp(config.get_backend())
# Boot Default Intention
intention = DefaultIntention(application)
# Run Application
application.run()
return True
return False
@staticmethod
def is_negation(statement):
for word in statement.split():
if word in NEGATION:
return True
return False
@staticmethod
def goodbye(statement):
for bye in GOODBYE:
if statement == re.sub('[?!.;,]', '', bye.lower()):
return True
return False
def end_conversation(self):
self.say("{}!".format(
choice(["See you later", "ByeBye", "Till another time", "It was good having talked to you", "Goodbye"])))
IdleIntention(self.application)
def save_person(self):
np.concatenate(self._face).tofile(os.path.join(config.NEW_FACE_DIRECTORY, "{}.bin".format(self._name)))
if __name__ == '__main__':
app = DefaultApp(config.get_backend())
IdleIntention(app)
app.run()
# Just reply with a random statement for now
self.say(choice(["Interesting", "Right", "I see", "Ok"]))
processed_utterance = language.analyze(self.chat, self.brain)
if processed_utterance.type == language.UtteranceType.QUESTION:
brain_response = self.brain.query_brain(processed_utterance)
print(language.utils.reply_to_question(brain_response, []))
elif processed_utterance.type == language.UtteranceType.STATEMENT:
brain_response = self.brain.update(processed_utterance)
#print(self.brain.brain_help.phrase_update(response))
else:
brain_response = 'unknown type'
print(brain_response)
return 0
def say(self, text, animation=None, block=False):
# Call Text To Speech for given Text
super(ContextApp, self).say(text, animation, block)
# Add whatever Pepper says to Chat as an Utterance
if self.has_chat:
self.chat.add_utterance(text, me=True)
if __name__ == '__main__':
# Run Application using Settings in pepper.config
ContextApp(config.get_backend()).run()
def on_face_known(self, faces):
"""
On Person Event.
Called every time a known face is detected.
"""
for person in faces:
if self.is_greeting_appropriate(person.name):
self.say("Hello, {}!".format(person.name))
def on_face_new(self, faces):
"""
On New Person Event.
Called every time an unknown face is detected.
"""
if self.is_greeting_appropriate("new"):
self.say("I see {} new people!".format(len(faces)))
def is_greeting_appropriate(self, name):
"""Returns True if greeting is appropriate and updates Greeting Time"""
if name not in self.nametime or (time() - self.nametime[name]) > self.GREET_TIMEOUT:
self.nametime[name] = time()
return True
return False
if __name__ == "__main__":
# Run Application with Backend specified in Global Configuration File
GreetingApplication(config.get_backend()).run()
image = objects[0].image
image.to_file(self.output)
with open(
os.path.join(self.output,
"{}_obj.json".format(image.hash)),
"w") as json_file:
json.dump([obj.dict() for obj in objects], json_file)
for obj in objects:
hash = str(obj.id)
path = os.path.join(self.output, image.hash, hash)
os.makedirs(path)
rgb = obj.image.get_image(obj.image_bounds)
depth = obj.image.get_depth(obj.image_bounds)
meta = obj.dict()
Image.fromarray(rgb).save(os.path.join(path, "rgb.png"))
np.save(os.path.join(path, "depth.npy"), depth)
with open(os.path.join(path, "meta.json"), "w") as json_file:
json.dump(meta, json_file)
self.log.info(objects)
if __name__ == '__main__':
CameraDumpApp(config.get_backend()).run()