Md. Khairul Alam
Published © GPL3+

Intelligent Door Lock

An Alexa enabled door lock with face recognition and remote control.

AdvancedWork in progress10 hours15,301
Intelligent Door Lock

Things used in this project

Story

Read more

Schematics

Block diagram of the System

Block1 iowgctjdgn

Demo Setup

Door lock m7i5jfa1je

VUI Diagram

Vui diagrami s5pccuu3ms

Arduino and Servo Lock connection

Servo lock dfnhl39ibk

Arduino & Raspberry Pi Connection

Arduino raspberry pi kyemo3nzab

Raspberry Pi Circuit

Raspberry Pi is equipped with a camera module, audio amplifier, and a button switch.
Raspberry pi circuit litlzeps22

Code

capture-button-upload-email.py

Python
This python code snippet captures a photo, upload it to S3 bucket, sent the photo to your email address with a notification.
import time
import picamera

import boto3

s3 = boto3.resource('s3')

import RPi.GPIO as GPIO

import smtplib
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from email.MIMEBase import MIMEBase
from email import encoders


GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)


def gpio_callback(self):
	capture_image()
	time.sleep(0.3)
	print('Captured')
	upload_image()
	time.sleep(2)
	send_email()
	

GPIO.add_event_detect(4, GPIO.FALLING, callback=gpio_callback, bouncetime=3000)


def capture_image():
	with picamera.PiCamera() as camera:
		camera.resolution = (640, 480)
		camera.start_preview()
		camera.capture('sample.jpg')
		camera.stop_preview()
		camera.close()
		return
		
				
def upload_image():
	file = open('sample.jpg','rb')
	object = s3.Object('taifur12345bucket','sample.jpg')
	ret = object.put(Body=file,
			Metadata={'FullName':'Guest'}
			)
	print(ret)
	return


def send_email(): 
    fromaddr = "Put From Which Email"
    toaddr = "put to which email"
     
    msg = MIMEMultipart()
     
    msg['From'] = fromaddr
    msg['To'] = toaddr
    msg['Subject'] = "New Guest"
     
    body = "A new guest is waiting at your front door. Photo of the guest is attached."
     
    msg.attach(MIMEText(body, 'plain'))
     
    filename = "sample.jpg"
    attachment = open("/home/pi/sample.jpg", "rb")
     
    part = MIMEBase('application', 'octet-stream')
    part.set_payload((attachment).read())
    encoders.encode_base64(part)
    part.add_header('Content-Disposition', "attachment; filename= %s" % filename)
     
    msg.attach(part)
     
    server = smtplib.SMTP('smtp.gmail.com', 587)
    server.starttls()
    server.login(fromaddr, "password of your email")
    text = msg.as_string()
    server.sendmail(fromaddr, toaddr, text)
    server.quit()
	

aws-iot-receive.py

Python
This python code snippet receives message from AWS IoT, sends command to Arduino and produce the greeting message for the guest.
import time
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
myMQTTClient = AWSIoTMQTTClient("doorLock")
myMQTTClient.configureEndpoint("a3jra11pv5kiyg.iot.eu-west-1.amazonaws.com", 8883)
myMQTTClient.configureCredentials("./rootCA.pem", "./privateKEY.key", "./certificate.crt")

import serial
ser = serial.Serial('/dev/ttyACM0',9600)
guest_name = None

import boto3
from contextlib import closing


import os

client = boto3.client('polly', 'eu-west-1')
	
# trigger when receive mqtt message and sent the message to arduno
def customOnMessage(message):
    global guest_name
    print("Received a new message: ")
    msg = message.payload
    ser.write(msg)
    ser.write('\n')
    if msg == 'open' and guest_name != None:
        play_greeting()
        guest_name = None 
    if msg.find('#') + 1:
        msg = msg.translate(None, '#')
        guest_name = msg
        print('removed #')		
    print(msg)
    print(guest_name)
	
# Suback callback
def customSubackCallback(mid, data):
    print("Received SUBACK packet id: ")
    print(mid)
    print("Granted QoS: ")
    print(data)
    print("++++++++++++++\n\n")

# AWSIoTMQTTClient connection configuration
myMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
myMQTTClient.configureDrainingFrequency(2)  # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10)  # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5)  # 5 sec
myMQTTClient.onMessage = customOnMessage

myMQTTClient.connect()
myMQTTClient.subscribeAsync("test/door", 1, ackCallback=customSubackCallback)

def play_greeting():
    global guest_name
    response = client.synthesize_speech(
	    OutputFormat='mp3',
	    Text=  'Welcome ' + guest_name + '. The door is open for you.',
            #Text=  'Welcome. The door is open for you.',
	    TextType='text',
	    VoiceId='Emma'
        )
    guest_name = None
    #print response
    if "AudioStream" in response:
        with closing(response["AudioStream"]) as stream:
            output = "welcome.mp3"

            try:
			    # Open a file for writing the output as a binary stream
                with open(output, "wb") as file:
                    file.write(stream.read())
            except IOError as error:
                # Could not write to file, exit gracefully
                print(error)
                sys.exit(-1)
        os.system('omxplayer welcome.mp3')
        print('played')

while True:
	time.sleep(0.1)

alexa-skill.txt

JSON
Use this JSON code for the Alexa Skill.
{
    "languageModel": {
        "invocationName": "door guard",
        "intents": [
            {
                "name": "AddGuestIntent",
                "slots": [],
                "samples": [
                    "Add guest in your memory",
                    "Add person in your memory",
                    "Add the person in your memory",
                    "Add the guest to your memory",
                    "Remember the man",
                    "Remember the guy",
                    "Remember the person",
                    "Remember the guest",
                    "Remember him",
                    "Remember her",
                    "Save the guest",
                    "Save the person",
                    "Save the guy",
                    "Remember",
                    "Save"
                ]
            },
            {
                "name": "AMAZON.CancelIntent",
                "slots": [],
                "samples": []
            },
            {
                "name": "AMAZON.HelpIntent",
                "slots": [],
                "samples": []
            },
            {
                "name": "AMAZON.StopIntent",
                "slots": [],
                "samples": []
            },
            {
                "name": "CheckDoorIntent",
                "slots": [],
                "samples": [
                    "Is the door unlocked",
                    "Is the door locked",
                    "Check door lock",
                    "Check door ",
                    "Is the door closed",
                    "What is the door condition",
                    "Is my door open",
                    "Check my door",
                    "Is the door open",
                    "Check the door",
                    "Is the door open or closed"
                ]
            },
            {
                "name": "CloseDoorIntent",
                "slots": [],
                "samples": [
                    "Lock door",
                    "Close door ",
                    "Lock the door ",
                    "Close the door ",
                    "Close my door",
                    "Make the door lock",
                    "Make the door close",
                    "Lock"
                ]
            },
            {
                "name": "DescribeGuestIntent",
                "slots": [],
                "samples": [
                    "Tell some details about the man",
                    "Tell some details about the guy",
                    "Give some details about the man",
                    "Give some details about the guy",
                    "Give some details about the person",
                    "Tell some details about the person",
                    "Tell some details about the guest",
                    "Give some details about the guest",
                    "Introduce the person",
                    "Introduce the guest",
                    "Give some details",
                    "Give details",
                    "Explain him",
                    "Explain her",
                    "How is he",
                    "How is she",
                    "How he look",
                    "How she looks"
                ]
            },
            {
                "name": "GiveAccessIntent",
                "slots": [],
                "samples": [
                    "Let the guest come",
                    "Let her come",
                    "Let him come",
                    "Allow her",
                    "Allow him",
                    "Let the guy enter",
                    "Let the person enter",
                    "Let the guest enter",
                    "Allow the guy",
                    "Allow the person",
                    "Allow the guest",
                    "Open the door",
                    "Open",
                    "Allow",
                    "Open the lock",
                    "Open lock",
                    "Let him enter",
                    "Let her enter"
                ]
            },
            {
                "name": "IdentifyGuestIntent",
                "slots": [],
                "samples": [
                    "Who want to meet",
                    "Who came",
                    "Who is waiting ",
                    "Who is at the front door",
                    "Who",
                    "Who is he",
                    "Who is she",
                    "Who is outside"
                ]
            }
        ],
        "types": []
    }
}

lambda-uploaded.py

Python
This is the code for lambda function. You neet to include this python file with AWSIoTPythonSDK in a zip file and then upload to Lambda.Link: https://github.com/aws/aws-iot-device-sdk-python
"""
This sample demonstrates a simple skill built with the Amazon Alexa Skills Kit.
The Intent Schema, and Sample Utterances for this skill, as well
as testing instructions are located at http://amzn.to/1LzFrj6
 
The code is developed by:
	Md. Khairul Alam
	February, 2018
For additional samples, visit the Alexa Skills Kit Getting Started guide at
http://amzn.to/1LGWsLG
"""
 
from __future__ import print_function
import urllib2
import xml.etree.ElementTree as etree
from datetime import datetime as dt

from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient
myMQTTClient = AWSIoTMQTTClient("doorLock")
myMQTTClient.configureEndpoint("a3jra11pv5kiyg.iot.eu-west-1.amazonaws.com", 8883)
myMQTTClient.configureCredentials("./rootCA.pem", "./privateKEY.key", "./certificate.crt")

# AWSIoTMQTTClient connection configuration
myMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
#myMQTTClient.configureOfflinePublishQueueing(-1)  # Infinite offline Publish queueing
myMQTTClient.configureDrainingFrequency(2)  # Draining: 2 Hz
myMQTTClient.configureConnectDisconnectTimeout(10)  # 10 sec
myMQTTClient.configureMQTTOperationTimeout(5)  # 5 sec

myMQTTClient.connect()
#myMQTTClient.connectAsync()


import boto3
import io
import time

BUCKET = "taifur12345bucket"
KEY = "sample.jpg"
COLLECTION = "family_collection"
IMAGE_ID = KEY

door_state = False

rekognition = boto3.client('rekognition', region_name='eu-west-1')
dynamodb = boto3.client('dynamodb', region_name='eu-west-1')
s3 = boto3.client('s3')

def update_index(tableName,faceId, fullName):
	response = dynamodb.put_item(
	TableName=tableName,
	Item={
		'RekognitionId': {'S': faceId},
		'FullName': {'S': fullName}
		}
	)
	#print(response)
def index_faces(bucket, key, collection_id, image_id=None, attributes=(), region="eu-west-1"):
	rekognition = boto3.client("rekognition", region)
	response = rekognition.index_faces(
		Image={
			"S3Object": {
				"Bucket": bucket,
				"Name": key,
			}
		},
		CollectionId=collection_id,
		ExternalImageId="taifur",
	    DetectionAttributes=attributes,
	)
	if response['ResponseMetadata']['HTTPStatusCode'] == 200:
		faceId = response['FaceRecords'][0]['Face']['FaceId']
		print(faceId)
		ret = s3.head_object(Bucket=bucket,Key=key)
		personFullName = ret['Metadata']['fullname']
		#print(ret)
		print(personFullName)
		update_index('taifur12345table',faceId,personFullName)

	# Print response to console.
	#print(response)
	return response['FaceRecords']


def lambda_handler(event, context):
    """ Route the incoming request based on type (LaunchRequest, IntentRequest,
    etc.) The JSON body of the request is provided in the event parameter.
    """
    print("event.session.application.applicationId=" +
          event['session']['application']['applicationId'])
          
    #myMQTTClient.connect()
 
    """
    Uncomment this if statement and populate with your skill's application ID to
    prevent someone else from configuring a skill that sends requests to this
    function.
    """
    # if (event['session']['application']['applicationId'] !=
    #         "amzn1.echo-sdk-ams.app.[unique-value-here]"):
    #     raise ValueError("Invalid Application ID")
 
    if event['session']['new']:
        on_session_started({'requestId': event['request']['requestId']},
                           event['session'])
 
    if event['request']['type'] == "LaunchRequest":
        return on_launch(event['request'], event['session'])
    elif event['request']['type'] == "IntentRequest":
        return on_intent(event['request'], event['session'])
    elif event['request']['type'] == "SessionEndedRequest":
        return on_session_ended(event['request'], event['session'])
 
 
def on_session_started(session_started_request, session):
    """ Called when the session starts """
 
    print("on_session_started requestId=" + session_started_request['requestId']
          + ", sessionId=" + session['sessionId'])
 
 
def on_launch(launch_request, session):
    """ Called when the user launches the skill without specifying what they
    want
    """
 
    print("on_launch requestId=" + launch_request['requestId'] +
          ", sessionId=" + session['sessionId'])
    # Dispatch to your skill's launch
    return get_welcome_response()
 
 
def on_intent(intent_request, session):
    """ Called when the user specifies an intent for this skill """
 
    print("on_intent requestId=" + intent_request['requestId'] +
          ", sessionId=" + session['sessionId'])
 
    intent = intent_request['intent']
    intent_name = intent_request['intent']['name']
 
    # Dispatch to your skill's intent handlers
    if intent_name == "IdentifyGuestIntent":
        return guest_search(intent, session)
    elif intent_name == "GiveAccessIntent":
        return give_access(intent, session)
    elif intent_name == "CloseDoorIntent":
        return close_door(intent, session)
    elif intent_name == "CheckDoorIntent":
        return check_door(intent, session)
    elif intent_name == "DescribeGuestIntent":
        return describe_guest(intent, session)
    elif intent_name == "AddGuestIntent":
        return add_guest(intent, session)
    elif intent_name == "AMAZON.HelpIntent":
        return get_welcome_response()
    elif intent_name == "AMAZON.StopIntent" or intent_name == "AMAZON.CancelIntent":
        return session_end(intent, session)
    else:
        raise ValueError("Invalid intent")

 
def on_session_ended(session_ended_request, session):
    """ Called when the user ends the session.
 
    Is not called when the skill returns should_end_session=true
    """
    print("on_session_ended requestId=" + session_ended_request['requestId'] +
          ", sessionId=" + session['sessionId'])
    # add cleanup logic here
 
# --------------- Functions that control the skill's behavior ------------------
 
 
def get_welcome_response():
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
 
    session_attributes = {}
    card_title = "Welcome"
    speech_output = "Welcome to the door lock application. " \
                    "You can ask me, who is at the front door or" \
                    " open the door"
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = "Please ask me for checking the door by telling, " \
                    "Who is at the front door?"
    should_end_session = False
    #myMQTTClient.publish("test/door", "welcome", 0)
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))

def give_access(intent, session):
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    #myMQTTClient.publish("test/door", "open", 0)
    myMQTTClient.publishAsync("test/door", "open", 1, ackCallback=None)
    global door_state
    session_attributes = {}
    card_title = "Opening Door"
    speech_output = "The door is now open."
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = ""
    should_end_session = True
    #myMQTTClient.connectAsync()
    #myMQTTClient.publish("test/door", "open", 0)
    time.sleep(2)
    door_state = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))
 
def close_door(intent, session):
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    #myMQTTClient.publish("test/door", "close", 0)
    myMQTTClient.publishAsync("test/door", "close", 1, ackCallback=None)
    global door_state
    session_attributes = {}
    card_title = "Closing Door"
    speech_output = "The door is now closed."
    
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = ""
    should_end_session = True
    door_state = False
    time.sleep(2)
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))


def check_door(intent, session):
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    global door_state
    session_attributes = {}
    card_title = "Checking Door"
    if door_state == True:
        speech_output = "The door is open."
    else:
        speech_output = "The door is closed."
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = ""
    should_end_session = True
    #myMQTTClient.publish("test/door", "open", 0)
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))
        
def describe_guest(intent, session):
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    session_attributes = {}
    card_title = "Guest Details"
    speech_output = "The guest is waiting with smiling face."
    
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = ""
    should_end_session = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))
        
def add_guest(intent, session):
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    for record in index_faces(BUCKET, KEY, COLLECTION, IMAGE_ID):
	    face = record['Face']
    #face = record['Face']
    session_attributes = {}
    card_title = "Adding Guest"
    speech_output = "The guest's details is stored for next time."
    
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = ""
    should_end_session = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))
 
		
def guest_search(intent, session):
    
    card_title = "Guest's Identity"
    session_attributes = {}
    should_end_session = True
    speech_output = "I dont know the person."
    reprompt_text = ""
    response = rekognition.search_faces_by_image(
            CollectionId='family_collection',
            Image={ 
				"S3Object": {
					"Bucket": BUCKET,
					"Name": KEY,
				}
			},                                    
			)
	#print(response)    
    for match in response['FaceMatches']:
        print (match['Face']['FaceId'],match['Face']['Confidence'])
			
        face = dynamodb.get_item(
			TableName='taifur12345table',  
			Key={'RekognitionId': {'S': match['Face']['FaceId']}}
			)
		
        if 'Item' in face:
            guest = face['Item']['FullName']['S']
            speech_output = guest + " is waiting at the door."
	        #print (face['Item']['FullName']['S'])
            #guest = face['Item']['FullName']['S']
            #speech_output = " is waiting at the door." 
            reprompt_text = ""
            break
        else:
            print ('no match found in person lookup')

			
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))


def session_end(intent, session):
    """ If we wanted to initialize the session to have some attributes we could
    add those here
    """
    session_attributes = {}
    card_title = "End"
    speech_output = "Thank you for calling me. Have a nice day!"
    
    # If the user either does not reply to the welcome message or says something
    # that is not understood, they will be prompted again with this text.
    reprompt_text = ""
    should_end_session = True
    return build_response(session_attributes, build_speechlet_response(
        card_title, speech_output, reprompt_text, should_end_session))        
 
# --------------- Helpers that build all of the responses ----------------------
 
 
def build_speechlet_response(title, output, reprompt_text, should_end_session):
    return {
        'outputSpeech': {
            'type': 'PlainText',
            'text': output
        },
        'card': {
            'type': 'Simple',
            'title': title,
            'content': output
        },
        'reprompt': {
            'outputSpeech': {
                'type': 'PlainText',
                'text': reprompt_text
            }
        },
        'shouldEndSession': should_end_session
    }
 
 
def build_response(session_attributes, speechlet_response):
    return {
        'version': '1.0',
        'sessionAttributes': session_attributes,
        'response': speechlet_response
    }

arduino-door-guard.ino

Arduino
This Arduino sketch is used for receiving the command for controlling the lock. The command is receiving using USB serial cable. A servo motor is used to control a 3D printed lock.
#include <Servo.h>

String inputString = "";         // a string to hold incoming data
boolean stringComplete = false;  // whether the string is complete

//servo motor is used to control the lock
Servo myservo;  // create servo object to control a servo

void setup() {
  // initialize serial:
  Serial.begin(9600);

  inputString.reserve(200);
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
}

void loop() {
  
  if (stringComplete) {
    //lcd.clear();
    //lcd.print(inputString);
    if(inputString == "open"){
        openDoor();
        delay(20);
      }
    else if(inputString == "close"){
        closeDoor();
        delay(20);
      }  
    // clear the string:
    inputString = "";
    stringComplete = false;
  }
}

/*
  SerialEvent occurs whenever a new data comes in the
 hardware serial RX.  This routine is run between each
 time loop() runs, so using delay inside loop can delay
 response.  Multiple bytes of data may be available.
 */

void serialEvent() {
  while (Serial.available()) {    
    // get the new byte:
    char inChar = (char)Serial.read();     
    // if the incoming character is a newline, set a flag
    // so the main loop can do something about it:
    if (inChar == '\n') {
      stringComplete = true;
    }
    else
    // add it to the inputString:  
      inputString += inChar;
  }
}

void openDoor(){
  myservo.write(0); //place servo knob at 0 degree
  delay(100);   
}

void closeDoor(){
  myservo.write(65); //place servo knob at 65 degree to fully closed the lock
  delay(100); 
}

capture-n-upload.py

Python
This code snippet captures a photo of the guest automatically when he presses the calling button and upload the photo to the S3 Bucket and send a notification to the house owner.
import time
import picamera

import boto3
s3 = boto3.resource('s3')

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

#this function automatically called in button press and can call other two functions
def gpio_callback(self):
	capture_image()
	time.sleep(0.3)
	print('Captured')
	upload_image()
	time.sleep(2)
	
#detect a button press and call gpio_callback function
GPIO.add_event_detect(4, GPIO.FALLING, callback=gpio_callback, bouncetime=2000)


#this function capture an image from pi camera and save it as sample.jpg
def capture_image():
	with picamera.PiCamera() as camera:
		camera.resolution = (640, 480)
		camera.start_preview()
		camera.capture('sample.jpg')
		camera.stop_preview()
		camera.close()
		return
		
				

#this function uploads the sample.jpg to AWS S3 Bucket with a name as Guest
def upload_image():
	file = open('sample.jpg','rb')
	object = s3.Object('taifur12345bucket','sample.jpg')
	ret = object.put(Body=file,
			Metadata={'FullName':'Guest'}
			)
	print(ret)
	return
	

index-face-and-store-db.py

Python
Use this code to index a face from S3 Bucket and store the index in DynamoDB with the full name.
import boto3
from decimal import Decimal
import json
import urllib

BUCKET = "taifur12345bucket"
KEY = "sample.jpg"
IMAGE_ID = KEY  # S3 key as ImageId
COLLECTION = "family_collection"

dynamodb = boto3.client('dynamodb', "eu-west-1")
s3 = boto3.client('s3')
# Note: you have to create the collection first!
# rekognition.create_collection(CollectionId=COLLECTION)

def update_index(tableName,faceId, fullName):
	response = dynamodb.put_item(
	TableName=tableName,
	Item={
		'RekognitionId': {'S': faceId},
		'FullName': {'S': fullName}
		}
	)
	#print(response)
def index_faces(bucket, key, collection_id, image_id=None, attributes=(), region="eu-west-1"):
	rekognition = boto3.client("rekognition", region)
	response = rekognition.index_faces(
		Image={
			"S3Object": {
				"Bucket": bucket,
				"Name": key,
			}
		},
		CollectionId=collection_id,
		ExternalImageId="taifur",
	    DetectionAttributes=attributes,
	)
	if response['ResponseMetadata']['HTTPStatusCode'] == 200:
		faceId = response['FaceRecords'][0]['Face']['FaceId']
		print(faceId)
		ret = s3.head_object(Bucket=bucket,Key=key)
		personFullName = ret['Metadata']['fullname']
		#print(ret)
		print(personFullName)
		update_index('taifur12345table',faceId,personFullName)

	# Print response to console.
	#print(response)
	return response['FaceRecords']


for record in index_faces(BUCKET, KEY, COLLECTION, IMAGE_ID):
	face = record['Face']
	# details = record['FaceDetail']
	print "Face ({}%)".format(face['Confidence'])
	print "  FaceId: {}".format(face['FaceId'])
	print "  ImageId: {}".format(face['ImageId'])

upload-multiple-image-with-name.py

Python
Use this code snippet to upload multiple images with full name to S3 Bucket.
import boto3

s3 = boto3.resource('s3')

# Get list of objects for indexing
images=[('afridi.jpg','Shahid Afridi'),
        ('sakib.jpg','Sakib Al Hasan'),
        ('kohli.jpg','Birat Kohli'),
        ('masrafi.jpg','Mashrafe Bin Mortaza'),
        ('ganguli.jpg','Sourav Ganguly')
       ]

# Iterate through list to upload objects to S3   
for image in images:
    file = open(image[0],'rb')
    object = s3.Object('taifur12345bucket',image[0])
    ret = object.put(Body=file,
                    Metadata={'FullName':image[1]}
                    )
    #print(image[0])
    #print(image[1])

Github Link for the Project

Credits

Md. Khairul Alam

Md. Khairul Alam

27 projects • 239 followers
Engineer, developer, maker, and hacker.

Comments