org.bytedeco.opencv.opencv_structured_light

Class StructuredLightPattern

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.opencv.opencv_core.Algorithm

org.bytedeco.opencv.opencv_structured_light.StructuredLightPattern

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

GrayCodePattern, SinusoidalPattern

@Namespace(value="cv::structured_light")
 @Properties(inherit=opencv_structured_light.class)
public class StructuredLightPattern
extends Algorithm

\brief Abstract base class for generating and decoding structured light patterns.

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
StructuredLightPattern(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
boolean	decode(MatVectorVector patternImages, GpuMat disparityMap)
boolean	decode(MatVectorVector patternImages, GpuMat disparityMap, GpuMatVector blackImages, GpuMatVector whiteImages, int flags)
boolean	decode(MatVectorVector patternImages, GpuMat disparityMap, MatVector blackImages, MatVector whiteImages, int flags)
boolean	decode(MatVectorVector patternImages, GpuMat disparityMap, UMatVector blackImages, UMatVector whiteImages, int flags)
boolean	decode(MatVectorVector patternImages, Mat disparityMap)
boolean	decode(MatVectorVector patternImages, Mat disparityMap, GpuMatVector blackImages, GpuMatVector whiteImages, int flags)
boolean	decode(MatVectorVector patternImages, Mat disparityMap, MatVector blackImages, MatVector whiteImages, int flags) \brief Decodes the structured light pattern, generating a disparity map
boolean	decode(MatVectorVector patternImages, Mat disparityMap, UMatVector blackImages, UMatVector whiteImages, int flags)
boolean	decode(MatVectorVector patternImages, UMat disparityMap)
boolean	decode(MatVectorVector patternImages, UMat disparityMap, GpuMatVector blackImages, GpuMatVector whiteImages, int flags)
boolean	decode(MatVectorVector patternImages, UMat disparityMap, MatVector blackImages, MatVector whiteImages, int flags)
boolean	decode(MatVectorVector patternImages, UMat disparityMap, UMatVector blackImages, UMatVector whiteImages, int flags)
boolean	generate(GpuMatVector patternImages)
boolean	generate(MatVector patternImages) \brief Generates the structured light pattern to project.
boolean	generate(UMatVector patternImages)

Methods inherited from class org.bytedeco.opencv.opencv_core.Algorithm

clear, empty, getDefaultName, position, read, save, save, write, write, write

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

StructuredLightPattern

public StructuredLightPattern(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

Method Detail

generate

@Cast(value="bool")
public boolean generate(@ByVal
                                            MatVector patternImages)

\brief Generates the structured light pattern to project.

Parameters:

patternImages - The generated pattern: a vector, in which each image is a CV_8U Mat at projector's resolution.

generate

@Cast(value="bool")
public boolean generate(@ByVal
                                            UMatVector patternImages)

generate

@Cast(value="bool")
public boolean generate(@ByVal
                                            GpuMatVector patternImages)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          Mat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          MatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          MatVector whiteImages,
                                          int flags)

\brief Decodes the structured light pattern, generating a disparity map

Parameters:

patternImages - The acquired pattern images to decode (vector>), loaded as grayscale and previously rectified.

disparityMap - The decoding result: a CV_64F Mat at image resolution, storing the computed disparity map.

blackImages - The all-black images needed for shadowMasks computation.

whiteImages - The all-white images needed for shadowMasks computation.

flags - Flags setting decoding algorithms. Default: DECODE_3D_UNDERWORLD. \note All the images must be at the same resolution.

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          Mat disparityMap)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          Mat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          UMatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          UMatVector whiteImages,
                                          int flags)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          Mat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          GpuMatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          GpuMatVector whiteImages,
                                          int flags)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          UMat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          MatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          MatVector whiteImages,
                                          int flags)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          UMat disparityMap)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          UMat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          UMatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          UMatVector whiteImages,
                                          int flags)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          UMat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          GpuMatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          GpuMatVector whiteImages,
                                          int flags)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          GpuMat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          MatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          MatVector whiteImages,
                                          int flags)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          GpuMat disparityMap)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          GpuMat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          UMatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          UMatVector whiteImages,
                                          int flags)

decode

@Cast(value="bool")
public boolean decode(@Const @ByRef
                                          MatVectorVector patternImages,
                                          @ByVal
                                          GpuMat disparityMap,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          GpuMatVector blackImages,
                                          @ByVal(nullValue="cv::InputArrayOfArrays(cv::noArray())")
                                          GpuMatVector whiteImages,
                                          int flags)