|
|
(2 intermediate revisions by the same user not shown) |
Line 1: |
Line 1: |
| <syntaxhighlight lang='python'> | | <syntaxhighlight lang='python'> |
− | #!/usr/bin/env python3
| + | // The script is located in the Scrip's directory of the cudastitcher project. |
− | """ Copyright (C) 2020 RidgeRun, LLC (http://www.ridgerun.com)
| |
− | All Rights Reserved.
| |
− | | |
− | The contents of this software are proprietary and confidential to RidgeRun,
| |
− | LLC. No part of this program may be photocopied, reproduced or translated
| |
− | into another programming language without prior written consent of
| |
− | RidgeRun, LLC. The user is free to modify the source code after obtaining
| |
− | a software license from RidgeRun. All source code changes must be provided
| |
− | back to RidgeRun without any encumbrance. """
| |
− | | |
− | """ Tool for estimate the homography matrix """
| |
− | | |
− | import argparse
| |
− | import cv2
| |
− | import json
| |
− | import numpy as np
| |
− | import sys
| |
− | | |
− | HOMOGRAPHY_DIMENSION = 3
| |
− | MIN_MATCHES = 4
| |
− | | |
− | def drawMatches(imageA, imageB, kpsA, kpsB, matches, status):
| |
− | '''
| |
− | Returns an image with the matches found.
| |
− | | |
− | Parameters:
| |
− | imageA (np.array): Image A
| |
− | imageB (np.arry): Image B
| |
− | kpsA (np.arry): Keypoints for image A
| |
− | kpsB (np.arry): Keypoints for image B
| |
− | matches (np.array): List of found matches between image A and image B
| |
− | status (int): status of homography estimation
| |
− | | |
− | Returns:
| |
− | Image
| |
− | '''
| |
− | | |
− | # initialize the output visualization image
| |
− | (hA, wA) = imageA.shape[:2]
| |
− | (hB, wB) = imageB.shape[:2]
| |
− | vis = np.zeros((max(hA, hB), wA + wB, 3), dtype="uint8")
| |
− | vis[0:hA, 0:wA] = imageA
| |
− | vis[0:hB, wA:] = imageB
| |
− | | |
− | for ((trainIdx, queryIdx), s) in zip(matches, status):
| |
− | # only process the match if the keypoint was successfully
| |
− | # matched
| |
− | if s == 1:
| |
− | # draw the match
| |
− | ptA = (int(kpsA[queryIdx][0]), int(kpsA[queryIdx][1]))
| |
− | ptB = (int(kpsB[trainIdx][0]) + wA, int(kpsB[trainIdx][1]))
| |
− | cv2.line(vis, ptA, ptB, (0, 255, 0), 1)
| |
− | | |
− | return vis
| |
− | | |
− | | |
− | def detectAndDescribe(gray, mask):
| |
− | '''
| |
− | Returns the keyponts and the correspoinding descriptors for the
| |
− | gray image.
| |
− | | |
− | Parameters:
| |
− | gray (np.array): Input image in grayscale.
| |
− | mask (np.arry): Mask to apply before the feature extraction.
| |
− | | |
− | Returns:
| |
− | Tuple with the keypoins and their descriptors.
| |
− | '''
| |
− | | |
− | # detect and extract features from the image
| |
− | detector = cv2.xfeatures2d.SIFT_create()
| |
− | (kps, features) = detector.detectAndCompute(gray, mask)
| |
− | kps = np.float32([kp.pt for kp in kps])
| |
− | | |
− | return (kps, features)
| |
− | | |
− | | |
− | def matchKeypoints(kpsA, kpsB, featuresA, featuresB,
| |
− | ratio, reprojThresh):
| |
− | '''
| |
− | Function that search for the correspondiencies for the given descriptors (featuresA and featuresB) and
| |
− | with those correspondencies keypoints, the homography matrix is calculated.
| |
− | | |
− | Parameters:
| |
− | kpsA (np.array): Keypoints of image A.
| |
− | kpsB (np.arry): Keypoints of image B.
| |
− | featuresA (np.arry): Descriptors of image A
| |
− | featuresB (np.arry): Descriptors of image B
| |
− | ratio (float): Max distance between a possible correspondence.
| |
− | reprojThresh (float): Reprojection error of the homography estimation
| |
− | | |
− | Returns:
| |
− | Tuple with the resulting matches, the homography H and the estimation status.
| |
− | '''
| |
− | | |
− | # compute the raw matches and initialize the list of actual matches
| |
− | matcher = cv2.DescriptorMatcher_create("BruteForce")
| |
− | rawMatches = matcher.knnMatch(featuresA, featuresB, 2)
| |
− | matches = []
| |
− | | |
− | # loop over the raw matches
| |
− | for m in rawMatches:
| |
− | # ensure the distance is within a certain ratio of each
| |
− | # other (i.e. Lowe's ratio test)
| |
− | if len(m) == 2 and m[0].distance < m[1].distance * ratio:
| |
− | matches.append((m[0].trainIdx, m[0].queryIdx))
| |
− | | |
− | print("matches: " + str(len(matches)))
| |
− | if len(matches) >= MIN_MATCHES:
| |
− | # construct the two sets of points
| |
− | ptsA = np.float32([kpsA[i] for (_, i) in matches])
| |
− | ptsB = np.float32([kpsB[i] for (i, _) in matches])
| |
− | | |
− | # compute the homography between the two sets of points
| |
− | (H, status) = cv2.findHomography(ptsA, ptsB, cv2.RANSAC,
| |
− | reprojThresh)
| |
− | | |
− | # return the matches along with the homograpy matrix
| |
− | # and status of each matched point
| |
− | return (matches, H, status)
| |
− | | |
− | # otherwise, no homograpy could be computed
| |
− | return None
| |
− | | |
− | | |
− | def imageEnhancement(img, sigma):
| |
− | '''
| |
− | Rerturns an image with some enhancement applied. Remove the noise of the input image img
| |
− | using a Gaussian filter and then convert it to grayscale.
| |
− | | |
− | Parameters:
| |
− | img (np.array): Input image img
| |
− | sigma (float): Sigma value of the Gaussian filter.
| |
− | | |
− | Returns:
| |
− | Image
| |
− | '''
| |
− | | |
− | # Declare the variables we are going to use
| |
− | kernel_size = 5
| |
− | | |
− | # Remove noise
| |
− | img = cv2.GaussianBlur(img, (kernel_size, kernel_size), sigma)
| |
− | | |
− | # Convert to grayscale
| |
− | gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
| |
− | | |
− | return gray
| |
− | | |
− | | |
− | def removeDistortion(img, K, d):
| |
− | '''
| |
− | Returns an image with the distortion provoked by the camera lens.
| |
− | | |
− | Parameters:
| |
− | img (np.array): Image img.
| |
− | K (np.arry): Camera matrix with a dimension of (3x3).
| |
− | d (np.arry): Vector with the distortion coefficients.
| |
− | Returns:
| |
− | Undistorted image.
| |
− | '''
| |
− | | |
− | # Read an example image and acquire its size
| |
− | h, w = img.shape[:2]
| |
− | | |
− | # Generate new camera matrix from parameters
| |
− | newcameramatrix, roi = cv2.getOptimalNewCameraMatrix(K, d, (w, h), 0)
| |
− | | |
− | # Generate look-up tables for remapping the camera image
| |
− | mapx, mapy = cv2.initUndistortRectifyMap(
| |
− | K, d, None, newcameramatrix, (w, h), 5)
| |
− | | |
− | # Remap the original image to a new image
| |
− | newimg = cv2.remap(img, mapx, mapy, cv2.INTER_LINEAR)
| |
− | return newimg
| |
− | | |
− | | |
− | def parseJSON(filename):
| |
− | '''
| |
− | Returns the algorithm variables read from a JSON configuration file.
| |
− | | |
− | Parameters:
| |
− | filename (string): Path to the JSON configuration file.
| |
− | | |
− | Returns:
| |
− | Tuple the the read variables: (K, D, reprojError, matchRatio, sigma, overlap, crop, fov, undistort)
| |
− | '''
| |
− | | |
− | with open(filename) as json_file:
| |
− | data = json.load(json_file)
| |
− | | |
− | # load config variables
| |
− | reprojError = float(data['reprojError'])
| |
− | matchRatio = float(data['matchRatio'])
| |
− | sigma = float(data['sigma'])
| |
− | fov = float(data['fov'])
| |
− | overlap = float(data['overlap'])
| |
− | crop = float(data['crop'])
| |
− | undistort = bool(data['undistort'])
| |
− | | |
− | # load camera matrix and distortion coeficients
| |
− | K = None
| |
− | D = None
| |
− | if undistort:
| |
− | K = np.zeros(HOMOGRAPHY_DIMENSION * HOMOGRAPHY_DIMENSION)
| |
− | for i, k in enumerate(data['K']):
| |
− | K[i] = k
| |
− | K = K.reshape(HOMOGRAPHY_DIMENSION, HOMOGRAPHY_DIMENSION)
| |
− | | |
− | D = np.zeros([1, len(data['d'])])
| |
− | for i, d in enumerate(data['d']):
| |
− | D[0, i] = d
| |
− | | |
− | return (K, D, reprojError, matchRatio,
| |
− | sigma, overlap, crop, fov, undistort)
| |
− | | |
− | def left_fixed(config, targetImage, originalImage, homographyScale):
| |
− | '''
| |
− | Performs the homography estimation betwen two images, leaving the left one fixed and
| |
− | transforming the right one to align them.
| |
− | | |
− | Parameters:
| |
− | config (string): Path to the JSON configuration file.
| |
− | targetImage (string): Path to the traget iamge.
| |
− | originalImage (string): Path to the original image.
| |
− | homographyScale (float): Scale factor for the generated homography.
| |
− | | |
− | Returns:
| |
− | No return value
| |
− | '''
| |
− | | |
− | (K, d, reprojThresh, ratio, sigma, overlap,
| |
− | crop, fov, undistort) = parseJSON(config)
| |
− | | |
− | # Load images
| |
− | target = cv2.imread(targetImage)
| |
− | original = cv2.imread(originalImage)
| |
− | height, width = target.shape[:2]
| |
− | | |
− | # crop
| |
− | cropImg = int((crop * target.shape[1]) / fov)
| |
− | if cropImg > 0:
| |
− | target = target[:, :-1 * cropImg]
| |
− | target = cv2.resize(target,(width, height), interpolation = cv2.INTER_CUBIC)
| |
− | original = original[:, cropImg:]
| |
− | original = cv2.resize(original,(width, height), interpolation = cv2.INTER_CUBIC)
| |
− | | |
− | # remove undistort
| |
− | if undistort:
| |
− | target = removeDistortion(target, K, d)
| |
− | original = removeDistortion(original, K, d)
| |
− | | |
− | # Enhance images
| |
− | enhancedTarget = imageEnhancement(target, sigma)
| |
− | enhancedOriginal = imageEnhancement(original, sigma)
| |
− | | |
− | # Mask
| |
− | overlapImg = int((overlap * target.shape[1]) / fov)
| |
− | targetMask = np.zeros(enhancedTarget.shape, dtype=np.uint8)
| |
− | targetMask[0:, (-1 * overlapImg):] = 1
| |
− | originalMask = np.zeros(enhancedOriginal.shape, dtype=np.uint8)
| |
− | originalMask[0:, 0:overlapImg] = 1
| |
− | | |
− | # Extract keypoints
| |
− | (kpsA, featuresA) = detectAndDescribe(enhancedOriginal, originalMask)
| |
− | (kpsB, featuresB) = detectAndDescribe(enhancedTarget, targetMask)
| |
− | | |
− | # Match features
| |
− | (matches, H, status) = matchKeypoints(
| |
− | kpsA, kpsB, featuresA, featuresB, ratio, reprojThresh)
| |
− | | |
− | vis = drawMatches(original, target, kpsA, kpsB, matches, status)
| |
− | cv2.imwrite('vis.jpg', vis)
| |
− | | |
− | # Apply homography
| |
− | result = cv2.warpPerspective(
| |
− | original, H, (target.shape[1] + original.shape[1], original.shape[0]))
| |
− | result[0:target.shape[0], 0:target.shape[1]] = target
| |
− | cv2.imwrite('result.jpg', result)
| |
− | | |
− | # Scale homography
| |
− | if homographyScale > 0:
| |
− | Hmap = cv2.reg_MapProjec(H)
| |
− | Hmap.scale(homographyScale)
| |
− | H = Hmap.getProjTr()
| |
− | | |
− | print("""RC_HOMOGRAPHY=\"{{\\"h00\\":{},\\"h01\\":{}, \\"h02\\":{}, \\"h10\\":{}, \\"h11\\":{}, \\"h12\\":{}, \\"h20\\":{}, \\"h21\\":{}, \\"h22\\":{}}}\"""".format(
| |
− | H[0][0],
| |
− | H[0][1],
| |
− | H[0][2],
| |
− | H[1][0],
| |
− | H[1][1],
| |
− | H[1][2],
| |
− | H[2][0],
| |
− | H[2][1],
| |
− | H[2][2])
| |
− | )
| |
− | | |
− | | |
− | def right_fixed(config, targetImage, originalImage, homographyScale):
| |
− | '''
| |
− | Performs the homography estimation betwen two images, leaving the right one fixed and
| |
− | transforming the left one to align them.
| |
− | | |
− | Parameters:
| |
− | config (string): Path to the JSON configuration file.
| |
− | targetImage (string): Path to the traget iamge.
| |
− | originalImage (string): Path to the original image.
| |
− | homographyScale (float): Scale factor for the generated homography.
| |
− | | |
− | Returns:
| |
− | No return value
| |
− | '''
| |
− | | |
− | (K, d, reprojThresh, ratio, sigma, overlap,
| |
− | crop, fov, undistort) = parseJSON(config)
| |
− | | |
− | # Load images
| |
− | target = cv2.imread(targetImage)
| |
− | original = cv2.imread(originalImage)
| |
− | height, width = target.shape[:2]
| |
− | | |
− | # crop
| |
− | cropImg = int((crop * target.shape[1]) / fov)
| |
− | if cropImg > 0:
| |
− | target = target[:, cropImg:]
| |
− | target = cv2.resize(target,(width, height), interpolation = cv2.INTER_CUBIC)
| |
− | original = original[:, :-1 * cropImg]
| |
− | original = cv2.resize(original,(width, height), interpolation = cv2.INTER_CUBIC)
| |
− | | |
− | # remove undistort
| |
− | if undistort:
| |
− | target = removeDistortion(target, K, d)
| |
− | original = removeDistortion(original, K, d)
| |
− | | |
− | # Enhance images
| |
− | enhancedTarget = imageEnhancement(target, sigma)
| |
− | enhancedOriginal = imageEnhancement(original, sigma)
| |
− | | |
− | # Mask
| |
− | overlapImg = int((overlap * target.shape[1]) / fov)
| |
− | targetMask = np.zeros(enhancedTarget.shape, dtype=np.uint8)
| |
− | targetMask[0:, 0:overlapImg] = 1
| |
− | originalMask = np.zeros(enhancedOriginal.shape, dtype=np.uint8)
| |
− | originalMask[0:, (-1 * overlapImg):] = 1
| |
− | | |
− | # Extract keypoints
| |
− | (kpsA, featuresA) = detectAndDescribe(enhancedOriginal, originalMask)
| |
− | (kpsB, featuresB) = detectAndDescribe(enhancedTarget, targetMask)
| |
− | | |
− | # Match features
| |
− | (matches, H, status) = matchKeypoints(
| |
− | kpsB, kpsA, featuresB, featuresA, ratio, reprojThresh)
| |
− | H = np.linalg.inv(H)
| |
− | | |
− | # X translation shift
| |
− | H[0][-1] += original.shape[1]
| |
− | | |
− | vis = drawMatches(target, original, kpsB, kpsA, matches, status)
| |
− | cv2.imwrite('vis.jpg', vis)
| |
− | | |
− | # Apply homography
| |
− | result = cv2.warpPerspective(
| |
− | original, H, (target.shape[1] + original.shape[1], original.shape[0]))
| |
− | result[0:target.shape[0], target.shape[1]:] = target
| |
− | cv2.imwrite('result.jpg', result)
| |
− | | |
− | # Scale homography
| |
− | if homographyScale > 0:
| |
− | Hmap = cv2.reg_MapProjec(H)
| |
− | H[0][-1] -= original.shape[1]
| |
− | Hmap.scale(homographyScale)
| |
− | H = Hmap.getProjTr()
| |
− | | |
− | print("""LC_HOMOGRAPHY=\"{{\\"h00\\":{},\\"h01\\":{}, \\"h02\\":{}, \\"h10\\":{}, \\"h11\\":{}, \\"h12\\":{}, \\"h20\\":{}, \\"h21\\":{}, \\"h22\\":{}}}\"""".format(
| |
− | H[0][0],
| |
− | H[0][1],
| |
− | H[0][2],
| |
− | H[1][0],
| |
− | H[1][1],
| |
− | H[1][2],
| |
− | H[2][0],
| |
− | H[2][1],
| |
− | H[2][2])
| |
− | )
| |
− | | |
− | def cmdline(argv):
| |
− | '''
| |
− | Function taht parse the command line optins before execute the algorithm
| |
− | | |
− | Parameters:
| |
− | config (list): List of command line arguments.
| |
− | | |
− | Returns:
| |
− | No return value
| |
− | '''
| |
− | | |
− | prog = argv[0]
| |
− | parser = argparse.ArgumentParser(
| |
− | prog=prog,
| |
− | description='Tool for use the prediction capabilities of the models in the Adversarial Anomaly Detector.',
| |
− | epilog='Type "%s <command> -h" for more information.' % prog)
| |
− | | |
− | subparsers = parser.add_subparsers(dest='command')
| |
− | subparsers.required = True
| |
− | | |
− | def add_command(cmd, desc, example=None):
| |
− | epilog = 'Example: %s %s' % (
| |
− | prog, example) if example is not None else None
| |
− | return subparsers.add_parser(
| |
− | cmd, description=desc, help=desc, epilog=epilog)
| |
− | | |
− | p = add_command('left_fixed', 'Estimation of homography between two images')
| |
− | | |
− | p.add_argument('--config', help='Path of configure file', default='')
| |
− | p.add_argument('--targetImage', help='Path of the target image', default='')
| |
− | p.add_argument('--originalImage', help='Path of the original image', default='')
| |
− | p.add_argument('--homographyScale', help='Scale factor of the homography. For example if you go from 1920x1080 in the estimation to 640x360 in the processing the scale factor should be 1/3', type=float, default=0)
| |
− | | |
− | p = add_command('right_fixed', 'Estimation of homographies two images')
| |
− | | |
− | p.add_argument('--config', help='Path of configure file', default='')
| |
− | p.add_argument('--targetImage', help='Path of the target image', default='')
| |
− | p.add_argument('--originalImage', help='Path of the original image', default='')
| |
− | p.add_argument('--homographyScale', help='Scale factor of the homography. For example if you go from 1920x1080 in the estimation to 640x360 in the processing the scale factor should be 1/3', type=float, default=0)
| |
− | | |
− | args = parser.parse_args(argv[1:] if len(argv) > 1 else ['-h'])
| |
− | func = globals()[args.command]
| |
− | del args.command
| |
− | func(**vars(args))
| |
− | | |
− | # ----------------------------------------------------------------------------
| |
− | | |
− | | |
− | if __name__ == "__main__":
| |
− | cmdline(sys.argv)
| |
− | | |
− | # ----------------------------------------------------------------------------
| |
| | | |
| </syntaxhighlight> | | </syntaxhighlight> |