NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
PyPI · #2722 most downloaded on PyPI
Open Source Differentiable Computer Vision Library for PyTorch
Last release 2 months ago
19 Jul 2026
Ships fairly regularly
a new release about every 4 months
Nearly every release is documented
notes for 42 of 44 stable releases
Nothing withdrawn
no release was ever pulled
7 years old
45 releases · first in 2019
Remove deprecated code from kornia.geometry.conversion by @pri1311 in #2437
In this release we have added a new Image API as placeholder to support a more generic multibackend api. You can export/import from files, numpy and dlapck.
>>> # from a torch.tensor
>>> data = torch.randint(0, 255, (3, 4, 5), dtype=torch.uint8) # CxHxW
>>> pixel_format = PixelFormat(
... color_space=ColorSpace.RGB,
... bit_depth=8,
... )
>>> layout = ImageLayout(
... image_size=ImageSize(4, 5),
... channels=3,
... channels_order=ChannelsOrder.CHANNELS_FIRST,
... )
>>> img = Image(data, pixel_format, layout)
>>> assert img.channels == 3We have added the ObjectDetector that includes by default the RT-DETR model. The detection pipeline is fully configurable by supplying a pre-processor, a model, and a post-processor. Example usage is shown below.
from io import BytesIO
import cv2
import numpy as np
import requests
import torch
from PIL import Image
import matplotlib.pyplot as plt
from kornia.contrib.models.rt_detr import RTDETR, DETRPostProcessor, RTDETRConfig
from kornia.contrib.object_detection import ObjectDetector, ResizePreProcessor
model_type = "hgnetv2_x" # also available: resnet18d, resnet34d, resnet50d, resnet101d, hgnetv2_l
checkpoint = f"https://github.com/kornia/kornia/releases/download/v0.7.0/rtdetr_{model_type}.ckpt"
config = RTDETRConfig(model_type, 80, checkpoint=checkpoint)
model = RTDETR.from_config(config).eval()
detector = ObjectDetector(model, ResizePreProcessor(640), DETRPostProcessor(0.3))
url = "https://github.com/kornia/data/raw/main/soccer.jpg"
img = Image.open(BytesIO(requests.get(url).content))
img = np.asarray(img, dtype=np.float32) / 255
img_pt = torch.from_numpy(img).permute(2, 0, 1)
detection = detector.predict([img_pt])
for cls_score_xywh in detection[0].numpy():
class_id = int(cls_score_xywh[0])
score = cls_score_xywh[1]
x, y, w, h = cls_score_xywh[2:].round().astype(int)
cv2.rectangle(img, (x, y, w, h), (255, 0, 0), 3)
text = f"{class_id}, {score:.2f}"
font = cv2.FONT_HERSHEY_SIMPLEX
(text_width, text_height), _ = cv2.getTextSize(text, font, 1, 2)
cv2.rectangle(img, (x, y - text_height, text_width, text_height), (255, 0, 0), cv2.FILLED)
cv2.putText(img, text, (x, y), font, 1, (255, 255, 255), 2)
plt.imshow(img)
plt.show()As part of the kornia.contrib module, we started building a models module where Deep Learning models for Computer Vision (Semantic Segmentation, Object Detection, etc.) will exist.
From an abstract base class ModelBase, we will implement and make available these deep learning models (eg Segment anything). Similarly, we provide standard structures to be used with the results of these models such as SegmentationResults.
The idea is that we can abstract and standardize how these models will behave with our High level APIs. Like for example interacting with the Visual Prompter backend (today Segment Anything is available).
ModelBase provides methods for loading checkpoints (load_checkpoint), and compiling itself via the torch.compile API. And we plan to increase it according to the needs of the community.
Within this release, we are also making other models available to be used like RT_DETR and tiny_vit.
Example of using these abstractions to implement a model:
# Each model should be a submodule inside the `kornia.contrib.models`, and the Model class itself will be exposed under this
# `models` module.
from kornia.contrib.models.base import ModelBase
from dataclasses import dataclass
from kornia.contrib.models.structures import SegmentationResults
from enum import Enum
class MyModelType(Enum):
"""Map the model types."""
a = 0
...
@dataclass
class MyModelConfig:
model_type: str | int | SamModelType | None = None
checkpoint: str | None = None
...
class MyModel(ModelBase[MyModelConfig]):
def __init__(...) -> None:
...
@staticmethod
def from_config(config: MyModelConfig) -> MyModel:
"""Build the model based on the config"""
...
def forward(...) -> SegmentationResults:
...In most object detection models, non-maximum suppression (NMS) is necessary to remove overlapping and similar bounding boxes. This post-processing algorithm has high latency, preventing object detectors from reaching real-time speed. DETR is a new class of detectors that eliminate NMS step by using transformer decoder to directly predict bounding boxes. RT-DETR enhances Deformable DETR to achieve real-time speed on server-class GPUs by using an efficient backbone. More details can be seen here
TinyViT is an efficient and high-performing transformer model for images. It achieves a top-1 accuracy of 84.8% on ImageNet-1k with only 21M parameters. See TinyViT for more information.
MobileSAM replaces the heavy ViT-H backbone in the original SAM with TinyViT, which is more than 100 times smaller in terms of parameters and around 40 times faster in terms of inference speed. See MobileSAM for more details.
To use MobileSAM, simply specify "mobile_sam" in the SamConfig:
from kornia.contrib.visual_prompter import VisualPrompter
from kornia.contrib.models.sam import SamConfig
prompter = VisualPrompter(SamConfig("mobile_sam", pretrained=True))Added the LightGlue LightGlue-based matcher in kornia API. This is based on the original code from paper “LightGlue: Local Feature Matching at Light Speed”. See [LSP23] for more details.
The LightGlue algorithm won a money prize in the Image Matching Challenge 2023 @ CVPR23: https://www.kaggle.com/competitions/image-matching-challenge-2023/overview
See a working example integrating with COLMAP: #2469
New kornia.sensors module to interface with sensors like Camera, IMU, GNSS etc.
We added CameraModel , PinholeModel , CameraModelBase for now.
Usage example:
Define a CameraModel
>>> # Pinhole Camera Model
>>> cam = CameraModel(ImageSize(480, 640), CameraModelType.PINHOLE, torch.Tensor([328., 328., 320., 240.]))
>>> # Brown Conrady Camera Model
>>> cam = CameraModel(ImageSize(480, 640), CameraModelType.BROWN_CONRADY, torch.Tensor([1.0, 1.0, 1.0, 1.0,
... 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]))
>>> # Kannala Brandt K3 Camera Model
>>> cam = CameraModel(ImageSize(480, 640), CameraModelType.KANNALA_BRANDT_K3, torch.Tensor([1.0, 1.0, 1.0,
... 1.0, 1.0, 1.0, 1.0, 1.0]))
>>> # Orthographic Camera Model
>>> cam = CameraModel(ImageSize(480, 640), CameraModelType.ORTHOGRAPHIC, torch.Tensor([328., 328., 320., 240.]))
>>> cam.params
tensor([328., 328., 320., 240.])kornia.geometry.solvers submoduleNew module for geometric vision solvers that include the following:
This is part of an upgrade of the find_fundamental to support the 7POINT algorithm.
Added kornia.utils.print_image API for printing any given image tensors or image path to terminal.
>>> kornia.utils.print_image("panda.jpg")TestColorJiggleGen by @johnnv1 in #2341geometry.conversions by @johnnv1 in #2357kornia/tutorials repo by @johnnv1 in #2366setup-python@v4 on env setup CI by @johnnv1 in #2380geometry.conversions by @johnnv1 in #2424kornia.geometry.conversion by @pri1311 in #2437alpha of focal loss by @qingpeng9802 in #2393disallow_untyped_defs on mypy by @johnnv1 in #2252solvers Submodule by Note truncated.
One column per quarter.
In this release we have added a new `ImagePrompter` API that settles the basis as a foundational api for the task to query geometric information to im
In this release we have added a new ImagePrompter API that settles the basis as a foundational api for the task to query geometric information to images inspired by LLM. We leverage the ImagePrompter API via the Segment Anything (SAM) making the model more accessible, packaged and well maintained for industry standards.
Check the full tutorial: https://github.com/kornia/tutorials/blob/master/nbs/image_prompter.ipynb
import kornia as K
from kornia.contrib.image_prompter import ImagePrompter
from kornia.geometry.keypoints import Keypoints
from kornia.geometry.boxes import Boxes
image: Tensor = K.io.load_image("soccer.jpg", ImageLoadType.RGB32, "cuda")
# Load the prompter
prompter = ImagePrompter(config, device="cuda")
# set the image: This will preprocess the image and already generate the embeddings of it
prompter.set_image(image)
# Generate the prompts
keypoints = Keypoints(torch.tensor([[[500, 375]]], device="cuda")) # BxNx2
# For the keypoints label: 1 indicates a foreground point; 0 indicates a background point
keypoints_labels = torch.tensor([[1]], device="cuda") # BxN
boxes = Boxes(
torch.tensor([[[[425, 600], [425, 875], [700, 600], [700, 875]]]], device="cuda"), mode='xyxy'
)
# Runs the prediction with all prompts
prediction = prompter.predict(
keypoints=keypoints,
keypoints_labels=keypoints_labels,
boxes=boxes,
multimask_output=True,
)
Blur images by preserving edges via Bilateral and Guided Blurring -> https://kornia.readthedocs.io/en/latest/filters.html#kornia.filters.guided_blur
ImageLoadType by @edgarriba in https://github.com/kornia/kornia/pull/2309kornia/data by @johnnv1 in https://github.com/kornia/kornia/pull/2319Full Changelog: https://github.com/kornia/kornia/compare/v0.6.11...v0.6.12
In this release we have added DISK, which is the best free local feature for 3D reconstruction. (part of winning solutions in IMC2021 together with Su
In this release we have added DISK, which is the best free local feature for 3D reconstruction. (part of winning solutions in IMC2021 together with SuperGlue). Thanks to @jatentaki for the great work and relicensing the DISK to Apache 2!
import kornia.feature as KF
disk = KF.DISK.from_pretrained('depth').to(device)
with torch.inference_mode():
inp = torch.cat([img1, img2], dim=0)
features1, features2 = disk(inp, 2048,
pad_if_not_divisible=True)
kps1, descs1 = features1.keypoints, features1.descriptors
kps2, descs2 = features2.keypoints, features2.descriptors
dists, idxs = KF.match_smnn(descs1, descs2, 0.98)
<img width="700" alt="image" src="https://user-images.githubusercontent.com/4803565/228498757-b852fb8a-9dd7-425a-a67f-649bee224dcc.png">
core.check, Boxes, and some others by @johnnv1 in https://github.com/kornia/kornia/pull/2219disallow_incomplete_defs on mypy by @johnnv1 in https://github.com/kornia/kornia/pull/2094assert_close() by @gau-nernst in https://github.com/kornia/kornia/pull/2233geometry.subpix by @johnnv1 in https://github.com/kornia/kornia/pull/2253Full Changelog: https://github.com/kornia/kornia/compare/v0.6.10...v0.6.11
DISK local feature by @jatentaki in https://github.com/kornia/kornia/pull/2285add depth_from_disparity function by @pri1311 in https://github.com/kornia/kornia/pull/2096
depth_from_disparity function by @pri1311 in https://github.com/kornia/kornia/pull/2096PadTo to docs by @johnnv1 in https://github.com/kornia/kornia/pull/2122apply_ColorMap for integer tensor by @johnnv1 in https://github.com/kornia/kornia/pull/1996CenterCrop docs example by @johnnv1 in https://github.com/kornia/kornia/pull/2124setup.py by @johnnv1 in https://github.com/kornia/kornia/pull/2137upscale_double by @vicsyl in https://github.com/kornia/kornia/pull/2105nightly labeled condition by @johnnv1 in https://github.com/kornia/kornia/pull/2140TestUpscaleDouble by @johnnv1 in https://github.com/kornia/kornia/pull/2147fail-fast:false as default on tests workflow by @johnnv1 in https://github.com/kornia/kornia/pull/2146depth_from_disparity to docs by @pri1311 in https://github.com/kornia/kornia/pull/2150LongestMaxSize and SmallestMaxSize by @johnnv1 in https://github.com/kornia/kornia/pull/2131sphinx-autodoc-typehints==1.21.3 by @johnnv1 in https://github.com/kornia/kornia/pull/2159TestSSIM3d, and BaseTester.gradcheck by @johnnv1 in https://github.com/kornia/kornia/pull/2152sphinx-autodoc-typehints by @johnnv1 in https://github.com/kornia/kornia/pull/2166boxes, MultiResolutionDetector. apply colormap, AugmentationSequential by @johnnv1 in https://github.com/kornia/kornia/pull/2167BaseTester by @johnnv1 in https://github.com/kornia/kornia/pull/2120x tests for torch=1.12.1 and accelerate not available by @johnnv1 in https://github.com/kornia/kornia/pull/2178filters module: Dropping JIT support by @johnnv1 in https://github.com/kornia/kornia/pull/2187integral_image and integral_tensor by @AnimeshMaheshwari22 in https://github.com/kornia/kornia/pull/1779assert_allclose by assert_close by @johnnv1 in https://github.com/kornia/kornia/pull/2210Augmentations by @johnnv1 in https://github.com/kornia/kornia/pull/2215Full Changelog: https://github.com/kornia/kornia/compare/v0.6.9...v0.6.10
Remove deprecated code in kornia.augmentation by @johnnv1 in https://github.com/kornia/kornia/pull/2028
kornia.geometry.liegroup by @edgarriba in https://github.com/kornia/kornia/pull/1960Hyperplane and Ray API by @edgarriba in https://github.com/kornia/kornia/pull/1963mypy from running on tests by @johnnv1 in https://github.com/kornia/kornia/pull/1983# type: ignore from kornia.feature by @johnnv1 in https://github.com/kornia/kornia/pull/1995kornia.geometry.linalg.euclidean_distance by @edgarriba in https://github.com/kornia/kornia/pull/2000type: ignore by @johnnv1 in https://github.com/kornia/kornia/pull/1998match_smnn by @anstadnik in https://github.com/kornia/kornia/pull/2020kornia.augmentation by @johnnv1 in https://github.com/kornia/kornia/pull/2028get method by @johnnv1 in https://github.com/kornia/kornia/pull/2047RandomGaussianNoise play nicely on GPU by @nitaifingerhut in https://github.com/kornia/kornia/pull/2050license_file by @johnnv1 in https://github.com/kornia/kornia/pull/2057queued and coverage upload by @johnnv1 in https://github.com/kornia/kornia/pull/2038fast_mode on grandchecks by @johnnv1 in https://github.com/kornia/kornia/pull/2069RandomMotionBlur is not deterministic when using self._params by @nitaifingerhut in https://github.com/kornia/kornia/pull/2068kornia.augmentation by @johnnv1 in https://github.com/kornia/kornia/pull/2052fail-fast on CI by @johnnv1 in https://github.com/kornia/kornia/pull/2085check_untyped_defs on mypy by @johnnv1 in https://github.com/kornia/kornia/pull/2086disallow_any_generics on mypy by @johnnv1 in https://github.com/kornia/kornia/pull/2092solve_cast on torch 1.9 by @johnnv1 in https://github.com/kornia/kornia/pull/2066TensorWrapper, Vector3, Scalar and improvements in fit_plane by @edgarriba in https://github.com/kornia/kornia/pull/1987Full Changelog: https://github.com/kornia/kornia/compare/v0.6.8...v0.6.9
In this release in we include an experimental kornia.nerf submodule with a high level API that implements a vanilla Neural Radiance Field (NeRF). Read
In this release in we include an experimental kornia.nerf submodule with a high level API that implements a vanilla Neural Radiance Field (NeRF). Read more about the roadmap of this project: https://github.com/kornia/kornia/issues/1936 // contribution done by @YanivHollander
from kornia.nerf import NerfSolver
from kornia.geomtry.camera import PinholeCamera
camera: PinholeCamera = create_one_camera(5, 9, device, dtype)
img = create_red_images_for_cameras(camera, device)
nerf_obj = NerfSolver(device=device, dtype=dtype)
num_img_rays = 15
nerf_obj.init_training(camera, 1.0, 3.0, False, img, num_img_rays, batch_size=5, num_ray_points=10, lr=1e-2)
nerf_obj.run(num_epochs=10)
img_rendered = nerf_obj.render_views(camera)[0].permute(2, 0, 1)
Improvements, docs and tutorials soon!
Added kornia.contrib.EdgeDetection API that implements dexined: https://github.com/xavysp/DexiNed
import kornia as K
from kornia.contrib import EdgeDetection
edge_detection = EdgeDetector().to(device)
# preprocess
img = K.image_to_tensor(frame, keepdim=False).to(device)
img = K.color.bgr_to_rgb(img.float())
# detect !
with torch.no_grad():
edges = edge_detection(img)
img_vis = K.tensor_to_image(edges.byte())
After testing kornia LoFTR and AdaLAM under big load, our users and we have experiences some bugs in corners cases, such as big images or no input correspondences, which caused pipeline to crash. Not anymore!
See demos in our HuggingFace space: https://huggingface.co/kornia <img width="887" alt="image" src="https://user-images.githubusercontent.com/4803565/195351434-85a52d81-da28-47db-9915-c9e621316506.png">
We have added homography-from-line-segments solver, as well as various speed-ups. We are not yet at OpenCV RANSAC quality level, more improvements to come :) But the line-solver is pretty unique! We also have example in our tutorials https://kornia-tutorials.readthedocs.io/en/latest/line_detection_and_matching_sold2.html
<img width="616" alt="image" src="https://user-images.githubusercontent.com/4803565/195350662-ca070a11-4c85-4082-b79d-c19eece5b328.png">
We are slowly working on being able to run kornia on M1. So far we have added possibility to test locally on M1 and mostly report Pytorch MPS backend crashes in various use-cases. Once this work is finished, we may provide some workarounds to have kornia-M1
Implemented Quaternion.slerp to interpolate between quaternions using quaternion arithmetic -- contributed by @cjpurackal
import torch
from kornia.geometry.quaternion import Quaternion
q0 = Quaternion.identity(batch_size=1)
q1 = Quaternion(torch.tensor([[1., .5, 0., 0.]]))
q2 = q0.slerp(q1, .3)
add_weighted to accept Tensors for alpha/beta/gamma by @nitaifingerhut in https://github.com/kornia/kornia/pull/1868EdgeDetection api by @edgarriba in https://github.com/kornia/kornia/pull/1483Full Changelog: https://github.com/kornia/kornia/compare/v0.6.7...v0.6.8
EdgeDetection api by @edgarriba in https://github.com/kornia/kornia/pull/1483Contributed by SOLD2 original authors
Contributed by SOLD2 original authors
<img width="741" alt="image" src="https://user-images.githubusercontent.com/4803565/187384452-2061da38-f70e-4329-ab36-ca24a5c622be.png">
Good old Lowe ratio-test is good for descriptor matching (implemented as match_snn, match_smnn in kornia, but it is often not enough: it does not take into account keypoint positions.
With this version we started to add geometry aware descriptor matchers, starting with FGINN and AdaLAM. Later we plan to add something like SuperGlue (but free version, ofc).
AdaLAM works particularly well with kornia.feature.KeyNetAffNetHardNet. AdaLAM is adopted from original author's implementation.
import matplotlib.pyplot as plt
import cv2
import kornia as K
import kornia.feature as KF
import numpy as np
import torch
from kornia_moons.feature import *
def load_torch_image(fname):
img = K.image_to_tensor(cv2.imread(fname), False).float() /255.
img = K.color.bgr_to_rgb(img)
return img
device = K.utils.get_cuda_device_if_available()
fname1 = 'kn_church-2.jpg'
fname2 = 'kn_church-8.jpg'
img1 = load_torch_image(fname1)
img2 = load_torch_image(fname2)
feature = KF.KeyNetAffNetHardNet(5000, True).eval().to(device)
input_dict = {"image0": K.color.rgb_to_grayscale(img1), # LofTR works on grayscale images only
"image1": K.color.rgb_to_grayscale(img2)}
hw1 = torch.tensor(img1.shape[2:])
hw2 = torch.tensor(img1.shape[2:])
adalam_config = {"device": device}
with torch.inference_mode():
lafs1, resps1, descs1 = feature(K.color.rgb_to_grayscale(img1))
lafs2, resps2, descs2 = feature(K.color.rgb_to_grayscale(img2))
dists, idxs = KF.match_adalam(descs1.squeeze(0), descs2.squeeze(0),
lafs1, lafs2, # Adalam takes into account also geometric information
config=adalam_config,
hw1=hw1, hw2=hw2) # Adalam also benefits from knowing image size
More - in our Tutorials section
Converting camera pose from (R,t) to actually pose in world coordinates can be a pain. We are relieving you from it, by implementing various conversion functions, such as camtoworld_to_worldtocam_Rt, worldtocam_to_camtoworld_Rt, camtoworld_graphics_to_vision_4x4, etc. The conversions come with two variants: for (R,t) tensor tuple, or with since extrinsics mat4x4.
More geometry-related stuff! We have added Quaternion API to make work with rotation representations easy. Checkout the PR
>>> q = Quaternion.identity(batch_size=4)
>>> q.data
Parameter containing:
tensor([[1., 0., 0., 0.],
[1., 0., 0., 0.],
[1., 0., 0., 0.],
[1., 0., 0., 0.]], requires_grad=True)
>>> q.real
tensor([[1.],
[1.],
[1.],
[1.]], grad_fn=<SliceBackward0>)
>>> q.vec
tensor([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]], grad_fn=<SliceBackward0>)
We recently included the RandomMosaic to mosaic image transforms and combine them into one output image. The output image is composed of the parts from each sub-image.
The mosaic transform steps are as follows:
>>> mosaic = RandomMosaic((300, 300), data_keys=["input", "bbox_xyxy"])
>>> boxes = torch.tensor([[
... [70, 5, 150, 100],
... [60, 180, 175, 220],
... ]]).repeat(8, 1, 1)
>>> input = torch.randn(8, 3, 224, 224)
>>> out = mosaic(input, boxes)
>>> out[0].shape, out[1].shape
(torch.Size([8, 3, 300, 300]), torch.Size([8, 8, 4]))
<img width="500" alt="image" src="https://user-images.githubusercontent.com/15955486/169169100-b974436a-4c01-4728-a3fc-acb2f773bccc.png">
Thanks to @nitaifingerhut
!wget https://github.com/kornia/data/raw/main/drslump.jpg
import torch
import kornia
import cv2
import matplotlib.pyplot as plt
# read the image with OpenCV
img: np.ndarray = cv2.imread('./drslump.jpg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# convert to torch tensor
data: torch.tensor = kornia.image_to_tensor(img, keepdim=False)/255. # BxCxHxW
data-=0.2*torch.rand_like(data).abs()
plt.figure(figsize=(12,8))
edge_blurred = kornia.filters.edge_aware_blur_pool2d(data, 19)
plt.imshow(kornia.tensor_to_image(torch.cat([data, edge_blurred],axis=3)))
<img width="729" alt="image" src="https://user-images.githubusercontent.com/4803565/187416038-0863f459-0ad7-473c-9efb-be9f857aa596.png">
total_variation + adding reduction by @nitaifingerhut in https://github.com/kornia/kornia/pull/1815Full Changelog: https://github.com/kornia/kornia/compare/v0.6.6...v0.6.7
total_variation + adding reduction by @nitaifingerhut in https://github.com/kornia/kornia/pull/1815deprecate filter2D filter3D api by @edgarriba in https://github.com/kornia/kornia/pull/1725
First of integrations to revamp kornia.geometry to align with Eigen and Sophus.
Docs: https://kornia.readthedocs.io/en/latest/geometry.line.html?#kornia.geometry.line.ParametrizedLine
See: example: https://github.com/kornia/kornia/blob/master/examples/geometry/fit_line2.py
load_imageAutomated the packaging infra in kornia_rs to handle multi architecture builds. Arm64 soon :)
See: https://github.com/kornia/kornia-rs
# load the image using the rust backend
img: Tensor = K.io.load_image(file_name, K.io.ImageLoadType.RGB32)
img = img[None] # 1xCxHxW / fp32 / [0, 1]
Created Kornia AI org under the HuggingFace platform. Starting to port the tutorials under HuggingFace kornia org to rapidly show live docs and make community. Link: https://huggingface.co/kornia
Demos:
EarlyStoppping condition by @edgarriba in https://github.com/kornia/kornia/pull/1718meshgrid need indexing argument by @FavorMylikes in https://github.com/kornia/kornia/pull/1629project and unproject in PinholeCamera by @YanivHollander in https://github.com/kornia/kornia/pull/1729filter2D filter3D api by @edgarriba in https://github.com/kornia/kornia/pull/1725rgb_to_y by @nitaifingerhut in https://github.com/kornia/kornia/pull/1734get_perspective_transform by @edgarriba in https://github.com/kornia/kornia/pull/1767KORNIA_CHECK_SAME_DEVICES by @MrShevan in https://github.com/kornia/kornia/pull/1788sphinxcontrib.gtagjs to track docs by @edgarriba in https://github.com/kornia/kornia/pull/1790ParametrizedLine and fit_line by @edgarriba in https://github.com/kornia/kornia/pull/1794Full Changelog: https://github.com/kornia/kornia/compare/v0.6.5...v0.6.6
ParametrizedLine and fit_line by @edgarriba in https://github.com/kornia/kornia/pull/1794project and unproject in PinholeCamera by @YanivHollander in https://github.com/kornia/kornia/pull/1729rgb_to_y by @nitaifingerhut in https://github.com/kornia/kornia/pull/1734KORNIA_CHECK_SAME_DEVICES by @MrShevan in https://github.com/kornia/kornia/pull/1788filter2D filter3D api by @edgarriba in https://github.com/kornia/kornia/pull/1725get_perspective_transform by @edgarriba in https://github.com/kornia/kornia/pull/1767Create kornia.io and implement load_image with rust
kornia.io and implement load_image with rust (#1701)diamond_square and plasma augmentations: RandomPlasmaBrightness, RandomPlasmaContrast, RandomPlasmaShadow (#1700)RandomRGBShift augmentation (#1694)adjust_sigmoid and adjust_log initial implementation (#1685)MS_SSIMLoss (#1655)torch.uint8 (#1705):woman_technologist: :man_technologist: We would like to thank all contributors for this new release ! @Jonas1312 @nitaifingerhut @qwertyforce @ashnair1 @ducha-aiki @z0gSh1u @simon-schaefer @shijianjian @edgarriba @HJoonKwon @ChristophReich1996 @Tanmay06 @dobosevych @miquelmarti @Oleksandra2020
If we forgot someone let us know :sunglasses:
kornia.io and implement load_image with rust (#1701)diamond_square and plasma augmentations: RandomPlasmaBrightness, RandomPlasmaContrast, RandomPlasmaShadow (#1700)RandomRGBShift augmentations (#1694)adjust_sigmoid and adjust_log initial implementation (#1685)pos_weight param to focal loss (#1744)MS_SSIMLoss (#1655)torch.uint8 (#1705)KORNIA_CHECK_SAME_DEVICES (#1775)Deprecated return_transform, enabled 3D augmentations in AugmentionSequential
draw_convex_polygon (#1636)return_transform, enabled 3D augmentations in AugmentionSequential (#1590):woman_technologist: :man_technologist: We would like to thank all contributors for this new release ! @ducha-aiki @edgarriba @shijianjian @juliendenize @ashnair1 @KhaledSharif @Parskatt @shazhou2015 @JoanFM @nrupatunga @kristijanbartol @miquelmarti @riegerfr @nitaifingerhut @dichen-cd @lamhoangtung @hasibzunair @wendy-xiaozong @rsomani95 @huuquan1994 @twsl
If we forgot someone let us know :sunglasses:
Added Hanning kernel, prepare for KCF tracking
:woman_technologist: :man_technologist: We would like to thank all contributors for this new release ! @ducha-aiki @edgarriba @shijianjian @julien-blanchon @lferraz @miquelmarti @twsl @nitaifingerhut @eungbean @aaroswings @huuquan1994 @rsomani95
If we forgot someone let us know :sunglasses:
Add container operation weights and OneOf documentation
ObjectDetectorTrainer (#1414)OneOf documentation (#1443)warp_perspective (#1452)draw_line image utility (#1456):woman_technologist: :man_technologist: We would like to thank all contributors for this new release ! @ducha-aiki @edgarriba @chinhsuanwu @chinhsuanwu @dobosevych @shijianjian @rvorias @rvorias @fmiotello @hal-314 @trysomeway @miquelmarti @calmdown13 @twsl Abdelrhman-Hosny
If we forgot someone let us know :sunglasses:
ObjectDetectorTrainer (#1414)OneOf documentation (#1443)warp_perspective (#1452)draw_line image utility (#1456)Fixes PyPI tarball missing required files #1421
0.6.1)Deprecate PyTorch 1.6/1.7 and add 1.9.1
0.6.0)Release time: 2021-10-22
:woman_technologist: :man_technologist: We would like to thank all contributors for this new release ! @AK391 @cclauss @edgarriba @ducha-aiki @isaaccorley @justanhduc @jatentaki @shijianjian @shiyangc-intusurg @SravanChittupalli @thatbrguy @nvshubhsharma @PWhiddy @oskarflordal @tacoelho @YanivHollander @jhacsonmeza
If we forgot someone let us know :sunglasses:
Removed deprecated codes for v6.0
0.5.11)Release time: 2021-09-19
:woman_technologist: :man_technologist: We would like to thank all contributors for this new release ! @Abdelrhman-Hosny @ducha-aiki @edgarriba @EStorm21 @lyhyl @shijianjian @thatbrguy
If we forgot someone let us know :sunglasses:
Added Basic pool request for DeFMO.
Add the connected components labeling algorithm
@bkntr @bsuleymanov @ducha-aiki @edgarriba @hal-314 @kingsj0405 @shijianjian
If we forgot someone let us know :sunglasses:
Grayscale to RGB image conversion.
@bsuleymanov @dhernandez0 @ducha-aiki
If we forgot someone let us know :sunglasses:
Added mix augmentations in containers
@dkoguciuk @edgarriba @lferraz @shijianjian
If we forgot someone let us know :sunglasses:
Added auto-generated images in docs
@copaah @ducha-aiki @edgarriba @eugene87222 @JoanFM @justanhduc @pmeier @shijianjian
If we forgot someone let us know :sunglasses:
Added denormalize homography function
@asottile @Borda @ducha-aiki @edgarriba @jhacsonmeza @justanhduc @Manza12 @priba @shijianjian
Special thanks to @Borda @carmocca @asottile for the help to improve the code health of the package.
If we forgot someone let us know :sunglasses:
Added inverse for augmentations
@Borda @dkoguciuk @edgarriba @Manza12 @lferraz @priba @shijianjian
If we forgot someone let us know :sunglasses:
Fixed angle axis to quaternion order bug
thanks to all your contributions @amonszpart @AnimeshMaheshwari22 @askaradeniz @edgarriba @jatentaki
The Kornia Team :nerd_face:
Deprecate some augmentation functionals
In this patch release we include the following features
RandomCropResize, RandomCropkornia.geometry.resizeHardNet8 deep featurestorch.float16ImageToTensorRandomInvertRandomChannelShuffleRandomGaussianNoiseDeprecated kornia.geometry.warp module.
In this release we have focus in bringing more classic Computer Vision functionalities to the PyTorch ecosystem, like morphological operators and more diversity with Deep Local Descriptors, color conversions and drawing functions. In addition, we have worked towards improving the integration with TPU and better support with Torchscript.
As a highlight we include a kornia.morphology that implements several functionalities to work with morphological operators on high-dimensional tensors and differentiability. Contributed by @Juclique
Morphology implements the following methods: dilation, erosion, open, close, close, gradient, top_hat and black_hat.
from kornia import morphology as morph
dilated_image = morph.dilation(tensor, kernel) # Dilation
plot_morph_image(dilated_image) # Plot
See a full tutorial here: https://github.com/kornia/tutorials/blob/master/source/morphology_101.ipynb
We have added a set of local feature-related models: MKDDescriptor #841 by implemented and ported to kornia by @manyids2; also we ported TFeat, AffNet, OriNet from authors repos #846.
Here is notebook, showing the usage and benefits of new features. We also show how to seamlessly integrate kornia and opencv code via new conversion library kornia_moons.
Also: exposed set_laf_orientation function #869
We include a new operator to perform augmentations with videos VideoSequential. The module is based in nn.Sequential and has the ability to concatenate our existing kornia.augmentations for multi-dimensional video tensors. Contributed by @shijianjian
import kornia
import torchvision
clip, _, _ = torchvision.io.read_video("drop.avi")
clip = clip.permute(3, 0, 1, 2)[None] / 255. # To BCTHW
input = torch.randn(2, 3, 1, 5, 6).repeat(1, 1, 4, 1, 1)
aug_list = VideoSequential(
kornia.augmentation.ColorJitter(0.1, 0.1, 0.1, 0.1, p=1.0),
kornia.augmentation.RandomAffine(360, p=1.0),
data_format="BTCHW",
same_on_frame=False)
)
out = aug(input)
See a full example in the following Colab: https://colab.research.google.com/drive/12dmHNkvEQrG-PHElbCXT9FgCr_aAGQSI?usp=sharing
We include an experimental functionality draw rectangle implemented in pure torch.tensor. Contributed by @mmathew23
rects = torch.tensor([[[110., 50., 310., 275.], [325., 100., 435., 275.]]])
color = torch.tensor([255., 0., 0.])
x_out = K.utils.draw_rectangle(x_rgb, rects, color)
See full example here: https://colab.research.google.com/drive/1me_DxgMvsHIheLh-Pao7rmrsafKO5Lg3?usp=sharing
binary_focal_loss_with_logits #830 by @xen0f0nrgb_to_lab #823 by @cceydaGaussianBlur augmentation #773 by @ZhiyuanChenget_gaussian_erf_kernel1d, get_gaussian_discrete #736 by @wyliequalize_clahe #895 by @lferrazblur_pool2d #894 by @shijianjianget_tps_transform, warp_points_tps, warp_image_tps #897 by @catalys1elastic transform 2d #853 by @IssamLaradji @edgarribakornia.geometry.warp module.
DepthWarper is now in kornia.geometry.depthHomographyWarper and related functions are now inside kornia.geometry.transform.kornia.contrib module.
max_pool_blurd2d is now in kornia.filtersWe refactored the interface of the functions warp_perspective, warp_affine, center_crop, crop_and_resize and crop_by_boxes in order to expose to the user the needed parameters by grid_sample [mode, padding_mode, align_corners]. #896
The param align_corners has been set by default to None that maps to True in case the user does not specify.
This comes from the motivation to match the behavior of the warping functions with OpenCV.
Example of warp_perspective:
def warp_perspective(src: torch.Tensor, M: torch.Tensor, dsize: Tuple[int, int],
mode: str = 'bilinear', padding_mode: str = 'zeros',
align_corners: Optional[bool] = None) -> torch.Tensor:
Please review the full release notes here: https://github.com/kornia/kornia/blob/master/CHANGELOG.md
We include new features for 3D augmentations:
We include new features for 3D augmentations:
RandomCrop3DCenterCrop3DRandomMotionBlur3DRandomEqualize3DFew more core functionalities to work on 3D volumetric tensors:
warp_affine3dwarp_perspective3dget_perspective_transform3dcrop_by_boxes3dmotion_blur3dequalize3dwarp_grid3dget_affine_matrix2d and get_affine_matrix3d (#618)solarize, posterize, sharpness, equalize (#623)equalize3d (#639)decompose 3x4projection matrix (#650)normalize_min_max functionality (#684)random equalize3d (#653)warp_affine3dwarp_perspective3dget_perspective_transform3dcrop_by_boxes3dwarp_grid3dunfold in contrib.extract_tensor_patches (#626)find_homography_dlt performance improvement and weights params made optional (#690)kornia.resize (#628)Affine transformation as nn.Module (#630)warp_projective (#689)@gaurav104 @shijianjian @mshalvagal @pmeier @ducha-aiki @qxcv @FGeri @vribeiro1 @ChetanPatil28 @alopezgit @jatentaki @dkoguciuk @ceroytres @ag14774
In this release we are including the following main features:
In this release we are including the following main features:
We include an kornia.feature.matching API to perform local descriptors matching such classical and derived version of the nearest neighbour (NN).
import torch
import kornia as K
desc1 = torch.rand(2500, 128)
desc2 = torch.rand(2500, 128)
dists, idxs = K.feature.matching.match_nn(desc1, desc2) # 2500 / 2500x2
We also introduce kornia.geometry.homography including different functionalities to work with homographies and differentiable estimators based on the DLT formulation and the iteratively-reweighted least squares (IRWLS).
import torch
import kornia as K
pts1 = torch.rand(1, 8, 2)
pts2 = torch.rand(1, 8, 2)
H = K.find_homography_dlt(pts1, pts2, weights=torch.rand(1, 8)) # 1x3x3
In addition, we have ported some of the existing algorithms from opencv.sfm to PyTorch under kornia.geometry.epipolar that includes different functionalities to work with Fundamental, Essential or Projection matrices, and Triangulation methods useful for Structure from Motion problems.
We expand the kornia.augmentaion with a series of operators to perform 3D augmentations for volumetric data BxCxDxHxW. In this release, we include the following first set of geometric 3D augmentations methods:
The API for 3D augmentation work same as with 2D image augmentations:
import torch
import kornia as K
x = torch.eye(3).repeat(3, 1, 1)
aug = K.augmentation.RandomVerticalFlip3D(p=1.0)
print(aug(x))
tensor([[[[[0., 0., 1.],
[0., 1., 0.],
[1., 0., 0.]],
<BLANKLINE>
[[0., 0., 1.],
[0., 1., 0.],
[1., 0., 0.]],
<BLANKLINE>
[[0., 0., 1.],
[0., 1., 0.],
[1., 0., 0.]]]]])
Finally, we introduce also a low level API to perform 4D features transformations kornia.warp_projective and extending the filtering operators to support 3D kernels kornia.filter3D.
We expand as well the list of the 2D image augmentations based on the paper AutoAugment: Learning Augmentation Policies from Data.
SolarizePosterizeSharpnessEqualizeRandomSolarizeRandomPosterizeRandomShaprnessRandomEqualizekornia.enhance submodule (#614) -> see details in hereThis release is just a checkpoint for the features in v0.4.0 with support to PyTorch 1.5.1.
This release is just a checkpoint for the features in v0.4.0 with support to PyTorch 1.5.1.
To see the new set of features check the release notes for Kornia 0.4.0.
This release mainly introduces the following items:
This release mainly introduces the following items:
Add support to Python 3.8
Exposes and fixes issues around align_corners.
Improve testing infrastructure adding parametrize for different devices and dtype and flake8/mypy support throw pytest by caching intermediate results. Test usage example:
pytest -v --device cpu,cuda --dtype float16,float32,float64 --flake8 --mypy
Today we released 0.3.0 which aligns with PyTorch releases cycle and includes:
Today we released 0.3.0 which aligns with PyTorch releases cycle and includes:
For more detailed changes check out v0.2.1 and v0.2.2.
We provide kornia.augmentation a high-level framework that implements kornia-core functionalities and is fully compatible with torchvision supporting batched mode, multi device cpu, gpu, and xla/tpu (comming), auto differentiable and able to retrieve (and chain) applied geometric transforms. To check how to reproduce torchvision in kornia refer to this Colab: Kornia vs. Torchvision @shijianjian
import kornia as K
import torchvision as T
# kornia
transform_fcn = torch.nn.Sequential(
K.augmentation.RandomAffine(
[-45., 45.], [0., 0.5], [0.5, 1.5], [0., 0.5], return_transform=True),
K.color.Normalize(0.1307, 0.3081),
)
# torchvision
transform_fcn = T.transforms.Compose([
T.transforms.RandomAffine(
[-45., 45.], [0., 0.5], [0.5, 1.5], [0., 0.5]),
T.transforms.ToTensor(),
T.transforms.Normalize((0.1307,), (0.3081,)),
])
Kornia has been designed to be very flexible in order to be integrated in other existing frameworks. See the example below about how easy you can define a custom data augmentation pipeline to later be integrated into any training framework such as Pytorch-Lighting. We provide examples in [here] and [here].
class DataAugmentatonPipeline(nn.Module):
"""Module to perform data augmentation using Kornia on torch tensors."""
def __init__(self, apply_color_jitter: bool = False) -> None:
super().__init__()
self._apply_color_jitter = apply_color_jitter
self._max_val: float = 1024.
self.transforms = nn.Sequential(
K.augmentation.Normalize(0., self._max_val),
K.augmentation.RandomHorizontalFlip(p=0.5)
)
self.jitter = K.augmentation.ColorJitter(0.5, 0.5, 0.5, 0.5)
@torch.no_grad() # disable gradients for effiency
def forward(self, x: torch.Tensor) -> torch.Tensor:
x_out = self.transforms(x)
if self._apply_color_jitter:
x_out = self.jitter(x_out)
return x_out
Now easy to run GPU tests with pytest --typetest cuda
This release is a checkpoint with minimum data augmentation API stability plus fixing some GPU tests before kornia upgrades to PyTorch v.1.5.0.
This release is a checkpoint with minimum data augmentation API stability plus fixing some GPU tests before kornia upgrades to PyTorch v.1.5.0.
In this release we support compatibility between kornia.augmentation and torchvision.transforms.
In this release we support compatibility between kornia.augmentation and torchvision.transforms.
We now support all the same existing operations with torch.Tensor in the GPU with extra features such as returning for each operator the transformation matrix generated to produce such transformation.
import kornia as K
import torchvision as T
# kornia
transform_fcn = torch.nn.Sequential(
K.augmentation.RandomAffine(
[-45., 45.], [0., 0.5], [0.5, 1.5], [0., 0.5], return_transform=True),
K.color.Normalize(0.1307, 0.3081),
)
# torchvision
transform_fcn = T.transforms.Compose([
T.transforms.RandomAffine(
[-45., 45.], [0., 0.5], [0.5, 1.5], [0., 0.5]),
T.transforms.ToTensor(),
T.transforms.Normalize((0.1307,), (0.3081,)),
])
Check the online documentations with the updated API [DOCS]
Check this Google Colab to see how to reproduce same results [Colab]
kornia.augmentation as a frameworkIn addition, we have re-designed kornia.augmentation such in a way that users can easily contribute with more operators, or just use it as a framework to create their custom operators.
Each of the kornia.augmentation modules inherit from AugmentationBase and one can easily define a new operator by creating a subclass and overriding a couple of methods.
Let's take a look at a custom MyRandomRotation . The class inherits from AugmentationBase making it a nn.Module so that can be stacked in a nn.Sequential to compute chained transformations.
To implement a new functionality two things needed: override get_params and apply
The get_params receives the shape of the input tensor and returns a dictionary with the parameters to use in the apply function.
The applyfunction receives as input a tensor and the dictionary defined in get_params; and returns a tuple with the transformed input and the transformation applied to it.
class MyRandomRotation(AugmentationBase):
def __init__(self, angle: float, return_transform: bool = True) -> None:
super(MyRandomRotation, self).__init__(self.apply, return_transform)
self.angle = angle
def get_params(self, batch_shape: torch.Size) -> Dict[str, torch.Tensor]:
angles_rad torch.Tensor = torch.rand(batch_shape) * K.pi
angles_deg = kornia.rad2deg(angles_rad) * self.angle
return dict(angles=angles_deg)
def apply(self, input: torch.Tensor, params: Dict[str, torch.Tensor]):
# compute transformation
angles: torch.Tensor = params['angles'].type_as(input)
center = torch.tensor([[W / 2, H / 2]]).type_as(input)
transform = K.get_rotation_matrix2d(
center, angles, torch.ones_like(angles))
# apply transformation
output = K.warp_affine(input, transform, (H, W))
return (output, transform)
# how to use it
# load an image and cast to tensor
img1: torch.Tensor = imread(...) # BxDxHxW
# instantiate and apply the transform
aug = MyRandomRotation(45., return_transformation=True)
img2, transform = aug(img1) # BxDxHxW - Bx3x3
Kornia v0.2.0 release is now available.
Kornia v0.2.0 release is now available.
The release contains over 50 commits and updates support to PyTorch 1.4. This is the result of a huge effort in the desing of the new data augmentation module, improvements in the set of the color space conversion algorithms and a refactor of the testing framework that allows to test the library using the cuda backend.
From this point forward, we will give support to the new data augmentation API. The kornia.augmentation module mimics the best of the existing data augmentation frameworks such torchvision or albumentations all re-implemented assuming as input torch.Tensor data structures that will allowing to run the standard transformations (geometric and color) in batch mode in the GPU and backprop through it.
In addition, a very interesting feature we are very proud to include, is the ability to return the transformation matrix for each of the transform which will make easier to concatenate and optimize the transforms process.
A quick overview of its usage:
import torch
import kornia
input: torch.Tensor = load_tensor_data(....) # BxCxHxW
transforms = torch.nn.Sequential(
kornia.augmentation.RandomGrayscale(),
kornia.augmentation.RandomAffine(degrees=(-15, 15)),
)
out: torch.Tensor = transforms(input) # CPU
out: torch.Tensor = transforms(input.cuda()) # GPU
# same returning the transformation matrix
transforms = torch.nn.Sequential(
kornia.augmentation.RandomGrayscale(return_transformation=True),
kornia.augmentation.RandomAffine(degrees=(-15, 15), return_transformation=True),
)
out, transform = transforms(input) # BxCxHxW , Bx3x3
This are the following features found we introduce in the module:
We have refactored our testing framework and we can now easily integrate GPU tests within our library. At this moment, this features is only available to run locally but very soon we will integrate with CircleCI and AWS infrastructure so that we can automate the process.
From root one just have to run: make test-gpu
Tests look like this:
import torch
from test.common import device
def test_rgb_to_grayscale(self, device):
channels, height, width = 3, 4, 5
img = torch.ones(channels, height, width).to(device)
assert kornia.rgb_to_grayscale(img).shape == (1, height, width)
Ref PR:
We have added few more algorithms for color space conversion:
kornia.hflip, kornia.vflip and kornia.rot180 (#268)kornia.transform_boxes (#368)As usual, thanks to the community to keep this project growing. Happy coding ! :sunrise_over_mountains:
Nothing published for this version
We have just released Kornia: a differentiable computer vision library for PyTorch.
We have just released Kornia: a differentiable computer vision library for PyTorch.
It consists of a set of routines and differentiable modules to solve generic computer vision problems. At its core, the package uses PyTorch as its main backend both for efficiency and to take advantage of the reverse-mode auto-differentiation to define and compute the gradient of complex functions.
Inspired by OpenCV, this library is composed by a subset of packages containing operators that can be inserted within neural networks to train models to perform image transformations, epipolar geometry, depth estimation, and low level image processing such as filtering and edge detection that operate directly on tensors.
It has over 300 commits and majorly refactors the whole library including over than 100 functions to solve generic Computer Vision problems.
Version 0.1.4 includes a reorganization of the internal API grouping functionalities that consists of the following components:
Big contribution in kornia.features:
GaussianBlur -> GaussianBlur2d and added an input to specify pad b0c522e60ef4c82a3d1881dd5901a25d7a4a02c5extract_patches_from_pyramid, extract_patches_simple, normalize_laf, ellipse_to_laf, make_upright, scale_laf, get_laf_scale 0a3cbb02850ac78059e0615da93144b5a64d3330geometry.depth submodule including: depth_to_3d, depth_to_normals, warp_frame_depth d1dedb8d37f99b752467ed4acaf4f767afbbad49Filter2D to apply arbitrary depthwise 2d kernels 94b56f2d43ed87a259aca3e6313d0f7a1222baf5project_points 636f4f5338e4fc1b6d32140c6f1febae3b64eb96unproject_points b02f403feaf1fdeb574fb87e1d70157ec0b4dbffdenormalize_coordinates b07ec45410f45469bad2067ce03b83dddcabb7c0harris_corner detector 977a1f6a8c7beef9c339fdd695032dec2705c7d3non_maxima_suppression_2d 84cc1287fcd9df2a437a2d25a61f171097047a76median_filter 6b6cf0543028dcf3bfb25a0ae9104e6ade26037eblur_filter d4c8df933570fa95546e84517a6d676e302e6e7dsobel_filter operator 9abe4c5afdbe486baadf07b427ad5468d57da603max_blur_pool_2d 621be3b59055f000896c45fe33a28fa3ca680841pyrup and pyrdown a4e110cd47dd6c7792751fb7294d068b7655486acrop_and_resize 41b4fed573c37c7310e4d7e03b73a54bce1eb2abcenter_crop b1188d50f7ecae001832e05e606ca55d0d630ae6inverse_affine_matrix 6e10fb9a0859ef35f82b6e2dfd58af828bda7a8cremap function b0401deac4b54e201095705ec8c18eabe943cd2baffine ceb3faf3b89596ba23bdc7e0f616b218edf997dfshear 81c5a2798f00663ee64ff74db87340daa6edb08dscale 75a84a373e9ce142fb4a1ac0d7fde8f3790b861ctranslate 11af4dde591258e057d1973bb00529f49fa6d63frotate 89c6d964c5a18254adf73a5f8da00d8a5068e7bcrgb_to_gray 9a2bea6057f4cf99eb6c16c96d5a1c952d95b4b2confusion_matrix f30606209f20f9f2d879b2eaec80215cc274a80anormalization on tensors 4c3f8fa52d3b9d86843716a99d5c833e80929212rgb_to_bgr e25f6a4900ede8786a0eee38f58f4ffd0908535ahsv_to_rgb 9726872019d71c3b9a3e7cabaf51e77a96220a45adjust_brightness b8fd8b6bce1707ea8a0b2fd5ba9498fe10d586b8pyrdown with avg_pool2d b83514302232cf8bc31c30f3981a168dd7b55e39rotation_matrix_to_quaternion 58c6e8e7038ad1ca4d9051e04b54b6a42fd72a74torch.gesv -> torch.solve in get_perspective_transform c347a41e85eae78d73ea821b06623383d7a142a4test_warp_perspective d19121effb69d4c17d53f6bea010941cb7730f32quaternion related docs to reflect quaternions 0161f65831ab9f975575586c4c1b1aec6e8a6b11Nothing published for this version
Your coding agent can read these notes before it upgrades. Set up the MCP server →