# kornia.enhance¶

The functions in this section perform normalisations and intensity transformations.

Calculate the weighted sum of two Tensors.

The function calculates the weighted sum of two Tensors as follows:

$out = src1 * alpha + src2 * beta + gamma$
Parameters
Return type

Tensor

Returns

Weighted Tensor of shape $$(B, C, H, W)$$.

Example

>>> input1 = torch.rand(1, 1, 5, 5)
>>> input2 = torch.rand(1, 1, 5, 5)
>>> output = add_weighted(input1, 0.5, input2, 0.5, 1.0)
>>> output.shape
torch.Size([1, 1, 5, 5])


This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision. The input image is expected to be in the range of [0, 1].

Parameters
Return type

Tensor

Returns

Adjusted image in the shape of $$(*, H, W)$$.

Note

See a working example here.

Example

>>> x = torch.ones(1, 1, 2, 2)
tensor([[[[1., 1.],
[1., 1.]]]])

>>> x = torch.ones(2, 5, 3, 3)
>>> y = torch.tensor([0.25, 0.50])
torch.Size([2, 5, 3, 3])


This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision. The input image is expected to be in the range of [0, 1].

Parameters
Return type

Tensor

Returns

Adjusted image in the shape of $$(*, H, W)$$.

Note

See a working example here.

Example

>>> x = torch.ones(1, 1, 2, 2)
tensor([[[[0.5000, 0.5000],
[0.5000, 0.5000]]]])

>>> x = torch.ones(2, 5, 3, 3)
>>> y = torch.tensor([0.65, 0.50])
torch.Size([2, 5, 3, 3])


Perform gamma correction on an image.

The input image is expected to be in the range of [0, 1].

Parameters
Return type

Tensor

Returns

Adjusted image in the shape of $$(*, H, W)$$.

Note

See a working example here.

Example

>>> x = torch.ones(1, 1, 2, 2)
tensor([[[[1., 1.],
[1., 1.]]]])

>>> x = torch.ones(2, 5, 3, 3)
>>> y1 = torch.ones(2) * 1.0
>>> y2 = torch.ones(2) * 2.0
torch.Size([2, 5, 3, 3])


The input image is expected to be an RGB image in the range of [0, 1].

Parameters
• input (Tensor) – Image to be adjusted in the shape of $$(*, 3, H, W)$$.

• hue_factor (Union[float, Tensor]) – How much to shift the hue channel. Should be in [-PI, PI]. PI and -PI give complete reversal of hue channel in HSV space in positive and negative direction respectively. 0 means no shift. Therefore, both -PI and PI will give an image with complementary colors while 0 gives the original image.

Return type

Tensor

Returns

Adjusted image in the shape of $$(*, 3, H, W)$$.

Note

See a working example here.

Example

>>> x = torch.ones(1, 3, 2, 2)
torch.Size([1, 3, 2, 2])

>>> x = torch.ones(2, 3, 3, 3)
>>> y = torch.ones(2) * 3.141516
torch.Size([2, 3, 3, 3])


Adjust color saturation of an image.

The input image is expected to be an RGB image in the range of [0, 1].

Parameters
Return type

Tensor

Returns

Adjusted image in the shape of $$(*, 3, H, W)$$.

Note

See a working example here.

Example

>>> x = torch.ones(1, 3, 3, 3)
torch.Size([1, 3, 3, 3])

>>> x = torch.ones(2, 3, 3, 3)
>>> y = torch.tensor([1., 2.])
torch.Size([2, 3, 3, 3])

kornia.enhance.invert(input, max_val=tensor(1.0))[source]

Invert the values of an input tensor by its maximum value.

Parameters
• input (Tensor) – The input tensor to invert with an arbitatry shape.

• max_val (Tensor, optional) – The expected maximum value in the input tensor. The shape has to according to the input tensor shape, or at least has to work with broadcasting. Default: tensor(1.)

Example

>>> img = torch.rand(1, 2, 4, 4)
>>> invert(img).shape
torch.Size([1, 2, 4, 4])

>>> img = 255. * torch.rand(1, 2, 3, 4, 4)
>>> invert(img, torch.tensor(255.)).shape
torch.Size([1, 2, 3, 4, 4])

>>> img = torch.rand(1, 3, 4, 4)
>>> invert(img, torch.tensor([[[[1.]]]])).shape
torch.Size([1, 3, 4, 4])

Return type

Tensor

kornia.enhance.posterize(input, bits)[source]

Reduce the number of bits for each color channel.

Non-differentiable function, torch.uint8 involved.

Parameters
• input (Tensor) – image tensor with shape $$(*, C, H, W)$$ to posterize.

• bits (Union[int, Tensor]) – number of high bits. Must be in range [0, 8]. If int or one element tensor, input will be posterized by this bits. If 1-d tensor, input will be posterized element-wisely, len(bits) == input.shape[-3]. If n-d tensor, input will be posterized element-channel-wisely, bits.shape == input.shape[:len(bits.shape)]

Return type

Tensor

Returns

Image with reduced color channels with shape $$(*, C, H, W)$$.

Example

>>> x = torch.rand(1, 6, 3, 3)
>>> out = posterize(x, bits=8)
>>> torch.testing.assert_allclose(x, out)

>>> x = torch.rand(2, 6, 3, 3)
>>> bits = torch.tensor([4, 2])
>>> posterize(x, bits).shape
torch.Size([2, 6, 3, 3])

kornia.enhance.sharpness(input, factor)[source]

Apply sharpness to the input tensor.

Implemented Sharpness function from PIL using torch ops. This implementation refers to: https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py#L326

Parameters
• input (Tensor) – image tensor with shape $$(*, C, H, W)$$ to sharpen.

• factor (Union[float, Tensor]) – factor of sharpness strength. Must be above 0. If float or one element tensor, input will be sharpened by the same factor across the whole batch. If 1-d tensor, input will be sharpened element-wisely, len(factor) == len(input).

Return type

Tensor

Returns

Sharpened image or images with shape $$(*, C, H, W)$$.

Example

>>> x = torch.rand(1, 1, 5, 5)
>>> sharpness(x, 0.5).shape
torch.Size([1, 1, 5, 5])


For each pixel in the image less than threshold.

We add ‘addition’ amount to it and then clip the pixel value to be between 0 and 1.0. The value of ‘addition’ is between -0.5 and 0.5.

Parameters
Return type

Tensor

Returns

The solarized images with shape $$(*, C, H, W)$$.

Example

>>> x = torch.rand(1, 4, 3, 3)
>>> out = solarize(x, thresholds=0.5, additions=0.)
>>> out.shape
torch.Size([1, 4, 3, 3])

>>> x = torch.rand(2, 4, 3, 3)
>>> thresholds = torch.tensor([0.8, 0.5])
torch.Size([2, 4, 3, 3])


## Equalization¶

kornia.enhance.equalize(input)[source]

Apply equalize on the input tensor.

Implements Equalize function from PIL using PyTorch ops based on uint8 format: https://github.com/tensorflow/tpu/blob/5f71c12a020403f863434e96982a840578fdd127/models/official/efficientnet/autoaugment.py#L355

Parameters

input (Tensor) – image tensor to equalize with shape $$(*, C, H, W)$$.

Return type

Tensor

Returns

Equalized image tensor with shape $$(*, C, H, W)$$.

Example

>>> x = torch.rand(1, 2, 3, 3)
>>> equalize(x).shape
torch.Size([1, 2, 3, 3])

kornia.enhance.equalize_clahe(input, clip_limit=40.0, grid_size=(8, 8))[source]

Apply clahe equalization on the input tensor.

NOTE: Lut computation uses the same approach as in OpenCV, in next versions this can change.

Parameters
Return type

Tensor

Returns

Equalized image or images with shape as the input.

Examples

>>> img = torch.rand(1, 10, 20)
>>> res = equalize_clahe(img)
>>> res.shape
torch.Size([1, 10, 20])

>>> img = torch.rand(2, 3, 10, 20)
>>> res = equalize_clahe(img)
>>> res.shape
torch.Size([2, 3, 10, 20])

kornia.enhance.equalize3d(input)[source]

Equalize the values for a 3D volumetric tensor.

Implements Equalize function for a sequence of images using PyTorch ops based on uint8 format: https://github.com/tensorflow/tpu/blob/master/models/official/efficientnet/autoaugment.py#L352

Parameters

input (Tensor) – image tensor with shape $$(*, C, D, H, W)$$ to equalize.

Return type

Tensor

Returns

Equalized volume with shape $$(B, C, D, H, W)$$.

kornia.enhance.histogram(x, bins, bandwidth, epsilon=1e-10)[source]

Estimate the histogram of the input tensor.

The calculation uses kernel density estimation which requires a bandwidth (smoothing) parameter.

Parameters
Return type

Tensor

Returns

Computed histogram of shape $$(B, N_{bins})$$.

Examples

>>> x = torch.rand(1, 10)
>>> bins = torch.torch.linspace(0, 255, 128)
>>> hist = histogram(x, bins, bandwidth=torch.tensor(0.9))
>>> hist.shape
torch.Size([1, 128])

kornia.enhance.histogram2d(x1, x2, bins, bandwidth, epsilon=1e-10)[source]

Estimate the 2d histogram of the input tensor.

The calculation uses kernel density estimation which requires a bandwidth (smoothing) parameter.

Parameters
Return type

Tensor

Returns

Computed histogram of shape $$(B, N_{bins}), N_{bins})$$.

Examples

>>> x1 = torch.rand(2, 32)
>>> x2 = torch.rand(2, 32)
>>> bins = torch.torch.linspace(0, 255, 128)
>>> hist = histogram2d(x1, x2, bins, bandwidth=torch.tensor(0.9))
>>> hist.shape
torch.Size([2, 128, 128])

kornia.enhance.image_histogram2d(image, min=0.0, max=255.0, n_bins=256, bandwidth=None, centers=None, return_pdf=False, kernel='triangular', eps=1e-10)[source]

Estimate the histogram of the input image(s).

The calculation uses triangular kernel density estimation.

Parameters
• image (Tensor) – Input tensor to compute the histogram with shape $$(H, W)$$, $$(C, H, W)$$ or $$(B, C, H, W)$$.

• min (float, optional) – Lower end of the interval (inclusive). Default: 0.0

• max (float, optional) – Upper end of the interval (inclusive). Ignored when centers is specified. Default: 255.0

• n_bins (int, optional) – The number of histogram bins. Ignored when centers is specified. Default: 256

• bandwidth (Optional[float], optional) – Smoothing factor. If not specified or equal to -1, $$(bandwidth = (max - min) / n_bins)$$. Default: None

• centers (Optional[Tensor], optional) – Centers of the bins with shape $$(n_bins,)$$. If not specified or empty, it is calculated as centers of equal width bins of [min, max] range. Default: None

• return_pdf (bool, optional) – If True, also return probability densities for each bin. Default: False

• kernel (str, optional) – kernel to perform kernel density estimation (triangular, gaussian, uniform, epanechnikov). Default: 'triangular'

Return type
Returns

Computed histogram of shape $$(bins)$$, $$(C, bins)$$,

$$(B, C, bins)$$.

Computed probability densities of shape $$(bins)$$, $$(C, bins)$$,

$$(B, C, bins)$$, if return_pdf is True. Tensor of zeros with shape of the histogram otherwise.

## Normalizations¶

kornia.enhance.normalize(data, mean, std)[source]

Normalize an image/video tensor with mean and standard deviation.

$\text{input[channel] = (input[channel] - mean[channel]) / std[channel]}$

Where mean is $$(M_1, ..., M_n)$$ and std $$(S_1, ..., S_n)$$ for n channels,

Parameters
Return type

Tensor

Returns

Normalised tensor with same size as input $$(B, C, *)$$.

Examples

>>> x = torch.rand(1, 4, 3, 3)
>>> out = normalize(x, torch.tensor([0.0]), torch.tensor([255.]))
>>> out.shape
torch.Size([1, 4, 3, 3])

>>> x = torch.rand(1, 4, 3, 3)
>>> mean = torch.zeros(4)
>>> std = 255. * torch.ones(4)
>>> out = normalize(x, mean, std)
>>> out.shape
torch.Size([1, 4, 3, 3])

kornia.enhance.normalize_min_max(x, min_val=0.0, max_val=1.0, eps=1e-06)[source]

Normalise an image/video tensor by MinMax and re-scales the value between a range.

The data is normalised using the following formulation:

$y_i = (b - a) * \frac{x_i - \text{min}(x)}{\text{max}(x) - \text{min}(x)} + a$

where $$a$$ is $$\text{min_val}$$ and $$b$$ is $$\text{max_val}$$.

Parameters
• x (Tensor) – The image tensor to be normalised with shape $$(B, C, *)$$.

• min_val (float, optional) – The minimum value for the new range. Default: 0.0

• max_val (float, optional) – The maximum value for the new range. Default: 1.0

• eps (float, optional) – Float number to avoid zero division. Default: 1e-06

Return type

Tensor

Returns

The normalised image tensor with same shape as input $$(B, C, *)$$.

Example

>>> x = torch.rand(1, 5, 3, 3)
>>> x_norm = normalize_min_max(x, min_val=-1., max_val=1.)
>>> x_norm.min()
tensor(-1.)
>>> x_norm.max()
tensor(1.0000)

kornia.enhance.denormalize(data, mean, std)[source]

Denormalize an image/video tensor with mean and standard deviation.

$\text{input[channel] = (input[channel] * std[channel]) + mean[channel]}$

Where mean is $$(M_1, ..., M_n)$$ and std $$(S_1, ..., S_n)$$ for n channels,

Parameters
Return type

Tensor

Returns

Denormalised tensor with same size as input $$(B, C, *)$$.

Examples

>>> x = torch.rand(1, 4, 3, 3)
>>> out = denormalize(x, 0.0, 255.)
>>> out.shape
torch.Size([1, 4, 3, 3])

>>> x = torch.rand(1, 4, 3, 3, 3)
>>> mean = torch.zeros(1, 4)
>>> std = 255. * torch.ones(1, 4)
>>> out = denormalize(x, mean, std)
>>> out.shape
torch.Size([1, 4, 3, 3, 3])

kornia.enhance.zca_mean(inp, dim=0, unbiased=True, eps=1e-06, return_inverse=False)[source]

Compute the ZCA whitening matrix and mean vector.

The output can be used with linear_transform(). See ZCAWhitening for details.

Parameters
• inp (Tensor) – input data tensor.

• dim (int, optional) – Specifies the dimension that serves as the samples dimension. Default: 0

• unbiased (bool, optional) – Whether to use the unbiased estimate of the covariance matrix. Default: True

• eps (float, optional) – a small number used for numerical stability. Default: 1e-06

• return_inverse (bool, optional) – Whether to return the inverse ZCA transform. Default: False

Shapes:
• inp: $$(D_0,...,D_{\text{dim}},...,D_N)$$ is a batch of N-D tensors.

• transform_matrix: $$(\Pi_{d=0,d\neq \text{dim}}^N D_d, \Pi_{d=0,d\neq \text{dim}}^N D_d)$$

• mean_vector: $$(1, \Pi_{d=0,d\neq \text{dim}}^N D_d)$$

• inv_transform: same shape as the transform matrix

Return type
Returns

A tuple containing the ZCA matrix and the mean vector. If return_inverse is set to True, then it returns the inverse ZCA matrix, otherwise it returns None.

Note

See a working example here.

Examples

>>> x = torch.tensor([[0,1],[1,0],[-1,0],[0,-1]], dtype = torch.float32)
>>> transform_matrix, mean_vector,_ = zca_mean(x) # Returns transformation matrix and data mean
>>> x = torch.rand(3,20,2,2)
>>> transform_matrix, mean_vector, inv_transform = zca_mean(x, dim = 1, return_inverse = True)
>>> # transform_matrix.size() equals (12,12) and the mean vector.size equal (1,12)

kornia.enhance.zca_whiten(inp, dim=0, unbiased=True, eps=1e-06)[source]

Apply ZCA whitening transform.

See ZCAWhitening for details.

Parameters
• inp (Tensor) – input data tensor.

• dim (int, optional) – Specifies the dimension that serves as the samples dimension. Default: 0

• unbiased (bool, optional) – Whether to use the unbiased estimate of the covariance matrix. Default: True

• eps (float, optional) – a small number used for numerical stability. Default: 1e-06

Return type

Tensor

Returns

Whiten Input data.

Note

See a working example here.

Examples

>>> x = torch.tensor([[0,1],[1,0],[-1,0]], dtype = torch.float32)
>>> zca_whiten(x)
tensor([[ 0.0000,  1.1547],
[ 1.0000, -0.5773],
[-1.0000, -0.5773]])

kornia.enhance.linear_transform(inp, transform_matrix, mean_vector, dim=0)[source]

Given a transformation matrix and a mean vector, this function will flatten the input tensor along the given dimension and subtract the mean vector from it. Then the dot product with the transformation matrix will be computed and then the resulting tensor is reshaped to the original input shape.

$\mathbf{X}_{T} = (\mathbf{X - \mu})(T)$
Parameters
Shapes:
• inp: $$(D_0,...,D_{\text{dim}},...,D_N)$$ is a batch of N-D tensors.

• transform_matrix: $$(\Pi_{d=0,d\neq \text{dim}}^N D_d, \Pi_{d=0,d\neq \text{dim}}^N D_d)$$

• mean_vector: $$(1, \Pi_{d=0,d\neq \text{dim}}^N D_d)$$

Return type

Tensor

Returns

Transformed data.

Example

>>> # Example where dim = 3
>>> inp = torch.ones((10,3,4,5))
>>> transform_mat = torch.ones((10*3*4,10*3*4))
>>> mean = 2*torch.ones((1,10*3*4))
>>> out = linear_transform(inp, transform_mat, mean, 3)
>>> print(out.shape, out.unique())  # Should a be (10,3,4,5) tensor of -120s
torch.Size([10, 3, 4, 5]) tensor([-120.])

>>> # Example where dim = 0
>>> inp = torch.ones((10,2))
>>> transform_mat = torch.ones((2,2))
>>> mean = torch.zeros((1,2))
>>> out = linear_transform(inp, transform_mat, mean)
>>> print(out.shape, out.unique()) # Should a be (10,2) tensor of 2s
torch.Size([10, 2]) tensor([2.])


## Modules¶

class kornia.enhance.Normalize(mean, std)[source]

Normalize a tensor image with mean and standard deviation.

$\text{input[channel] = (input[channel] - mean[channel]) / std[channel]}$

Where mean is $$(M_1, ..., M_n)$$ and std $$(S_1, ..., S_n)$$ for n channels,

Parameters
Shape:
• Input: Image tensor of size $$(*, C, ...)$$.

• Output: Normalised tensor with same size as input $$(*, C, ...)$$.

Examples

>>> x = torch.rand(1, 4, 3, 3)
>>> out = Normalize(0.0, 255.)(x)
>>> out.shape
torch.Size([1, 4, 3, 3])

>>> x = torch.rand(1, 4, 3, 3)
>>> mean = torch.zeros(4)
>>> std = 255. * torch.ones(4)
>>> out = Normalize(mean, std)(x)
>>> out.shape
torch.Size([1, 4, 3, 3])

class kornia.enhance.Denormalize(mean, std)[source]

Denormalize a tensor image with mean and standard deviation.

$\text{input[channel] = (input[channel] * std[channel]) + mean[channel]}$

Where mean is $$(M_1, ..., M_n)$$ and std $$(S_1, ..., S_n)$$ for n channels,

Parameters
Shape:
• Input: Image tensor of size $$(*, C, ...)$$.

• Output: Denormalised tensor with same size as input $$(*, C, ...)$$.

Examples

>>> x = torch.rand(1, 4, 3, 3)
>>> out = Denormalize(0.0, 255.)(x)
>>> out.shape
torch.Size([1, 4, 3, 3])

>>> x = torch.rand(1, 4, 3, 3, 3)
>>> mean = torch.zeros(1, 4)
>>> std = 255. * torch.ones(1, 4)
>>> out = Denormalize(mean, std)(x)
>>> out.shape
torch.Size([1, 4, 3, 3, 3])

class kornia.enhance.ZCAWhitening(dim=0, eps=1e-06, unbiased=True, detach_transforms=True, compute_inv=False)[source]

Compute the ZCA whitening matrix transform and the mean vector and applies the transform to the data.

The data tensor is flattened, and the mean $$\mathbf{\mu}$$ and covariance matrix $$\mathbf{\Sigma}$$ are computed from the flattened data $$\mathbf{X} \in \mathbb{R}^{N \times D}$$, where $$N$$ is the sample size and $$D$$ is flattened dimensionality (e.g. for a tensor with size 5x3x2x2 $$N = 5$$ and $$D = 12$$). The ZCA whitening transform is given by:

$\mathbf{X}_{\text{zca}} = (\mathbf{X - \mu})(US^{-\frac{1}{2}}U^T)^T$

where $$U$$ are the eigenvectors of $$\Sigma$$ and $$S$$ contain the corresponding eigenvalues of $$\Sigma$$. After the transform is applied, the output is reshaped to same shape.

Parameters
• dim (int, optional) – Determines the dimension that represents the samples axis. Default: 0

• eps (float, optional) – a small number used for numerical stability. Default: 1e-06

• unbiased (bool, optional) – Whether to use the biased estimate of the covariance matrix. Default: True

• compute_inv (bool, optional) – Compute the inverse transform matrix. Default: False

• detach_transforms (bool, optional) – Detaches gradient from the ZCA fitting. Default: True

shape:
• x: $$(D_0,...,D_{\text{dim}},...,D_N)$$ is a batch of N-D tensors.

• x_whiten: $$(D_0,...,D_{\text{dim}},...,D_N)$$ same shape as input.

Note

See a working example here.

Examples

>>> x = torch.tensor([[0,1],[1,0],[-1,0],[0,-1]], dtype = torch.float32)
>>> zca = ZCAWhitening().fit(x)
>>> x_whiten = zca(x)
>>> zca = ZCAWhitening()
>>> x_whiten = zca(x, include_fit = True) # Includes the fitting step
>>> x_whiten = zca(x) # Can run now without the fitting set
>>> # Enable backprop through ZCA fitting process
>>> zca = ZCAWhitening(detach_transforms = False)
>>> x_whiten = zca(x, include_fit = True) # Includes the fitting step


Note

This implementation uses svd() which yields NaNs in the backwards step if the singular values are not unique. See here for more information.

References

fit(x)[source]

Fit ZCA whitening matrices to the data.

Parameters

x (Tensor) – Input data.

Returns

Returns a fitted ZCAWhiten object instance.

forward(x, include_fit=False)[source]

Apply the whitening transform to the data.

Parameters
Return type

Tensor

Returns

The transformed data.

inverse_transform(x)[source]

Apply the inverse transform to the whitened data.

Parameters

x (Tensor) – Whitened data.

Return type

Tensor

Returns

Original data.

This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision. The input image is expected to be in the range of [0, 1].

Parameters

brightness_factor (Union[float, Tensor]) – Brightness adjust factor per element in the batch. 0 does not modify the input image while any other number modify the brightness.

Shape:
• Input: Image/Input to be adjusted in the shape of $$(*, N)$$.

• Output: Adjusted image in the shape of $$(*, N)$$.

Example

>>> x = torch.ones(1, 1, 3, 3)
tensor([[[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]]]])

>>> x = torch.ones(2, 5, 3, 3)
>>> y = torch.ones(2)
torch.Size([2, 5, 3, 3])


This implementation aligns OpenCV, not PIL. Hence, the output differs from TorchVision. The input image is expected to be in the range of [0, 1].

Parameters

contrast_factor (Union[float, Tensor]) – Contrast adjust factor per element in the batch. 0 generates a completely black image, 1 does not modify the input image while any other non-negative number modify the brightness by this factor.

Shape:
• Input: Image/Input to be adjusted in the shape of $$(*, N)$$.

• Output: Adjusted image in the shape of $$(*, N)$$.

Example

>>> x = torch.ones(1, 1, 3, 3)
tensor([[[[0.5000, 0.5000, 0.5000],
[0.5000, 0.5000, 0.5000],
[0.5000, 0.5000, 0.5000]]]])

>>> x = torch.ones(2, 5, 3, 3)
>>> y = torch.ones(2)
torch.Size([2, 5, 3, 3])


Adjust color saturation of an image.

The input image is expected to be an RGB image in the range of [0, 1].

Parameters

saturation_factor (Union[float, Tensor]) – How much to adjust the saturation. 0 will give a black and white image, 1 will give the original image while 2 will enhance the saturation by a factor of 2.

Shape:
• Input: Image/Tensor to be adjusted in the shape of $$(*, 3, H, W)$$.

• Output: Adjusted image in the shape of $$(*, 3, H, W)$$.

Example

>>> x = torch.ones(1, 3, 3, 3)
tensor([[[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]],

[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]],

[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]]]])

>>> x = torch.ones(2, 3, 3, 3)
>>> y = torch.ones(2)
>>> torch.nn.functional.mse_loss(x, out)
tensor(0.)


The input image is expected to be an RGB image in the range of [0, 1].

Parameters

hue_factor (Union[float, Tensor]) – How much to shift the hue channel. Should be in [-PI, PI]. PI and -PI give complete reversal of hue channel in HSV space in positive and negative direction respectively. 0 means no shift. Therefore, both -PI and PI will give an image with complementary colors while 0 gives the original image.

Shape:
• Input: Image/Tensor to be adjusted in the shape of $$(*, 3, H, W)$$.

• Output: Adjusted image in the shape of $$(*, 3, H, W)$$.

Example

>>> x = torch.ones(1, 3, 3, 3)
tensor([[[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]],

[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]],

[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]]]])

>>> x = torch.ones(2, 3, 3, 3)
>>> y = torch.ones(2) * 3.141516
torch.Size([2, 3, 3, 3])


Perform gamma correction on an image.

The input image is expected to be in the range of [0, 1].

Parameters
Shape:
• Input: Image to be adjusted in the shape of $$(*, N)$$.

• Output: Adjusted image in the shape of $$(*, N)$$.

Example

>>> x = torch.ones(1, 1, 3, 3)
tensor([[[[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]]]])

>>> x = torch.ones(2, 5, 3, 3)
>>> y1 = torch.ones(2) * 1.0
>>> y2 = torch.ones(2) * 2.0
torch.Size([2, 5, 3, 3])


Calculate the weighted sum of two Tensors.

The function calculates the weighted sum of two Tensors as follows:

$out = src1 * alpha + src2 * beta + gamma$
Parameters
Shape:
• Input1: Tensor of shape $$(B, C, H, W)$$.

• Input2: Tensor of shape $$(B, C, H, W)$$.

• Output: Weighted tensor of shape $$(B, C, H, W)$$.

Example

>>> input1 = torch.rand(1, 1, 5, 5)
>>> input2 = torch.rand(1, 1, 5, 5)
>>> output = AddWeighted(0.5, 0.5, 1.0)(input1, input2)
>>> output.shape
torch.Size([1, 1, 5, 5])

class kornia.enhance.Invert(max_val=tensor(1.0))[source]

Invert the values of an input tensor by its maximum value.

Parameters
• input – The input tensor to invert with an arbitatry shape.

• max_val (Tensor, optional) – The expected maximum value in the input tensor. The shape has to according to the input tensor shape, or at least has to work with broadcasting. Default: 1.0.

Example

>>> img = torch.rand(1, 2, 4, 4)
>>> Invert()(img).shape
torch.Size([1, 2, 4, 4])

>>> img = 255. * torch.rand(1, 2, 3, 4, 4)
>>> Invert(torch.tensor(255.))(img).shape
torch.Size([1, 2, 3, 4, 4])

>>> img = torch.rand(1, 3, 4, 4)
>>> Invert(torch.tensor([[[[1.]]]]))(img).shape
torch.Size([1, 3, 4, 4])