org.bytedeco.opencv.global

Class opencv_stitching

java.lang.Object

org.bytedeco.opencv.presets.opencv_stitching

org.bytedeco.opencv.global.opencv_stitching

All Implemented Interfaces:

InfoMapper

public class opencv_stitching
extends opencv_stitching

Field Summary

Fields

Modifier and Type	Field and Description
static int	WAVE_CORRECT_HORIZ enum cv::detail::WaveCorrectKind
static int	WAVE_CORRECT_VERT enum cv::detail::WaveCorrectKind

Constructor Summary

Constructors

Constructor and Description
opencv_stitching()

Method Summary

Modifier and Type	Method and Description
static boolean	calibrateRotatingCamera(MatVector Hs, Mat K)
static void	computeImageFeatures(Feature2D featuresFinder, GpuMatVector images, ImageFeatures features)
static void	computeImageFeatures(Feature2D featuresFinder, GpuMatVector images, ImageFeatures features, GpuMatVector masks)
static void	computeImageFeatures(Feature2D featuresFinder, MatVector images, ImageFeatures features)
static void	computeImageFeatures(Feature2D featuresFinder, MatVector images, ImageFeatures features, MatVector masks) \brief
static void	computeImageFeatures(Feature2D featuresFinder, UMatVector images, ImageFeatures features)
static void	computeImageFeatures(Feature2D featuresFinder, UMatVector images, ImageFeatures features, UMatVector masks)
static void	computeImageFeatures2(Feature2D featuresFinder, GpuMat image, ImageFeatures features)
static void	computeImageFeatures2(Feature2D featuresFinder, GpuMat image, ImageFeatures features, GpuMat mask)
static void	computeImageFeatures2(Feature2D featuresFinder, Mat image, ImageFeatures features)
static void	computeImageFeatures2(Feature2D featuresFinder, Mat image, ImageFeatures features, Mat mask) \brief
static void	computeImageFeatures2(Feature2D featuresFinder, UMat image, ImageFeatures features)
static void	computeImageFeatures2(Feature2D featuresFinder, UMat image, ImageFeatures features, UMat mask)
static void	createLaplacePyr(GpuMat img, int num_levels, UMatVector pyr)
static void	createLaplacePyr(Mat img, int num_levels, UMatVector pyr)
static void	createLaplacePyr(UMat img, int num_levels, UMatVector pyr)
static void	createLaplacePyrGpu(GpuMat img, int num_levels, UMatVector pyr)
static void	createLaplacePyrGpu(Mat img, int num_levels, UMatVector pyr)
static void	createLaplacePyrGpu(UMat img, int num_levels, UMatVector pyr)
static Stitcher	createStitcher()
static Stitcher	createStitcher(boolean try_use_gpu) Deprecated. use Stitcher::create
static Stitcher	createStitcherScans()
static Stitcher	createStitcherScans(boolean try_use_gpu) Deprecated. use Stitcher::create
static void	createWeightMap(GpuMat mask, float sharpness, GpuMat weight)
static void	createWeightMap(Mat mask, float sharpness, Mat weight)
static void	createWeightMap(UMat mask, float sharpness, UMat weight)
static void	estimateFocal(ImageFeatures features, MatchesInfo pairwise_matches, double[] focals)
static void	estimateFocal(ImageFeatures features, MatchesInfo pairwise_matches, DoubleBuffer focals)
static void	estimateFocal(ImageFeatures features, MatchesInfo pairwise_matches, DoublePointer focals) \brief Estimates focal lengths for each given camera.
static void	findMaxSpanningTree(int num_images, MatchesInfo pairwise_matches, Graph span_tree, int[] centers)
static void	findMaxSpanningTree(int num_images, MatchesInfo pairwise_matches, Graph span_tree, IntBuffer centers)
static void	findMaxSpanningTree(int num_images, MatchesInfo pairwise_matches, Graph span_tree, IntPointer centers)
static void	focalsFromHomography(Mat H, double[] f0, double[] f1, boolean[] f0_ok, boolean[] f1_ok)
static void	focalsFromHomography(Mat H, double[] f0, double[] f1, BoolPointer f0_ok, BoolPointer f1_ok)
static void	focalsFromHomography(Mat H, DoubleBuffer f0, DoubleBuffer f1, boolean[] f0_ok, boolean[] f1_ok)
static void	focalsFromHomography(Mat H, DoubleBuffer f0, DoubleBuffer f1, BoolPointer f0_ok, BoolPointer f1_ok)
static void	focalsFromHomography(Mat H, DoublePointer f0, DoublePointer f1, boolean[] f0_ok, boolean[] f1_ok)
static void	focalsFromHomography(Mat H, DoublePointer f0, DoublePointer f1, BoolPointer f0_ok, BoolPointer f1_ok) \addtogroup stitching_autocalib \{
static IntPointer	leaveBiggestComponent(ImageFeatures features, MatchesInfo pairwise_matches, float conf_threshold)
static BytePointer	matchesGraphAsString(StringVector pathes, MatchesInfo pairwise_matches, float conf_threshold)
static void	normalizeUsingWeightMap(GpuMat weight, GpuMat src)
static void	normalizeUsingWeightMap(Mat weight, Mat src) \}
static void	normalizeUsingWeightMap(UMat weight, UMat src)
static boolean	overlapRoi(Point tl1, Point tl2, Size sz1, Size sz2, Rect roi) \} stitching_match
static void	restoreImageFromLaplacePyr(UMatVector pyr)
static void	restoreImageFromLaplacePyrGpu(UMatVector pyr)
static Rect	resultRoi(PointVector corners, SizeVector sizes)
static Rect	resultRoi(PointVector corners, UMatVector images)
static Rect	resultRoiIntersection(PointVector corners, SizeVector sizes)
static Point	resultTl(PointVector corners)
static void	selectRandomSubset(int count, int size, int[] subset)
static void	selectRandomSubset(int count, int size, IntBuffer subset)
static void	selectRandomSubset(int count, int size, IntPointer subset)
static IntPointer	stitchingLogLevel()
static void	waveCorrect(MatVector rmats, int kind) \brief Tries to make panorama more horizontal (or vertical).

Methods inherited from class org.bytedeco.opencv.presets.opencv_stitching

map

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

WAVE_CORRECT_HORIZ

public static final int WAVE_CORRECT_HORIZ

enum cv::detail::WaveCorrectKind

See Also:

Constant Field Values

WAVE_CORRECT_VERT

public static final int WAVE_CORRECT_VERT

enum cv::detail::WaveCorrectKind

See Also:

Constant Field Values

Constructor Detail

opencv_stitching

public opencv_stitching()

Method Detail

computeImageFeatures

@Namespace(value="cv::detail")
public static void computeImageFeatures(@opencv_core.Ptr
                                                                       Feature2D featuresFinder,
                                                                       @ByVal
                                                                       MatVector images,
                                                                       @StdVector
                                                                       ImageFeatures features,
                                                                       @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                                                       MatVector masks)

\brief

Parameters:

featuresFinder -

images -

features -

masks -

computeImageFeatures

@Namespace(value="cv::detail")
public static void computeImageFeatures(@opencv_core.Ptr
                                                                       Feature2D featuresFinder,
                                                                       @ByVal
                                                                       MatVector images,
                                                                       @StdVector
                                                                       ImageFeatures features)

computeImageFeatures

@Namespace(value="cv::detail")
public static void computeImageFeatures(@opencv_core.Ptr
                                                                       Feature2D featuresFinder,
                                                                       @ByVal
                                                                       UMatVector images,
                                                                       @StdVector
                                                                       ImageFeatures features,
                                                                       @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                                                       UMatVector masks)

computeImageFeatures

@Namespace(value="cv::detail")
public static void computeImageFeatures(@opencv_core.Ptr
                                                                       Feature2D featuresFinder,
                                                                       @ByVal
                                                                       UMatVector images,
                                                                       @StdVector
                                                                       ImageFeatures features)

computeImageFeatures

@Namespace(value="cv::detail")
public static void computeImageFeatures(@opencv_core.Ptr
                                                                       Feature2D featuresFinder,
                                                                       @ByVal
                                                                       GpuMatVector images,
                                                                       @StdVector
                                                                       ImageFeatures features,
                                                                       @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                                                       GpuMatVector masks)

computeImageFeatures

@Namespace(value="cv::detail")
public static void computeImageFeatures(@opencv_core.Ptr
                                                                       Feature2D featuresFinder,
                                                                       @ByVal
                                                                       GpuMatVector images,
                                                                       @StdVector
                                                                       ImageFeatures features)

computeImageFeatures2

@Namespace(value="cv::detail")
 @Name(value="computeImageFeatures")
public static void computeImageFeatures2(@opencv_core.Ptr
                                                                                                             Feature2D featuresFinder,
                                                                                                             @ByVal
                                                                                                             Mat image,
                                                                                                             @ByRef
                                                                                                             ImageFeatures features,
                                                                                                             @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                                                             Mat mask)

\brief

Parameters:

featuresFinder -

image -

features -

mask -

computeImageFeatures2

@Namespace(value="cv::detail")
 @Name(value="computeImageFeatures")
public static void computeImageFeatures2(@opencv_core.Ptr
                                                                                                             Feature2D featuresFinder,
                                                                                                             @ByVal
                                                                                                             Mat image,
                                                                                                             @ByRef
                                                                                                             ImageFeatures features)

computeImageFeatures2

@Namespace(value="cv::detail")
 @Name(value="computeImageFeatures")
public static void computeImageFeatures2(@opencv_core.Ptr
                                                                                                             Feature2D featuresFinder,
                                                                                                             @ByVal
                                                                                                             UMat image,
                                                                                                             @ByRef
                                                                                                             ImageFeatures features,
                                                                                                             @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                                                             UMat mask)

computeImageFeatures2

@Namespace(value="cv::detail")
 @Name(value="computeImageFeatures")
public static void computeImageFeatures2(@opencv_core.Ptr
                                                                                                             Feature2D featuresFinder,
                                                                                                             @ByVal
                                                                                                             UMat image,
                                                                                                             @ByRef
                                                                                                             ImageFeatures features)

computeImageFeatures2

@Namespace(value="cv::detail")
 @Name(value="computeImageFeatures")
public static void computeImageFeatures2(@opencv_core.Ptr
                                                                                                             Feature2D featuresFinder,
                                                                                                             @ByVal
                                                                                                             GpuMat image,
                                                                                                             @ByRef
                                                                                                             ImageFeatures features,
                                                                                                             @ByVal(nullValue="cv::InputArray(cv::noArray())")
                                                                                                             GpuMat mask)

computeImageFeatures2

@Namespace(value="cv::detail")
 @Name(value="computeImageFeatures")
public static void computeImageFeatures2(@opencv_core.Ptr
                                                                                                             Feature2D featuresFinder,
                                                                                                             @ByVal
                                                                                                             GpuMat image,
                                                                                                             @ByRef
                                                                                                             ImageFeatures features)

overlapRoi

@Namespace(value="cv::detail")
 @Cast(value="bool")
public static boolean overlapRoi(@ByVal
                                                                                     Point tl1,
                                                                                     @ByVal
                                                                                     Point tl2,
                                                                                     @ByVal
                                                                                     Size sz1,
                                                                                     @ByVal
                                                                                     Size sz2,
                                                                                     @ByRef
                                                                                     Rect roi)

\} stitching_match

resultRoi

@Namespace(value="cv::detail")
 @ByVal
public static Rect resultRoi(@Const @ByRef
                                                                    PointVector corners,
                                                                    @Const @ByRef
                                                                    UMatVector images)

resultRoi

@Namespace(value="cv::detail")
 @ByVal
public static Rect resultRoi(@Const @ByRef
                                                                    PointVector corners,
                                                                    @Const @ByRef
                                                                    SizeVector sizes)

resultRoiIntersection

@Namespace(value="cv::detail")
 @ByVal
public static Rect resultRoiIntersection(@Const @ByRef
                                                                                PointVector corners,
                                                                                @Const @ByRef
                                                                                SizeVector sizes)

resultTl

@Namespace(value="cv::detail")
 @ByVal
public static Point resultTl(@Const @ByRef
                                                                    PointVector corners)

selectRandomSubset

@Namespace(value="cv::detail")
public static void selectRandomSubset(int count,
                                                                     int size,
                                                                     @StdVector
                                                                     IntPointer subset)

selectRandomSubset

@Namespace(value="cv::detail")
public static void selectRandomSubset(int count,
                                                                     int size,
                                                                     @StdVector
                                                                     IntBuffer subset)

selectRandomSubset

@Namespace(value="cv::detail")
public static void selectRandomSubset(int count,
                                                                     int size,
                                                                     @StdVector
                                                                     int[] subset)

stitchingLogLevel

@Namespace(value="cv::detail")
 @ByRef
public static IntPointer stitchingLogLevel()

waveCorrect

@Namespace(value="cv::detail")
public static void waveCorrect(@ByRef
                                                              MatVector rmats,
                                                              @Cast(value="cv::detail::WaveCorrectKind")
                                                              int kind)

\brief Tries to make panorama more horizontal (or vertical).

Parameters:

rmats - Camera rotation matrices.

kind - Correction kind, see detail::WaveCorrectKind.

matchesGraphAsString

@Namespace(value="cv::detail")
 @opencv_core.Str
public static BytePointer matchesGraphAsString(@ByRef
                                                                                                StringVector pathes,
                                                                                                @StdVector
                                                                                                MatchesInfo pairwise_matches,
                                                                                                float conf_threshold)

leaveBiggestComponent

@Namespace(value="cv::detail")
 @StdVector
public static IntPointer leaveBiggestComponent(@StdVector
                                                                                          ImageFeatures features,
                                                                                          @StdVector
                                                                                          MatchesInfo pairwise_matches,
                                                                                          float conf_threshold)

findMaxSpanningTree

@Namespace(value="cv::detail")
public static void findMaxSpanningTree(int num_images,
                                                                      @StdVector
                                                                      MatchesInfo pairwise_matches,
                                                                      @ByRef
                                                                      Graph span_tree,
                                                                      @StdVector
                                                                      IntPointer centers)

findMaxSpanningTree

@Namespace(value="cv::detail")
public static void findMaxSpanningTree(int num_images,
                                                                      @StdVector
                                                                      MatchesInfo pairwise_matches,
                                                                      @ByRef
                                                                      Graph span_tree,
                                                                      @StdVector
                                                                      IntBuffer centers)

findMaxSpanningTree

@Namespace(value="cv::detail")
public static void findMaxSpanningTree(int num_images,
                                                                      @StdVector
                                                                      MatchesInfo pairwise_matches,
                                                                      @ByRef
                                                                      Graph span_tree,
                                                                      @StdVector
                                                                      int[] centers)

normalizeUsingWeightMap

@Namespace(value="cv::detail")
public static void normalizeUsingWeightMap(@ByVal
                                                                          Mat weight,
                                                                          @ByVal
                                                                          Mat src)

\}

normalizeUsingWeightMap

@Namespace(value="cv::detail")
public static void normalizeUsingWeightMap(@ByVal
                                                                          UMat weight,
                                                                          @ByVal
                                                                          UMat src)

normalizeUsingWeightMap

@Namespace(value="cv::detail")
public static void normalizeUsingWeightMap(@ByVal
                                                                          GpuMat weight,
                                                                          @ByVal
                                                                          GpuMat src)

createWeightMap

@Namespace(value="cv::detail")
public static void createWeightMap(@ByVal
                                                                  Mat mask,
                                                                  float sharpness,
                                                                  @ByVal
                                                                  Mat weight)

createWeightMap

@Namespace(value="cv::detail")
public static void createWeightMap(@ByVal
                                                                  UMat mask,
                                                                  float sharpness,
                                                                  @ByVal
                                                                  UMat weight)

createWeightMap

@Namespace(value="cv::detail")
public static void createWeightMap(@ByVal
                                                                  GpuMat mask,
                                                                  float sharpness,
                                                                  @ByVal
                                                                  GpuMat weight)

createLaplacePyr

@Namespace(value="cv::detail")
public static void createLaplacePyr(@ByVal
                                                                   Mat img,
                                                                   int num_levels,
                                                                   @ByRef
                                                                   UMatVector pyr)

createLaplacePyr

@Namespace(value="cv::detail")
public static void createLaplacePyr(@ByVal
                                                                   UMat img,
                                                                   int num_levels,
                                                                   @ByRef
                                                                   UMatVector pyr)

createLaplacePyr

@Namespace(value="cv::detail")
public static void createLaplacePyr(@ByVal
                                                                   GpuMat img,
                                                                   int num_levels,
                                                                   @ByRef
                                                                   UMatVector pyr)

createLaplacePyrGpu

@Namespace(value="cv::detail")
public static void createLaplacePyrGpu(@ByVal
                                                                      Mat img,
                                                                      int num_levels,
                                                                      @ByRef
                                                                      UMatVector pyr)

createLaplacePyrGpu

@Namespace(value="cv::detail")
public static void createLaplacePyrGpu(@ByVal
                                                                      UMat img,
                                                                      int num_levels,
                                                                      @ByRef
                                                                      UMatVector pyr)

createLaplacePyrGpu

@Namespace(value="cv::detail")
public static void createLaplacePyrGpu(@ByVal
                                                                      GpuMat img,
                                                                      int num_levels,
                                                                      @ByRef
                                                                      UMatVector pyr)

restoreImageFromLaplacePyr

@Namespace(value="cv::detail")
public static void restoreImageFromLaplacePyr(@ByRef
                                                                             UMatVector pyr)

restoreImageFromLaplacePyrGpu

@Namespace(value="cv::detail")
public static void restoreImageFromLaplacePyrGpu(@ByRef
                                                                                UMatVector pyr)

focalsFromHomography

@Namespace(value="cv::detail")
public static void focalsFromHomography(@Const @ByRef
                                                                       Mat H,
                                                                       @ByRef
                                                                       DoublePointer f0,
                                                                       @ByRef
                                                                       DoublePointer f1,
                                                                       @Cast(value="bool*") @ByRef
                                                                       BoolPointer f0_ok,
                                                                       @Cast(value="bool*") @ByRef
                                                                       BoolPointer f1_ok)

\addtogroup stitching_autocalib \{

/** \brief Tries to estimate focal lengths from the given homography under the assumption that the camera undergoes rotations around its centre only.

Parameters:

H - Homography.

f0 - Estimated focal length along X axis.

f1 - Estimated focal length along Y axis.

f0_ok - True, if f0 was estimated successfully, false otherwise.

f1_ok - True, if f1 was estimated successfully, false otherwise.

See "Construction of Panoramic Image Mosaics with Global and Local Alignment" by Heung-Yeung Shum and Richard Szeliski.

focalsFromHomography

@Namespace(value="cv::detail")
public static void focalsFromHomography(@Const @ByRef
                                                                       Mat H,
                                                                       @ByRef
                                                                       DoubleBuffer f0,
                                                                       @ByRef
                                                                       DoubleBuffer f1,
                                                                       @Cast(value="bool*") @ByRef
                                                                       boolean[] f0_ok,
                                                                       @Cast(value="bool*") @ByRef
                                                                       boolean[] f1_ok)

focalsFromHomography

@Namespace(value="cv::detail")
public static void focalsFromHomography(@Const @ByRef
                                                                       Mat H,
                                                                       @ByRef
                                                                       double[] f0,
                                                                       @ByRef
                                                                       double[] f1,
                                                                       @Cast(value="bool*") @ByRef
                                                                       BoolPointer f0_ok,
                                                                       @Cast(value="bool*") @ByRef
                                                                       BoolPointer f1_ok)

focalsFromHomography

@Namespace(value="cv::detail")
public static void focalsFromHomography(@Const @ByRef
                                                                       Mat H,
                                                                       @ByRef
                                                                       DoublePointer f0,
                                                                       @ByRef
                                                                       DoublePointer f1,
                                                                       @Cast(value="bool*") @ByRef
                                                                       boolean[] f0_ok,
                                                                       @Cast(value="bool*") @ByRef
                                                                       boolean[] f1_ok)

focalsFromHomography

@Namespace(value="cv::detail")
public static void focalsFromHomography(@Const @ByRef
                                                                       Mat H,
                                                                       @ByRef
                                                                       DoubleBuffer f0,
                                                                       @ByRef
                                                                       DoubleBuffer f1,
                                                                       @Cast(value="bool*") @ByRef
                                                                       BoolPointer f0_ok,
                                                                       @Cast(value="bool*") @ByRef
                                                                       BoolPointer f1_ok)

focalsFromHomography

@Namespace(value="cv::detail")
public static void focalsFromHomography(@Const @ByRef
                                                                       Mat H,
                                                                       @ByRef
                                                                       double[] f0,
                                                                       @ByRef
                                                                       double[] f1,
                                                                       @Cast(value="bool*") @ByRef
                                                                       boolean[] f0_ok,
                                                                       @Cast(value="bool*") @ByRef
                                                                       boolean[] f1_ok)

estimateFocal

@Namespace(value="cv::detail")
public static void estimateFocal(@StdVector
                                                                ImageFeatures features,
                                                                @StdVector
                                                                MatchesInfo pairwise_matches,
                                                                @StdVector
                                                                DoublePointer focals)

\brief Estimates focal lengths for each given camera.

Parameters:

features - Features of images.

pairwise_matches - Matches between all image pairs.

focals - Estimated focal lengths for each camera.

estimateFocal

@Namespace(value="cv::detail")
public static void estimateFocal(@StdVector
                                                                ImageFeatures features,
                                                                @StdVector
                                                                MatchesInfo pairwise_matches,
                                                                @StdVector
                                                                DoubleBuffer focals)

estimateFocal

@Namespace(value="cv::detail")
public static void estimateFocal(@StdVector
                                                                ImageFeatures features,
                                                                @StdVector
                                                                MatchesInfo pairwise_matches,
                                                                @StdVector
                                                                double[] focals)

calibrateRotatingCamera

@Namespace(value="cv::detail")
 @Cast(value="bool")
public static boolean calibrateRotatingCamera(@Const @ByRef
                                                                                                  MatVector Hs,
                                                                                                  @ByRef
                                                                                                  Mat K)

createStitcher

@Namespace(value="cv")
 @opencv_core.Ptr
public static Stitcher createStitcher(@Cast(value="bool")
                                                                               boolean try_use_gpu)

Deprecated. use Stitcher::create

createStitcher

@Namespace(value="cv")
 @opencv_core.Ptr
public static Stitcher createStitcher()

createStitcherScans

@Namespace(value="cv")
 @opencv_core.Ptr
public static Stitcher createStitcherScans(@Cast(value="bool")
                                                                                    boolean try_use_gpu)

Deprecated. use Stitcher::create

createStitcherScans

@Namespace(value="cv")
 @opencv_core.Ptr
public static Stitcher createStitcherScans()