1600853360
In this tutorial we will implement basic search in a Django website and touch upon ways to improve it with more advanced options.
Note: I gave a version of this tutorial at DjangoCon US 2019. You can see the video here:
I also have a Django Chat podcast episode all about search in discussion with Django Fellow Carlton Gibson. Complete source code can be found on Github.
To start let’s create a new Django project ( see here if you need help with this). I’ve done so in a directory called search
. On your command line, enter the following commands to install the latest version with Pipenv
, create a project called citysearch_project
, set up the initial database via migrate
, and then start the local web server with runserver
.
#django #python
1620177818
Welcome to my blog , hey everyone in this article you learn how to customize the Django app and view in the article you will know how to register and unregister models from the admin view how to add filtering how to add a custom input field, and a button that triggers an action on all objects and even how to change the look of your app and page using the Django suit package let’s get started.
#django #create super user django #customize django admin dashboard #django admin #django admin custom field display #django admin customization #django admin full customization #django admin interface #django admin register all models #django customization
1620200340
Welcome to my Blog, in this article we learn about how to integrate CKEditor in Django and inside this, we enable the image upload button to add an image in the blog from local. When I add a CKEditor first time in my project then it was very difficult for me but now I can easily implement it in my project so you can learn and implement CKEditor in your project easily.
#django #add image upload in ckeditor #add image upload option ckeditor #ckeditor image upload #ckeditor image upload from local #how to add ckeditor in django #how to add image upload plugin in ckeditor #how to install ckeditor in django #how to integrate ckeditor in django #image upload in ckeditor #image upload option in ckeditor
1620185280
Welcome to my blog, hey everyone in this article we are going to be working with queries in Django so for any web app that you build your going to want to write a query so you can retrieve information from your database so in this article I’ll be showing you all the different ways that you can write queries and it should cover about 90% of the cases that you’ll have when you’re writing your code the other 10% depend on your specific use case you may have to get more complicated but for the most part what I cover in this article should be able to help you so let’s start with the model that I have I’ve already created it.
**Read More : **How to make Chatbot in Python.
Read More : Django Admin Full Customization step by step
let’s just get into this diagram that I made so in here:
Describe each parameter in Django querset
we’re making a simple query for the myModel table so we want to pull out all the information in the database so we have this variable which is gonna hold a return value and we have our myModel models so this is simply the myModel model name so whatever you named your model just make sure you specify that and we’re gonna access the objects attribute once we get that object’s attribute we can simply use the all method and this will return all the information in the database so we’re gonna start with all and then we will go into getting single items filtering that data and go to our command prompt.
Here and we’ll actually start making our queries from here to do this let’s just go ahead and run** Python manage.py shell** and I am in my project file so make sure you’re in there when you start and what this does is it gives us an interactive shell to actually start working with our data so this is a lot like the Python shell but because we did manage.py it allows us to do things a Django way and actually query our database now open up the command prompt and let’s go ahead and start making our first queries.
#django #django model queries #django orm #django queries #django query #model django query #model query #query with django
1593056092
There are countless Python packages easily added to any project. But there are some packages you can't help but use in every Django web app because they've proven to be extremely beneficial and time-saving.
We decided to focus on those packages, the ones you'll end up installing regularly, and explain the installation and configurations needed to get them up and running.
While some Python packages offer cool functionality needed for one specific project, the packages discussed below are the bread-and-butter of the Django packages.
Django Web Framework
But we can't jump into Django packages by talking about the Django web framework.
A web framework is comprised of modules or packages that allow developers to quickly write web applications without having to handle the precise details of the protocol and other web app management.
Django is considered a full-stack web framework in which a database, application server, template engine, authentication module, and dispatcher are all neatly combined to create a high-level framework. These individual components are included upon package installation and often just need some minor configurations for them to function correctly.
macOS Terminal
(env)User-Macbook:env user$ pip install django
Windows Command Prompt
(env)C:\Users\Owner\desktop\env> pip install django
At the time of this article, the latest version of Django is 3.0.8. To install the latest version, all you need is the command pip install django
.
If you wish to install a different version, then specify the version number as demonstrated in the command pip install django==2.1.15
. Please note that there are two equal signs after the package name, not one.
Once the installation is complete, you will need to start configuring your Django web app with a project and an application. If you want to jump right into building your Django web app, check out the quick start guides to Django Installation and Django Configuration. Or if you are just getting started and need a step-by-step tutorial, see the Beginner's Guide to Django Web Apps.
But we are here to talk about Python Packages meant for Django web apps, not basic Django configurations so we'll keep moving.
We have a lot to cover.
(1) Django TinyMCE4 Lite
macOS Terminal
(env)User-Macbook:mysite user$ pip install django-tinymce4-lite
Windows Command Prompt
(env) C:\Users\Owner\Desktop\Code\env\mysite>pip install django-tinymce4-lite
Once you have finished the basic configurations of your web app, you can install a cool Python package named django-tinymce4-lite. This package is actually a smaller version of the Django application django-tinymce4 that contains a widget to render Django form fields as TinyMCE editors.
TinyMCE is a WYSIWYG ("what you see is what you get") text editor that converts HTML elements into editor instances or "plain text". This python package is highly recommended if you are looking to create a blog as you can easily edit text that is then formatted to HTML within the actual template.
env > mysite > mysite > settings.py
INSTALLED_APPS = [
...
...
'tinymce',
]
TINYMCE_DEFAULT_CONFIG = {
'height': 400,
'width': 1000,
'cleanup_on_startup': True,
'custom_undo_redo_levels': 20,
'selector': 'textarea',
'browser_spellcheck': 'True',
'theme': 'modern',
'plugins': '''
textcolor save link image media preview codesample contextmenu
table code lists fullscreen insertdatetime nonbreaking
contextmenu directionality searchreplace wordcount visualblocks
visualchars code fullscreen autolink lists charmap print hr
anchor pagebreak
''',
'toolbar1': '''
fullscreen preview bold italic underline | fontselect,
fontsizeselect | forecolor backcolor | alignleft alignright |
aligncenter alignjustify | indent outdent | bullist numlist table |
| link image media | codesample
''',
'toolbar2': '''
visualblocks visualchars |
charmap hr pagebreak nonbreaking anchor | code |
''',
'contextmenu': 'formats | link image',
'menubar': True,
'statusbar': True,
}
After installation, you will need to add tinymce
to the list of installed apps in the settings file then add the default configurations below. The default configurations define the height, weight, spellcheck, and toolbars.
env > mysite > mysite > urls.py
"""mysite URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include ('main.urls')),
path('tinymce/', include('tinymce.urls')), #add this
]
Then add the TinyMCE path to the project URLs.
env > mysite > main > models.py
from django.db import models
from tinymce import HTMLField
class MyModel(models.Model):
...
content = HTMLField()
Finally, you can quickly add TinyMCE to the Django model by importing HTMLField
at the top of the page then calling it in the model field. If you are unsure of how to use Django models, check out the article, How to use Django Models for more information.
(2) Pillow
macOS Terminal
(env)User-Macbook:mysite user$ pip install Pillow
Windows Command Prompt
(env) C:\Users\Owner\Desktop\Code\env\mysite>pip install Pillow
So, this package is not specific to Django but is needed for image and file uploads to work correctly in a Django project. If you are looking to have a media upload field in your Django model for let's say an article cover image, you need to install Pillow. It's a Python Imaging Library fork for uploading files correctly.
env > mysite > mysite > settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
Once installed, you need to add a media folder URL and ROOT directory to your settings file.
env > mysite > mysite > urls.py
from django.contrib import admin
from django.urls import path, include
from django.conf import settings #add this
from django.conf.urls.static import static #add this
urlpatterns = [
path('admin/', admin.site.urls),
path('', include ('main.urls')),
]
if settings.DEBUG: #add this
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
Then you need to add the necessary imports at the top of your project's URL file and specify the URL pattern to the media folder. Keep in mind that the media upload will not work in production given the if condition. You will need to reconfigure your media upload location when you are ready to deploy.
env > mysite > main > models.py
from django.db import models
class MyModel(models.Model):
...
image = models.ImageField(upload_to='images/')
Now to upload an image, go to your models file and add an ImageField
with the upload location as 'images/'
. The uploaded images will then be added to a media > images folder that will automatically be created upon the upload.
For more information about correctly creating a model, accessing the upload location in the Django admin, and rendering the model in a template, refer to How to use Django Models.
(3) Django Crispy Forms
macOS Terminal
(env)User-Macbook:mysite user$ pip install django-crispy-forms
Windows Command Prompt
(env) C:\Users\Owner\desktop\code\env\mysite>pip install django-crispy-forms
Let's talk about Django forms. Their functionality is great but their appearance isn't the best. You can choose to install django-crispy-forms in your project to quickly solve this issue.
env > mysite > mysite > settings.py
INSTALLED_APPS = [
...
'crispy_forms',
]
CRISPY_TEMPLATE_PACK = 'uni_form'
For it to function correctly, you will need to go to the settings file and add crispy_forms
to the installed apps list. Keep in mind that there is an underscore between crispy and forms.
Then you need to specify the crispy template pack. The one listed below is the default but if you are using the Bootstrap CSS framework, check out how to integrate Bootstrap with django-crispy-forms.
env > mysite > main > templates > main > contact.html
{% load crispy_forms_tags %}
<form method="post">
{% csrf_token %}
{{form|crispy}}
<button type="submit">Submit</button>
</form>
The package django-crispy-forms is added to the project in the form of a filter added within the Django template language {{form}}
. This format will not only call all of the form fields but also format each field according to the crispy form template pack specified in the settings.
Refer to the article Render Forms with Django Crispy Forms for more information regarding the form rendering process using crispy forms and the article Build a Django Contact Form with Email Backend for more general information on how to build a Django form.
(4) Django Tables
macOS Terminal
(env)User-Macbook:mysite user$ pip install django-tables2
Windows Command Prompt
(env) C:\Users\Owner\desktop\code\env\mysite>pip install django-tables2
Now let's say you want to create a dynamic table in your Django project that connects to a model. Install django-tables2, a Django-specific package for table rendering.
env > mysite > mysite > settings.py
INSTALLED_APPS = [
...
'django_tables2',
]
Add Django tables to the installed apps.
env > mysite > main > models.py
from django.db import models
class MyModel(models.Model):
name = models.CharField(max_length=100, verbose_name="full name")
email = models.EmailField(max_length=200)
Then create the model you wish to use in the table.
After you have created the model, you will need to run the commands python manage.py makemigrations
and python manage.py migrate
to add the model to the database and add your model objects via the Django admin. For more instruction, see How to Use Django Models.
env > mysite > main > (New File) tables.py
import django_tables2 as tables
from .models import MyModel
class MyTable(tables.Table):
class Meta:
model = MyModel
fields = ("name", "email", )
Now, create a new file called tables.py in the application folder, main, and import tables
from django_tables2
at the top of the file. Then create a class that specifies the model and field names.
env > mysite > main > views.py (Class-based views)
...
from django_tables2 import SingleTableView
from .models import MyModel
from .tables import MyTable
class ListView(SingleTableView):
model = MyModel
table_class = MyTable
template_name = 'main/table.html'
If you are looking to use class-based views, go to the views file and add the view class specifying the model, table, and template. Again, you will need to import the necessary variables from their appropriate files at the top of the file.
env > mysite > main > urls.py (Class-based views)
from django.urls import path
from . import views
app_name = "main"
urlpatterns = [
path("table", views.ListView.as_view()),
]
Then make sure there is a tables URL in the app urls.py file. If you are looking to learn more about class-based views, check out the article Django Class-based Views.
env > mysite > main > views.py (Function-based views)
...
from django_tables2 import SingleTableView
from .models import MyModel
from .tables import MyTable
def list(request):
model = MyModel.objects.all()
table = MyTable(model)
return render(request=request, template_name="main/table.html", context={"model":model, "table":table})
Or you can choose to do function-based views in the views.py file. Either one will work, but the format is different.
env > mysite > main > urls.py (Function-based views)
from django.urls import path
from . import views
app_name = "main"
urlpatterns = [
path("table", views.list, name="list"),
]
Then add the table URL in the app urls.py file.
env > mysite > main > templates > main > (New File) table.html
{% load render_table from django_tables2 %}
<div>
{% render_table table %}
</div>
With the views and URLs configured, you can render the table in the template by loading in render_table from django_tables2
at the top of the file then calling render_table
and the context of the table passed in the view.
By default, the class-based view passes the table context as just table
, and in the function-based view, we also chose to specify the context of the table as table
.
If you want to add Bootstrap CSS to the table:
env > mysite > main > tables.py
import django_tables2 as tables
from .models import MyModel
class MyTable(tables.Table):
class Meta:
model = MyModel
template_name = "django_tables2/bootstrap4.html"
fields = ("name", "email",)
Add a template name to the tables.py file connecting to the Bootstrap template. This and other template files can be found in the Lib > site-packages > django_tables2 > templates > django_tables2 folder of your project.
env > mysite > main > templates > main > (New File) table.html
{% extends "main/header.html" %}
{% block content %}
{% load render_table from django_tables2 %}
<div class="container">
{% render_table table %}
</div>
{% endblock %}
Then you can extend to a header that loads in the Bootstrap CDNs. This is the easiest way of adding Bootstrap to all of your templates using the same piece of code.
If you are unsure of how to use the extends tag with the Bootstrap CDNs, check out the Django extends tag and block content section in the Beginner's Guide to Django Web Apps.
(5) Django Filter
macOS Terminal
(env)User-Macbook:mysite user$ pip install django-filter
Windows Command Prompt
(env) C:\Users\Owner\desktop\code\env\mysite> pip install django-filter
Now that you have a table, you probably want the ability to search for specific content within the rows and filter the table by its results. The django-filter package can easily be used on top of the django-tables2 package to accomplish this.
env > mysite > mysite > settings.py
INSTALLED_APPS = [
...
'django_filters',
]
Add Django filters to the installed apps. Note that is django_filters
not django_filter
.
env > mysite > main > (New File) filters.py
import django_filters
from .models import MyModel
class MyFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
class Meta:
model = MyModel
fields = {'name', 'email'}
Now, create a new file called filters.py in the application folder, main, and import django_filters. Then list the model and the model fields you wish to filter by.
You can also choose to add django_filters.CharFilter
to the class. In the example above, the filter displays any rows where the name column contains the query specified.
You can also choose to do django_filters.CharFilter(lookup_expr='iexact')
if you are looking to filter only by an exact query match.
env > mysite > main > views.py (Class-based views)
...
from django_tables2 import SingleTableMixin
from django_filters.views import FilterView
from .models import MyModel
from .tables import MyTable
from .filters import MyFilter
class ListView(SingleTableMixin, FilterView):
model = MyModel
table_class = MyTable
template_name = 'main/table.html'
filterset_class = MyFilter
Then for a class-based view, import FilterView from django_filters.views at the top of the file and change django_tables2 import from SingleTableView
to SingleTableMixin
. You will also need to import your custom filter from the filter.py file.
In the class view, ListView
will now inherit SingleTableMixin
and FilterView
and list the filterset_class
as the custom filter within it.
env > mysite > main > templates > main > table.html
{% load render_table from django_tables2 %}
<div>
<br>
<form action="" method="GET">
{{filter.form}}
<button type="submit">Filter</button>
</form>
<br>
{% render_table table %}
</div>
With class-based views, the URL will stay the same but you will need to add a form HTML element and the Django Template language calling the filter and the form within the template. You also need a submit button within the form to submit your filter queries. Nothing changes about the way the table renders.
env > mysite > main > views.py (Function-based views)
...
from django_tables2.views import SingleTableMixin
from django_filter import FilterView
from .models import MyModel
from .tables import MyTable
def list(request):
model = MyModel.objects.all()
filterset_class = MyFilter(request.GET, model)
table = MyTable(filterset_class.qs)
return render(request=request, template_name="main/table.html", context={"model":model, "table":table, "filterset_class":filterset_class})
If using function-based views, make the same imports and the class-based views, then create an instance of the MyFilter class and pass in a GET request and model as arguments. Pass in the filterset_class
as a queryset argument in the table then lists the filterset_class
as context in the return render.
env > mysite > main > templates > main > table.html
{% load render_table from django_tables2 %}
<div>
<br>
<form action="" method="GET">
{{filterset_class.form}}
<button type="submit">Filter</button>
</form>
<br>
{% render_table table %}
</div>
With function-based views, you will need to specify the filterset_class
, or the context declared, as the filter on the form. Everything else is the same format as the class-based template.
If you are looking to style the form, either scroll back up to the Django Crispy Forms section or click at the article mentioned earlier, Render Forms with Django Crispy Forms.
(6) Python Decouple
macOS Terminal
(env)User-Macbook:mysite user$ pip install python-decouple
Windows Command Prompt
(env) C:\Users\Owner\desktop\code\env\mysite> pip install python-decouple
The last and arguably most important Python package we will discuss is python-decouple. This package hides your sensitive configuration keys and information from hackers. It was created for Django but it is now considered a "generic tool" for separating configuration settings.
env > mysite > (New File) .env
SECRET_KEY =sdjioerb43buobnodhioh4i34hgip
DEBUG =True
env > mysite > mysite > settings.py
from decouple import config
SECRET_KEY = config('SECRET_KEY')
DEBUG = config('DEBUG', cast=bool)
Create a new file named .env in the project folder then import config in the settings.py file. Then transfer all of the configuration settings and variables you wish to hide to the .env file and call each variable using the python-decouple format of config('variable')
.
#programming #django #python
1646698200
What is face recognition? Or what is recognition? When you look at an apple fruit, your mind immediately tells you that this is an apple fruit. This process, your mind telling you that this is an apple fruit is recognition in simple words. So what is face recognition then? I am sure you have guessed it right. When you look at your friend walking down the street or a picture of him, you recognize that he is your friend Paulo. Interestingly when you look at your friend or a picture of him you look at his face first before looking at anything else. Ever wondered why you do that? This is so that you can recognize him by looking at his face. Well, this is you doing face recognition.
But the real question is how does face recognition works? It is quite simple and intuitive. Take a real life example, when you meet someone first time in your life you don't recognize him, right? While he talks or shakes hands with you, you look at his face, eyes, nose, mouth, color and overall look. This is your mind learning or training for the face recognition of that person by gathering face data. Then he tells you that his name is Paulo. At this point your mind knows that the face data it just learned belongs to Paulo. Now your mind is trained and ready to do face recognition on Paulo's face. Next time when you will see Paulo or his face in a picture you will immediately recognize him. This is how face recognition work. The more you will meet Paulo, the more data your mind will collect about Paulo and especially his face and the better you will become at recognizing him.
Now the next question is how to code face recognition with OpenCV, after all this is the only reason why you are reading this article, right? OK then. You might say that our mind can do these things easily but to actually code them into a computer is difficult? Don't worry, it is not. Thanks to OpenCV, coding face recognition is as easier as it feels. The coding steps for face recognition are same as we discussed it in real life example above.
OpenCV comes equipped with built in face recognizer, all you have to do is feed it the face data. It's that simple and this how it will look once we are done coding it.
OpenCV has three built in face recognizers and thanks to OpenCV's clean coding, you can use any of them by just changing a single line of code. Below are the names of those face recognizers and their OpenCV calls.
cv2.face.createEigenFaceRecognizer()
cv2.face.createFisherFaceRecognizer()
cv2.face.createLBPHFaceRecognizer()
We have got three face recognizers but do you know which one to use and when? Or which one is better? I guess not. So why not go through a brief summary of each, what you say? I am assuming you said yes :) So let's dive into the theory of each.
This algorithm considers the fact that not all parts of a face are equally important and equally useful. When you look at some one you recognize him/her by his distinct features like eyes, nose, cheeks, forehead and how they vary with respect to each other. So you are actually focusing on the areas of maximum change (mathematically speaking, this change is variance) of the face. For example, from eyes to nose there is a significant change and same is the case from nose to mouth. When you look at multiple faces you compare them by looking at these parts of the faces because these parts are the most useful and important components of a face. Important because they catch the maximum change among faces, change the helps you differentiate one face from the other. This is exactly how EigenFaces face recognizer works.
EigenFaces face recognizer looks at all the training images of all the persons as a whole and try to extract the components which are important and useful (the components that catch the maximum variance/change) and discards the rest of the components. This way it not only extracts the important components from the training data but also saves memory by discarding the less important components. These important components it extracts are called principal components. Below is an image showing the principal components extracted from a list of faces.
Principal Components source
You can see that principal components actually represent faces and these faces are called eigen faces and hence the name of the algorithm.
So this is how EigenFaces face recognizer trains itself (by extracting principal components). Remember, it also keeps a record of which principal component belongs to which person. One thing to note in above image is that Eigenfaces algorithm also considers illumination as an important component.
Later during recognition, when you feed a new image to the algorithm, it repeats the same process on that image as well. It extracts the principal component from that new image and compares that component with the list of components it stored during training and finds the component with the best match and returns the person label associated with that best match component.
Easy peasy, right? Next one is easier than this one.
This algorithm is an improved version of EigenFaces face recognizer. Eigenfaces face recognizer looks at all the training faces of all the persons at once and finds principal components from all of them combined. By capturing principal components from all the of them combined you are not focusing on the features that discriminate one person from the other but the features that represent all the persons in the training data as a whole.
This approach has drawbacks, for example, images with sharp changes (like light changes which is not a useful feature at all) may dominate the rest of the images and you may end up with features that are from external source like light and are not useful for discrimination at all. In the end, your principal components will represent light changes and not the actual face features.
Fisherfaces algorithm, instead of extracting useful features that represent all the faces of all the persons, it extracts useful features that discriminate one person from the others. This way features of one person do not dominate over the others and you have the features that discriminate one person from the others.
Below is an image of features extracted using Fisherfaces algorithm.
Fisher Faces source
You can see that features extracted actually represent faces and these faces are called fisher faces and hence the name of the algorithm.
One thing to note here is that even in Fisherfaces algorithm if multiple persons have images with sharp changes due to external sources like light they will dominate over other features and affect recognition accuracy.
Getting bored with this theory? Don't worry, only one face recognizer is left and then we will dive deep into the coding part.
I wrote a detailed explaination on Local Binary Patterns Histograms in my previous article on face detection using local binary patterns histograms. So here I will just give a brief overview of how it works.
We know that Eigenfaces and Fisherfaces are both affected by light and in real life we can't guarantee perfect light conditions. LBPH face recognizer is an improvement to overcome this drawback.
Idea is to not look at the image as a whole instead find the local features of an image. LBPH alogrithm try to find the local structure of an image and it does that by comparing each pixel with its neighboring pixels.
Take a 3x3 window and move it one image, at each move (each local part of an image), compare the pixel at the center with its neighbor pixels. The neighbors with intensity value less than or equal to center pixel are denoted by 1 and others by 0. Then you read these 0/1 values under 3x3 window in a clockwise order and you will have a binary pattern like 11100011 and this pattern is local to some area of the image. You do this on whole image and you will have a list of local binary patterns.
LBP Labeling
Now you get why this algorithm has Local Binary Patterns in its name? Because you get a list of local binary patterns. Now you may be wondering, what about the histogram part of the LBPH? Well after you get a list of local binary patterns, you convert each binary pattern into a decimal number (as shown in above image) and then you make a histogram of all of those values. A sample histogram looks like this.
Sample Histogram
I guess this answers the question about histogram part. So in the end you will have one histogram for each face image in the training data set. That means if there were 100 images in training data set then LBPH will extract 100 histograms after training and store them for later recognition. Remember, algorithm also keeps track of which histogram belongs to which person.
Later during recognition, when you will feed a new image to the recognizer for recognition it will generate a histogram for that new image, compare that histogram with the histograms it already has, find the best match histogram and return the person label associated with that best match histogram.
Below is a list of faces and their respective local binary patterns images. You can see that the LBP images are not affected by changes in light conditions.
LBP Faces source
The theory part is over and now comes the coding part! Ready to dive into coding? Let's get into it then.
Coding Face Recognition with OpenCV
The Face Recognition process in this tutorial is divided into three steps.
[There should be a visualization diagram for above steps here]
To detect faces, I will use the code from my previous article on face detection. So if you have not read it, I encourage you to do so to understand how face detection works and its Python coding.
Before starting the actual coding we need to import the required modules for coding. So let's import them first.
#import OpenCV module
import cv2
#import os module for reading training data directories and paths
import os
#import numpy to convert python lists to numpy arrays as
#it is needed by OpenCV face recognizers
import numpy as np
#matplotlib for display our images
import matplotlib.pyplot as plt
%matplotlib inline
The more images used in training the better. Normally a lot of images are used for training a face recognizer so that it can learn different looks of the same person, for example with glasses, without glasses, laughing, sad, happy, crying, with beard, without beard etc. To keep our tutorial simple we are going to use only 12 images for each person.
So our training data consists of total 2 persons with 12 images of each person. All training data is inside training-data
folder. training-data
folder contains one folder for each person and each folder is named with format sLabel (e.g. s1, s2)
where label is actually the integer label assigned to that person. For example folder named s1 means that this folder contains images for person 1. The directory structure tree for training data is as follows:
training-data
|-------------- s1
| |-- 1.jpg
| |-- ...
| |-- 12.jpg
|-------------- s2
| |-- 1.jpg
| |-- ...
| |-- 12.jpg
The test-data
folder contains images that we will use to test our face recognizer after it has been successfully trained.
As OpenCV face recognizer accepts labels as integers so we need to define a mapping between integer labels and persons actual names so below I am defining a mapping of persons integer labels and their respective names.
Note: As we have not assigned label 0
to any person so the mapping for label 0 is empty.
#there is no label 0 in our training data so subject name for index/label 0 is empty
subjects = ["", "Tom Cruise", "Shahrukh Khan"]
You may be wondering why data preparation, right? Well, OpenCV face recognizer accepts data in a specific format. It accepts two vectors, one vector is of faces of all the persons and the second vector is of integer labels for each face so that when processing a face the face recognizer knows which person that particular face belongs too.
For example, if we had 2 persons and 2 images for each person.
PERSON-1 PERSON-2
img1 img1
img2 img2
Then the prepare data step will produce following face and label vectors.
FACES LABELS
person1_img1_face 1
person1_img2_face 1
person2_img1_face 2
person2_img2_face 2
Preparing data step can be further divided into following sub-steps.
s1, s2
.sLabel
where Label
is an integer representing the label we have assigned to that subject. So for example, folder name s1
means that the subject has label 1, s2 means subject label is 2 and so on. The label extracted in this step is assigned to each face detected in the next step.[There should be a visualization for above steps here]
Did you read my last article on face detection? No? Then you better do so right now because to detect faces, I am going to use the code from my previous article on face detection. So if you have not read it, I encourage you to do so to understand how face detection works and its coding. Below is the same code.
#function to detect face using OpenCV
def detect_face(img):
#convert the test image to gray image as opencv face detector expects gray images
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#load OpenCV face detector, I am using LBP which is fast
#there is also a more accurate but slow Haar classifier
face_cascade = cv2.CascadeClassifier('opencv-files/lbpcascade_frontalface.xml')
#let's detect multiscale (some images may be closer to camera than others) images
#result is a list of faces
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5);
#if no faces are detected then return original img
if (len(faces) == 0):
return None, None
#under the assumption that there will be only one face,
#extract the face area
(x, y, w, h) = faces[0]
#return only the face part of the image
return gray[y:y+w, x:x+h], faces[0]
I am using OpenCV's LBP face detector. On line 4, I convert the image to grayscale because most operations in OpenCV are performed in gray scale, then on line 8 I load LBP face detector using cv2.CascadeClassifier
class. After that on line 12 I use cv2.CascadeClassifier
class' detectMultiScale
method to detect all the faces in the image. on line 20, from detected faces I only pick the first face because in one image there will be only one face (under the assumption that there will be only one prominent face). As faces returned by detectMultiScale
method are actually rectangles (x, y, width, height) and not actual faces images so we have to extract face image area from the main image. So on line 23 I extract face area from gray image and return both the face image area and face rectangle.
Now you have got a face detector and you know the 4 steps to prepare the data, so are you ready to code the prepare data step? Yes? So let's do it.
#this function will read all persons' training images, detect face from each image
#and will return two lists of exactly same size, one list
# of faces and another list of labels for each face
def prepare_training_data(data_folder_path):
#------STEP-1--------
#get the directories (one directory for each subject) in data folder
dirs = os.listdir(data_folder_path)
#list to hold all subject faces
faces = []
#list to hold labels for all subjects
labels = []
#let's go through each directory and read images within it
for dir_name in dirs:
#our subject directories start with letter 's' so
#ignore any non-relevant directories if any
if not dir_name.startswith("s"):
continue;
#------STEP-2--------
#extract label number of subject from dir_name
#format of dir name = slabel
#, so removing letter 's' from dir_name will give us label
label = int(dir_name.replace("s", ""))
#build path of directory containin images for current subject subject
#sample subject_dir_path = "training-data/s1"
subject_dir_path = data_folder_path + "/" + dir_name
#get the images names that are inside the given subject directory
subject_images_names = os.listdir(subject_dir_path)
#------STEP-3--------
#go through each image name, read image,
#detect face and add face to list of faces
for image_name in subject_images_names:
#ignore system files like .DS_Store
if image_name.startswith("."):
continue;
#build image path
#sample image path = training-data/s1/1.pgm
image_path = subject_dir_path + "/" + image_name
#read image
image = cv2.imread(image_path)
#display an image window to show the image
cv2.imshow("Training on image...", image)
cv2.waitKey(100)
#detect face
face, rect = detect_face(image)
#------STEP-4--------
#for the purpose of this tutorial
#we will ignore faces that are not detected
if face is not None:
#add face to list of faces
faces.append(face)
#add label for this face
labels.append(label)
cv2.destroyAllWindows()
cv2.waitKey(1)
cv2.destroyAllWindows()
return faces, labels
I have defined a function that takes the path, where training subjects' folders are stored, as parameter. This function follows the same 4 prepare data substeps mentioned above.
(step-1) On line 8 I am using os.listdir
method to read names of all folders stored on path passed to function as parameter. On line 10-13 I am defining labels and faces vectors.
(step-2) After that I traverse through all subjects' folder names and from each subject's folder name on line 27 I am extracting the label information. As folder names follow the sLabel
naming convention so removing the letter s
from folder name will give us the label assigned to that subject.
(step-3) On line 34, I read all the images names of of the current subject being traversed and on line 39-66 I traverse those images one by one. On line 53-54 I am using OpenCV's imshow(window_title, image)
along with OpenCV's waitKey(interval)
method to display the current image being traveresed. The waitKey(interval)
method pauses the code flow for the given interval (milliseconds), I am using it with 100ms interval so that we can view the image window for 100ms. On line 57, I detect face from the current image being traversed.
(step-4) On line 62-66, I add the detected face and label to their respective vectors.
But a function can't do anything unless we call it on some data that it has to prepare, right? Don't worry, I have got data of two beautiful and famous celebrities. I am sure you will recognize them!
Let's call this function on images of these beautiful celebrities to prepare data for training of our Face Recognizer. Below is a simple code to do that.
#let's first prepare our training data
#data will be in two lists of same size
#one list will contain all the faces
#and other list will contain respective labels for each face
print("Preparing data...")
faces, labels = prepare_training_data("training-data")
print("Data prepared")
#print total faces and labels
print("Total faces: ", len(faces))
print("Total labels: ", len(labels))
Preparing data...
Data prepared
Total faces: 23
Total labels: 23
This was probably the boring part, right? Don't worry, the fun stuff is coming up next. It's time to train our own face recognizer so that once trained it can recognize new faces of the persons it was trained on. Read? Ok then let's train our face recognizer.
As we know, OpenCV comes equipped with three face recognizers.
cv2.face.createEigenFaceRecognizer()
cv2.face.createFisherFaceRecognizer()
cv2.face.LBPHFisherFaceRecognizer()
I am going to use LBPH face recognizer but you can use any face recognizer of your choice. No matter which of the OpenCV's face recognizer you use the code will remain the same. You just have to change one line, the face recognizer initialization line given below.
#create our LBPH face recognizer
face_recognizer = cv2.face.createLBPHFaceRecognizer()
#or use EigenFaceRecognizer by replacing above line with
#face_recognizer = cv2.face.createEigenFaceRecognizer()
#or use FisherFaceRecognizer by replacing above line with
#face_recognizer = cv2.face.createFisherFaceRecognizer()
Now that we have initialized our face recognizer and we also have prepared our training data, it's time to train the face recognizer. We will do that by calling the train(faces-vector, labels-vector)
method of face recognizer.
#train our face recognizer of our training faces
face_recognizer.train(faces, np.array(labels))
Did you notice that instead of passing labels
vector directly to face recognizer I am first converting it to numpy array? This is because OpenCV expects labels vector to be a numpy
array.
Still not satisfied? Want to see some action? Next step is the real action, I promise!
Now comes my favorite part, the prediction part. This is where we actually get to see if our algorithm is actually recognizing our trained subjects's faces or not. We will take two test images of our celeberities, detect faces from each of them and then pass those faces to our trained face recognizer to see if it recognizes them.
Below are some utility functions that we will use for drawing bounding box (rectangle) around face and putting celeberity name near the face bounding box.
#function to draw rectangle on image
#according to given (x, y) coordinates and
#given width and heigh
def draw_rectangle(img, rect):
(x, y, w, h) = rect
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
#function to draw text on give image starting from
#passed (x, y) coordinates.
def draw_text(img, text, x, y):
cv2.putText(img, text, (x, y), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 255, 0), 2)
First function draw_rectangle
draws a rectangle on image based on passed rectangle coordinates. It uses OpenCV's built in function cv2.rectangle(img, topLeftPoint, bottomRightPoint, rgbColor, lineWidth)
to draw rectangle. We will use it to draw a rectangle around the face detected in test image.
Second function draw_text
uses OpenCV's built in function cv2.putText(img, text, startPoint, font, fontSize, rgbColor, lineWidth)
to draw text on image.
Now that we have the drawing functions, we just need to call the face recognizer's predict(face)
method to test our face recognizer on test images. Following function does the prediction for us.
#this function recognizes the person in image passed
#and draws a rectangle around detected face with name of the
#subject
def predict(test_img):
#make a copy of the image as we don't want to chang original image
img = test_img.copy()
#detect face from the image
face, rect = detect_face(img)
#predict the image using our face recognizer
label= face_recognizer.predict(face)
#get name of respective label returned by face recognizer
label_text = subjects[label]
#draw a rectangle around face detected
draw_rectangle(img, rect)
#draw name of predicted person
draw_text(img, label_text, rect[0], rect[1]-5)
return img
predict(face)
method. This method will return a lableNow that we have the prediction function well defined, next step is to actually call this function on our test images and display those test images to see if our face recognizer correctly recognized them. So let's do it. This is what we have been waiting for.
print("Predicting images...")
#load test images
test_img1 = cv2.imread("test-data/test1.jpg")
test_img2 = cv2.imread("test-data/test2.jpg")
#perform a prediction
predicted_img1 = predict(test_img1)
predicted_img2 = predict(test_img2)
print("Prediction complete")
#create a figure of 2 plots (one for each test image)
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))
#display test image1 result
ax1.imshow(cv2.cvtColor(predicted_img1, cv2.COLOR_BGR2RGB))
#display test image2 result
ax2.imshow(cv2.cvtColor(predicted_img2, cv2.COLOR_BGR2RGB))
#display both images
cv2.imshow("Tom cruise test", predicted_img1)
cv2.imshow("Shahrukh Khan test", predicted_img2)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.waitKey(1)
cv2.destroyAllWindows()
Predicting images...
Prediction complete
wohooo! Is'nt it beautiful? Indeed, it is!
Face Recognition is a fascinating idea to work on and OpenCV has made it extremely simple and easy for us to code it. It just takes a few lines of code to have a fully working face recognition application and we can switch between all three face recognizers with a single line of code change. It's that simple.
Although EigenFaces, FisherFaces and LBPH face recognizers are good but there are even better ways to perform face recognition like using Histogram of Oriented Gradients (HOGs) and Neural Networks. So the more advanced face recognition algorithms are now a days implemented using a combination of OpenCV and Machine learning. I have plans to write some articles on those more advanced methods as well, so stay tuned!
Download Details:
Author: informramiz
Source Code: https://github.com/informramiz/opencv-face-recognition-python
License: MIT License