org.bytedeco.opencv.opencv_structured_light

Class SinusoidalPattern

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.opencv.opencv_core.Algorithm

org.bytedeco.opencv.opencv_structured_light.StructuredLightPattern

org.bytedeco.opencv.opencv_structured_light.SinusoidalPattern

All Implemented Interfaces:

AutoCloseable

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

\brief Class implementing Fourier transform profilometry (FTP) , phase-shifting profilometry (PSP) and Fourier-assisted phase-shifting profilometry (FAPS) based on \cite faps.

This class generates sinusoidal patterns that can be used with FTP, PSP and FAPS.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SinusoidalPattern.Params \brief Parameters of SinusoidalPattern constructor

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
SinusoidalPattern(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
void	computeDataModulationTerm(GpuMatVector patternImages, GpuMat dataModulationTerm, GpuMat shadowMask)
void	computeDataModulationTerm(GpuMatVector patternImages, Mat dataModulationTerm, Mat shadowMask)
void	computeDataModulationTerm(GpuMatVector patternImages, UMat dataModulationTerm, UMat shadowMask)
void	computeDataModulationTerm(MatVector patternImages, GpuMat dataModulationTerm, GpuMat shadowMask)
void	computeDataModulationTerm(MatVector patternImages, Mat dataModulationTerm, Mat shadowMask) \brief compute the data modulation term.
void	computeDataModulationTerm(MatVector patternImages, UMat dataModulationTerm, UMat shadowMask)
void	computeDataModulationTerm(UMatVector patternImages, GpuMat dataModulationTerm, GpuMat shadowMask)
void	computeDataModulationTerm(UMatVector patternImages, Mat dataModulationTerm, Mat shadowMask)
void	computeDataModulationTerm(UMatVector patternImages, UMat dataModulationTerm, UMat shadowMask)
void	computePhaseMap(GpuMatVector patternImages, GpuMat wrappedPhaseMap)
void	computePhaseMap(GpuMatVector patternImages, GpuMat wrappedPhaseMap, GpuMat shadowMask, GpuMat fundamental)
void	computePhaseMap(GpuMatVector patternImages, Mat wrappedPhaseMap)
void	computePhaseMap(GpuMatVector patternImages, Mat wrappedPhaseMap, Mat shadowMask, Mat fundamental)
void	computePhaseMap(GpuMatVector patternImages, UMat wrappedPhaseMap)
void	computePhaseMap(GpuMatVector patternImages, UMat wrappedPhaseMap, UMat shadowMask, UMat fundamental)
void	computePhaseMap(MatVector patternImages, GpuMat wrappedPhaseMap)
void	computePhaseMap(MatVector patternImages, GpuMat wrappedPhaseMap, GpuMat shadowMask, GpuMat fundamental)
void	computePhaseMap(MatVector patternImages, Mat wrappedPhaseMap)
void	computePhaseMap(MatVector patternImages, Mat wrappedPhaseMap, Mat shadowMask, Mat fundamental) \brief Compute a wrapped phase map from sinusoidal patterns.
void	computePhaseMap(MatVector patternImages, UMat wrappedPhaseMap)
void	computePhaseMap(MatVector patternImages, UMat wrappedPhaseMap, UMat shadowMask, UMat fundamental)
void	computePhaseMap(UMatVector patternImages, GpuMat wrappedPhaseMap)
void	computePhaseMap(UMatVector patternImages, GpuMat wrappedPhaseMap, GpuMat shadowMask, GpuMat fundamental)
void	computePhaseMap(UMatVector patternImages, Mat wrappedPhaseMap)
void	computePhaseMap(UMatVector patternImages, Mat wrappedPhaseMap, Mat shadowMask, Mat fundamental)
void	computePhaseMap(UMatVector patternImages, UMat wrappedPhaseMap)
void	computePhaseMap(UMatVector patternImages, UMat wrappedPhaseMap, UMat shadowMask, UMat fundamental)
static SinusoidalPattern	create()
static SinusoidalPattern	create(SinusoidalPattern.Params parameters) \brief Constructor.
void	findProCamMatches(GpuMat projUnwrappedPhaseMap, GpuMat camUnwrappedPhaseMap, GpuMatVector matches)
void	findProCamMatches(GpuMat projUnwrappedPhaseMap, GpuMat camUnwrappedPhaseMap, MatVector matches)
void	findProCamMatches(GpuMat projUnwrappedPhaseMap, GpuMat camUnwrappedPhaseMap, UMatVector matches)
void	findProCamMatches(Mat projUnwrappedPhaseMap, Mat camUnwrappedPhaseMap, GpuMatVector matches)
void	findProCamMatches(Mat projUnwrappedPhaseMap, Mat camUnwrappedPhaseMap, MatVector matches) \brief Find correspondences between the two devices thanks to unwrapped phase maps.
void	findProCamMatches(Mat projUnwrappedPhaseMap, Mat camUnwrappedPhaseMap, UMatVector matches)
void	findProCamMatches(UMat projUnwrappedPhaseMap, UMat camUnwrappedPhaseMap, GpuMatVector matches)
void	findProCamMatches(UMat projUnwrappedPhaseMap, UMat camUnwrappedPhaseMap, MatVector matches)
void	findProCamMatches(UMat projUnwrappedPhaseMap, UMat camUnwrappedPhaseMap, UMatVector matches)
void	unwrapPhaseMap(GpuMat wrappedPhaseMap, GpuMat unwrappedPhaseMap, Size camSize)
void	unwrapPhaseMap(GpuMat wrappedPhaseMap, GpuMat unwrappedPhaseMap, Size camSize, GpuMat shadowMask)
void	unwrapPhaseMap(Mat wrappedPhaseMap, Mat unwrappedPhaseMap, Size camSize)
void	unwrapPhaseMap(Mat wrappedPhaseMap, Mat unwrappedPhaseMap, Size camSize, Mat shadowMask) \brief Unwrap the wrapped phase map to remove phase ambiguities.
void	unwrapPhaseMap(UMat wrappedPhaseMap, UMat unwrappedPhaseMap, Size camSize)
void	unwrapPhaseMap(UMat wrappedPhaseMap, UMat unwrappedPhaseMap, Size camSize, UMat shadowMask)

Methods inherited from class org.bytedeco.opencv.opencv_structured_light.StructuredLightPattern

decode, decode, decode, decode, decode, decode, decode, decode, decode, decode, decode, decode, generate, generate, generate

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

SinusoidalPattern

public SinusoidalPattern(Pointer p)

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

Method Detail

create

@opencv_core.Ptr
public static SinusoidalPattern create(@opencv_core.Ptr
                                                        SinusoidalPattern.Params parameters)

\brief Constructor.

Parameters:

parameters - SinusoidalPattern parameters SinusoidalPattern::Params: width, height of the projector and patterns parameters.

create

@opencv_core.Ptr
public static SinusoidalPattern create()

computePhaseMap

public void computePhaseMap(@ByVal
                            MatVector patternImages,
                            @ByVal
                            Mat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            Mat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            Mat fundamental)

\brief Compute a wrapped phase map from sinusoidal patterns.

Parameters:

patternImages - Input data to compute the wrapped phase map.

wrappedPhaseMap - Wrapped phase map obtained through one of the three methods.

shadowMask - Mask used to discard shadow regions.

fundamental - Fundamental matrix used to compute epipolar lines and ease the matching step.

computePhaseMap

public void computePhaseMap(@ByVal
                            MatVector patternImages,
                            @ByVal
                            Mat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            UMatVector patternImages,
                            @ByVal
                            Mat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            Mat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            Mat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            UMatVector patternImages,
                            @ByVal
                            Mat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            GpuMatVector patternImages,
                            @ByVal
                            Mat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            Mat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            Mat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            GpuMatVector patternImages,
                            @ByVal
                            Mat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            MatVector patternImages,
                            @ByVal
                            UMat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            UMat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            UMat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            MatVector patternImages,
                            @ByVal
                            UMat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            UMatVector patternImages,
                            @ByVal
                            UMat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            UMat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            UMat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            UMatVector patternImages,
                            @ByVal
                            UMat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            GpuMatVector patternImages,
                            @ByVal
                            UMat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            UMat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            UMat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            GpuMatVector patternImages,
                            @ByVal
                            UMat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            MatVector patternImages,
                            @ByVal
                            GpuMat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            GpuMat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            GpuMat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            MatVector patternImages,
                            @ByVal
                            GpuMat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            UMatVector patternImages,
                            @ByVal
                            GpuMat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            GpuMat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            GpuMat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            UMatVector patternImages,
                            @ByVal
                            GpuMat wrappedPhaseMap)

computePhaseMap

public void computePhaseMap(@ByVal
                            GpuMatVector patternImages,
                            @ByVal
                            GpuMat wrappedPhaseMap,
                            @ByVal(nullValue="cv::OutputArray(cv::noArray())")
                            GpuMat shadowMask,
                            @ByVal(nullValue="cv::InputArray(cv::noArray())")
                            GpuMat fundamental)

computePhaseMap

public void computePhaseMap(@ByVal
                            GpuMatVector patternImages,
                            @ByVal
                            GpuMat wrappedPhaseMap)

unwrapPhaseMap

public void unwrapPhaseMap(@ByVal
                           Mat wrappedPhaseMap,
                           @ByVal
                           Mat unwrappedPhaseMap,
                           @ByVal
                           Size camSize,
                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                           Mat shadowMask)

\brief Unwrap the wrapped phase map to remove phase ambiguities.

Parameters:

wrappedPhaseMap - The wrapped phase map computed from the pattern.

unwrappedPhaseMap - The unwrapped phase map used to find correspondences between the two devices.

camSize - Resolution of the camera.

shadowMask - Mask used to discard shadow regions.

unwrapPhaseMap

public void unwrapPhaseMap(@ByVal
                           Mat wrappedPhaseMap,
                           @ByVal
                           Mat unwrappedPhaseMap,
                           @ByVal
                           Size camSize)

unwrapPhaseMap

public void unwrapPhaseMap(@ByVal
                           UMat wrappedPhaseMap,
                           @ByVal
                           UMat unwrappedPhaseMap,
                           @ByVal
                           Size camSize,
                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                           UMat shadowMask)

unwrapPhaseMap

public void unwrapPhaseMap(@ByVal
                           UMat wrappedPhaseMap,
                           @ByVal
                           UMat unwrappedPhaseMap,
                           @ByVal
                           Size camSize)

unwrapPhaseMap

public void unwrapPhaseMap(@ByVal
                           GpuMat wrappedPhaseMap,
                           @ByVal
                           GpuMat unwrappedPhaseMap,
                           @ByVal
                           Size camSize,
                           @ByVal(nullValue="cv::InputArray(cv::noArray())")
                           GpuMat shadowMask)

unwrapPhaseMap

public void unwrapPhaseMap(@ByVal
                           GpuMat wrappedPhaseMap,
                           @ByVal
                           GpuMat unwrappedPhaseMap,
                           @ByVal
                           Size camSize)

findProCamMatches

public void findProCamMatches(@ByVal
                              Mat projUnwrappedPhaseMap,
                              @ByVal
                              Mat camUnwrappedPhaseMap,
                              @ByVal
                              MatVector matches)

\brief Find correspondences between the two devices thanks to unwrapped phase maps.

Parameters:

projUnwrappedPhaseMap - Projector's unwrapped phase map.

camUnwrappedPhaseMap - Camera's unwrapped phase map.

matches - Images used to display correspondences map.

findProCamMatches

public void findProCamMatches(@ByVal
                              Mat projUnwrappedPhaseMap,
                              @ByVal
                              Mat camUnwrappedPhaseMap,
                              @ByVal
                              UMatVector matches)

findProCamMatches

public void findProCamMatches(@ByVal
                              Mat projUnwrappedPhaseMap,
                              @ByVal
                              Mat camUnwrappedPhaseMap,
                              @ByVal
                              GpuMatVector matches)

findProCamMatches

public void findProCamMatches(@ByVal
                              UMat projUnwrappedPhaseMap,
                              @ByVal
                              UMat camUnwrappedPhaseMap,
                              @ByVal
                              MatVector matches)

findProCamMatches

public void findProCamMatches(@ByVal
                              UMat projUnwrappedPhaseMap,
                              @ByVal
                              UMat camUnwrappedPhaseMap,
                              @ByVal
                              UMatVector matches)

findProCamMatches

public void findProCamMatches(@ByVal
                              UMat projUnwrappedPhaseMap,
                              @ByVal
                              UMat camUnwrappedPhaseMap,
                              @ByVal
                              GpuMatVector matches)

findProCamMatches

public void findProCamMatches(@ByVal
                              GpuMat projUnwrappedPhaseMap,
                              @ByVal
                              GpuMat camUnwrappedPhaseMap,
                              @ByVal
                              MatVector matches)

findProCamMatches

public void findProCamMatches(@ByVal
                              GpuMat projUnwrappedPhaseMap,
                              @ByVal
                              GpuMat camUnwrappedPhaseMap,
                              @ByVal
                              UMatVector matches)

findProCamMatches

public void findProCamMatches(@ByVal
                              GpuMat projUnwrappedPhaseMap,
                              @ByVal
                              GpuMat camUnwrappedPhaseMap,
                              @ByVal
                              GpuMatVector matches)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      MatVector patternImages,
                                      @ByVal
                                      Mat dataModulationTerm,
                                      @ByVal
                                      Mat shadowMask)

\brief compute the data modulation term.

Parameters:

patternImages - captured images with projected patterns.

dataModulationTerm - Mat where the data modulation term is saved.

shadowMask - Mask used to discard shadow regions.

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      UMatVector patternImages,
                                      @ByVal
                                      Mat dataModulationTerm,
                                      @ByVal
                                      Mat shadowMask)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      GpuMatVector patternImages,
                                      @ByVal
                                      Mat dataModulationTerm,
                                      @ByVal
                                      Mat shadowMask)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      MatVector patternImages,
                                      @ByVal
                                      UMat dataModulationTerm,
                                      @ByVal
                                      UMat shadowMask)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      UMatVector patternImages,
                                      @ByVal
                                      UMat dataModulationTerm,
                                      @ByVal
                                      UMat shadowMask)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      GpuMatVector patternImages,
                                      @ByVal
                                      UMat dataModulationTerm,
                                      @ByVal
                                      UMat shadowMask)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      MatVector patternImages,
                                      @ByVal
                                      GpuMat dataModulationTerm,
                                      @ByVal
                                      GpuMat shadowMask)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      UMatVector patternImages,
                                      @ByVal
                                      GpuMat dataModulationTerm,
                                      @ByVal
                                      GpuMat shadowMask)

computeDataModulationTerm

public void computeDataModulationTerm(@ByVal
                                      GpuMatVector patternImages,
                                      @ByVal
                                      GpuMat dataModulationTerm,
                                      @ByVal
                                      GpuMat shadowMask)