Using the underlying concept of numpy arrays, we can create empty numpy arrays to store the incoming information and then we can process it and then display it simultaneously. The primary draw back will be the more expensive the processing the more likely the video feed will lag. Additionally, if we resize them to smaller windows then it could reduce the overhead of the program. 

All you need to do is to copy the incoming information from the .read method and store then into numpy arrays or image objects and then process them.

Creating many streams from one camera

```python
import numpy as np
import cv2

cap = cv2.VideoCapture(0) # 0 is default, otherwise specify with a name or index
```
Too show what is being captured constantly, we can use a while true loop. We use the ret variable to determine if the camera data in stream is being used already or not. 
```python
while True:
       ret, frame = cap.read()  
       cv2.imshow('frame', frame)

       if cv2.waitKey(1) == ord('q'):
            break

cap.release()
cv2.destroyAllWindows()
```

We are functionally using the image display method and then running it repeatedly to simulate live video. The include of the waitkey method will allow us to terminate the while loop when we press the q button. 


University of Michigan - Ann Arbor

Basic Tools and Concepts include:
- Conceptual Data Storage in OpenCV
- Import
- Resize
- Display
- Rotate
- Alpha Values
- File Management
- Slicing / Copying
- Live Camera Importing


Basic Tools

To install opencv please use ```pip install opencv```. Entering this command line on the command line console will allow you to install and then later import in your python script. For mac users, the usage of ```pip3``` may be necessary. 

To use OpenCV in the script use
```python
import cv2
```

Installing and Importing OpenCV

Include your python script within a folder and then have a separate folder to store your images and videos. Although it is not necessary to include a separate folder for files, but it will be very useful for ensuring a consistent path to files. This will make the coding process easier when loading in files. 

File Management with OpenCV

This command will work to load in the file named ```logo.jpg``` from the assets folder. If you did not include a separate folder to store images and video files, but they are in the same folder as the python script you can just include its file name. 

```python
img = cv2.imread('assets/logo.jpg` )
```

By default OpenCV loads files in BGR and not RGB. We can specify what mode we want to read in the images. 

```python
-1, cv2.IMREAD_COLOR #default flag, ignore all transparent areas and load in full image
0, cv2.IMREAD_GRAYSCALE # loads image in grayscale
1, cv2.IMREAD_UNCHANGED # loads in image with alpha channel (transparency info)
```

Loading in Assets in OpenCV

Displaying images in OpenCV is very simple and straightforward, simply call the ```imshow``` method, pass in the first parameter which is the window name and the second parameter which is the cv object name. 
```python
cv2.imshow('Image', img)
```
It is also common practice to include the waitkey method after loading an image or video to specify how long the image will be available for before the window is closed. 
```python
cv2.waitkey(0)
```
The integer value specifies the amount of time until the window is closed. Time is measured in seconds and a value of 0 means unlimited time. This means that it will wait until the user inputs a command (press a button) before continuing. If a non zero value, is used i.e 5, then the method will wait 5 seconds before destroying all windows. A button press would just immediately move to the next step. 

After creating windows, window objects should be destroyed if they are no longer needed. 
```pyhton
cv2.destroyAllWindows()
```
This will destroy all windows created before this method was called. 

Displaying Images

Not all images are going to be available in the correct dimensions for easy usage. I.e. we may be given an image that is 1600x1600, which is far too big to display on a screen. We can resize the image as needed using the ```cv2.resize()``` method.

```python
img = cv2.resize(img, (0,0), fx = 0.5, fy = 0.5) 
```

fx would change the horizontal width by a factor of 0.5 and fy would affect the vertical length. 

You can also manually indicate the specific dimensions of the image that you want to resize to. Both methods will achieve the same effect if you know exactly how big or small the resulting image should be. 

Resizing Images

Image rotations are also very useful to help display images in a more helpful manner. i.e. if a photo is taken vertically but would display the key information more clearly in a landscape position, rotations can be helpful for that. 

```python 
img = cv2.rotate(img, cv2.cv2.ROTATE_90_COUNTERCLOCKWISE)
```

There are many different options as to how you would want the image to rotate and thus can be used as seen necessary. Additionally, the ```.rotate()``` method can be used multiple times to achieve the desired result. 


Rotating Images

After performing manipulation on the images, we would often want to save a copy for later usage and or for reference. We can use the ```cv2.imwrite()``` method to achieve this. We can specify the file type and name with this method. 

```python
cv2.imwrite('new_img.jpg', img)
```

This can be a good embedded feature as users often wish to modify label and then export the labeled photo for usage in ML or general analysis. 

Exporting / Writing Images

OpenCV actively uses numpy arrays to store information for each pixel. We have BGR color channels that are being stored inside of each pixel.
```
[
[[0,0,0], [], [] [255,255,255]],
[],
[],
]
```
Color values are stored and it's ```array[row][col]```.

Where each channel's information is stored
```
   blue   green    red
[     0,        0  ,     0   ]
```
Values can span between 0 and 255. Therefore, it is important to understand that openCV doesn't actually do anything to the image beyond adjusting what information is stored where. i.e. If we wanted to rotate the image, it would just move the values accordingly. Thus it is important to understand that we can actually just manipulate the underlying values directly if we actually wanted to. 

To access specific values
```python
#specific index
print(img[256][400])
#splicing
print(img[256][40:400])
```

Conceptual Breakdown of OpenCV Image Storage

Using the idea that the data is stored inside a numpy array, we can splice the information from the array.

Given an img object, we can use: 
```python
sliced_img = img[500:700, 600:900]
img[100:300, 650:950] = tag
```
It is important to pick a region that is the same size as what you copied. 

Therefore, you can use this idea with a UI to select a region and get the right pixel values. Otherwise to slice/copy you need to know the exact pixel values ahead of time.

Slicing / Copying Portions of the Image

Live Video Feed Processing

This is a very important feature to understand because it will be necessary to create circles, squares, etc. when labeling and identifying eyes. 

Shape Creation 

The putText method will start its coordinate values from the bottom left. It will require the img object, the string, the coordinate start location, the font, scale of font, color of text, thickness and an optional argument that specifies line type. 

It is recommended to use cv2.LINE_AA.

```python
font = cv2.FONT_HERSHEY_SIMPLEX
img = cv2.putText(img, '1Cademy', (200, height - 10), font, 4, (0,0,0), 5, cv2.LINE_AA)
```

Font scale will magnify the size of the font. OpenCV provides a bunch of different fonts, and you will simply need to specify the value into a variable to keep the character count in each line low for readability, but not absolutely necessary. 

Learn Before

Related

Learn After