DEV Community: Tina

How to set up a custom email domain through SES and SNS using (mostly) CloudFormation

Tina — Wed, 11 Jan 2023 19:18:30 +0000

Prerequisites:

Have an AWS account
Have a domain
Some familiarity with CloudFormation

For one of my pet projects, BiteMe (an online multiplayer snake game), I wanted to have a custom email domain to receive emails without the need to set up one through paid service (I checked, you have to pay 6$/month through google business). Considering that this is more than my whole AWS bill, I knew there must be another option.

This article will show you how to set up a POC using AWS Simple Email Service and AWS Simple Notification Service using CloudFormation (apart from two manual steps), which should get you a custom email domain that is virtually free. And you get to learn how to use SES and SNS.

Some terminology

Simple Email Service (SES)
SES is mostly known for sending emails but for 3 regions (us-west-2, us-east-1, eu-west-1) it can also receive emails.

Simple Notification Service (SNS)
SNS is a service that can send notifications either to other applications or to end user through email, sms or a push notification.

CloudFormation (CF)
CloudFormation is an IaaC service provided by AWS. It allows for resource provisioning through a yaml or json file.

Tip💡: Use the CloudFormation service in AWS console to check your deployment status. Deploy to AWS step by step to isolate errors. Always check that the resource has been created in the service.

The steps are:

Create an email identity
Verify that the domain we want to use is indeed ours
Set up an MX record to receive emails
Create an SNS Topic
Create a rule that would say what to do with the email once its received

To see how to do it in a console, follow this link.

Yes, using the console might be easier, but you loose so many benefits - versioning, the possibility of code reviews, integrating it into your CICD, share it with someone, ...

1. Create an email Identity (SES)

First of all, we need to create the Email Identity, which is basically the @mydomain.com:



EmailSES:
 Type: AWS::SES::EmailIdentity
 Properties:
   EmailIdentity: 'yourdomain.com'

Once deployed, check that an email identity was created in SES.

2. Verify the domain (DNS provider, Route53)

In order to verify the domain, we need to add DNS records to our DNS provider. If your DNS provider is Route53, you can use the Fn::GetAtt to get the three records and put them directly to your Route53:

Note that the EmailSES is how we named our Email Identity in the previous step.



WebsiteDNS:
 Type: AWS::Route53::RecordSetGroup
 Properties:
   HostedZoneId: YOURHOSTEDZONEID
   RecordSets:
     - Name:
         Fn::GetAtt: [ EmailSES, DkimDNSTokenName1 ]
       Type: CNAME
       TTL: 600
       ResourceRecords:
         - Fn::GetAtt: [ EmailSES, DkimDNSTokenValue1 ]
     - Name:
         Fn::GetAtt: [ EmailSES, DkimDNSTokenName2 ]
       Type: CNAME
       TTL: 600
       ResourceRecords:
         - Fn::GetAtt: [ EmailSES, DkimDNSTokenValue2 ]
     - Name:
         Fn::GetAtt: [ EmailSES, DkimDNSTokenName3 ]
       Type: CNAME
       TTL: 600
       ResourceRecords:
         - Fn::GetAtt: [ EmailSES, DkimDNSTokenValue3 ]

Once deployed, check that 3 CNAME records were created in Route53.

If your provider is not Route53, you can copy the records from the created Email Identity and paste it to your provider.

Wait until the Identity status turns to Verified (you should receive an email).

3. Set up MX record (DNS Provider, Route53)

This is to set up the email receiving endpoint with your DNS provider. As we use Route53, we can just add another record after those 3 that we created in step two. Note that the endpoint will be dependent on the region that you are in, see docs for more info:



- Name: yourdomain.com
  Type: MX
  TTL: 600
  ResourceRecords:
    - '10 inbound-smtp.{REGION}.amazonaws.com'  # this will depend on your region

Once deployed, check that the MX Record was created in Route53 / your DNS provider.

4. Create an SNS Topic (SNS)

So, now SES knows that the domain is yours and you can receive emails. However, we also need to tell it what should happen to the received emails. SES can trigger these actions:

Save email to an S3 bucket
Invoke a lambda function
Publish to an SNS topic

We will want to publish to SNS to send us an email when such an event happens, so we need to create one. We also have to create a subscription (in this case an email address) through which we will receive the notification:



EmailSNS:
 Type: AWS::SNS::Topic
 Properties:
   Subscription:
     - Endpoint: 'youremail@gmail.com' # the email to receive the notifications
       Protocol: email
   TopicName: 'my-sns-topic-name'

Once deployed, you can check that the SNS has been created. You will also see that the status of you subscription (SNS -> created topic -> subscriptions) is pending confirmation. Check the email address that you have provided as an endpoint to confirm subscription. ❗️Check the spam folder❗️

If you want to use an SNS topic in a different AWS account, add a step that will give SES the permission to publish it there, see the documentation. Since the SNS that will be processing these events is part of the same account, we do not need to create this permission.

5. Create a RuleSet with a Rule (SES)

To tell SES to publish to an SNS topic, we need to create a Rule. However, a rule has to be part of a RuleSet, therefore we need to create that first:



EmailRuleSet:
 Type: AWS::SES::ReceiptRuleSet
 Properties:
   RuleSetName: 'my-ruleset-name'

Once deployed you can check that the rule set was created in SES -> Email Receiving -> All rule sets.

You will notice that the status is inactive. Unfortunately, the ReceiptRuleSet type does not have a property to set the RuleSet active (see the issue here) so we need to manually do so. It is also important to note that there can only be one active rule set per region. So, if you were setting a staging and production rule, they would both have to be in this rule set.

Side note, deleting an active ruleset from CloudFormation will throw an error, better to delete from CloudFormation as well as manually.

Finally, we need to create the rule that will take all the emails and publish them into the created SNS. The rule can be defined with various granularity, here in the example, we are only taking emails that come from the email address info@yourdomain.com. To set a different granularity, check the documentation here:



EmailRule:
 Type: AWS::SES::ReceiptRule
 Properties:
   Rule:
     Actions:
       - SNSAction:
           TopicArn:
             Ref: EmailSNS  # name of your SNS resource
     Enabled: true
     Name: 'your-rule-name'
     ScanEnabled: true
     Recipients:
       - 'info@yourdomain.com'
   RuleSetName:
     Ref: EmailRuleSet  # name of your rule set resource

Once deployed you can check that the rule has been created in SES -> Email Receiving -> RuleSet. The status should be Enabled.

Final checks

Domain is verified (CNAME records are present)
Subscription is confirmed (check spam folder of provided email endpoint)
RuleSet is Active (manually activate)

And that’s it!

Sending a testing email will look something like this:

Unfortunately, these emails cannot be customized as the email delivery feature is intended to provide internal system alerts, not marketing messages. But as a proof of concept without any backend logic, it's not bad 🙂

Where next?

Since SES can invoke a lambda, you can create a lambda function to process the received emails and then use SES to send a proper email with the received content. That way, you won’t need the SNS at all.

Some useful links:
https://docs.aws.amazon.com/ses/latest/dg/receiving-email.html
https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html
https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ses-emailidentity.html
https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html
https://aws.amazon.com/premiumsupport/knowledge-center/sns-topic-email-notifications/

Introduction to Object-relational mapping: the what, why, when and how of ORM

Tina — Thu, 19 Nov 2020 21:44:56 +0000

If you have ever used a relational database for persisting your data and an object-oriented programming language for your application, then Object-relational mapping paradigm is definitely something you should be familiar with. If not then read on as this article hopes to provide an introduction to the concept of ORM by answering the basic questions like why is there a need for an ORM, what an ORM is, the benefits and drawbacks of ORM, first steps needed to set up an ORM and the patterns of setting it up.

Understanding the need for ORM

Object-oriented programming languages (OOP) are great in combining variables and functions into classes and objects. Imagine this as objects in the real world (cars) each with their properties (wheels) and behaviours (drive). On the other hand, relational databases (also called Relational Database Management System or RDBMS) are powerful in their relationships between individual tables through the use of foreign keys. Imagine this as relations in the real world between one entity (passengers) and another (plane seats) linked together by a unique identifier (plane ticket ID). Today, the majority of applications are written in an OOP language and at the same time persist their data in the relational databases. Consequently, a need for a more harmonic way to communicate between them arose.

The clash between objects and relations is a highly complex problem as these two represent fundamentally different paradigms. The differences vary from the basic data structures, through differences in manipulations and transactions to conceptual differences. A more umbrella term that covers both specific and philosophical contrasts between them is Object-relational impedance mismatch (also Paradigm Mismatch).

It is important to state that the difference between the object-oriented and relational concept is intentional as they are optimised to do what they are best at. The object-oriented programming language is powerful in its ability to describe the real world using objects as the fundamental data type and the four principles of OOP - encapsulation, abstraction, inheritance and polymorphism. On the other hand, relational databases are exceptional in persisting data and thanks to the nature of the relationship between entities (most commonly represented by tables) through primary and foreign keys, they ensure data integrity through referential integrity. They also use Structured Query Language (SQL) designed for fast data retrieving and manipulation. Since both concepts are widely used, especially together, Object Relational Mapping tools can blur the line between the OOP language and RDBMS a little bit and allow your application to make the best of both sides.

Once upon a time, there was Object Relational Mapping (ORM)...

ORM is a concept that lets you manipulate data from a database through an object-oriented paradigm. In other words, it allows you to call and manipulate data from the database using your language of choice instead of SQL. The process of converting data into objects is called hydration and usually involves converting column values into object properties. That is why ORM libraries are language-specific (here is a list of ORM libraries). That is only the basic concept, the ORM libraries are much more powerful, especially when your application and database get more complex.

Here are the benefits that ORM can bring...

Greatly supplements raw SQL as the library encapsulates SQL queries into simpler methods, allowing you to interact with the object directly. This is highly beneficial as it saves time from repetitive SQL queries. Moreover, it also means that you do not have to know SQL too well but keep in mind that understanding how a relational database works will allow you to understand the magic that is happening under the hood.
Interacts with your database in your favourite OOP language.
Allows for the use of your database of choice without the need to worry about the different SQL dialects.
Built-in features that could greatly save your time (for example optimistic and pessimistic locks).
Improves the maintainability of your code by having a clear data structure overview in classes and objects and enables check for data types.
Using SQLite in development but MySQL in production? No problem, the link between database and application is loose so changes on either side are easier to implement.

...and here are some drawbacks

ORMs take a bit of time to get used to, these libraries are definitely on the more complex end so getting the hang of them might take a bit of time. Consequently setting them up correctly to take advantage of their full potential can also be time-consuming.
There is a lot of magic happening under the hood which makes the understanding of what is happening difficult. To not lose control, it is good to double-check the documentation and do the research to make sure it’s doing what you want. *Without deeper understanding and correctly calling the methods, the SQL queries can be more performance heavy than writing SQL directly, especially when more data leads to a larger number of SQL queries (the so-called N+1 problem).

That being said, you do not have to use ORM for the OOP and RDBMS to coexist. There is a heated debate between those for and against ORM (I won’t go into the details here, but here is a cool article looking at the dispute through values or an article on why ORMs are so hated by Martin Fowler). You need to decide for yourself, whether using ORM will improve your application or instead bring unnecessary complexity. One way to avoid the problem altogether is to just use a non-relational database and/or switch to functional programming language...

So how do I set up ORM? Easy as 1, 2, 3...

The first step is to select and install a library that implements the Object-relational mapping paradigm based on the OOP language that you are using
The second step is to create a connection (in ORM terms a session) between the ORM and your database. This step can be found in the documentation of the ORM library. Here is an example of this step documented for SQLAlchemy, which is an ORM library for Python.
The third step is to set up the mapping itself. What I mean by that is creating the entity classes that are then linked to your relational tables and connecting them to each other. This process should again be nicely documented in the ORM library’s documentation. Here is an example of SQLAlchemy documentation to inspire you. Unsurprisingly, there are few ways on how to approach the mapping itself, these are called ORM Patterns. The two most common ones are active record and data mapper.

ORM Patterns: Active Record vs Data Mapper

The ORM Patterns can be viewed as philosophies on how to map data between tables and objects. Think of it as how the ORM layer between the table and objects is behaving.

With Active Record, a table is represented by a class (usually called entities) where properties of the class more or less correspond directly with the columns of the table. Therefore, an object instance is tied to a single row in the table. The biggest difference from the Data Mapper paradigm is that in addition to the data the entities also contain methods that operate on them (save, delete, insert...), allowing for much closer binding between data and objects. The major benefit of an active record is its simplicity and quick set up as what you see in one is likely represented in the other. However, because of the tighter coupling between data and methods, the object contradicts the single responsibility principle (here is a nice summary by Uncle Bob). Moreover, testing these bound objects is difficult and with increasing complexity, changes in one side can have an unwanted impact on the other. That is why Active Record is most suitable for CRUD applications. ORM libraries that support Active Record are Ruby on Rails (Ruby), Laravel’s Eloquent (PHP), Symphony’s Propel (PHP), Django’s ORM (Python).

As for Data Mapper, the set up is similar to the active record, however, the objects do not contain data manipulation methods (we cannot call a save method on the object to persist the data). Instead, the objects access the Data Mapper layer that transfers the information to the persistent database and vice versa (in Java’s Hibernate this is called the Entity Manager). Thanks to this separation, the objects do not need to know how the data are saved into the database and they do not need to inherit the ORM methods thus following the single responsibility principle. Resulting from this detachment is also a much stricter process of interaction with the database which allows for more formal process and stricter control over database access. ORM libraries that support Data Mapper are Hibernate (Java), Doctrine 2 (PHP), SQL Alchemy (Python), Entity Framework (MS .NET), Prisma (Golang).

While Active Record is trying to blur the line between them as much as possible and creates a direct link, the Data Mapper creates a true middle layer that isolates the persistent database from the app’s business logic.

...and the OOP and RDBMS lived happily ever after

At the end of the day, ORM is just a tool. A powerful, magical tool that can bridge the differences between two very different worlds and allow you, the user, to interact with relations as if they were objects in the language of your choice. However, just with any tool, it requires practice and understanding, as relying only on the magic can lead to dangerous performance issues. Whether you decide to implement ORM or not, keep in mind that the decision is entirely up to you, so make sure that you understand what your application needs, especially in the future, to keep OOP, RDBMS and you happy ever after. The end.

Discovering OpenCV with Python: Coin Amount Calculation

Tina — Mon, 10 Aug 2020 22:12:01 +0000

Since I already explored coin detection, I decided to take the real-life application of OpenCV one step further. Now that I can find the coins, naturally, the next step would be to correctly identify the coins and subsequently calculate their amount.

Detect coins

As previously explored in a separate article here, detecting the coins is the first step. I used the Hough Circle Transformation to find these and therefore had the radius of each coin and the coordinates of the center. The logic behind the value identification lies in the radii of each coin as we have only visual information, therefore the precision of the circles drawn around the coins needed to be high.

Identify coins

Since each picture can be taken from a different height, we cannot directly translate the number of pixels to millimetres. Therefore the identification of coins had to be relative based on their radii.

For example, The smallest coin (1 CZK) has a radius of 20 mm and the second to smallest coin (2 CZK) has a radius of 21.5 mm. Therefore, the 2 CZK coin’s radius is 1.075 times larger than the radius of the 1 CZK coin. Amount of pixels representing the radii in the picture must, therefore, also follow the same ratio. This logic works with any coin, but you have to let the program know, which coin is the base coin that you derive the ratios from. In my case, it was easiest to say that the smallest coin on the picture represents the smallest coin in real life so each analysed image had to have at least one 1 CZK coin.

From there, I just created a dictionary of all important information related to each coin - name, value, count, radius, ratio-to-smallest-coin and ran a for cycle for each of the coins, or to be precise, circles found by the Hough circle Transformation.

Now, all that was left was that each time a coin is identified, the value is written to the center of the coin and added to the total value variable. After running through all the coins, the total amount is calculated. As usual, all work can be found here, on GitHub.

Let’s test it!

First I tested the program on the most nicely scanned coins that the internet could offer and found this picture. After some tweaking with the parameters in Hough Transformation, I got this result:



The total amount is 88 CZK
1 CZK = 1x
2 CZK = 1x
5 CZK = 1x
10 CZK = 1x
20 CZK = 1x
50 CZK = 1x

This gave me the confidence to try to test it on a picture of coins that I took at home. I thought, just as with the picture above, that few tries with the parameters would result in the correct amount.

Unfortunately, that was not the case. See, the biggest problem was that Hough could not detect the circles well enough to fit the ratio. It either made the circle too small and hence thought it was smaller value or the opposite or did not detect them at all. I tried changing the background from white to black, different distance to take the picture, different lighting and still nothing. It took me days of trying almost every combination of parameters to realise that this was not the way. The secret lies in preprocessing the image.

The most important realization was that the output could be only as good as the input data that we are providing.

Logically, by increasing the quality of input data, the quality (here it would be precision of circles drawn) would also increase. Consequently, making sure that the picture quality was high enough and stretching the gamma to bring out the contrast helped Hough to better detect the edges. To some degree, the previous improvements like black background helped as well. Then suddenly, few tweaks later, success!

Here is the final output:



The total amount is 151 CZK
1 CZK = 4x
2 CZK = 1x
5 CZK = 5x
10 CZK = 2x
20 CZK = 5x
50 CZK = 0x

This project again represents the accumulation of previous knowledge but is more valuable for me as it has a tangible real-life application that I could test at home. The biggest lesson learnt was to think about why the program is not performing well (bad preprocessing of image) rather than just trying to change various parameters of the Hough Circle Transformation and hope for the best. As always, may the Python be with you.

Discovering OpenCV with Python: Coin Detection

Tina — Sat, 01 Aug 2020 13:42:36 +0000

This time, I would like to demonstrate the combined knowledge of edge detection and convolution and use these powers for image analysis rather than just processing. I shall use the force to detect coins in a picture and draw a circle around them!

Those of you that are more familiar with computer vision might have an “I see” moment thinking of the existing function that would save me a lot of time...but since I am a promising padawan and wanted to apply all the hard-earned knowledge to practice, I went the hard way, taking the “Never tell me the odds” (Solo, Ep V) sort of approach. Haha.

The key logic rests upon five loops

If we go backwards, to draw a circle around the coins, I need to know their radius and coordinates of their centres. To obtain that, I used convolution, that I am explaining here, to compare the coins to reference circles of increasing sizes until more than a certain percentage of the edge pixels were aligned with the circle. Lastly, to be able to convolute the circles, I needed to find the edge of the coins, which I have explored in this article. Sounds simple enough? Nevertheless, allow me to break down the approach to you in more detail, in case you would like to try it yourself, this time in the correct chronological order. As always, everything is available on GitHub.

Step 1: Find the edges

The aim is to outline the coins and find their edge. I used Gaussian blur with 5x5 kernel and Canny edge detection to find the edges. Here are the results.

Step 2: Generate the reference circles (first two loops)

Draw circles on a separate image from the smallest to largest (I checked the radius of the smallest and largest coin in the image to establish the boundaries). With each iteration increase the radius by one pixel. Using another loop, save the coordinates of the edge pixels to a list.

Step 2.1: Move the reference circle through coin image (third loop)

For each reference circle generated before, move the center of reference circle through the coin image. Optimize for coin image boundaries, as there is no point to align the center of reference circle to the first corner pixel of the coin image.

Step 2.1.1: Aligning the reference circles to the coin edges (fourth loop)

For each reference circle position in the original coin image, iterate through the list of circle coordinates and align their position to the original image. Here, we need to establish two threshold values. First is the edge threshold, i.e. how many edge pixels need to match the reference circle to be considered enough. The second threshold is the intensity threshold, i.e. the minimal whiteness of the edge pixel, to be still considered a part of an edge. If both thresholds are passed, then consider the alignment as an identified coin.

Step 3: Draw circles around the coins (fifth loop)

For all the identified coins' radiuses and center coordinates, draw a circle in the original image.

Let’s run it! ~squeal of excitement!~

The first time I ran the code, I set the parameters for min and max radius to be 40 till 57 and had a constant stream of coordinates and radiuses printing out to see the progress. It was late so I went to bed thinking that I will see beautiful circles around coins in the morning. When I got up and went to check, the program was just passing radius 44. I mean, I expected the function to run slower, with Python being an interpreted language, but this was a bit extreme.

So I optimised. Some variables were taken out of loops and were pre-processed and therefore not calculated through each iteration (e.g. circumference of reference circle). Another drastic optimisation was resizing the image to half its size. This led to a 4 times faster run as the loops had fewer pixels to go through!

Yes, there is an easier way

As I hinted at the beginning, there is, of course, an easier and much more accurate way of detecting circles in OpenCV, the so-called Hough Circle Transformation (here is a link to an alternative explanation). Not only the function gives one result per circle (unlike the manual way, as you can see below), but because OpenCV has the implementation in C++, which is a compiled language, it also runs much faster.



def hough_circle_detection(coins, min_r, max_r):

    # turn original image to grayscale

    gray = cv2.cvtColor(coins, cv2.COLOR_BGR2GRAY)


    # blur grayscale image

    blurred = cv2.medianBlur(gray, 5)


    return cv2.HoughCircles(

        blurred,  # source image (blurred and grayscaled)

        cv2.HOUGH_GRADIENT,  # type of detection

        1,  # inverse ratio of accumulator res. to image res.

        40,  # minimum distance between the centers of circles

        param1=50,  # Gradient value passed to edge detection

        param2=30,  # accumulator threshold for the circle centers

        minRadius=min_r2,  # min circle radius

        maxRadius=max_r2,  # max circle radius

    )

Here is the final comparison

The biggest challenge for me was to wrap my head around all the nested loops. What helped most was to literally draw the loops out to visually see the logic behind. Figuring out how to exactly do the alignment of comparison circle on the original image was another toughie. Of course, there is tons of room for improvement, but overall I am very pleased with the results. Hope you enjoyed the post and as usual, would love some feedback :) May the Python be with you.

Discovering OpenCV with Python: Gamma correction

Tina — Fri, 24 Jul 2020 20:06:06 +0000

Another practical exercise that I had quite some fun with was gamma correction. This concept is mainly used when we want to adjust the brightness of an image. We could also use it to restore the faded pictures to their previous depth of colour. Since I am just a Python Padawan, we will be demonstrating this on grayscale pictures but I promise, the concept works on coloured images as well.

In this short article, I will focus on the restoration of faded pictures.

A bit of (mathematical) background

The logic behind is based on a concept called linear stretching. The faded picture simply means that the values of pixels are compressed to a smaller range and therefore not using the full range of values (in grayscale that would be from 0 to 255). For example, in the faded picture below, the values of the pixels range from 101 to 160. What linear stretching does, is that it re-scales the values to their full range from 0 to 255.

Here is the mathematical formula on how this can be achieved with each value:

Python implementation

Just like in convolution, the necessary step is to cycle through every pixel and apply this mathematical formula to each of them. Be sure to check out my GitHub to see how it can be done.

And voila, below is the result, look closely at how the histogram of pixel values stretched out from the original narrow range:

Tool used to create histogram

Hope you enjoyed the post, I recommend having a go at this and playing around with different images. Again, would appreciate if you let me know your thoughts. May the Python be with you.

Discovering OpenCV using Python: Edge detection

Tina — Sun, 19 Jul 2020 18:15:07 +0000

During my learning of the ways of the force in OpenCV, it was a matter of time before encountering edge detection. This concept, that also falls under image processing, uses the same principle of convolution that I wrote about before. The aim of the edge detection is to highlight the outline of the most important information of an image. This is one of the essential steps in object detection and directly affects machines’ understanding of the world.

So what is an edge?

First of all, it is important to understand that the real world is continuous whereas a picture of the real world is made up of discrete (individual) pixels. Now let’s zoom in on the pixels for one second:

It is obvious to all of us, that the edge is where the red line is indicating; however, it is not possible to draw the edge between the smallest two units (not entirely true, there are methods, like super-sampling). Therefore, the computer checks whether a pixel is on an edge by comparing the pixel’s adjacent neighbors. Here, if we were to go from left to right, pixel number 2 is an edge as there is a significant difference between 1 and 3. Same applies for pixel number 3. The result would look something like this:

Nevertheless, in real life, pictures also include gray pixels with various intensity (value from 1 to 254). Therefore, to see how much the gradient changed (see also gradient magnitude if you are more interested), we use the first derivative to indicate the magnitude of change. It is then up to us to establish a threshold that would determine whether the magnitude of change is large enough to be considered an edge. To take it one step further, we could also use the second derivative and look for zero-crossing values, which capture the local maxima in the picture gradient (see image below).

In addition, due to the nature of edge detection, they are quite sensitive to noise (think about poor image quality; therefore, it is highly recommended to blur the image in order to smooth the noise out and therefore increase the accuracy of the edges.

Said in simpler words, first order derivatives are best for identification of strong edges by establishing a threshold whereas second order derivatives are best for locating where the edge is. Both types are noise sensitive, so blur the images first to obtain best results.

Examples of edge detection

I will be applying various types of edge detection methods on this original image below. Be sure to check out the code on my GitHub.

Original image source

First order derivative - Sobel operator

Sobel edge detector is a first order derivative edge detection method. It calculates the gradients separately along the X axis and Y axis. The kernels already incorporate a smoothing effect. There are many other types of kernels like Scharr or Prewitt.

Second order derivative - Laplacian operator

Unlike Sobel operator, Laplacian uses only one kernel, nevertheless, more popular use is to combine it with the Gaussian blur in order to reduce noise.

Canny edge detection

Canny edge detector is probably one of the most widely used edge detection methods. The reason why it is superior to the so far mentioned methods is due to “non-maximum suppression” to produce a one pixel thick edge. The detection consists of many steps, check it out here.

Real life application

Edge detection is just a first step that is necessary for further image analysis like shape detection or object identification. Apart from the most obvious use in machine vision (i.e. self driving vehicles), it is also widely used on analysis of medical images to help with diagnostics or even identify pathological objects like tumor.

All in all, this was yet again a fun way to play around with OpenCV, let me know what you think and may the Python be with you.

Discovering OpenCV using Python: Convolution

Tina — Sun, 12 Jul 2020 20:28:44 +0000

It has been three months since I started my Python development journey and under the watchful eye of my snakey Jedi master (read boyfriend working as developer) I have started to explore the mighty OpenCV library. I first heard about computer vision in connection with self-driving cars and how they identify objects; however, computer vision is much more powerful than just allowing computers to "see" the real world.

The goal of this lesson was to grasp the principle of convolution that acts as a building stone of most image processing functions.

As master Kenobi said, "the Force is what gives a Jedi his/her power" and naturally, as I am a smart padawan, I immediately grasped the meaning of these wise words in these technological times: use Python.

Let's first learn the basics of OpenCV

My first interactions with OpenCV were quite harmonious, I explored some basic image manipulation functions on image processing using useful resources on the internet and of course the documentation itself (read an image, draw a line, change color, blend two images...). After that, when I was deemed ready, it was time to get serious.

What is convolution?

Convolution is a mathematical way of combining two signals to form a third signal (Digital Signal Processing). To really understand this I-still-don't-get-it definition, I manually went through the whole process by implementing a simple 3x3 matrix.

To put it in simple words, imagine a picture, which consists of many pixels. For simplicity, let's say the image is in gray-scale. The process starts with taking a pixel (which really is just a value between 0 till 255, 0 being black and 255 being white) and considering that as "center". Now, take the convolution matrix (also called kernel), align it to the center pixel and identify the center's local neighbors up to the size of the convolution matrix. Multiply this new identified matrix with the convolution matrix (both are of same size) and add up their products (for excel geeks, SUMPRODUCT). Save the sumproduct as a value of the transformed pixel in the same location as center pixel but in a new image (not the original, as that would disrupt the values of the neighboring pixels). Doing so for every pixel of the original image is convolution (see image below).

image source

Let's get back to image processing

If you have ever edited an image to increase blur or to sharpen, then you have experienced the practical use of convolution in image processing. The transformation depends on the values and shape of the convolution matrix and thanks to the smart people who are willing to share, there are many useful sources that already provide the required matrices for various transformations. Here are the results from my application of some matrices:

All work is of course available and documented on GitHub, so check it out!

It is important to mention that convolution is not used only in image processing, but it is a powerful method that is applied in various fields (mathematics, digital signal processing, audio processing, machine learning, ...). Though the explanation provided above is closely related to image processing, the principle behind it is same for every application.

In conclusion

For those that are also at the beginning of the journey, I wholeheartedly recommend getting your hands dirty by playing around with these matrices and explore OpenCV. Fair word of warning, it is quite math intense so brush up on your derivations and matrice operations. May the Python be with you.