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

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

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

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. 

Creating Text

When developing with OpenCV, it is recommended to organize project files by keeping the main Python script in the root directory and storing images and videos in a separate subfolder (such as `/assets`). This directory structure ensures consistent relative file paths and simplifies the file loading process.

Project Directory Structure for OpenCV

OpenCV provides built-in methods to draw geometric shapes, such as lines, rectangles, and circles, directly onto images. These drawing operations are frequently used in computer vision tasks to annotate frames, highlight specific regions of interest, and add graphical overlays.

Shape Creation in OpenCV

In OpenCV, you can save an image to disk using the `cv2.imwrite()` function. This function takes the desired file path (where the file extension determines the output format) and the image array as arguments:

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

This is commonly used to export processed, annotated, or labeled images for further analysis or machine learning applications.

Writing Images (OpenCV)

In OpenCV, capturing a live video feed involves reading and displaying frames continuously in a loop.

```python
import cv2

# 0 is the default camera; otherwise specify an index
cap = cv2.VideoCapture(0) 

while True:
    # ret is a boolean indicating if the frame was successfully read
    ret, frame = cap.read() 
    
    cv2.imshow('frame', frame)
    
    # waitKey(1) refreshes the display and allows termination via the 'q' key
    if cv2.waitKey(1) == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
```
This approach functionally relies on the image display method, running it repeatedly to simulate live video. The `cv2.waitKey(1)` method is essential to update the window and process GUI events.

Live Video Feed Processing in OpenCV

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


University of Michigan - Ann Arbor

OpenCV is a very useful tool for image recognition. It is often used in tandem with machine learning libraries, but also allow for relatively simple image manipulation tools such as rotating, resizing and changing data values. 

The child nodes will break into Basic Tools and Advanced Concepts.

Computer Vision with OpenCV

Basic Tools

Advanced Concepts:
- Object Recognition
- Object Labeling
- Contour Maps
- Machine Learning Applications
- Color Detection
- Corner Detection
- Randomized Color Generation
- Color Extraction

Learn Before

Related

Learn After