mirror of https://github.com/open-mmlab/mmcv.git
155 lines
4.1 KiB
Markdown
155 lines
4.1 KiB
Markdown
## Image
|
|
|
|
This module provides some image processing methods, which requires `opencv` to be installed.
|
|
|
|
### Read/Write/Show
|
|
To read or write images files, use `imread` or `imwrite`.
|
|
|
|
```python
|
|
import mmcv
|
|
|
|
img = mmcv.imread('test.jpg')
|
|
img = mmcv.imread('test.jpg', flag='grayscale')
|
|
img_ = mmcv.imread(img) # nothing will happen, img_ = img
|
|
mmcv.imwrite(img, 'out.jpg')
|
|
```
|
|
|
|
To read images from bytes
|
|
|
|
```python
|
|
with open('test.jpg', 'rb') as f:
|
|
data = f.read()
|
|
img = mmcv.imfrombytes(data)
|
|
```
|
|
|
|
To show an image file or a loaded image
|
|
|
|
```python
|
|
mmcv.imshow('tests/data/color.jpg')
|
|
# this is equivalent to
|
|
|
|
for i in range(10):
|
|
img = np.random.randint(256, size=(100, 100, 3), dtype=np.uint8)
|
|
mmcv.imshow(img, win_name='test image', wait_time=200)
|
|
```
|
|
|
|
### Color space conversion
|
|
Supported conversion methods:
|
|
- bgr2gray
|
|
- gray2bgr
|
|
- bgr2rgb
|
|
- rgb2bgr
|
|
- bgr2hsv
|
|
- hsv2bgr
|
|
|
|
```python
|
|
img = mmcv.imread('tests/data/color.jpg')
|
|
img1 = mmcv.bgr2rgb(img)
|
|
img2 = mmcv.rgb2gray(img1)
|
|
img3 = mmcv.bgr2hsv(img)
|
|
```
|
|
|
|
### Resize
|
|
There are three resize methods. All `imresize_*` methods have an argument `return_scale`,
|
|
if this argument is `False`, then the return value is merely the resized image, otherwise
|
|
is a tuple `(resized_img, scale)`.
|
|
|
|
```python
|
|
# resize to a given size
|
|
mmcv.imresize(img, (1000, 600), return_scale=True)
|
|
|
|
# resize to the same size of another image
|
|
mmcv.imresize_like(img, dst_img, return_scale=False)
|
|
|
|
# resize by a ratio
|
|
mmcv.imrescale(img, 0.5)
|
|
|
|
# resize so that the max edge no longer than 1000, short edge no longer than 800
|
|
# without changing the aspect ratio
|
|
mmcv.imrescale(img, (1000, 800))
|
|
```
|
|
|
|
### Rotate
|
|
To rotate an image by some angle, use `imrotate`. The center can be specified,
|
|
which is the center of original image by default. There are two modes of rotating,
|
|
one is to keep the image size unchanged so that some parts of the image will be
|
|
cropped after rotating, the other is to extend the image size to fit the rotated
|
|
image.
|
|
|
|
```python
|
|
img = mmcv.imread('tests/data/color.jpg')
|
|
|
|
# rotate the image clockwise by 30 degrees.
|
|
img_ = mmcv.imrotate(img, 30)
|
|
|
|
# rotate the image counterclockwise by 90 degrees.
|
|
img_ = mmcv.imrotate(img, -90)
|
|
|
|
# rotate the image clockwise by 30 degrees, and rescale it by 1.5x at the same time.
|
|
img_ = mmcv.imrotate(img, 30, scale=1.5)
|
|
|
|
# rotate the image clockwise by 30 degrees, with (100, 100) as the center.
|
|
img_ = mmcv.imrotate(img, 30, center=(100, 100))
|
|
|
|
# rotate the image clockwise by 30 degrees, and extend the image size.
|
|
img_ = mmcv.imrotate(img, 30, auto_bound=True)
|
|
```
|
|
|
|
### Flip
|
|
To flip an image, use `imflip`.
|
|
|
|
```python
|
|
img = mmcv.imread('tests/data/color.jpg')
|
|
|
|
# flip the image horizontally
|
|
mmcv.imflip(img)
|
|
|
|
# flip the image vertically
|
|
mmcv.imflip(img, direction='vertical')
|
|
```
|
|
|
|
### Crop
|
|
`imcrop` can crop the image with one or some regions, represented as (x1, y1, x2, y2).
|
|
|
|
```python
|
|
import mmcv
|
|
import numpy as np
|
|
|
|
img = mmcv.imread('tests/data/color.jpg')
|
|
|
|
# crop the region (10, 10, 100, 120)
|
|
bboxes = np.array([10, 10, 100, 120])
|
|
patch = mmcv.imcrop(img, bboxes)
|
|
|
|
# crop two regions (10, 10, 100, 120) and (0, 0, 50, 50)
|
|
bboxes = np.array([[10, 10, 100, 120], [0, 0, 50, 50]])
|
|
patches = mmcv.imcrop(img, bboxes)
|
|
|
|
# crop two regions, and rescale the patches by 1.2x
|
|
patches = mmcv.imcrop(img, bboxes, scale_ratio=1.2)
|
|
```
|
|
|
|
### Padding
|
|
There are two methods `impad` and `impad_to_multiple` to pad an image to the
|
|
specific size with given values.
|
|
|
|
```python
|
|
img = mmcv.imread('tests/data/color.jpg')
|
|
|
|
# pad the image to (1000, 1200) with all zeros
|
|
img_ = mmcv.impad(img, shape=(1000, 1200), pad_val=0)
|
|
|
|
# pad the image to (1000, 1200) with different values for three channels.
|
|
img_ = mmcv.impad(img, shape=(1000, 1200), pad_val=[100, 50, 200])
|
|
|
|
# pad the image on left, right, top, bottom borders with all zeros
|
|
img_ = mmcv.impad(img, padding=(10, 20, 30, 40), pad_val=0)
|
|
|
|
# pad the image on left, right, top, bottom borders with different values
|
|
# for three channels.
|
|
img_ = mmcv.impad(img, padding=(10, 20, 30, 40), pad_val=[100, 50, 200])
|
|
|
|
# pad an image so that each edge is a multiple of some value.
|
|
img_ = mmcv.impad_to_multiple(img, 32)
|
|
```
|