def test_simple(self):
img = self.get_sample('stitching/a1.png')
finder= cv.ORB.create()
imgFea = cv.detail.computeImageFeatures2(finder,img)
self.assertIsNotNone(imgFea)
matcher = cv.detail_BestOf2NearestMatcher(False, 0.3)
self.assertIsNotNone(matcher)
matcher = cv.detail_AffineBestOf2NearestMatcher(False, False, 0.3)
self.assertIsNotNone(matcher)
matcher = cv.detail_BestOf2NearestRangeMatcher(2, False, 0.3)
self.assertIsNotNone(matcher)
estimator = cv.detail_AffineBasedEstimator()
self.assertIsNotNone(estimator)
estimator = cv.detail_HomographyBasedEstimator()
self.assertIsNotNone(estimator)
adjuster = cv.detail_BundleAdjusterReproj()
self.assertIsNotNone(adjuster)
adjuster = cv.detail_BundleAdjusterRay()
self.assertIsNotNone(adjuster)
adjuster = cv.detail_BundleAdjusterAffinePartial()
self.assertIsNotNone(adjuster)
adjuster = cv.detail_NoBundleAdjuster()
self.assertIsNotNone(adjuster)
compensator=cv.detail.ExposureCompensator_createDefault(cv.detail.ExposureCompensator_NO)
self.assertIsNotNone(compensator)
compensator=cv.detail.ExposureCompensator_createDefault(cv.detail.ExposureCompensator_GAIN)
self.assertIsNotNone(compensator)
compensator=cv.detail.ExposureCompensator_createDefault(cv.detail.ExposureCompensator_GAIN_BLOCKS)
self.assertIsNotNone(compensator)
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)
self.assertIsNotNone(seam_finder)
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)
self.assertIsNotNone(seam_finder)
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM)
self.assertIsNotNone(seam_finder)
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR")
self.assertIsNotNone(seam_finder)
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR_GRAD")
self.assertIsNotNone(seam_finder)
seam_finder = cv.detail_DpSeamFinder("COLOR")
self.assertIsNotNone(seam_finder)
seam_finder = cv.detail_DpSeamFinder("COLOR_GRAD")
self.assertIsNotNone(seam_finder)
blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
self.assertIsNotNone(blender)
blender = cv.detail.Blender_createDefault(cv.detail.Blender_FEATHER)
self.assertIsNotNone(blender)
blender = cv.detail.Blender_createDefault(cv.detail.Blender_MULTI_BAND)
self.assertIsNotNone(blender)
timelapser = cv.detail.Timelapser_createDefault(cv.detail.Timelapser_AS_IS);
self.assertIsNotNone(timelapser)
timelapser = cv.detail.Timelapser_createDefault(cv.detail.Timelapser_CROP);
self.assertIsNotNone(timelapser)
def __init__(self):
self.liste_pos_coin = []
self.init = False
self.nb_point_cle = 500
self.seuil_appariement = 0.3
self.seuil_confiance = 1
self.indices = []
self.matcher_type = "Best"
self.type_estimateur = "homography"
self.fct_couture = "dp_color"
self.surface_compo = "plane"
self.correction_horizon = False
self.try_cuda = False
self.correction_exposition = cv.detail.ExposureCompensator_GAIN_BLOCKS
self.force_melange = 100
self.couture_visible = False
self.liste_taille_masque = []
self.liste_masque_compo = []
self.liste_masque_compo_piece = []
self.liste_masque_piece_init = False
# self.liste_masque_piece = []
self.cameras = []
self.focales = []
self.parametre_ba = ""
self.focale_moyenne = 1
self.algo_composition = None
self.algo_correct_expo = None
self.composition = None
self.gains = []
self.liste_fct_cout = ['ray', 'reproj', 'affine', 'no']
self.fct_cout = self.liste_fct_cout[0]
self.cout = {
self.liste_fct_cout[0]: cv.detail_BundleAdjusterRay,
self.liste_fct_cout[1]: cv.detail_BundleAdjusterReproj,
self.liste_fct_cout[2]: cv.detail_BundleAdjusterAffine,
self.liste_fct_cout[3]: cv.detail_NoBundleAdjuster
}
self.liste_couture = [
"no", "voronoi", "gc_color", "gc_colorgrad", "dp_color",
"dp_colorgrad"
]
self.fct_couture = self.liste_couture[0]
self.couture = {
self.liste_couture[0]:
cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO),
self.liste_couture[1]:
cv.detail.SeamFinder_createDefault(
cv.detail.SeamFinder_VORONOI_SEAM),
self.liste_couture[2]:
cv.detail_GraphCutSeamFinder("COST_COLOR"),
self.liste_couture[3]:
cv.detail_GraphCutSeamFinder("COST_COLOR_GRAD"),
self.liste_couture[4]:
cv.detail_DpSeamFinder("COLOR"),
self.liste_couture[5]:
cv.detail_DpSeamFinder("COLOR_GRAD")
}
def seam_type_check(seam_find_type):
seam_finder = None
if seam_find_type == "no":
seam_finder = cv2.detail.SeamFinder_createDefault(
cv2.detail.SeamFinder_NO)
elif seam_find_type == "voronoi":
seam_finder = cv2.detail.SeamFinder_createDefault(
cv2.detail.SeamFinder_VORONOI_SEAM)
elif seam_find_type == "gc_color":
seam_finder = cv2.detail_GraphCutSeamFinder("COST_COLOR")
elif seam_find_type == "gc_colorgrad":
seam_finder = cv2.detail_GraphCutSeamFinder("COST_COLOR_GRAD")
elif seam_find_type == "dp_color":
seam_finder = cv2.detail_DpSeamFinder("COLOR")
elif seam_find_type == "dp_colorgrad":
seam_finder = cv2.detail_DpSeamFinder("COLOR_GRAD")
if seam_finder is None:
print("Can't create the following seam finder ", seam_find_type)
exit()
return seam_finder
def main():
img_names = [r'C:\Scratch\IPA_Data\FullRes\a0_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a1_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a2_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a3_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a4_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a5_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a6_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a7_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a8_nor.tif',
r'C:\Scratch\IPA_Data\FullRes\a9_nor.tif']
# r'C:\Scratch\IPA_Data\FullRes\b0_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b1_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b2_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b3_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b4_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b5_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b6_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b7_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b8_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\b9_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c0_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c1_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c2_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c3_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c4_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c5_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c6_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c7_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c8_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\c9_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d0_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d1_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d2_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d3_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d4_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d5_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d6_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d7_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d8_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\d9_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e0_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e1_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e2_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e3_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e4_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e5_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e6_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e7_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e8_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\e9_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f0_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f1_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f2_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f3_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f4_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f5_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f6_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f7_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f8_nor.tif',
# r'C:\Scratch\IPA_Data\FullRes\f9_nor.tif']
print(img_names)
# ================ DEFINE ALL PARAMETERS ================
# Flags
try_cuda = False
work_megapix = 8
features_type = "surf"
matcher_type = "affine"
estimator_type = "affine"
match_conf = 0.75
conf_thresh = 1.0
ba_cost_func = "affine"
ba_refine_mask = "xxxxx"
wave_correct = "vert"
save_graph_var = None
# Compositing Flags
warp_type = "affine"
seam_megapix = 2.0
seam_find_type = "gc_color"
compose_megapix = -1
expos_comp = "no"
expos_comp_nr_feeds = 1
# expos_comp_nr_filtering = 2
expos_comp_block_size = 32
blend_type = "multiband"
blend_strength = 5
result_name = "test_result_3.png"
timelapse_name = None
range_width = 8
# Check if there is to be wave correction, then set the boolean check value
if wave_correct == 'no':
do_wave_correct = False
else:
do_wave_correct = True
# Check if there is to be a graph file created
if save_graph_var is None:
save_graph = False
else:
save_graph = True
save_graph_to = save_graph_var
# Check if the exposure is to be compensated, if so define which compensator to use
if expos_comp == 'no':
expos_comp_type = cv.detail.ExposureCompensator_NO
elif expos_comp == 'gain':
expos_comp_type = cv.detail.ExposureCompensator_GAIN
elif expos_comp == 'gain_blocks':
expos_comp_type = cv.detail.ExposureCompensator_GAIN_BLOCKS
elif expos_comp == 'channel':
expos_comp_type = cv.detail.ExposureCompensator_CHANNELS
elif expos_comp == 'channel_blocks':
expos_comp_type = cv.detail.ExposureCompensator_CHANNELS_BLOCKS
else:
print("Bad exposure compensation method")
exit()
# Check if the timelapse is to be output. AKA the intermediate layers
if timelapse_name is not None:
timelapse = True
if timelapse_name == "as_is":
timelapse_type = cv.detail.Timelapser_AS_IS
elif timelapse_name == "crop":
timelapse_type = cv.detail.Timelapser_CROP
else:
print("Bad timelapse method")
exit()
else:
timelapse = False
# Check the feature type to be used and create the finder class that will be used
# TODO - See if there other feature detectors which are more suitable
if features_type == 'orb':
finder = cv.ORB.create(500, 1.1, 8, 50, 0, 2, 0, 50, 20)
elif features_type == 'surf':
finder = cv.xfeatures2d_SURF.create(100, 8, 4, False, False)
elif features_type == 'sift':
finder = cv.xfeatures2d_SIFT.create()
else:
print("Unknown descriptor type")
exit()
# Pre-allocate other variables to work with
seam_work_aspect = 1 # Seam aspect ratio
full_img_sizes = [] # Size of full images
features = [] # Array for storing features
images = [] # Array for storing information about images
is_work_scale_set = False # Bool for working image scaling
is_seam_scale_set = False # Bool for seams scaling
is_compose_scale_set = False # Bool for composition image scaling
# Iterate through the image names
for name in img_names:
# Reads the image into a numpy array
full_img = cv.imread(cv.samples.findFile(name))
# Check if the file could be read successfully
if full_img is None:
print("Cannot read image ", name)
exit()
# Add image size to the list ...
# TODO Could change this to be constant...
full_img_sizes.append((full_img.shape[1], full_img.shape[0]))
# Define the working scale the images should be used based on the number of megapixel entered
if work_megapix < 0:
# If a negative value entered, use its true scale
img = full_img
work_scale = 1
is_work_scale_set = True
else:
if is_work_scale_set is False:
work_scale = min(1.0, np.sqrt(work_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1])))
is_work_scale_set = True
img = cv.resize(src=full_img, dsize=None, fx=work_scale, fy=work_scale, interpolation=cv.INTER_LINEAR_EXACT)
# Define the scale for the seams that they will be processed
if is_seam_scale_set is False:
seam_scale = min(1.0, np.sqrt(seam_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1])))
seam_work_aspect = seam_scale / work_scale
is_seam_scale_set = True
# Get the image features for this image
img_fea = cv.detail.computeImageFeatures2(finder, img)
test_feat_img = cv.drawKeypoints(img, img_fea.getKeypoints(), None, (255, 0, 0), 4)
cv.namedWindow('image', cv.WINDOW_NORMAL)
cv.imshow('image', test_feat_img)
cv.resizeWindow('image', int(full_img_sizes[0][0] / 10), int(full_img_sizes[0][1] / 10))
cv.waitKey()
features.append(img_fea)
img = cv.resize(src=full_img, dsize=None, fx=seam_scale, fy=seam_scale, interpolation=cv.INTER_LINEAR_EXACT)
images.append(img)
# Define the matcher type to be used for the features
if matcher_type == "affine":
matcher = cv.detail_AffineBestOf2NearestMatcher(False, try_cuda, match_conf)
elif range_width == -1:
matcher = cv.detail_BestOf2NearestMatcher(try_cuda, match_conf)
else:
matcher = cv.detail_BestOf2NearestRangeMatcher(range_width, try_cuda, match_conf)
# Apply the matcher to the features, obtaining matches between them
p = matcher.apply2(features)
# Frees unused memory
matcher.collectGarbage()
# Save the graph if chosen
if save_graph:
f = open(save_graph_to, "w")
f.write(cv.detail.matchesGraphAsString(img_names, p, conf_thresh))
f.close()
# Remove matches if not above a confidence threshold
indices = cv.detail.leaveBiggestComponent(features, p, match_conf)
# Pre-allocate
img_subset = [] # Array to hold subset of images numpy arrays?
img_names_subset = [] # Array to list the names of subset images
full_img_sizes_subset = [] # Sizes of the images in their full resolution within the subset
num_images = len(indices) # Number of images as determined by the thresholding of the feature matches
# TODO this appears to be the issue running into before... the matching beforehand is producing 0 results
# Itearte through the images that were matched and get lists of matches/images
for i in range(num_images):
img_names_subset.append(img_names[indices[i, 0]]) # Append the names
img_subset.append(images[indices[i, 0]]) # Append the actual image arrays
full_img_sizes_subset.append(full_img_sizes[indices[i, 0]]) # Append their sizes
# Update the list of images and image names
images = img_subset
img_names = img_names_subset
full_img_sizes = full_img_sizes_subset
# Get new number of matched images (shouldn't change with the mosaicing project
num_images = len(img_names)
# Do a simple test to check if sufficient images
if num_images < 2:
print("Need more images")
exit()
# Generate the estimator based on what was set to determine approximate relative orientation parameters
if estimator_type == "affine":
estimator = cv.detail_AffineBasedEstimator()
else:
estimator = cv.detail_HomographyBasedEstimator()
b, cameras = estimator.apply(features, p, None)
# Check if estimation passed based on the boolean 'b'
if not b:
print("Homography estimation failed.")
exit()
# Iterate through the camera orientations computed
for cam in cameras:
# Convert the camera rotation matrix to float 32
cam.R = cam.R.astype(np.float32)
# TODO read up on the documentation here
# Define bundle adjustment cost function
if ba_cost_func == "reproj":
adjuster = cv.detail_BundleAdjusterReproj()
elif ba_cost_func == "ray":
adjuster = cv.detail_BundleAdjusterRay()
elif ba_cost_func == "affine":
adjuster = cv.detail_BundleAdjusterAffinePartial()
elif ba_cost_func == "no":
adjuster = cv.detail_NoBundleAdjuster()
else:
print("Unknown bundle adjustment cost function: ", ba_cost_func)
exit()
# Set the threshold for the adjuster
adjuster.setConfThresh(1)
# Pre-allocate array of the mask to be applied to determine which camera parameters to compute
refine_mask = np.zeros((3, 3), np.uint8)
# Determine which parameters to compute? Or vice versa... not compute
# TODO check this
if ba_refine_mask[0] == 'x':
refine_mask[0, 0] = 1
if ba_refine_mask[1] == 'x':
refine_mask[0, 1] = 1
if ba_refine_mask[2] == 'x':
refine_mask[0, 2] = 1
if ba_refine_mask[3] == 'x':
refine_mask[1, 1] = 1
if ba_refine_mask[4] == 'x':
refine_mask[1, 2] = 1
# Apply the refinement mask to the adjuster
adjuster.setRefinementMask(refine_mask)
# Recompute the camera orientation parameters with the refinement mask
b, cameras = adjuster.apply(features, p, cameras)
# Check if the parameters adjusted correctly
if not b:
print("Camera parameters adjusting failed.")
exit()
# Get list of focal lengths to scale images accordingly...
# TODO probably remove this scaling as not required for this project, thus warped_image_scale should stay = 1
focals = []
for cam in cameras:
focals.append(cam.focal)
sorted(focals)
if len(focals) % 2 == 1:
warped_image_scale = focals[len(focals) // 2]
else:
warped_image_scale = (focals[len(focals) // 2]+focals[len(focals) // 2-1])/2
# Perform the wave correction
# TODO adjust this... only performs a horizontal correction, need to implement a vertical correction. Possibly both.
# Potentially not required at all if the estimation of camera parameter bundle adjustment is performed well
if do_wave_correct:
rmats = []
for cam in cameras:
rmats.append(np.copy(cam.R))
if wave_correct == 'vert':
rmats = cv.detail.waveCorrect(rmats, cv.detail.WAVE_CORRECT_VERT)
elif wave_correct == 'horiz':
rmats = cv.detail.waveCorrect(rmats, cv.detail.WAVE_CORRECT_HORIZ)
for idx, cam in enumerate(cameras):
cam.R = rmats[idx]
# Pre-allocation
corners = [] # Dimensions of warped images
masks_warped = [] # The masking regions of the warped areas
images_warped = [] # the images warped
sizes = [] # Sizes of ....?
masks = [] # Masks for the seams ...?
# Iterate through the images creating 'i' as the index number and appending the pre-allocated mask
for i in range(0, num_images):
um = cv.UMat(255*np.ones((images[i].shape[0], images[i].shape[1]), np.uint8))
masks.append(um)
# This creates the warper to be used to distort the images according to the layout or shape they're to be stitched
warper = cv.PyRotationWarper(warp_type, warped_image_scale*seam_work_aspect)
# Iterate through the images to create the seams
for idx in range(0, num_images):
# Get the respective camera matrix
mat_k = cameras[idx].K().astype(np.float32)
# Scale the K matrix for the seam aspect scale
mat_k[0, 0] *= seam_work_aspect
mat_k[0, 2] *= seam_work_aspect
mat_k[1, 1] *= seam_work_aspect
mat_k[1, 2] *= seam_work_aspect
# Project the image into the warping shape
# TODO Not sure if we actually need the images warped. If the rotation and translation should suffice
corner, image_wp = warper.warp(images[idx], mat_k, cameras[idx].R, cv.INTER_LINEAR, cv.BORDER_REFLECT)
corners.append(corner)
sizes.append((image_wp.shape[1], image_wp.shape[0]))
images_warped.append(image_wp)
# Warp the masks as well
p, mask_wp = warper.warp(masks[idx], mat_k, cameras[idx].R, cv.INTER_NEAREST, cv.BORDER_CONSTANT)
masks_warped.append(mask_wp.get())
# Pre-allocation and conversion of the images warped images to floats
images_warped_f = []
for img in images_warped:
imgf = img.astype(np.float32)
images_warped_f.append(imgf)
# If exposure correction required.... Shouldn't although there is one bad image in there so quite possibly
if cv.detail.ExposureCompensator_CHANNELS == expos_comp_type:
compensator = cv.detail_ChannelsCompensator(expos_comp_nr_feeds)
# compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
elif cv.detail.ExposureCompensator_CHANNELS_BLOCKS == expos_comp_type:
compensator = cv.detail_BlocksChannelsCompensator(
expos_comp_block_size, expos_comp_block_size, expos_comp_nr_feeds)
# compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
else:
compensator = cv.detail.ExposureCompensator_createDefault(expos_comp_type)
# Apply the exposure compensator? Or set it up at least
compensator.feed(corners=corners, images=images_warped, masks=masks_warped)
# Define the type of seam finder to be used
if seam_find_type == "no":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)
elif seam_find_type == "voronoi":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM)
elif seam_find_type == "gc_color":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR")
elif seam_find_type == "gc_colorgrad":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR_GRAD")
elif seam_find_type == "dp_color":
seam_finder = cv.detail_DpSeamFinder("COLOR")
elif seam_find_type == "dp_colorgrad":
seam_finder = cv.detail_DpSeamFinder("COLOR_GRAD")
if seam_finder is None:
print("Can't create the following seam finder ", seam_find_type)
exit()
# Find the seams
# TODO potentially try using the non-warped images
seam_finder.find(images_warped_f, corners, masks_warped)
# Clear the variables from memory / use later
imgListe = []
images_warped = []
images_warped_f = []
masks = []
# Clear or pre-allocate variables
compose_scale = 1
corners = []
sizes = []
blender = None
timelapser = None
compose_work_aspect = 1
# Iterate through all the images again
for idx, name in enumerate(img_names):
# Read in image and get the composition scale. Should be left to 1...
# TODO check the composition scale and whether this needs to be scaled
full_img = cv.imread(name)
# Compute the composition scale, work aspect ratio, warped image scale and create a warper to scale
if not is_compose_scale_set:
if compose_megapix > 0:
compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1])))
is_compose_scale_set = True
compose_work_aspect = compose_scale / work_scale
warped_image_scale *= compose_work_aspect
warper = cv.PyRotationWarper(warp_type, warped_image_scale)
for i in range(0, len(img_names)):
# Adjust the camera parameters based on the composition work aspect ratio
cameras[i].focal *= compose_work_aspect
cameras[i].ppx *= compose_work_aspect
cameras[i].ppy *= compose_work_aspect
# Compute the size of the scaled full image
sz = (full_img_sizes[i][0] * compose_scale, full_img_sizes[i][1]*compose_scale)
# Get the intrinsic camera matrix
mat_k = cameras[i].K().astype(np.float32)
# Generate a warper for the rotation and intrinsic matrix
# TODO this could possibly be just the rotation matrix
# One possibility this isn't working is due to it should be translating images...
roi = warper.warpRoi(sz, mat_k, cameras[i].R)
# Get the corners from the output parameters
corners.append(roi[0:2])
# Get the sizes of the output parameters
sizes.append(roi[2:4])
# Scale the image to a size greater than the full resolution, otherwise leave as is
if abs(compose_scale - 1) > 1e-1:
img = cv.resize(src=full_img, dsize=None, fx=compose_scale, fy=compose_scale, interpolation=cv.INTER_LINEAR_EXACT)
else:
img = full_img
# Create a tuple of the image size
img_size = (img.shape[1], img.shape[0])
# Convert the intrinsic matrix to float 32
mat_k = cameras[idx].K().astype(np.float32)
# Warp the images accordingly...
# TODO look at the interpolation and border values
corner, image_warped = warper.warp(img, mat_k, cameras[idx].R, cv.INTER_LINEAR, cv.BORDER_REFLECT)
# Define the masks and warp them as well to the same shape
mask = 255*np.ones((img.shape[0], img.shape[1]), np.uint8)
p, mask_warped = warper.warp(mask, mat_k, cameras[idx].R, cv.INTER_NEAREST, cv.BORDER_CONSTANT)
# Apply the exposure compensation
compensator.apply(idx, corners[idx], image_warped, mask_warped)
# Convert the images back to integer for minimal memory use
image_warped_s = image_warped.astype(np.int16)
image_warped = [] # Clear variable
# Dilate the warped mask image
dilated_mask = cv.dilate(masks_warped[idx], None)
# Resize the dilated mask to create the seam mask
seam_mask = cv.resize(dilated_mask, (mask_warped.shape[1], mask_warped.shape[0]), 0, 0, cv.INTER_LINEAR_EXACT)
# Get the output seam
mask_warped = cv.bitwise_and(seam_mask, mask_warped)
# If the blender object hasn't been created yet
if blender is None and not timelapse:
blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
dst_sz = cv.detail.resultRoi(corners=corners, sizes=sizes)
# Get the blend width
blend_width = np.sqrt(dst_sz[2]*dst_sz[3]) * blend_strength / 100
# Check if a width is computed. Based on the blend strength
if blend_width < 1:
blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
# Create a multiband blender
elif blend_type == "multiband":
blender = cv.detail_MultiBandBlender()
blender.setNumBands((np.log(blend_width)/np.log(2.) - 1.).astype(np.int))
# Create a feather blender
elif blend_type == "feather":
blender = cv.detail_FeatherBlender()
blender.setSharpness(1./blend_width)
# Prepare the blender based on the distance
blender.prepare(dst_sz)
# If a timelapse type is passed, create the timelapser object
elif timelapser is None and timelapse:
timelapser = cv.detail.Timelapser_createDefault(timelapse_type)
timelapser.initialize(corners, sizes)
# If the timelapse parameter is passed
if timelapse:
# Initialise an array of ones of the right shape
matones = np.ones((image_warped_s.shape[0], image_warped_s.shape[1]), np.uint8)
# Adds the warped image into the list
timelapser.process(image_warped_s, matones, corners[idx])
# Get the index for where the file name starts
pos_s = img_names[idx].rfind("/")
# Get the fixed file name
if pos_s == -1:
fixed_file_name = "fixed_" + img_names[idx]
else:
fixed_file_name = img_names[idx][:pos_s + 1]+"fixed_" + img_names[idx][pos_s + 1:]
# Write the temporary partial image
cv.imwrite(fixed_file_name, timelapser.getDst())
else:
# Pass the warped image into the blender
blender.feed(cv.UMat(image_warped_s), mask_warped, corners[idx])
# If the timelapse parameter is not passed
if not timelapse:
# Pre-allocate the results
result = None
result_mask = None
# Get the blended results
result, result_mask = blender.blend(result, result_mask)
# Output the final result
cv.imwrite(result_name, result)
# Make the image shape fit into the window
zoomx = 600.0 / result.shape[1]
# Show the final output
dst = cv.normalize(src=result, dst=None, alpha=255., norm_type=cv.NORM_MINMAX, dtype=cv.CV_8U)
dst = cv.resize(dst, dsize=None, fx=zoomx, fy=zoomx)
cv.imshow(result_name, dst)
cv.waitKey()
print('Done')
except AttributeError:
print("SIFT not available")
try:
FEATURES_FIND_CHOICES['brisk'] = cv.BRISK_create
except AttributeError:
print("BRISK not available")
try:
FEATURES_FIND_CHOICES['akaze'] = cv.AKAZE_create
except AttributeError:
print("AKAZE not available")
SEAM_FIND_CHOICES = OrderedDict()
SEAM_FIND_CHOICES['gc_color'] = cv.detail_GraphCutSeamFinder('COST_COLOR')
SEAM_FIND_CHOICES['gc_colorgrad'] = cv.detail_GraphCutSeamFinder(
'COST_COLOR_GRAD')
SEAM_FIND_CHOICES['dp_color'] = cv.detail_DpSeamFinder('COLOR')
SEAM_FIND_CHOICES['dp_colorgrad'] = cv.detail_DpSeamFinder('COLOR_GRAD')
SEAM_FIND_CHOICES['voronoi'] = cv.detail.SeamFinder_createDefault(
cv.detail.SeamFinder_VORONOI_SEAM)
SEAM_FIND_CHOICES['no'] = cv.detail.SeamFinder_createDefault(
cv.detail.SeamFinder_NO)
ESTIMATOR_CHOICES = OrderedDict()
ESTIMATOR_CHOICES['homography'] = cv.detail_HomographyBasedEstimator
ESTIMATOR_CHOICES['affine'] = cv.detail_AffineBasedEstimator
WARP_CHOICES = (
'spherical',
'plane',
'affine',
'cylindrical',
def main():
args = parser.parse_args()
img_names=args.img_names
print(img_names)
preview = args.preview
try_cuda = args.try_cuda
work_megapix = args.work_megapix
seam_megapix = args.seam_megapix
compose_megapix = args.compose_megapix
conf_thresh = args.conf_thresh
features_type = args.features
matcher_type = args.matcher
estimator_type = args.estimator
ba_cost_func = args.ba
ba_refine_mask = args.ba_refine_mask
wave_correct = args.wave_correct
if wave_correct=='no':
do_wave_correct= False
else:
do_wave_correct=True
if args.save_graph is None:
save_graph = False
else:
save_graph =True
save_graph_to = args.save_graph
warp_type = args.warp
if args.expos_comp=='no':
expos_comp_type = cv.detail.ExposureCompensator_NO
elif args.expos_comp=='gain':
expos_comp_type = cv.detail.ExposureCompensator_GAIN
elif args.expos_comp=='gain_blocks':
expos_comp_type = cv.detail.ExposureCompensator_GAIN_BLOCKS
elif args.expos_comp=='channel':
expos_comp_type = cv.detail.ExposureCompensator_CHANNELS
elif args.expos_comp=='channel_blocks':
expos_comp_type = cv.detail.ExposureCompensator_CHANNELS_BLOCKS
else:
print("Bad exposure compensation method")
exit()
expos_comp_nr_feeds = args.expos_comp_nr_feeds
expos_comp_nr_filtering = args.expos_comp_nr_filtering
expos_comp_block_size = args.expos_comp_block_size
match_conf = args.match_conf
seam_find_type = args.seam
blend_type = args.blend
blend_strength = args.blend_strength
result_name = args.output
if args.timelapse is not None:
timelapse = True
if args.timelapse=="as_is":
timelapse_type = cv.detail.Timelapser_AS_IS
elif args.timelapse=="crop":
timelapse_type = cv.detail.Timelapser_CROP
else:
print("Bad timelapse method")
exit()
else:
timelapse= False
range_width = args.rangewidth
if features_type=='orb':
finder= cv.ORB.create()
elif features_type=='surf':
finder= cv.xfeatures2d_SURF.create()
elif features_type=='sift':
finder= cv.xfeatures2d_SIFT.create()
else:
print ("Unknown descriptor type")
exit()
seam_work_aspect = 1
full_img_sizes=[]
features=[]
images=[]
is_work_scale_set = False
is_seam_scale_set = False
is_compose_scale_set = False;
for name in img_names:
full_img = cv.imread(cv.samples.findFile(name))
if full_img is None:
print("Cannot read image ", name)
exit()
full_img_sizes.append((full_img.shape[1],full_img.shape[0]))
if work_megapix < 0:
img = full_img
work_scale = 1
is_work_scale_set = True
else:
if is_work_scale_set is False:
work_scale = min(1.0, np.sqrt(work_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1])))
is_work_scale_set = True
img = cv.resize(src=full_img, dsize=None, fx=work_scale, fy=work_scale, interpolation=cv.INTER_LINEAR_EXACT)
if is_seam_scale_set is False:
seam_scale = min(1.0, np.sqrt(seam_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1])))
seam_work_aspect = seam_scale / work_scale
is_seam_scale_set = True
imgFea= cv.detail.computeImageFeatures2(finder,img)
features.append(imgFea)
img = cv.resize(src=full_img, dsize=None, fx=seam_scale, fy=seam_scale, interpolation=cv.INTER_LINEAR_EXACT)
images.append(img)
if matcher_type== "affine":
matcher = cv.detail_AffineBestOf2NearestMatcher(False, try_cuda, match_conf)
elif range_width==-1:
matcher = cv.detail.BestOf2NearestMatcher_create(try_cuda, match_conf)
else:
matcher = cv.detail.BestOf2NearestRangeMatcher_create(range_width, try_cuda, match_conf)
p=matcher.apply2(features)
matcher.collectGarbage()
if save_graph:
f = open(save_graph_to,"w")
f.write(cv.detail.matchesGraphAsString(img_names, p, conf_thresh))
f.close()
indices=cv.detail.leaveBiggestComponent(features,p,0.3)
img_subset =[]
img_names_subset=[]
full_img_sizes_subset=[]
num_images=len(indices)
for i in range(len(indices)):
img_names_subset.append(img_names[indices[i,0]])
img_subset.append(images[indices[i,0]])
full_img_sizes_subset.append(full_img_sizes[indices[i,0]])
images = img_subset;
img_names = img_names_subset;
full_img_sizes = full_img_sizes_subset;
num_images = len(img_names)
if num_images < 2:
print("Need more images")
exit()
if estimator_type == "affine":
estimator = cv.detail_AffineBasedEstimator()
else:
estimator = cv.detail_HomographyBasedEstimator()
b, cameras =estimator.apply(features,p,None)
if not b:
print("Homography estimation failed.")
exit()
for cam in cameras:
cam.R=cam.R.astype(np.float32)
if ba_cost_func == "reproj":
adjuster = cv.detail_BundleAdjusterReproj()
elif ba_cost_func == "ray":
adjuster = cv.detail_BundleAdjusterRay()
elif ba_cost_func == "affine":
adjuster = cv.detail_BundleAdjusterAffinePartial()
elif ba_cost_func == "no":
adjuster = cv.detail_NoBundleAdjuster()
else:
print( "Unknown bundle adjustment cost function: ", ba_cost_func )
exit()
adjuster.setConfThresh(1)
refine_mask=np.zeros((3,3),np.uint8)
if ba_refine_mask[0] == 'x':
refine_mask[0,0] = 1
if ba_refine_mask[1] == 'x':
refine_mask[0,1] = 1
if ba_refine_mask[2] == 'x':
refine_mask[0,2] = 1
if ba_refine_mask[3] == 'x':
refine_mask[1,1] = 1
if ba_refine_mask[4] == 'x':
refine_mask[1,2] = 1
adjuster.setRefinementMask(refine_mask)
b,cameras = adjuster.apply(features,p,cameras)
if not b:
print("Camera parameters adjusting failed.")
exit()
focals=[]
for cam in cameras:
focals.append(cam.focal)
sorted(focals)
if len(focals)%2==1:
warped_image_scale = focals[len(focals) // 2]
else:
warped_image_scale = (focals[len(focals) // 2]+focals[len(focals) // 2-1])/2
if do_wave_correct:
rmats=[]
for cam in cameras:
rmats.append(np.copy(cam.R))
rmats = cv.detail.waveCorrect( rmats, cv.detail.WAVE_CORRECT_HORIZ)
for idx,cam in enumerate(cameras):
cam.R = rmats[idx]
corners=[]
mask=[]
masks_warped=[]
images_warped=[]
sizes=[]
masks=[]
for i in range(0,num_images):
um=cv.UMat(255*np.ones((images[i].shape[0],images[i].shape[1]),np.uint8))
masks.append(um)
warper = cv.PyRotationWarper(warp_type,warped_image_scale*seam_work_aspect) # warper peut etre nullptr?
for idx in range(0,num_images):
K = cameras[idx].K().astype(np.float32)
swa = seam_work_aspect
K[0,0] *= swa
K[0,2] *= swa
K[1,1] *= swa
K[1,2] *= swa
corner,image_wp =warper.warp(images[idx],K,cameras[idx].R,cv.INTER_LINEAR, cv.BORDER_REFLECT)
corners.append(corner)
sizes.append((image_wp.shape[1],image_wp.shape[0]))
images_warped.append(image_wp)
p,mask_wp =warper.warp(masks[idx],K,cameras[idx].R,cv.INTER_NEAREST, cv.BORDER_CONSTANT)
masks_warped.append(mask_wp.get())
images_warped_f=[]
for img in images_warped:
imgf=img.astype(np.float32)
images_warped_f.append(imgf)
if cv.detail.ExposureCompensator_CHANNELS == expos_comp_type:
compensator = cv.detail_ChannelsCompensator(expos_comp_nr_feeds)
# compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
elif cv.detail.ExposureCompensator_CHANNELS_BLOCKS == expos_comp_type:
compensator=cv.detail_BlocksChannelsCompensator(expos_comp_block_size, expos_comp_block_size,expos_comp_nr_feeds)
# compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
else:
compensator=cv.detail.ExposureCompensator_createDefault(expos_comp_type)
compensator.feed(corners=corners, images=images_warped, masks=masks_warped)
if seam_find_type == "no":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)
elif seam_find_type == "voronoi":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM);
elif seam_find_type == "gc_color":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR")
elif seam_find_type == "gc_colorgrad":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR_GRAD")
elif seam_find_type == "dp_color":
seam_finder = cv.detail_DpSeamFinder("COLOR")
elif seam_find_type == "dp_colorgrad":
seam_finder = cv.detail_DpSeamFinder("COLOR_GRAD")
if seam_finder is None:
print("Can't create the following seam finder ",seam_find_type)
exit()
seam_finder.find(images_warped_f, corners,masks_warped )
imgListe=[]
compose_scale=1
corners=[]
sizes=[]
images_warped=[]
images_warped_f=[]
masks=[]
blender= None
timelapser=None
compose_work_aspect=1
for idx,name in enumerate(img_names): # https://github.com/opencv/opencv/blob/master/samples/cpp/stitching_detailed.cpp#L725 ?
full_img = cv.imread(name)
if not is_compose_scale_set:
if compose_megapix > 0:
compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1])))
is_compose_scale_set = True;
compose_work_aspect = compose_scale / work_scale;
warped_image_scale *= compose_work_aspect
warper = cv.PyRotationWarper(warp_type,warped_image_scale)
for i in range(0,len(img_names)):
cameras[i].focal *= compose_work_aspect
cameras[i].ppx *= compose_work_aspect
cameras[i].ppy *= compose_work_aspect
sz = (full_img_sizes[i][0] * compose_scale,full_img_sizes[i][1]* compose_scale)
K = cameras[i].K().astype(np.float32)
roi = warper.warpRoi(sz, K, cameras[i].R);
corners.append(roi[0:2])
sizes.append(roi[2:4])
if abs(compose_scale - 1) > 1e-1:
img =cv.resize(src=full_img, dsize=None, fx=compose_scale, fy=compose_scale, interpolation=cv.INTER_LINEAR_EXACT)
else:
img = full_img;
img_size = (img.shape[1],img.shape[0]);
K=cameras[idx].K().astype(np.float32)
corner,image_warped =warper.warp(img,K,cameras[idx].R,cv.INTER_LINEAR, cv.BORDER_REFLECT)
mask =255*np.ones((img.shape[0],img.shape[1]),np.uint8)
p,mask_warped =warper.warp(mask,K,cameras[idx].R,cv.INTER_NEAREST, cv.BORDER_CONSTANT)
compensator.apply(idx,corners[idx],image_warped,mask_warped)
image_warped_s = image_warped.astype(np.int16)
image_warped=[]
dilated_mask = cv.dilate(masks_warped[idx],None)
seam_mask = cv.resize(dilated_mask,(mask_warped.shape[1],mask_warped.shape[0]),0,0,cv.INTER_LINEAR_EXACT)
mask_warped = cv.bitwise_and(seam_mask,mask_warped)
if blender==None and not timelapse:
blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
dst_sz = cv.detail.resultRoi(corners=corners,sizes=sizes)
blend_width = np.sqrt(dst_sz[2]*dst_sz[3]) * blend_strength / 100
if blend_width < 1:
blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
elif blend_type == "multiband":
blender = cv.detail_MultiBandBlender()
blender.setNumBands((np.log(blend_width)/np.log(2.) - 1.).astype(np.int))
elif blend_type == "feather":
blender = cv.detail_FeatherBlender()
blender.setSharpness(1./blend_width)
blender.prepare(dst_sz)
elif timelapser==None and timelapse:
timelapser = cv.detail.Timelapser_createDefault(timelapse_type)
timelapser.initialize(corners, sizes)
if timelapse:
matones=np.ones((image_warped_s.shape[0],image_warped_s.shape[1]), np.uint8)
timelapser.process(image_warped_s, matones, corners[idx])
pos_s = img_names[idx].rfind("/");
if pos_s == -1:
fixedFileName = "fixed_" + img_names[idx];
else:
fixedFileName = img_names[idx][:pos_s + 1 ]+"fixed_" + img_names[idx][pos_s + 1: ]
cv.imwrite(fixedFileName, timelapser.getDst())
else:
blender.feed(cv.UMat(image_warped_s), mask_warped, corners[idx])
if not timelapse:
result=None
result_mask=None
result,result_mask = blender.blend(result,result_mask)
cv.imwrite(result_name,result)
zoomx = 600.0 / result.shape[1]
dst=cv.normalize(src=result,dst=None,alpha=255.,norm_type=cv.NORM_MINMAX,dtype=cv.CV_8U)
dst=cv.resize(dst,dsize=None,fx=zoomx,fy=zoomx)
cv.imshow(result_name,dst)
cv.waitKey()
print('Done')
class SeamFinder:
"""https://docs.opencv.org/4.x/d7/d09/classcv_1_1detail_1_1SeamFinder.html""" # noqa
SEAM_FINDER_CHOICES = OrderedDict()
SEAM_FINDER_CHOICES['dp_color'] = cv.detail_DpSeamFinder('COLOR')
SEAM_FINDER_CHOICES['dp_colorgrad'] = cv.detail_DpSeamFinder('COLOR_GRAD')
SEAM_FINDER_CHOICES['voronoi'] = cv.detail.SeamFinder_createDefault(
cv.detail.SeamFinder_VORONOI_SEAM) # noqa
SEAM_FINDER_CHOICES['no'] = cv.detail.SeamFinder_createDefault(
cv.detail.SeamFinder_NO) # noqa
DEFAULT_SEAM_FINDER = list(SEAM_FINDER_CHOICES.keys())[0]
def __init__(self, finder=DEFAULT_SEAM_FINDER):
self.finder = SeamFinder.SEAM_FINDER_CHOICES[finder]
def find(self, imgs, corners, masks):
"""https://docs.opencv.org/4.x/d0/dd5/classcv_1_1detail_1_1DpSeamFinder.html#a7914624907986f7a94dd424209a8a609""" # noqa
imgs_float = [img.astype(np.float32) for img in imgs]
return self.finder.find(imgs_float, corners, masks)
@staticmethod
def resize(seam_mask, mask):
dilated_mask = cv.dilate(seam_mask, None)
resized_seam_mask = cv.resize(dilated_mask,
(mask.shape[1], mask.shape[0]), 0, 0,
cv.INTER_LINEAR_EXACT)
return cv.bitwise_and(resized_seam_mask, mask)
@staticmethod
def draw_seam_mask(img, seam_mask, color=(0, 0, 0)):
seam_mask = cv.UMat.get(seam_mask)
overlayed_img = np.copy(img)
overlayed_img[seam_mask == 0] = color
return overlayed_img
@staticmethod
def draw_seam_polygons(panorama, blended_seam_masks, alpha=0.5):
return add_weighted_image(panorama, blended_seam_masks, alpha)
@staticmethod
def draw_seam_lines(panorama,
blended_seam_masks,
linesize=1,
color=(0, 0, 255)):
seam_lines = \
SeamFinder.exctract_seam_lines(blended_seam_masks, linesize)
panorama_with_seam_lines = panorama.copy()
panorama_with_seam_lines[seam_lines == 255] = color
return panorama_with_seam_lines
@staticmethod
def exctract_seam_lines(blended_seam_masks, linesize=1):
seam_lines = cv.Canny(np.uint8(blended_seam_masks), 100, 200)
seam_indices = (seam_lines == 255).nonzero()
seam_lines = remove_invalid_line_pixels(seam_indices, seam_lines,
blended_seam_masks)
kernelsize = linesize + linesize - 1
kernel = np.ones((kernelsize, kernelsize), np.uint8)
return cv.dilate(seam_lines, kernel)
@staticmethod
def blend_seam_masks(
seam_masks,
corners,
sizes,
colors=[
(255, 000, 000), # Blue
(000, 000, 255), # Red
(000, 255, 000), # Green
(000, 255, 255), # Yellow
(255, 000, 255), # Magenta
(128, 128, 255), # Pink
(128, 128, 128), # Gray
(000, 000, 128), # Brown
(000, 128, 255)
] # Orange
):
blender = Blender("no")
blender.prepare(corners, sizes)
for idx, (seam_mask, size,
corner) in enumerate(zip(seam_masks, sizes, corners)):
if idx + 1 > len(colors):
raise ValueError("Not enough default colors! Pass additional "
"colors to \"colors\" parameter")
one_color_img = create_img_by_size(size, colors[idx])
blender.feed(one_color_img, seam_mask, corner)
return blender.blend()
images_warped_f=[]
for img in images_warped:
imgf=img.astype(np.float32)
images_warped_f.append(imgf)
compensator=cv.detail.ExposureCompensator_createDefault(expos_comp_type)
compensator.feed(corners, images_warped, masks_warped)
if seam_find_type == "no":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO)
elif seam_find_type == "voronoi":
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM);
elif seam_find_type == "gc_color":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR")
elif seam_find_type == "gc_colorgrad":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR_GRAD")
elif seam_find_type == "dp_color":
seam_finder = cv.detail_DpSeamFinder("COLOR")
elif seam_find_type == "dp_colorgrad":
seam_finder = cv.detail_DpSeamFinder("COLOR_GRAD")
if seam_finder is None:
print("Can't create the following seam finder ",seam_find_type)
exit()
seam_finder.find(images_warped_f, corners,masks_warped )
imgListe=[]
compose_scale=1
corners=[]
sizes=[]
images_warped=[]
images_warped_f=[]
masks=[]
blender= None
timelapser=None
else:
compensator = cv.detail.ExposureCompensator_createDefault(
expos_comp_type)
compensator.feed(corners=corners, images=images_warped, masks=masks_warped)
if seam_find_type == "no":
seam_finder = cv.detail.SeamFinder_createDefault(
cv.detail.SeamFinder_NO)
elif seam_find_type == "voronoi":
seam_finder = cv.detail.SeamFinder_createDefault(
cv.detail.SeamFinder_VORONOI_SEAM)
elif seam_find_type == "gc_color":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR")
elif seam_find_type == "gc_colorgrad":
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR_GRAD")
elif seam_find_type == "dp_color":
seam_finder = cv.detail_DpSeamFinder("COLOR")
elif seam_find_type == "dp_colorgrad":
seam_finder = cv.detail_DpSeamFinder("COLOR_GRAD")
if seam_finder is None:
print("Can't create the following seam finder ", seam_find_type)
exit()
seam_finder.find(images_warped_f, corners, masks_warped)
imgListe = []
compose_scale = 1
corners = []
sizes = []
images_warped = []
images_warped_f = []
masks = []
blender = None
timelapser = None
class Stitch2:
finder = cv.ORB.create()
matcher = cv.detail.BestOfNearestMarcher_create(False, 0.3)
warp_type = "cylindrical"
p = list()
last_p = list()
estimator = cv.detail_HomographyBasedEstimator()
adjustor = cv.detail_BundleAdjusterRay()
seam_finder = cv.detail_DpSeamFinder("COLOR_GRAD")
all_cameras = list()
focals = list()
rmats = list()
work_scale = 0.6
seam_scale = 0.25
conf_thresh = 0.3
seam_work_aspect = 1
full_img_sizes = []
features = []
images = []
is_work_scale_set = False
is_seam_scale_set = False
is_compose_scale_set = False
do_wave_correct = True
images = list()
features = list()
def __init__(self, img1):
# first image push to list
self._get_refine_mask()
self._getWarper()
self._getCompensator()
self._getMask(img1)
self.__appendImg(img1)
def __appendImg(self, full_img):
self.full_img_sizes.append((full_img.shape[1], full_img.shape[0]))
self._getMask(full_img)
if self.work_megapix < 0:
img = full_img
self.work_scale = 1
self.is_work_scale_set = True
else:
if self.is_work_scale_set is False:
self.work_scale = min(
1.0,
np.sqrt(self.work_megapix * 1e6 /
(full_img.shape[0] * full_img.shape[1])))
self.is_work_scale_set = True
img = cv.resize(src=full_img,
dsize=None,
fx=self.work_scale,
fy=self.work_scale,
interpolation=cv.INTER_LINEAR_EXACT)
if self.is_seam_scale_set is False:
self.seam_scale = min(
1.0,
np.sqrt(self.seam_megapix * 1e6 /
(full_img.shape[0] * full_img.shape[1])))
self.seam_work_aspect = self.seam_scale / self.work_scale
self.is_seam_scale_set = True
img_feat = cv.detail.computeImageFeatures2(self.finder, img)
self.features.append(img_feat)
img = cv.resize(src=full_img,
dsize=None,
fx=self.seam_scale,
fy=self.seam_scale,
interpolation=cv.INTER_LINEAR_EXACT)
self.images.append(img)
def getNew(self, img2):
# get new images and calculate all
self.__appendImg(img2)
img_feat = cv.detail.computeImageFeatures2(self.finder, img2)
self.features.append(img_feat)
def matchImg(self):
# get matcher for last two features
_p = self.matcher.apply2(self.features[-2:])
self.last_p = _p
self.p.append(_p) # append the maching info to previous info
self.matcher.collectGarbage()
def _get_refine_mask(self):
# set mask
# apply to last two features?
self.refine_mask = np.zeros((3, 3), np.uint8)
self.refine_mask[0, 0] = 1
self.refine_mask[0, 1] = 1
self.refine_mask[0, 2] = 1
self.refine_mask[1, 1] = 1
self.refine_mask[1, 2] = 1
def estimateImg(self):
# cameras is the last two camera
b, cameras = self.estimator.apply(self.features[-2:], self.last_p,
None)
if not b:
print("Homography estimation failed.")
exit()
for cam in cameras:
cam.R = cam.R.astype(np.float32)
self.adjustor.setConfThresh(0.3)
self.adjuster.setRefinementMask(self.refine_mask)
b, cameras = self.adjuster.apply(self.features[-2:], self.last_p,
cameras)
if not b:
print("Camera parameters adjusting failed.")
return
# append last two/one? camera to all_cameras
self.all_cameras.append(cameras[-1])
# append last two/one? camera's focals
for cam in cameras:
self.focals.append(cam.focal)
self.rmats.append(np.copy(cam.R))
self.focals.sort()
if len(self.focals) % 2 == 1: # get median
self.warped_image_scale = self.focals[len(self.focals) // 2]
else:
self.warped_image_scale = (
self.focals[len(self.focals) // 2] +
self.focals[len(self.focals) // 2 - 1]) / 2
corners = []
masks_warped = []
images_warped = []
images_warped_f = []
sizes = []
masks = []
def waveCorrect(self):
if self.do_wave_correct:
self.rmats = cv.detail.waveCorrect(self.rmats,
cv.detail.WAVE_CORRECT_HORIZ)
for idx, cam in enumerate(self.all_cameras):
cam.R = self.rmats[idx]
def _getMask(self, img):
um = cv.UMat(255 * np.ones((img.shape[0], img.shape[1]), np.uint8))
self.masks.append(um)
def _getWarper(self):
self.warper = cv.PyRotationWarper(
self.warp_type, self.warped_image_scale * self.seam_work_aspect)
# warper could be nullptr?
def getNewMaskWarped(self):
idx = -1
K = self.all_cameras[idx].K().astype(np.float32)
swa = self.seam_work_aspect
K[0, 0] *= swa
K[0, 2] *= swa
K[1, 1] *= swa
K[1, 2] *= swa
corner, image_wp = self.warper.warp(self.images[idx], K,
self.all_cameras[idx].R,
cv.INTER_LINEAR, cv.BORDER_REFLECT)
self.corners.append(corner)
self.sizes.append((image_wp.shape[1], image_wp.shape[0]))
self.images_warped.append(image_wp)
p, mask_wp = self.warper.warp(self.masks[idx], K,
self.all_cameras[idx].R,
cv.INTER_NEAREST, cv.BORDER_CONSTANT)
self.masks_warped.append(mask_wp.get())
imgf = image_wp.astype(np.float32)
self.images_warped_f.append(imgf)
def _getCompensator(self):
expos_comp_block_size = 32
expos_comp_nr_feeds = 1
self.compensator = cv.detail_BlocksChannelsCompensator(
expos_comp_block_size, expos_comp_block_size, expos_comp_nr_feeds)
def applyCompensator(self):
self.compensator.feed(corners=self.corners,
images=self.images_warped,
masks=self.masks_warped)
def applySeamFinder(self):
self.seam_finder.find(self.images_warped_f, self.corners,
self.masks_warped)
def applyBlender(self):
for idx, full_img in enumerate(self.images):
if not self.is_compose_scale_set:
if self.compose_megapix > 0:
compose_scale = min(
1.0,
np.sqrt(self.compose_megapix * 1e6 /
(full_img.shape[0] * full_img.shape[1])))
self.is_compose_scale_set = True
compose_work_aspect = self.compose_scale / self.work_scale
self.warped_image_scale *= compose_work_aspect
# a new warper
warper = cv.PyRotationWarper(self.warp_type,
self.warped_image_scale)
for i in range(0, len(img_names)):
cameras[i].focal *= compose_work_aspect
cameras[i].ppx *= compose_work_aspect
cameras[i].ppy *= compose_work_aspect
sz = (full_img_sizes[i][0] * compose_scale,
full_img_sizes[i][1] * compose_scale)
K = cameras[i].K().astype(np.float32)
roi = warper.warpRoi(sz, K, cameras[i].R)
corners.append(roi[0:2])
sizes.append(roi[2:4])
def getAllMasksWarped(self):
warper = cv.PyRotationWarper(
self.warp_type, self.warped_image_scale *
self.seam_work_aspect) # warper could be nullptr?
num_images = self.images.count
for idx in range(0, num_images):
K = self.all_cameras[idx].K().astype(np.float32)
swa = self.seam_work_aspect
K[0, 0] *= swa
K[0, 2] *= swa
K[1, 1] *= swa
K[1, 2] *= swa
corner, image_wp = warper.warp(self.images[idx], K,
self.all_cameras[idx].R,
cv.INTER_LINEAR, cv.BORDER_REFLECT)
self.corners.append(corner)
self.sizes.append((image_wp.shape[1], image_wp.shape[0]))
self.images_warped.append(image_wp)
p, mask_wp = warper.warp(self.masks[idx], K,
self.all_cameras[idx].R, cv.INTER_NEAREST,
cv.BORDER_CONSTANT)
self.masks_warped.append(mask_wp.get())
for img in self.images_warped:
imgf = img.astype(np.float32)
self.images_warped_f.append(imgf)
class SeamFinder:
"""https://docs.opencv.org/4.x/d7/d09/classcv_1_1detail_1_1SeamFinder.html""" # noqa
SEAM_FINDER_CHOICES = OrderedDict()
SEAM_FINDER_CHOICES['dp_color'] = cv.detail_DpSeamFinder('COLOR')
SEAM_FINDER_CHOICES['dp_colorgrad'] = cv.detail_DpSeamFinder('COLOR_GRAD')
SEAM_FINDER_CHOICES['voronoi'] = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM) # noqa
SEAM_FINDER_CHOICES['no'] = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_NO) # noqa
DEFAULT_SEAM_FINDER = list(SEAM_FINDER_CHOICES.keys())[0]
def __init__(self, finder=DEFAULT_SEAM_FINDER):
self.finder = SeamFinder.SEAM_FINDER_CHOICES[finder]
def find(self, imgs, corners, masks):
"""https://docs.opencv.org/4.x/d0/dd5/classcv_1_1detail_1_1DpSeamFinder.html#a7914624907986f7a94dd424209a8a609""" # noqa
imgs_float = [img.astype(np.float32) for img in imgs]
return self.finder.find(imgs_float, corners, masks)
@staticmethod
def resize(seam_mask, mask):
dilated_mask = cv.dilate(seam_mask, None)
resized_seam_mask = cv.resize(dilated_mask, (mask.shape[1],
mask.shape[0]),
0, 0, cv.INTER_LINEAR_EXACT)
return cv.bitwise_and(resized_seam_mask, mask)
@staticmethod
def draw_seam_mask(img, seam_mask, color=(0, 0, 0)):
seam_mask = cv.UMat.get(seam_mask)
overlayed_img = np.copy(img)
overlayed_img[seam_mask == 0] = color
return overlayed_img
@staticmethod
def draw_seam_polygons(panorama, blended_seam_masks, alpha=0.5):
return add_weighted_image(panorama, blended_seam_masks, alpha)
@staticmethod
def draw_seam_lines(panorama, blended_seam_masks,
linesize=1, color=(0, 0, 255)):
seam_lines = \
SeamFinder.exctract_seam_lines(blended_seam_masks, linesize)
panorama_with_seam_lines = panorama.copy()
panorama_with_seam_lines[seam_lines == 255] = color
return panorama_with_seam_lines
@staticmethod
def exctract_seam_lines(blended_seam_masks, linesize=1):
seam_lines = cv.Canny(np.uint8(blended_seam_masks), 100, 200)
seam_indices = (seam_lines == 255).nonzero()
seam_lines = remove_invalid_line_pixels(
seam_indices, seam_lines, blended_seam_masks
)
kernelsize = linesize + linesize - 1
kernel = np.ones((kernelsize, kernelsize), np.uint8)
return cv.dilate(seam_lines, kernel)
@staticmethod
def blend_seam_masks(seam_masks, corners, sizes):
imgs = colored_img_generator(sizes)
blended_seam_masks, _ = \
Blender.create_panorama(imgs, seam_masks, corners, sizes)
return blended_seam_masks
