mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-28 15:30:49 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #16257 from ianare:more-pythonic

Browse Source
This commit is contained in:
Alexander Alekhin 2020-01-16 13:57:08 +00:00
commit 2b9cfe1e1c
1 changed files with 371 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

590
samples/python/stitching_detailed.py
View File

@ -8,114 +8,305 @@ Show how to use Stitcher API from python.
# Python 2/3 compatibility # Python 2/3 compatibility
from __future__ import print_function from __future__ import print_function
import numpy as np
import cv2 as cv
import sys
import argparse import argparse
from collections import OrderedDict
parser = argparse.ArgumentParser(prog='stitching_detailed.py', description='Rotation model images stitcher') import cv2 as cv
parser.add_argument('img_names', nargs='+',help='files to stitch',type=str) import numpy as np
parser.add_argument('--preview',help='Run stitching in the preview mode. Works faster than usual mode but output image will have lower resolution.',type=bool,dest = 'preview' )
parser.add_argument('--try_cuda',action = 'store', default = False,help='Try to use CUDA. The default value is no. All default values are for CPU mode.',type=bool,dest = 'try_cuda' ) EXPOS_COMP_CHOICES = OrderedDict()
parser.add_argument('--work_megapix',action = 'store', default = 0.6,help=' Resolution for image registration step. The default is 0.6 Mpx',type=float,dest = 'work_megapix' ) EXPOS_COMP_CHOICES['gain_blocks'] = cv.detail.ExposureCompensator_GAIN_BLOCKS
parser.add_argument('--features',action = 'store', default = 'orb',help='Type of features used for images matching. The default is orb.',type=str,dest = 'features' ) EXPOS_COMP_CHOICES['gain'] = cv.detail.ExposureCompensator_GAIN
parser.add_argument('--matcher',action = 'store', default = 'homography',help='Matcher used for pairwise image matching.',type=str,dest = 'matcher' ) EXPOS_COMP_CHOICES['channel'] = cv.detail.ExposureCompensator_CHANNELS
parser.add_argument('--estimator',action = 'store', default = 'homography',help='Type of estimator used for transformation estimation.',type=str,dest = 'estimator' ) EXPOS_COMP_CHOICES['channel_blocks'] = cv.detail.ExposureCompensator_CHANNELS_BLOCKS
parser.add_argument('--match_conf',action = 'store', default = 0.3,help='Confidence for feature matching step. The default is 0.65 for surf and 0.3 for orb.',type=float,dest = 'match_conf' ) EXPOS_COMP_CHOICES['no'] = cv.detail.ExposureCompensator_NO
parser.add_argument('--conf_thresh',action = 'store', default = 1.0,help='Threshold for two images are from the same panorama confidence.The default is 1.0.',type=float,dest = 'conf_thresh' )
parser.add_argument('--ba',action = 'store', default = 'ray',help='Bundle adjustment cost function. The default is ray.',type=str,dest = 'ba' ) BA_COST_CHOICES = OrderedDict()
parser.add_argument('--ba_refine_mask',action = 'store', default = 'xxxxx',help='Set refinement mask for bundle adjustment. mask is "xxxxx"',type=str,dest = 'ba_refine_mask' ) BA_COST_CHOICES['ray'] = cv.detail_BundleAdjusterRay
parser.add_argument('--wave_correct',action = 'store', default = 'horiz',help='Perform wave effect correction. The default is "horiz"',type=str,dest = 'wave_correct' ) BA_COST_CHOICES['reproj'] = cv.detail_BundleAdjusterReproj
parser.add_argument('--save_graph',action = 'store', default = None,help='Save matches graph represented in DOT language to <file_name> file.',type=str,dest = 'save_graph' ) BA_COST_CHOICES['affine'] = cv.detail_BundleAdjusterAffinePartial
parser.add_argument('--warp',action = 'store', default = 'plane',help='Warp surface type. The default is "spherical".',type=str,dest = 'warp' ) BA_COST_CHOICES['no'] = cv.detail_NoBundleAdjuster
parser.add_argument('--seam_megapix',action = 'store', default = 0.1,help=' Resolution for seam estimation step. The default is 0.1 Mpx.',type=float,dest = 'seam_megapix' )
parser.add_argument('--seam',action = 'store', default = 'no',help='Seam estimation method. The default is "gc_color".',type=str,dest = 'seam' ) FEATURES_FIND_CHOICES = OrderedDict()
parser.add_argument('--compose_megapix',action = 'store', default = -1,help='Resolution for compositing step. Use -1 for original resolution.',type=float,dest = 'compose_megapix' ) try:
parser.add_argument('--expos_comp',action = 'store', default = 'no',help='Exposure compensation method. The default is "gain_blocks".',type=str,dest = 'expos_comp' ) FEATURES_FIND_CHOICES['surf'] = cv.xfeatures2d_SURF.create
parser.add_argument('--expos_comp_nr_feeds',action = 'store', default = 1,help='Number of exposure compensation feed.',type=np.int32,dest = 'expos_comp_nr_feeds' ) except AttributeError:
parser.add_argument('--expos_comp_nr_filtering',action = 'store', default = 2,help='Number of filtering iterations of the exposure compensation gains',type=float,dest = 'expos_comp_nr_filtering' ) print("SURF not available")
parser.add_argument('--expos_comp_block_size',action = 'store', default = 32,help='BLock size in pixels used by the exposure compensator.',type=np.int32,dest = 'expos_comp_block_size' ) # if SURF not available, ORB is default
parser.add_argument('--blend',action = 'store', default = 'multiband',help='Blending method. The default is "multiband".',type=str,dest = 'blend' ) FEATURES_FIND_CHOICES['orb'] = cv.ORB.create
parser.add_argument('--blend_strength',action = 'store', default = 5,help='Blending strength from [0,100] range.',type=np.int32,dest = 'blend_strength' ) try:
parser.add_argument('--output',action = 'store', default = 'result.jpg',help='The default is "result.jpg"',type=str,dest = 'output' ) FEATURES_FIND_CHOICES['sift'] = cv.xfeatures2d_SIFT.create
parser.add_argument('--timelapse',action = 'store', default = None,help='Output warped images separately as frames of a time lapse movie, with "fixed_" prepended to input file names.',type=str,dest = 'timelapse' ) except AttributeError:
parser.add_argument('--rangewidth',action = 'store', default = -1,help='uses range_width to limit number of images to match with.',type=int,dest = 'rangewidth' ) 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',
'fisheye',
'stereographic',
'compressedPlaneA2B1',
'compressedPlaneA1.5B1',
'compressedPlanePortraitA2B1',
'compressedPlanePortraitA1.5B1',
'paniniA2B1',
'paniniA1.5B1',
'paniniPortraitA2B1',
'paniniPortraitA1.5B1',
'mercator',
'transverseMercator',
)
WAVE_CORRECT_CHOICES = ('horiz', 'no', 'vert',)
BLEND_CHOICES = ('multiband', 'feather', 'no',)
parser = argparse.ArgumentParser(
prog="stitching_detailed.py", description="Rotation model images stitcher"
)
parser.add_argument(
'img_names', nargs='+',
help="Files to stitch", type=str
)
parser.add_argument(
'--try_cuda',
action='store',
default=False,
help="Try to use CUDA. The default value is no. All default values are for CPU mode.",
type=bool, dest='try_cuda'
)
parser.add_argument(
'--work_megapix', action='store', default=0.6,
help="Resolution for image registration step. The default is 0.6 Mpx",
type=float, dest='work_megapix'
)
parser.add_argument(
'--features', action='store', default=list(FEATURES_FIND_CHOICES.keys())[0],
help="Type of features used for images matching. The default is '%s'." % FEATURES_FIND_CHOICES.keys(),
choices=FEATURES_FIND_CHOICES.keys(),
type=str, dest='features'
)
parser.add_argument(
'--matcher', action='store', default='homography',
help="Matcher used for pairwise image matching.",
choices=('homography', 'affine'),
type=str, dest='matcher'
)
parser.add_argument(
'--estimator', action='store', default=list(ESTIMATOR_CHOICES.keys())[0],
help="Type of estimator used for transformation estimation.",
choices=ESTIMATOR_CHOICES.keys(),
type=str, dest='estimator'
)
parser.add_argument(
'--match_conf', action='store',
help="Confidence for feature matching step. The default is 0.3 for ORB and 0.65 for other feature types.",
type=float, dest='match_conf'
)
parser.add_argument(
'--conf_thresh', action='store', default=1.0,
help="Threshold for two images are from the same panorama confidence.The default is 1.0.",
type=float, dest='conf_thresh'
)
parser.add_argument(
'--ba', action='store', default=list(BA_COST_CHOICES.keys())[0],
help="Bundle adjustment cost function. The default is '%s'." % list(BA_COST_CHOICES.keys())[0],
choices=BA_COST_CHOICES.keys(),
type=str, dest='ba'
)
parser.add_argument(
'--ba_refine_mask', action='store', default='xxxxx',
help="Set refinement mask for bundle adjustment. It looks like 'x_xxx', "
"where 'x' means refine respective parameter and '_' means don't refine, "
"and has the following format:<fx><skew><ppx><aspect><ppy>. "
"The default mask is 'xxxxx'. "
"If bundle adjustment doesn't support estimation of selected parameter then "
"the respective flag is ignored.",
type=str, dest='ba_refine_mask'
)
parser.add_argument(
'--wave_correct', action='store', default=WAVE_CORRECT_CHOICES[0],
help="Perform wave effect correction. The default is '%s'" % WAVE_CORRECT_CHOICES[0],
choices=WAVE_CORRECT_CHOICES,
type=str, dest='wave_correct'
)
parser.add_argument(
'--save_graph', action='store', default=None,
help="Save matches graph represented in DOT language to <file_name> file.",
type=str, dest='save_graph'
)
parser.add_argument(
'--warp', action='store', default=WARP_CHOICES[0],
help="Warp surface type. The default is '%s'." % WARP_CHOICES[0],
choices=WARP_CHOICES,
type=str, dest='warp'
)
parser.add_argument(
'--seam_megapix', action='store', default=0.1,
help="Resolution for seam estimation step. The default is 0.1 Mpx.",
type=float, dest='seam_megapix'
)
parser.add_argument(
'--seam', action='store', default=list(SEAM_FIND_CHOICES.keys())[0],
help="Seam estimation method. The default is '%s'." % list(SEAM_FIND_CHOICES.keys())[0],
choices=SEAM_FIND_CHOICES.keys(),
type=str, dest='seam'
)
parser.add_argument(
'--compose_megapix', action='store', default=-1,
help="Resolution for compositing step. Use -1 for original resolution. The default is -1",
type=float, dest='compose_megapix'
)
parser.add_argument(
'--expos_comp', action='store', default=list(EXPOS_COMP_CHOICES.keys())[0],
help="Exposure compensation method. The default is '%s'." % list(EXPOS_COMP_CHOICES.keys())[0],
choices=EXPOS_COMP_CHOICES.keys(),
type=str, dest='expos_comp'
)
parser.add_argument(
'--expos_comp_nr_feeds', action='store', default=1,
help="Number of exposure compensation feed.",
type=np.int32, dest='expos_comp_nr_feeds'
)
parser.add_argument(
'--expos_comp_nr_filtering', action='store', default=2,
help="Number of filtering iterations of the exposure compensation gains.",
type=float, dest='expos_comp_nr_filtering'
)
parser.add_argument(
'--expos_comp_block_size', action='store', default=32,
help="BLock size in pixels used by the exposure compensator. The default is 32.",
type=np.int32, dest='expos_comp_block_size'
)
parser.add_argument(
'--blend', action='store', default=BLEND_CHOICES[0],
help="Blending method. The default is '%s'." % BLEND_CHOICES[0],
choices=BLEND_CHOICES,
type=str, dest='blend'
)
parser.add_argument(
'--blend_strength', action='store', default=5,
help="Blending strength from [0,100] range. The default is 5",
type=np.int32, dest='blend_strength'
)
parser.add_argument(
'--output', action='store', default='result.jpg',
help="The default is 'result.jpg'",
type=str, dest='output'
)
parser.add_argument(
'--timelapse', action='store', default=None,
help="Output warped images separately as frames of a time lapse movie, "
"with 'fixed_' prepended to input file names.",
type=str, dest='timelapse'
)
parser.add_argument(
'--rangewidth', action='store', default=-1,
help="uses range_width to limit number of images to match with.",
type=int, dest='rangewidth'
)
__doc__ += '\n' + parser.format_help() __doc__ += '\n' + parser.format_help()
def get_matcher(args):
try_cuda = args.try_cuda
matcher_type = args.matcher
if args.match_conf is None:
if args.features == 'orb':
match_conf = 0.3
else:
match_conf = 0.65
else:
match_conf = args.match_conf
range_width = args.rangewidth
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)
return matcher
def get_compensator(args):
expos_comp_type = EXPOS_COMP_CHOICES[args.expos_comp]
expos_comp_nr_feeds = args.expos_comp_nr_feeds
expos_comp_block_size = args.expos_comp_block_size
# expos_comp_nr_filtering = args.expos_comp_nr_filtering
if expos_comp_type == cv.detail.ExposureCompensator_CHANNELS:
compensator = cv.detail_ChannelsCompensator(expos_comp_nr_feeds)
# compensator.setNrGainsFilteringIterations(expos_comp_nr_filtering)
elif expos_comp_type == cv.detail.ExposureCompensator_CHANNELS_BLOCKS:
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)
return compensator
def main(): def main():
args = parser.parse_args() args = parser.parse_args()
img_names=args.img_names img_names = args.img_names
print(img_names) print(img_names)
_preview = args.preview
try_cuda = args.try_cuda
work_megapix = args.work_megapix work_megapix = args.work_megapix
seam_megapix = args.seam_megapix seam_megapix = args.seam_megapix
compose_megapix = args.compose_megapix compose_megapix = args.compose_megapix
conf_thresh = args.conf_thresh 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 ba_refine_mask = args.ba_refine_mask
wave_correct = args.wave_correct wave_correct = args.wave_correct
if wave_correct=='no': if wave_correct == 'no':
do_wave_correct= False do_wave_correct = False
else: else:
do_wave_correct=True do_wave_correct = True
if args.save_graph is None: if args.save_graph is None:
save_graph = False save_graph = False
else: else:
save_graph =True save_graph = True
save_graph_to = args.save_graph
warp_type = args.warp 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_type = args.blend
blend_strength = args.blend_strength blend_strength = args.blend_strength
result_name = args.output result_name = args.output
if args.timelapse is not None: if args.timelapse is not None:
timelapse = True timelapse = True
if args.timelapse=="as_is": if args.timelapse == "as_is":
timelapse_type = cv.detail.Timelapser_AS_IS timelapse_type = cv.detail.Timelapser_AS_IS
elif args.timelapse=="crop": elif args.timelapse == "crop":
timelapse_type = cv.detail.Timelapser_CROP timelapse_type = cv.detail.Timelapser_CROP
else: else:
print("Bad timelapse method") print("Bad timelapse method")
exit() exit()
else: else:
timelapse= False timelapse = False
range_width = args.rangewidth finder = FEATURES_FIND_CHOICES[args.features]()
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 seam_work_aspect = 1
full_img_sizes=[] full_img_sizes = []
features=[] features = []
images=[] images = []
is_work_scale_set = False is_work_scale_set = False
is_seam_scale_set = False is_seam_scale_set = False
is_compose_scale_set = False is_compose_scale_set = False
@ -124,45 +315,41 @@ def main():
if full_img is None: if full_img is None:
print("Cannot read image ", name) print("Cannot read image ", name)
exit() exit()
full_img_sizes.append((full_img.shape[1],full_img.shape[0])) full_img_sizes.append((full_img.shape[1], full_img.shape[0]))
if work_megapix < 0: if work_megapix < 0:
img = full_img img = full_img
work_scale = 1 work_scale = 1
is_work_scale_set = True is_work_scale_set = True
else: else:
if is_work_scale_set is False: 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]))) work_scale = min(1.0, np.sqrt(work_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
is_work_scale_set = True is_work_scale_set = True
img = cv.resize(src=full_img, dsize=None, fx=work_scale, fy=work_scale, interpolation=cv.INTER_LINEAR_EXACT) 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: 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_scale = min(1.0, np.sqrt(seam_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
seam_work_aspect = seam_scale / work_scale seam_work_aspect = seam_scale / work_scale
is_seam_scale_set = True is_seam_scale_set = True
imgFea= cv.detail.computeImageFeatures2(finder,img) img_feat = cv.detail.computeImageFeatures2(finder, img)
features.append(imgFea) features.append(img_feat)
img = cv.resize(src=full_img, dsize=None, fx=seam_scale, fy=seam_scale, interpolation=cv.INTER_LINEAR_EXACT) img = cv.resize(src=full_img, dsize=None, fx=seam_scale, fy=seam_scale, interpolation=cv.INTER_LINEAR_EXACT)
images.append(img) images.append(img)
if matcher_type== "affine":
matcher = cv.detail_AffineBestOf2NearestMatcher(False, try_cuda, match_conf) matcher = get_matcher(args)
elif range_width==-1: p = matcher.apply2(features)
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() matcher.collectGarbage()
if save_graph: if save_graph:
f = open(save_graph_to,"w") with open(args.save_graph, 'w') as fh:
f.write(cv.detail.matchesGraphAsString(img_names, p, conf_thresh)) fh.write(cv.detail.matchesGraphAsString(img_names, p, conf_thresh))
f.close()
indices=cv.detail.leaveBiggestComponent(features,p,0.3) indices = cv.detail.leaveBiggestComponent(features, p, 0.3)
img_subset =[] img_subset = []
img_names_subset=[] img_names_subset = []
full_img_sizes_subset=[] full_img_sizes_subset = []
num_images=len(indices)
for i in range(len(indices)): for i in range(len(indices)):
img_names_subset.append(img_names[indices[i,0]]) img_names_subset.append(img_names[indices[i, 0]])
img_subset.append(images[indices[i,0]]) img_subset.append(images[indices[i, 0]])
full_img_sizes_subset.append(full_img_sizes[indices[i,0]]) full_img_sizes_subset.append(full_img_sizes[indices[i, 0]])
images = img_subset images = img_subset
img_names = img_names_subset img_names = img_names_subset
full_img_sizes = full_img_sizes_subset full_img_sizes = full_img_sizes_subset
@ -171,196 +358,159 @@ def main():
print("Need more images") print("Need more images")
exit() exit()
if estimator_type == "affine": estimator = ESTIMATOR_CHOICES[args.estimator]()
estimator = cv.detail_AffineBasedEstimator() b, cameras = estimator.apply(features, p, None)
else:
estimator = cv.detail_HomographyBasedEstimator()
b, cameras =estimator.apply(features,p,None)
if not b: if not b:
print("Homography estimation failed.") print("Homography estimation failed.")
exit() exit()
for cam in cameras: for cam in cameras:
cam.R=cam.R.astype(np.float32) cam.R = cam.R.astype(np.float32)
if ba_cost_func == "reproj": adjuster = BA_COST_CHOICES[args.ba]()
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) adjuster.setConfThresh(1)
refine_mask=np.zeros((3,3),np.uint8) refine_mask = np.zeros((3, 3), np.uint8)
if ba_refine_mask[0] == 'x': if ba_refine_mask[0] == 'x':
refine_mask[0,0] = 1 refine_mask[0, 0] = 1
if ba_refine_mask[1] == 'x': if ba_refine_mask[1] == 'x':
refine_mask[0,1] = 1 refine_mask[0, 1] = 1
if ba_refine_mask[2] == 'x': if ba_refine_mask[2] == 'x':
refine_mask[0,2] = 1 refine_mask[0, 2] = 1
if ba_refine_mask[3] == 'x': if ba_refine_mask[3] == 'x':
refine_mask[1,1] = 1 refine_mask[1, 1] = 1
if ba_refine_mask[4] == 'x': if ba_refine_mask[4] == 'x':
refine_mask[1,2] = 1 refine_mask[1, 2] = 1
adjuster.setRefinementMask(refine_mask) adjuster.setRefinementMask(refine_mask)
b,cameras = adjuster.apply(features,p,cameras) b, cameras = adjuster.apply(features, p, cameras)
if not b: if not b:
print("Camera parameters adjusting failed.") print("Camera parameters adjusting failed.")
exit() exit()
focals=[] focals = []
for cam in cameras: for cam in cameras:
focals.append(cam.focal) focals.append(cam.focal)
sorted(focals) sorted(focals)
if len(focals)%2==1: if len(focals) % 2 == 1:
warped_image_scale = focals[len(focals) // 2] warped_image_scale = focals[len(focals) // 2]
else: else:
warped_image_scale = (focals[len(focals) // 2]+focals[len(focals) // 2-1])/2 warped_image_scale = (focals[len(focals) // 2] + focals[len(focals) // 2 - 1]) / 2
if do_wave_correct: if do_wave_correct:
rmats=[] rmats = []
for cam in cameras: for cam in cameras:
rmats.append(np.copy(cam.R)) rmats.append(np.copy(cam.R))
rmats = cv.detail.waveCorrect( rmats, cv.detail.WAVE_CORRECT_HORIZ) rmats = cv.detail.waveCorrect(rmats, cv.detail.WAVE_CORRECT_HORIZ)
for idx,cam in enumerate(cameras): for idx, cam in enumerate(cameras):
cam.R = rmats[idx] cam.R = rmats[idx]
corners=[] corners = []
mask=[] masks_warped = []
masks_warped=[] images_warped = []
images_warped=[] sizes = []
sizes=[] masks = []
masks=[] for i in range(0, num_images):
for i in range(0,num_images): um = cv.UMat(255 * np.ones((images[i].shape[0], images[i].shape[1]), np.uint8))
um=cv.UMat(255*np.ones((images[i].shape[0],images[i].shape[1]),np.uint8))
masks.append(um) masks.append(um)
warper = cv.PyRotationWarper(warp_type,warped_image_scale*seam_work_aspect) # warper peut etre nullptr? warper = cv.PyRotationWarper(warp_type, warped_image_scale * seam_work_aspect) # warper could be nullptr?
for idx in range(0,num_images): for idx in range(0, num_images):
K = cameras[idx].K().astype(np.float32) K = cameras[idx].K().astype(np.float32)
swa = seam_work_aspect swa = seam_work_aspect
K[0,0] *= swa K[0, 0] *= swa
K[0,2] *= swa K[0, 2] *= swa
K[1,1] *= swa K[1, 1] *= swa
K[1,2] *= swa K[1, 2] *= swa
corner,image_wp =warper.warp(images[idx],K,cameras[idx].R,cv.INTER_LINEAR, cv.BORDER_REFLECT) corner, image_wp = warper.warp(images[idx], K, cameras[idx].R, cv.INTER_LINEAR, cv.BORDER_REFLECT)
corners.append(corner) corners.append(corner)
sizes.append((image_wp.shape[1],image_wp.shape[0])) sizes.append((image_wp.shape[1], image_wp.shape[0]))
images_warped.append(image_wp) images_warped.append(image_wp)
p, mask_wp = warper.warp(masks[idx], K, cameras[idx].R, cv.INTER_NEAREST, cv.BORDER_CONSTANT)
p,mask_wp =warper.warp(masks[idx],K,cameras[idx].R,cv.INTER_NEAREST, cv.BORDER_CONSTANT)
masks_warped.append(mask_wp.get()) masks_warped.append(mask_wp.get())
images_warped_f=[]
images_warped_f = []
for img in images_warped: for img in images_warped:
imgf=img.astype(np.float32) imgf = img.astype(np.float32)
images_warped_f.append(imgf) images_warped_f.append(imgf)
if cv.detail.ExposureCompensator_CHANNELS == expos_comp_type:
compensator = cv.detail_ChannelsCompensator(expos_comp_nr_feeds) compensator = get_compensator(args)
# 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) 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) seam_finder = SEAM_FIND_CHOICES[args.seam]
elif seam_find_type == "voronoi": seam_finder.find(images_warped_f, corners, masks_warped)
seam_finder = cv.detail.SeamFinder_createDefault(cv.detail.SeamFinder_VORONOI_SEAM) compose_scale = 1
elif seam_find_type == "gc_color": corners = []
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR") sizes = []
elif seam_find_type == "gc_colorgrad": blender = None
seam_finder = cv.detail_GraphCutSeamFinder("COST_COLOR_GRAD") timelapser = None
elif seam_find_type == "dp_color": # https://github.com/opencv/opencv/blob/master/samples/cpp/stitching_detailed.cpp#L725 ?
seam_finder = cv.detail_DpSeamFinder("COLOR") for idx, name in enumerate(img_names):
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) full_img = cv.imread(name)
if not is_compose_scale_set: if not is_compose_scale_set:
if compose_megapix > 0: if compose_megapix > 0:
compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0]*full_img.shape[1]))) compose_scale = min(1.0, np.sqrt(compose_megapix * 1e6 / (full_img.shape[0] * full_img.shape[1])))
is_compose_scale_set = True is_compose_scale_set = True
compose_work_aspect = compose_scale / work_scale compose_work_aspect = compose_scale / work_scale
warped_image_scale *= compose_work_aspect warped_image_scale *= compose_work_aspect
warper = cv.PyRotationWarper(warp_type,warped_image_scale) warper = cv.PyRotationWarper(warp_type, warped_image_scale)
for i in range(0,len(img_names)): for i in range(0, len(img_names)):
cameras[i].focal *= compose_work_aspect cameras[i].focal *= compose_work_aspect
cameras[i].ppx *= compose_work_aspect cameras[i].ppx *= compose_work_aspect
cameras[i].ppy *= compose_work_aspect cameras[i].ppy *= compose_work_aspect
sz = (full_img_sizes[i][0] * compose_scale,full_img_sizes[i][1]* compose_scale) sz = (full_img_sizes[i][0] * compose_scale, full_img_sizes[i][1] * compose_scale)
K = cameras[i].K().astype(np.float32) K = cameras[i].K().astype(np.float32)
roi = warper.warpRoi(sz, K, cameras[i].R) roi = warper.warpRoi(sz, K, cameras[i].R)
corners.append(roi[0:2]) corners.append(roi[0:2])
sizes.append(roi[2:4]) sizes.append(roi[2:4])
if abs(compose_scale - 1) > 1e-1: 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) img = cv.resize(src=full_img, dsize=None, fx=compose_scale, fy=compose_scale,
interpolation=cv.INTER_LINEAR_EXACT)
else: else:
img = full_img img = full_img
_img_size = (img.shape[1],img.shape[0]) _img_size = (img.shape[1], img.shape[0])
K=cameras[idx].K().astype(np.float32) K = cameras[idx].K().astype(np.float32)
corner,image_warped =warper.warp(img,K,cameras[idx].R,cv.INTER_LINEAR, cv.BORDER_REFLECT) 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) 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) 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) compensator.apply(idx, corners[idx], image_warped, mask_warped)
image_warped_s = image_warped.astype(np.int16) image_warped_s = image_warped.astype(np.int16)
image_warped=[] dilated_mask = cv.dilate(masks_warped[idx], None)
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)
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)
mask_warped = cv.bitwise_and(seam_mask,mask_warped) if blender is None and not timelapse:
if blender==None and not timelapse:
blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO) blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
dst_sz = cv.detail.resultRoi(corners=corners,sizes=sizes) dst_sz = cv.detail.resultRoi(corners=corners, sizes=sizes)
blend_width = np.sqrt(dst_sz[2]*dst_sz[3]) * blend_strength / 100 blend_width = np.sqrt(dst_sz[2] * dst_sz[3]) * blend_strength / 100
if blend_width < 1: if blend_width < 1:
blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO) blender = cv.detail.Blender_createDefault(cv.detail.Blender_NO)
elif blend_type == "multiband": elif blend_type == "multiband":
blender = cv.detail_MultiBandBlender() blender = cv.detail_MultiBandBlender()
blender.setNumBands((np.log(blend_width)/np.log(2.) - 1.).astype(np.int)) blender.setNumBands((np.log(blend_width) / np.log(2.) - 1.).astype(np.int))
elif blend_type == "feather": elif blend_type == "feather":
blender = cv.detail_FeatherBlender() blender = cv.detail_FeatherBlender()
blender.setSharpness(1./blend_width) blender.setSharpness(1. / blend_width)
blender.prepare(dst_sz) blender.prepare(dst_sz)
elif timelapser==None and timelapse: elif timelapser is None and timelapse:
timelapser = cv.detail.Timelapser_createDefault(timelapse_type) timelapser = cv.detail.Timelapser_createDefault(timelapse_type)
timelapser.initialize(corners, sizes) timelapser.initialize(corners, sizes)
if timelapse: if timelapse:
matones=np.ones((image_warped_s.shape[0],image_warped_s.shape[1]), np.uint8) ma_tones = np.ones((image_warped_s.shape[0], image_warped_s.shape[1]), np.uint8)
timelapser.process(image_warped_s, matones, corners[idx]) timelapser.process(image_warped_s, ma_tones, corners[idx])
pos_s = img_names[idx].rfind("/") pos_s = img_names[idx].rfind("/")
if pos_s == -1: if pos_s == -1:
fixedFileName = "fixed_" + img_names[idx] fixed_file_name = "fixed_" + img_names[idx]
else: else:
fixedFileName = img_names[idx][:pos_s + 1 ]+"fixed_" + img_names[idx][pos_s + 1: ] fixed_file_name = img_names[idx][:pos_s + 1] + "fixed_" + img_names[idx][pos_s + 1:]
cv.imwrite(fixedFileName, timelapser.getDst()) cv.imwrite(fixed_file_name, timelapser.getDst())
else: else:
blender.feed(cv.UMat(image_warped_s), mask_warped, corners[idx]) blender.feed(cv.UMat(image_warped_s), mask_warped, corners[idx])
if not timelapse: if not timelapse:
result=None result = None
result_mask=None result_mask = None
result,result_mask = blender.blend(result,result_mask) result, result_mask = blender.blend(result, result_mask)
cv.imwrite(result_name,result) cv.imwrite(result_name, result)
zoomx = 600.0 / result.shape[1] zoom_x = 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.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) dst = cv.resize(dst, dsize=None, fx=zoom_x, fy=zoom_x)
cv.imshow(result_name,dst) cv.imshow(result_name, dst)
cv.waitKey() cv.waitKey()
print('Done') print("Done")
if __name__ == '__main__': if __name__ == '__main__':