Name: 知っておきたい画像処理の8つのビット! (8-Bits Of Image Processing You Should Know!)
Uploaded: 2021-01-14T10:14:46.000Z
Duration: 36 min 48 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

It's been a while since I've done one of these videos, but this video is eight bits of image processing.

法助動詞 B1

You should know, and you might be thinking, Well, why do I need to know anything about image processing?

Well, images are just too dear rays of data on the algorithms that we apply to this data can shape.

Obviously, some of the applications involved images and cameras and video footage.

But there's also other ways of manipulating two D data to your advantage, for example, in things like procedural generation.

On the whole, I think most programs should have an awareness of image processing.

It is a very useful tool to have in your toolbox.

Before I start, I'm going to show you the video that I've created to demonstrate the eight bits, and it's quite nice because it allows us to quickly compare the algorithms.

So here it's going to show the first bit, which will be fresh holding, and we can choose different numbers to look at the different algorithms and see what their effects are because it's working with video, you see, here's a live feed of my arm waving around.

I think it makes quite a nice interactive tool, which is great for learning.

But this video is going to be a bit different to some of my others are not going to go through it line by line from scratch.

I've already created the code, and what I really want to emphasize is what is the image processing that is going on?

This is the process of beina rising an image.

I'm going to assume it's a grayscale image, so the pixels go from black to white.

Fish holding involves taking an individual pixel on, classifying it as being above or below.

If it's above the threshold, you are the one.

If it's below the special, you output zero.

This green line represents a single row in our image.

If I take this row on plot its exposition against the brightness of that pixel, I might get something that looks like this.

Fresh holding involves specifying an appropriate value to access a cut off so any pixels above that value will get classified as one on any below.

The red dash line represents my threshold value.

So now with my blue pen, I can indicate what the binary equivalent of this might be.

But that goes above the threshold toe one below.

Officials above the session old, and we've finalized our image to demonstrate these programs.

I'm using a pixel game engine application that I've already created on.

I feel it's necessary to give you a brief overview of what this application is before we get stuck into the algorithm code, just so it makes some sort of sense.

Fundamentally, it's based on the idea of a frame, which is a fixed to de array of pixels, in this case 3 20 by 2 40 the pixels of floating point type.

So instead of working with RGB values, I'm taking the RGB from the camera and converting it to a floating point value between zero and one by converting to the floating point domain from the interview, domain allows me to avoid complex cities such as interview division.

This simple frame class has some accesses get and set, which will do boundary checks for me, so I could quite happily set, the pixels value beyond the edges of the image.

And if I get something from beyond, the image just returns a black pixel.

My frame class also overrides the assignment operator, so I can have multiple frames in my application, and I can transfer the contents of one frame to the other.

With these for this video, I'm not going to dwell on the image capture side of things.

I've already done that in other videos, and it's enough to say that we simply use the escapee library to capture a frame from a webcam.

So in on user create, the webcam is initialized and in on user update, I capture the image from the webcam per frame and convert the pixels to floating point and store it in a frame called input.

This program shows eight different algorithms, and so the bulk of the code shown here handles the selection of which algorithm is currently being demonstrated on.

The algorithms also have a degree of user input, which allows the user to change the values to play with the algorithm and see how they respond under different circumstances.

For example, when the user presses the one key on the keyboard, it changes the current algorithm being demonstrated to threshold.

So let's continue looking at that algorithm.

We do a little bit of user input if their values to change and then we actually perform the algorithm under demonstration on fish.

For all of the pixels in the frame, we read the input value of a pixel for that location.

Compare it with a threshold value, which will give us a one or a zero in response.

And then we write that to an output frame at the end of the program.

Hopefully, you can see fresh holding is very simple indeed.

My webcam has some automatic gain correction, which is what you saw then, as the image sort of changed and faded, I can't override those settings using the AP I for the camera, but for this video, it doesn't really matter.

We can see The input image here on the left is in gray scale, but the outputs image here on the right is in black and white.

It's been buying arised on, it says here, I can use the said an excuse to change the value of the fresh holds A.

It's halfway between the minimum and maximum intensity is for the gray scale.

As I increase the threshold value, we see less pixels being attributed to a binary one.

Fresh holding is essentially the coarsest of filters, and this is usually the first step in removing as much rubbish from an image as you can.

For example, here you can see on the notebook the text.

One lone coder comes through quite clearly, but the lines on this, like grayness off it doesn't so if we were then to go on and extract this text, for example, it's much easier now.

We're not contaminated with this spatial background noise with fresh hold.

It is out bit to motion on for this video.

I'm assuming the simplest kind of motion.

The word motion implies that something has moved on for something to move takes time.

So to detect motion in an image we need to allow time to have elapsed.

Fortunately with video, this is quite simple because a video camera returns successive frames in time, which means we have a built in Delta time between each frame alongside movement in time.

The object was in one location, and now it's in another.

But for this bit, let's not think of objects as being the things we're looking at.

Instead, we're looking at pixel grayscale values.

So over time, if something is moving in the image, a particular pixel value is also changing.

So we can identify that motion has occurred by looking at the difference off pixel values between successive frames of video input on DSO.

On this graph, we can see that the difference between A and B is related to the change in that grayscale value.

The end result of this could be signed and in some applications.

It gives you additional information, but for our application, I'm just going to take the absolute value of this to tell us that motion for that pixel is likely to have occurred.

The code for motion detection is equally a simple us thresh holding.

I'm going to go through every single pixel in my frames with these nested four loops, and I'm going to look at the difference between the current frame onto the previous frame by subtracting them on them, taking the absolute value of that result on dhe, setting that in the corresponding location to the output frame and then draw the input and output frames.

I update the previous input frame before I acquire a new image in the input frame.

Here's the algorithm running on its looking at a reasonably static scene, but as soon as things start to move, I'll bring my hand into the scene.

We're looking at the difference between one frame and the previous frame, but we only see illumination in the output where there has been changed.

So that signifies that motion has occurred in those locations because the frame rate of my camera is reasonably quick.

I get what looks like an edge around the object that's moving, but don't be fooled by this, it's not strictly an edge, although you can use it as an edge.

It is just the difference between the two frames.

Motion detection like this is usually a foundation algorithm.

It is used to guide your decisions in subsequent algorithms that you apply to the image.

For example, I might want a system to shut down if nothing in this scene is moving, I mean, why bother taking more images if nothing has changed?

字幕リスト動画再生

知っておきたい画像処理の8つのビット! (8-Bits Of Image Processing You Should Know!)

process

constant

demonstrate

scale