AWS python lambda Blur detection in an image for Tulip

I was wanting to brainstorm some simple ideas for ML/Vision type experiments. One of the first I came up with is that we take a whole lot of pictures with Tulip, so I thought - It would be useful to check if the image was blurry. Actually maybe this would be useful to be built into the camera widget itself :slight_smile:

First off, what are your ideas for simple, very foundational ML/Vision/LLM experiments to try? :slight_smile:

I wanted to play with a bit of the opencv vision library, and use it for basic blur detection. This is what I came up with.

First up, trying to get a lambda layer for opencv

This guy has a video on it

Or, you can get a pre built one from here

I think you need to use since 4.7 throws a opencv-aws-lambda-lib64-libz-so-1-version-zlib-1-2-9-not-found

And then why you are at it, create an imutils layer. I think the easiest method is the ec2 micro method with How to Create a Python Layer in Aws Lambda | by Rafael Campana | BRLink | Medium

Ok, so how do we figure out if an image is blurry or not? Luckily, this guy knows how

variation of the Laplacian

Make a little lambda function (add your lambda layers)

59 import boto3

import logging

import urllib3

import os

import numpy as np

import argparse

import cv2

import json

# Configure Logger

logger = logging.getLogger()


# AWS Runtime Region

aws_runtime_region = os.environ[ 'AWS_REGION' ]

# Argument Parsing

arg_parser = argparse.ArgumentParser()

arg_parser.add_argument( "-t" , "--threshold" , type = float , default = 100.0 ,

help = "focus measures below this value are considered 'blurry'" )

cmd_args = vars (arg_parser.parse_args())

def compute_laplacian_variance(image):

return cv2.Laplacian(image, cv2.CV_64F).var()

def download_image(url):

http_client = urllib3.PoolManager()

try :

response = http_client.request( 'GET' , url)

image_data = np.asarray(bytearray(, dtype = "uint8" )

return cv2.imdecode(image_data, cv2.IMREAD_COLOR)

except Exception as error:

logger.error(f "Error in downloading image: {error}" )

return None

def lambda_handler(event, context):

logger.debug(f "Event: {event}" )

image_url = event.get( "url" )

if not image_url:

return { 'statusCode' : 400 , 'body' : json.dumps({ 'error' : 'No URL provided' })}

image = download_image(image_url)

if image is None or not image.size:

return { 'statusCode' : 400 , 'body' : json.dumps({ 'error' : 'Failed to download image' })}

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

laplacian_variance = compute_laplacian_variance(gray_image)

logger.debug(f "Laplacian Variance: {laplacian_variance}" )

is_blurry = laplacian_variance < cmd_args[ "threshold" ]

is_blurry = bool (is_blurry)

if is_blurry:

logger.debug( "Image is blurry." )

else :

logger.debug( "Image is not blurry." )

return { 'statusCode' : 200 , 'body' : { 'is_blurry' : is_blurry}}

Create permissions, and then a postgres function to call it

CREATE OR REPLACE FUNCTION public .check_image_for_blur(url text)

RETURNS boolean

LANGUAGE plpgsql

AS $ function $


create_json TEXT;

response TEXT;

is_blurry_boolean boolean;


RAISE INFO 'Started' ;

-- Create Json



create_json row_to_json(t)





) t;

SELECT into response payload FROM aws_lambda.invoke(aws_commons.create_lambda_function_arn( 'check-image-for-blur' , 'us-east-1' ),

create_json::json, 'RequestResponse'


RAISE INFO 'response:%' ,response;

-- Parse the response to get is_blurry

select into is_blurry_boolean (response::json-> 'body' ->> 'is_blurry' )::boolean;

-- Return the is_blurry boolean value

return is_blurry_boolean;

end ;

$ function $


Make your tulip function (use image_url as the input)

Then a trigger off a camera widget


Hello there,

I have gone through your post and found it very much useful and informative a you have mentioned various useful sources //
Also, I have a good interest in learning aws python so from where should I start as there are many resources available so I am a bit confused to be honest.
Hoping for a quick response.