Project Tittle : AI Virtual Mouse

An AI based mouse controller we will first detect the hand landmarks and then track and click
based on these points. we will also apply some smoothing techniques to make it more usable

So then we go in pycharm project and we have created it by the name AI virtual mouse
so we have here is the hand tracking module now that we go written this module from scratch
so the project we have added a lot of different methods to this particular class so now the thing is
that in our project we added the fingers up method and the fine distance method and this will
allow us to very easily create this project .

Now if we have to go to file settings and we have to go to the interpreter and we have to add the
opencv python and we have to install it and then we also have to install mediapipe through
which we will get all this hand tracking functionality
so media pipe and we are going to hit install okay so now both of these are installed and we can
hit okay so the first thing we will do we will go and create a new python file and we will call it
ai virtual mouse project . so we will first import cv2 then we are going to import numpy as np
and then we will import our module which is hand tracking module as htm and then we are
going to imports .Now apart from all of this that we will do is adding a new library which will
allow us to move around with our mouse so with the python script we will be able to move our
mouse we will be able to click on it . we are going to use auto pi so we are going to hit install on
that and it installed so we can close this and we can go back and now we can also import auto pi
so the first thing we will do is we will run our webcam to see everything is working.

so we will write here cap is equals to cv2 dot video capture and we are going to write that our
video id is one now we will use zero if we have one camera so i'm using now the second thing is
that we have to have a fixed width and height
so we cannot leave it to the default of the camera so we need to change our width and height so
we will write here cap dot set and the prop id for width is three then the prop id for height is 4
so we will make it 480. so that's how we can define the word and height actually.
what we can do is we can put them in variables because we need to use them later on as well
so let's declare our variables over here so we are going to write here that our width of the cam
and the height of the cam is equals to 640 by 480 and we can just input these values here so this
is the height of the cam and then we can simply go let's remove this and then we can simply go
and write while true we are going to say success and image is equals to cap dot read and we are
going to get our frame value
05:50
so once we have this frame value
05:54
then we are going to say cb2 dot im show
05:57
and we will say that our image and then
06:00
i mg and then cv2.weight key
06:05
and one so this is pretty much that we
06:08
have been doing
06:09
in all our projects so let's run this
06:12
and see if it works
06:16
there you go so now you can see my
06:17
webcam and there is my hand
06:20
so that is all good so next what we can
06:24
do is we can add our detector for the
06:27
hand tracking
06:28
but actually let's discuss what are the
06:30
steps that we are going to take today
06:32
to create this project so the first step
06:35
will be
06:37
let's put some numbering as well so it
06:39
is easier to remember
06:40
so the first step will be to find the
06:43
hand
06:44
landmarks so that will be the first step
06:48
then the second step will be to get the
06:51
tip of the
06:52
index and the middle finger so the idea
06:54
is that if we have just the index finger
06:57
then the mouse will move
06:59
if we have the middle finger up as well
07:02
then it will be in uh clicking mode
07:06
so if it is in clicking mode and if the
07:08
distance
07:09
between the two fingers is uh less than
07:12
a certain value
07:13
then we will detect it as a click so you
07:15
can bring your fingers together and it
07:16
will click
07:18
so in that mode we are not going to move
07:20
the mouse but
07:21
in the index mode where we are moving
07:24
uh that is the only mode in which we
07:27
will move
07:28
so what we can do here is that our
07:32
second
07:33
uh what do you call our second step
07:36
will be to get the tip
07:41
tip of the index and
07:44
middle fingers so once we have the
07:48
tip of the index and middle finger what
07:51
we will do is we will check
07:53
which of these fingers are up so we will
07:56
write here number three
07:58
check which
08:01
fingers are up
08:04
then in the fourth step based on this
08:07
information we will check if it is in
08:10
moving mode so we will write here
08:12
only index finger
08:16
which means it is in moving
08:20
mode so we will move our mouse
08:23
and if it is in moving mode then
08:26
we are going to
08:30
then we are going to convert our
08:31
coordinates
08:33
the units now why do we need to convert
08:37
because our webcam will give us a value
08:41
of let's say 640 to 480.
08:44
so for my screen i have a full hd which
08:47
means
08:48
920 by 1080 so we need to convert these
08:52
coordinates
08:53
so that we get the correct positioning
08:59
okay so then
09:03
okay it's bringing it back we can change
09:05
that later
09:06
then we will add another step to
09:08
actually smooth in the values
09:11
so why do we need to do that so that it
09:13
is not very
09:15
jittery it doesn't flicker a lot so we
09:18
will write here
09:19
smoothen values
09:23
so we will smoothen these values and
09:25
once that
09:26
is done we can simply move our mouse so
09:29
move mouse
09:32
okay so this might seem a lot but it
09:35
these steps are very easy some of them
09:37
are single lines some of them just two
09:38
lines
09:39
so don't worry about these then number
09:42
eight
09:42
will be to check if we are in clicking
09:46
mode
09:46
so when both index
09:50
and middle fingers are
09:53
up then it is clicking
09:57
mode so once it is clicking mode
10:01
we will find the distance between these
10:03
fingers
10:05
so we will find distance
10:09
this tense between
10:13
fingers and if the finger
10:16
is if the distance is short then we are
10:20
going to click
10:21
so we will write here click mouse
10:24
if distance short
10:29
so these are the 10 steps we have to
10:32
follow and the 11th and 12th
10:34
step is fairly easy so the 11th step
10:38
is the frame rate to see if we are
10:41
getting a decent amount of frame rate
10:43
and the 12th step is to display
10:48
so we have already done this display
10:51
thing
10:52
so we do not need to do anything more in
10:55
that
10:55
now what we can do is we can go on to
10:57
the frame rate the frame rate is very
10:59
simple as well
11:01
we have done this quite a lot of times
11:03
by now
11:04
so we will simply write time dot time
11:07
and then we are going to write fbs
11:11
is equals to 1 divided by c time which
11:15
is the current time
11:16
minus the previous time
11:20
and then we will write that the previous
11:22
time
11:23
is equals to the current time
11:26
and then we will write cb2 dot put text
11:30
image then our string
11:34
which will we will first convert it into
11:36
integer and then we will write
11:38
our fps and then
11:41
we are going to write the position so we
11:43
will write
11:44
10 and let's say 50 or let's say 20 and
11:48
50.
11:49
then we will write cv2 dot
11:52
font cv2
11:56
dot font
11:59
plane and then let's say for the
12:01
thickness
12:02
or this is the scale let's put it as
12:04
three and
12:05
then we have okay we need to go back
12:09
then we have the color 255
12:13
uh let's keep it blue yeah
12:18
and then we will write three this is the
12:21
thickness
12:22
so if we run this we should have here p
12:26
time p time equals to
12:29
zero so if we run this
12:34
we should have our frame rate
12:37
there we go
12:41
so that is quite good
12:44
okay so next we have the frame rate we
12:48
have the display
12:49
now we are going to do the actual part
12:52
of all of these
12:53
steps so first of all we have to get the
12:55
landmarks to get the landmarks we have
12:57
to declare here the detector we have to
13:00
create
13:00
the object so detector
13:04
is equals to hdm
13:08
dot hand detector and
13:11
inside that do we need to add something
13:13
we can
13:14
add for example the maximum hands
13:16
because we are only
13:18
expecting one hand so we can write here
13:20
one
13:21
and the rest we can keep same
13:25
then here we are going to go down and we
13:28
are going to write
13:29
that our image image
13:32
is equals to detector dot
13:35
find hands not fingers up
13:39
fine hands find
13:42
hands and then we
13:45
are going to find the positions of these
13:49
hands
13:50
so we are going to write here lm list
13:52
and the bounding box so this is
13:54
something that we added in our previous
13:56
project
13:57
and we will write here the detector
14:00
detector
14:02
dot uh find position
14:05
i think the spellings detector
14:08
find position and then we will write
14:12
image so we are sending in our image and
14:15
that
14:16
should detect it and it should also draw
14:19
so let's run this and see if it detects
14:24
we have an issue uh finance oh we have
14:28
to give
14:29
argument of image my bad
14:33
okay so there you go so now we are
14:35
detecting our bounding box and we are
14:37
detecting
14:38
the fingers uh and the landmarks as well
14:42
so that is pretty good so we are done
14:44
with step number one
14:46
and now we will check
14:49
that if if
14:52
our length of our lm list
14:56
is not equals to zero then we are going
14:59
to
15:01
uh get the tip info so
15:04
we can actually put this up here
15:08
so here we will write x1 and y1
15:11
so these are the points of the index
15:12
finger so we are going to write
15:14
lm list and we will write that it is
15:17
point number eight
15:19
and we want from uh we want the element
15:22
number one
15:23
and two so we will write it like this
15:27
uh the same thing we will do for our
15:30
second finger which is the middle finger
15:32
we will write x2
15:34
and y2 and here instead of 8 we will
15:36
write 12.
15:37
so this will give us the coordinates
15:41
of our index and middle fingers so
15:44
we do not need to draw these at this
15:46
point
15:47
so we can just print them out if you
15:49
want to see
15:51
we can print x1 y1
15:54
and then x2 and y2
15:57
so we can print those
16:01
and we are getting an error x1 y1
16:07
not enough values to unpack expect it to
16:10
got one
16:12
why is that
16:17
lm list let me check here what is the
16:21
issue
16:29
this is find position yeah
16:33
and this is lm list and bounding box yes
16:38
so that should be fine
16:42
okay let's print out the lm list first
16:46
print lm list
16:50
let's check that
16:57
yeah we are getting some values and they
16:59
seem fine
17:02
uh
17:06
oh okay my bad should be one
17:10
one and colin
17:15
okay there you go so now we are getting
17:17
the points
17:26
there you go so now we are getting all
17:28
these points so
17:29
for the index finger and the middle
17:31
finger
17:32
we move them around you can see the
17:35
values they change
17:37
okay so this is good we are done with
17:41
our second parts now we will go on to
17:44
the
17:44
third part check which fingers are up
17:47
now this is extremely simple because we
17:49
have already created a method by the
17:51
name fingers up
17:52
all we have to do is we have to call it
17:54
we will write here
17:57
detector dot
18:00
find not find fingers up
18:03
and we will store it in fingers
18:07
so we can push this in
18:13
and let's print out so print
18:17
fingers and we will remove the print
18:20
from here
18:21
so let's run that
18:28
so there you go so all the fingers are
18:29
up all of them are
18:31
closed one two three
18:34
four and five so we are getting these
18:37
values
18:37
so that is pretty good now let's go to
18:40
the next step
18:41
which is okay let me push those all of
18:43
these in
18:45
okay so step number four is only index
18:49
finger
18:49
moving mode so now we need to check if
18:53
only the index finger is up so we will
18:56
write here
18:57
if if fingers
19:01
at one which is the index finger
19:05
is equals to one and
19:08
fingers at two
19:12
is equals to zero so this is when the
19:15
index finger is up and the middle finger
19:17
is down
19:18
so this will be moving mode so now we
19:21
need to
19:21
move our finger
19:25
now we need to check where our finger is
19:27
moving so we get those points and we
19:29
send it to the mouse
19:31
coordinates okay so first of all what we
19:35
will do is
19:36
we will write here that we need to
19:38
convert
19:39
so here we are converting our
19:41
coordinates so we will write here that
19:44
x3 is equals to
19:47
we will write np dot interp we are going
19:51
to convert
19:52
one range to another range so here we
19:54
are converting the x1 value
19:57
and the initial range is basically from
20:00
zero to the width
20:04
of our webcam and
20:07
then the second range is from
20:10
zero to the width
20:13
of the screen but we didn't get the
20:16
width of the screen
20:17
now i know that my screen is this size
20:20
but it could be different for yours
20:22
so in order to get the exact value what
20:24
we will do is we will go up here
20:26
and we will write here that our width of
20:29
the screen
20:31
and the height of the screen is equals
20:34
to
20:35
auto pi dot screen
20:38
dot size so this will give us the size
20:41
of the screen
20:42
so if we remove the print from here
20:45
and if we remove this statement and all
20:49
of this
20:51
uh yeah so then we can print this
20:54
print w screen
20:57
and height screen okay
21:01
let's run this and there you go
21:04
so now you can see it's telling me it's
21:05
9 to 1920
21:07
by 1080 so this is the idea
21:10
now that we have these values let's
21:13
comment this
21:14
now that we have these values we'll go
21:17
back here
21:19
and
21:23
we are going to continue
21:26
that it is from 0 to the width
21:30
of the screen so the same thing we will
21:34
do
21:34
with the height we will copy this and we
21:36
will write here y3
21:38
and then we will write here y1 and then
21:42
we will write here
21:43
height and then height
21:47
so this is the idea so these are the
21:50
points
21:51
that now we have converted and now we
21:53
will
21:54
send this value to the mouse we will
21:56
smoothen these values
21:58
but we will do that later on first we
22:00
need to see what is the original
22:02
result and then we can convert it so
22:04
here we are going to write auto pi
22:07
dot move mouse dot move
22:11
and then we are going to write that
22:15
our x 3 and our y 3
22:18
are our coordinates
22:22
so let's try this and see what happens
22:28
so you can see my mouse here if i bring
22:31
in my hand
22:32
and this is my index finger and now you
22:34
can see it is moving
22:35
but the problem is when i'm going to the
22:37
right it's going to the left
22:40
so this is very annoying and it is very
22:44
it's not intuitive so what we will do is
22:47
we will flip
22:47
it in order to flip it we just need to
22:50
flip the width
22:51
so what we will say is we will say that
22:53
whatever the width of the screen is
22:56
screen is minus this
22:59
so now if i go to the right it should go
23:01
to the right
23:02
so the image here will be flipped but in
23:05
reality i'm moving to the right
23:07
and the mouse is also moving to the
23:09
right now if i move to the left
23:10
the mouse is also moving to the left
23:14
so this should be easier to work with
23:17
so that is good what we can do
23:22
is we can draw a circle so that we know
23:25
that we are
23:26
what you call moving the mouse so here
23:29
we can write
23:30
cv2 dot circle and we will write
23:33
image and then we are going to write x1
23:37
and y1 so we want to draw on that
23:40
and let's say 15 is the radius and the
23:43
color
23:44
is purple and
23:47
then we will write cb2 dot fill cv2
23:51
dot filled
23:55
there we go so let's run that
24:01
yeah so now whenever we are in moving
24:03
mode
24:04
then it will show us this big circle
24:08
so that we know that we are in moving
24:10
mode
24:11
okay so this is good
24:15
so now one of the issues here is that
24:19
when i am moving when i'm moving
24:23
i can go up very easily it's not that
24:25
bad
24:26
it flickers at the top much more than in
24:29
the center
24:30
but i can go there but if i want to go
24:32
down it's very hard because
24:34
the hand is not detected properly
24:38
again if i move down you can see it's
24:41
not detecting properly and i'm unable to
24:43
go down
24:44
so what we can do is we can set a region
24:47
where
24:47
we want to detect the movement instead
24:50
of the whole
24:51
image size we can set a particular range
24:54
so how can we do that first of all let's
24:58
create that range
24:59
so we will write here cv2 dot rectangle
25:02
and we will set in our image
25:05
and then we are going to call this let's
25:08
say
25:10
frame so this will be a certain value
25:12
for example
25:13
100 or 200 something like that so we
25:15
will call it
25:16
frame reduction
25:20
and we will also again call it frame
25:23
reduction so we can go up and we can
25:27
declare it here frame reduction is
25:30
equals to let's say 100
25:32
so we will write here this is basically
25:34
frame
25:36
reduction reduction
25:42
okay so that should be good
25:48
now once we have the frame reduction
25:51
what we can do is
25:52
uh now we need to give in the second
25:54
value so this is the initial value
25:56
now we need to give the diagonal points
25:58
so we will write here that the width of
26:00
the cam
26:02
minus the frame r
26:05
and then the second point will be
26:10
the height of the camera minus
26:14
frame r then we will give in the color
26:18
two five
26:19
five zero and two five five and then we
26:22
will give in the thickness
26:25
so this will draw a rectangle so let's
26:28
try that
26:29
so whenever we are in
26:32
it's not drawing anything oh it is yeah
26:35
whenever we are in
26:36
okay um
26:39
okay maybe we nee we need to put this
26:41
outside
26:43
so we can put it outside here
26:47
because we won't always want to see it
26:49
whenever we have the hand in
26:51
we want to see it so now you can see we
26:54
have
26:55
our box now the idea here is that when i
26:58
reach the top of this rectangle
27:02
it should be the mouse should be at the
27:04
top of my screen
27:05
and when i reach the bottom of this it
27:08
should be at the bottom of the screen
27:10
so and same thing for the corners if i
27:13
am moving at this corner it should be at
27:15
the corner
27:15
but now you can see it is not at the
27:17
corner so again you can adjust these
27:19
values up and down
27:20
we will keep it in the center for now
27:22
but later on if you want to you can
27:24
adjust
27:25
so how can you reflect this on our
27:28
x3 and y3 so how can you change these
27:31
values
27:32
so all you have to do is it's very
27:33
simple instead of zero
27:35
you will right here frame r
27:39
you will write here frame r and here you
27:42
are going to write
27:43
width of the cam minus frame r and
27:46
height of the cam
27:46
minus frame r that's it so now your
27:49
values
27:50
should reflect properly
27:53
so here if i have my finger at the
27:57
top right corner you can see it reaches
28:00
the top right corner
28:01
if i have it on the other side you can
28:03
see it's reaching the top
28:05
and now if i go back and i go down you
28:08
can see it reaches down
28:11
so we are having some issues as well
28:13
it's going out of bounds
28:15
we can fix those issues later what we
28:18
can do is we can push this
28:19
up as well a little bit so that it is
28:22
easier for our
28:23
fingers to move around but we can do
28:25
that later
28:26
we can move on to the next step
28:30
which is to detect the click
28:35
okay so then we are going to
28:38
detect the click so here
28:42
we have to check if both the index and
28:45
middle fingers are
28:46
up so we are going to copy this part
28:49
and we are going to paste it here and we
28:53
will write one
28:54
and one so if both of them are up
28:57
then we need to find the length of
29:00
between our fingers so what we will do
29:02
here is we will write
29:04
that our detector dot find distance
29:09
dot find distance between
29:13
which points point number eight and
29:15
point number twelve
29:17
so uh these are the landmark ids so
29:19
landmark
29:20
eight and landmark twelve and then we
29:23
will write image
29:24
then it will unpack the values of length
29:29
and then the image and then
29:32
the what did i do here it should be
29:35
comma
29:35
and then we also get a bunch of info
29:39
that we are going to ignore
29:42
so the main thing that we need is the
29:44
length so we need to know
29:46
what is the distance between these two
29:48
fingers so what we can do is we can
29:50
write here print
29:51
length and let's try it
29:56
so when we are in our detection mode it
29:59
is giving us the length
30:01
and it is telling us uh there is a good
30:03
indication because
30:05
it actually gives a center point as well
30:07
and it draws a line in between
30:09
so that is pretty good okay
30:13
so what we can do next is we can check
30:17
that if the length is below a certain
30:20
value
30:20
then we will detect it as a click but we
30:23
need to define that
30:24
threshold so we are going to go back
30:29
and let's try it out so here it should
30:31
be open here it should be closed
30:33
so i can see it's around 30 something
30:40
so if it's less than 40 maybe
30:46
yeah okay so we can say if it's around
30:48
less than 40
30:49
then it is detected as a click uh
30:53
you can do a normalization here as well
30:56
but that will be
30:57
quite detailed so we are not going to go
31:00
into that
31:00
so we will write here length is less
31:03
than
31:04
40 then we are going to
31:07
cv2 dot circle
31:10
we are going to draw the same circle
31:13
that we had drawn here
31:16
but this time we are going to draw it in
31:18
green so
31:19
we have the detection that it has been
31:22
clicked
31:24
so let's try that so
31:28
here there you go
31:33
um we could draw it to the center one as
31:36
well
31:37
it will look better okay how can we do
31:39
that basically this is the information
31:41
we are getting for the line
31:43
so we can write here info line
31:46
or we can write line info
31:52
and then based on this line info if we
31:55
go
31:55
to our fine distance you can see
32:00
cx and cy are the last elements so
32:03
this is the fourth and this is the fifth
32:06
so we will write here this is the fourth
32:10
and this here is the fifth
32:15
push it down okay
32:18
so let's run this and hopefully this
32:21
time
32:22
the center one will be green there you
32:25
go
32:25
so now it looks a little bit better so
32:28
that's good
32:30
okay so what is next now we actually
32:33
need to click
32:34
so rather than just changing it to green
32:37
we need to click and the clicking part
32:39
is way easier than you think
32:42
and that is auto pi dot
32:45
mouse dot click and that's it
32:48
so now it should click uh by the way
32:51
these two we are
32:52
already doing so we should write here
32:56
that we are checking the distance here
32:59
and then
32:59
we are clicking the mouse if the
33:02
distance is short
33:03
over here so that's the idea
33:06
okay so let's try it so what i will do
33:09
is
33:10
i will try to click and minimize this
33:13
this part here so here is my finger
33:17
and if i move around and i click
33:20
you can see it's shaking a lot
33:24
yeah it clicked there you go it click
33:27
again
33:27
but as you can see it shakes a lot so
33:30
this is a very big problem
33:32
which is not allowing us to use this
33:34
properly
33:35
so what can we do as i mentioned before
33:39
if we go up here we can smoothen the
33:42
values
33:43
so how can we smooth in the values so
33:45
what we can do is instead of
33:47
sending in exactly the same value that
33:50
for example if it goes from 0 to 100
33:52
instead of saying go to 100 directly we
33:54
will dilute it a little bit
33:57
so we will smoothen it we will reduce
33:59
its value so it goes step by step
34:02
so what we can do is first of all we are
34:05
going to create a value
34:07
called smooth
34:11
the ning
34:15
is equals to let's say five
34:19
so this is a random value that i've
34:21
chosen later on we can see what is the
34:24
effect
34:26
okay so now what we will do is we will
34:29
we need to also create two variables
34:33
so what we will do is we will write here
34:36
in fact we need to create more than two
34:38
variables
34:39
so we should separate the variable
34:41
declarations here
34:45
yeah that should be fine okay so what we
34:47
will do is we will say that
34:49
our previous location we will call it
34:52
previous location of x and the previous
34:55
location of y is equals to
34:58
0 0 and the current location of
35:02
x location of
35:05
x and the current location
35:08
of y so again these will be 0 and 0.
35:12
so what we will do is what did i do here
35:16
so what we will do is we will use these
35:19
values
35:20
and we will update them each iteration
35:23
to smoothen our uh mouse
35:27
so here we are going to go here now
35:29
instead of x3 and y3
35:31
we are going to send in the smoothen
35:33
values of current location
35:35
and we will update our previous location
35:39
so how can we do that we will write here
35:42
that our current location
35:44
of x is equals to our previous location
35:48
of x plus our x3
35:53
minus our previous location of x
35:57
divided by the smoothing value
36:00
so whatever the value is we will divide
36:02
it by that and the same thing we will do
36:05
with our y value so we can write here y
36:09
you can multiply with this as well you
36:11
can multiply smoothing as well
36:13
then you will have to go into points so
36:15
0.1 0.2
36:17
or you can divide and keep it whole
36:19
numbers it's up to you
36:21
so we write here y 3 and then we will
36:24
write
36:25
y and then we will write that's it okay
36:28
so then we will just send in our
36:32
x value and y value instead of
36:35
x three and y three and
36:39
then we will just update these values
36:41
once we have
36:42
uh use them so we will write here
36:45
previous
36:45
location x and previous location y
36:49
is equals to current location x
36:53
okay let's put y first current location
36:57
uh current location
37:00
x okay so that is the idea
37:04
now uh let's put a very dramatic value
37:08
let's say 20
37:09
and let's run it
37:14
so now you will see if i move it around
37:17
you see it is quite smooth
37:19
but it is quite slow
37:23
so we need to find you see
37:26
when i stop it takes a while to stop so
37:29
what we need to do is we need to find a
37:31
good balance
37:32
so let's try five
37:40
so i like this it moves nicely and it
37:43
stops
37:44
it doesn't shake a lot there you go i
37:47
can click as well
37:49
there you go and
37:52
let's click on the minimize there you go
37:54
so yeah
37:55
that looks good let's try
38:02
10.
38:09
uh 10 is good but it's a little bit
38:12
slower
38:12
yeah it's hard to stop at that point
38:15
yeah
38:16
10 is a little bit fast uh it is a
38:18
little bit slower
38:19
so maybe seven
38:27
yeah this one is better there you go i
38:30
can do that i can
38:32
go to this one i can click on this one
38:36
and this one again there you go
38:40
so it is pretty good
38:44
so that is quite nice
38:48
so that is pretty much it as you can see
38:51
it works quite well
38:52
and we broke it down into different
38:55
steps and
38:56
when you go and try to solve each of
38:58
these steps
38:59
it becomes very easy to get a solution
39:03
and all of this is possible thanks to
39:06
our hand tracking module that we created
39:08
earlier
39:09
if we don't do that then it will be
39:11
quite difficult
39:13
and it will take quite a lot of time to
39:15
actually create such a project
39:17
but as you can see it was quite easy and
39:20
quite simple
39:21
what we achieved in this short amount of
39:23
time
39:25
so this is it for today's video i hope
39:27
you have learned something new
39:29
if you like the video give it a thumbs
39:30
up and don't forget to subscribe
39:32
and i will see you in the next one
English (auto-generated)
AllFrom your searchPythonMachine learningRaspberry PiRelatedFrom Murtaza's Workshop -
Robotics and AIRecently uploadedWatched