structuredLightAndPhaseUnwrapping.puml

@startuml 

namespace cv::structured_light{
cv::algorithm <|-- StructuredLightPattern: heritance
StructuredLightPattern <|-- SinusoidalPattern: heritance
SinusoidalPattern <|-- SinusoidalPatternProfilometry_Impl: heritance
SinusoidalPatternProfilometry_Impl *-- Marker

class StructuredLightPattern {

  ..generate..  

  +virtual bool generate( OutputArrayOfArrays patternImages )

  ..decode..

  +virtual bool decode( InputArrayOfArrays patternImages, InputArrayOfArrays blackImages = noArray(), InputArrayOfArrays whiteImages = noArray(),  OutputArray disparityMap, int flags );
}

class SinusoidalPattern{

+struct Params 
     int width 
     int height
     int nbrOfPeriods
     float shiftValue
     int methodId
     int nbrOfPixelsBetweenMarkers
     bool horizontal
     bool setMarkers
     

+static Ptr<SinusoidalPattern> create( const SinusoidalPattern::Params &parameters = SinusoidalPattern::Params() );

+virtual void computePhaseMap( InputArrayOfArrays patternImages, OutputArray wrappedCamPhaseMap );

+virtual void unwrapPhaseMap( InputArray wrappedCamPhaseMap, OutputArray unwrappedCamPhaseMap );

+virtual void findProCamMatches( InputArray unwrappedProjPhaseMap, InputArray unwrappedCamPhaseMap,  OutputArrayOfArrays matches );

}

class Marker{
    -Point center, up, right, left, down
    
    +Marker();
    +Marker( Point c );
    +void drawMarker( InputOutputArray pattern );
}

class SinusoidalPatternProfilometry_Impl{  

    Params params;

    +SinusoidalPatternProfilometry_Impl::SinusoidalPatternProfilometry_Impl( const SinusoidalPattern::Params &parameters );

    +virtual ~SinusoidalPatternProfilometry_Impl::SinusoidalPatternProfilometry_Impl();

    +void computePhaseMap( InputArrayOfArrays patternImages, OutputArray wrappedCamPhaseMap );

    +void unwrapPhaseMap( InputArray wrappedCamPhaseMap, OutputArray unwrappedCamPhaseMap );

    +void findProCamMatches( InputArray unwrappedProjPhaseMap, InputArray unwrappedCamPhaseMap,  OutputArrayOfArrays matches );

    -void computeDft( InputArray patternImage, OutputArray FourierTransform );
    
    -void computeInverseDft(InputArray FourierTransform, OutputArray inverseFourierTransform, bool realOutput );

    -void computeDftMagnitude(InputArray FourierTransform, OutputArray FourierTransformMagnitude);

    -void computeFtPhaseMap( InputArray inverseFourierTransform, OutputArray wrappedPhaseMap );

    -void swapQuadrants( InputArray image, int centerX, int centerY);

    -void frequencyFiltering( InputOutputArray FourierTransform, int centerX1, int centerY1, int halfRegionWidth, int halfRegionHeight, bool keepInsideRegion, int centerX2 = -1, int centerY2 = -1 ); 

    -bool findMaxInHalvesTransform( InputArray FourierTransformMag, Point &maxPos1, Point &maxPos2 );

    -void computePsPhaseMap( InputArrayOfArrays patternImages, OutputArray wrappedPhaseMap );

    -void computeShadowMask( InputArrayOfArrays patternImages, OutputArray shadowMask );

    -void computeDataModulationTerm( InputArrayOfArrays patternImages, OutputArray dataModulationTerm );

}
}
namespace cv::phase_unwrapping{
cv::algorithm <|-- PhaseUnwrapping : heritance 
PhaseUnwrapping <|-- HistogramPhaseUnwrapping : heritance
HistogramPhaseUnwrapping <|-- HistogramPhaseUnwrapping_Impl: heritance
HistogramPhaseUnwrapping_Impl *-- Pixel
HistogramPhaseUnwrapping_Impl *-- Edge
HistogramPhaseUnwrapping_Impl *-- HistogramBin
HistogramPhaseUnwrapping_Impl *-- Histogram
class PhaseUnwrapping{
    
    +virtual void unwrapPhaseMap( InputOutputArray wrappedPhaseMap, InputOutputArray unwrappedPhaseMap )

}

class HistogramPhaseUnwrapping{

    +struct Params
        int width
        int height
        float histThresh
        int nbrOfSmallBins
        int nbrOfLargeBins

    +static Ptr<HistogramPhaseUnwrapping> create( const HistogramPhaseUnwrapping::Params &parameters );

    +virtual void getInverseReliabilityMap( OutputArray inverseReliabilityMap );
    
}   

class HistogramPhaseUnwrapping_Impl{

    -vector<Pixel> pixels

    -Histogram histogram

    +HistogramPhaseUnwrapping_Impl::HistogramPhaseUnwrapping_Impl();

    +virtual ~HistogramPhaseUnwrapping_Impl();

    +void unwrapPhaseMap( InputOutputArray wrappedPhaseMap, InputOutputArray unwrappedPhaseMap, Histogram hist );

    -void computePixelsReliability( InputArray wrappedPhaseMap, InputArray shadowMask = noArray() );

    -void computeEdgesReliabilityAndCreateHistogram();

    -void createAndSortEdge( int idx1, int idx2 );

    -void unwrapHistogram();

    -float wrap( float a, float b );

    -int findWrap( float a, float b );

    
}

class Pixel{

    -float phaseValue
    -int idx
    -bool valid
    -float inverseReliability
    -int increment

    +Pixel::Pixel();
    
    +Pixel::Pixel( float pV, int id, bool v, float iR, int inc );

    +float getPhaseValue();
    
    +int getIndex();

    +bool getValidity();

    +float getInverseReliability();

}

class Edge{
    
    -int pix1;
    -int pix2;
    -float inverseReliability;

    +Edge::Edge();

    +Edge::Edge( int p1, int p2, float iR, int inc );

}

class HistogramBin{

    -float start
    -float end
    -int nbrOfEdges
    -std::vector<Edge> edges

    +HistogramBin::HistogramBin()
    
    +HistogramBin::HistogramBin( float s, float e, int nbr );
    
    +void addEdge( Edge e );

}

class Histogram{

    -std::vector<HistogramBin> bins;
    -float thresh;
    -float smallWidth;
    -float largeWidth;
    -float nbrOfSmallBins;
    -float nbrOfLargeBins;

    +Histogram::Histogram();
    
    +void createBins( float t, int nbrOfBinsBeforeThresh, int nbrOfBinsAfterThresh );

    +void addBin( HistogramBin b );

    +void addEdgeInBin( Edge e, int binIndex );

    +float getThresh();
    
    +float getSmallWidth();

    +float getLargeWidth();
}

}
@enduml