/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#include <cv.h>

/****************************************************************************************\
*                               1D HMM  experimental                                     *
\****************************************************************************************/

typedef CvImgObsInfo Cv1DObsInfo;


OPENCVAPI CvStatus  icvCreate1DHMM( CvEHMM** this_hmm,
                                   int state_number, int* num_mix, int obs_size );

OPENCVAPI CvStatus  icvRelease1DHMM( CvEHMM** phmm );

OPENCVAPI CvStatus  icvUniform1DSegm( Cv1DObsInfo* obs_info, CvEHMM* hmm );

OPENCVAPI CvStatus  icvInit1DMixSegm( Cv1DObsInfo** obs_info_array, int num_img, CvEHMM* hmm);

OPENCVAPI CvStatus  icvEstimate1DHMMStateParams( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm);

OPENCVAPI CvStatus  icvEstimate1DObsProb( CvImgObsInfo* obs_info, CvEHMM* hmm );

OPENCVAPI CvStatus  icvEstimate1DTransProb( Cv1DObsInfo** obs_info_array,
                                           int num_seq,
                                           CvEHMM* hmm );

OPENCVAPI float  icvViterbi( Cv1DObsInfo* obs_info, CvEHMM* hmm);

OPENCVAPI CvStatus  icv1DMixSegmL2( CvImgObsInfo** obs_info_array, int num_img, CvEHMM* hmm );

OPENCVAPI void  icvDrawMosaic( CvSubdiv2D* subdiv, IplImage* src, IplImage* dst );

OPENCVAPI int   icvSubdiv2DCheck( CvSubdiv2D* subdiv );

OPENCVAPI CvSubdiv2DPoint* icvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f pt );

CV_INLINE  CvSubdiv2D* icvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage )
{
    CvSubdiv2D* subdiv = cvCreateSubdiv2D( CV_SEQ_KIND_SUBDIV2D, sizeof(*subdiv),
                         sizeof(CvSubdiv2DPoint), sizeof(CvQuadEdge2D), storage );

    cvInitSubdivDelaunay2D( subdiv, rect );

    return subdiv;
}


CV_INLINE double icvSqDist2D32f( CvPoint2D32f pt1, CvPoint2D32f pt2 )
{
    double dx = pt1.x - pt2.x;
    double dy = pt1.y - pt2.y;

    return dx*dx + dy*dy;
}

typedef struct CvSeqTreeIterator
{
    CvSeq* seq;
    int level;
    int maxLevel;
}
CvSeqTreeIterator;

OPENCVAPI void icvInitSeqTreeIterator( CvSeqTreeIterator* seqIterator, CvSeq* first, int maxLevel );
OPENCVAPI CvSeq* icvNextSeq( CvSeqTreeIterator* seqIterator );
OPENCVAPI CvSeq* icvPrevSeq( CvSeqTreeIterator* seqIterator );

// Bilateral filter
///////////////////////////////////////////////////////////
OPENCVAPI void cvBilateralFiltering(IplImage* in, IplImage* out, int thresh_space, int thresh_color);

///////////////////////////////////////////////////////////
// Triangulation
OPENCVAPI void cvDecompPoly( CvContour* cont, CvSubdiv2D** subdiv, CvMemStorage* storage );
///////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////
// Gradient runs
typedef struct _CvGrRun
{
    int       x1,x2;
    int       z1,z2;    
}CvGrRun;
typedef struct _CvGrRunSt
{
    int       count;
    CvGrRun*  runs;
}CvGrRunSt;

OPENCVAPI  CvGrRunSt* cvAllocateGrRuns( int stringcount, int runcount );

OPENCVAPI  void cvReleaseGrRuns( CvGrRunSt* strings, int stringcount );

OPENCVAPI  void cvCreateSimpleGradientRuns( IplImage*  src,                          
                                 CvGrRunSt* hRuns, 
                                 CvGrRunSt* vRuns );

OPENCVAPI  void cvCreateGradientRunsWithApprox( IplImage*  src,                          
                                     double     intThresh, 
                                     double     cosThresh, 
                                     CvGrRunSt* hRuns, 
                                     CvGrRunSt* vRuns );

OPENCVAPI  void  cvGrRunsApprox( CvGrRunSt* grRuns, 
                       int        stcount,
                       double     thresh,
                       double     cos_thresh );

OPENCVAPI  CvSeq* cvGetSegmentsFromGradientRuns( CvGrRunSt*     hRuns, 
                                      CvGrRunSt*     vRuns,
                                      int            imgH,
                                      int            imgW,
                                      double         thresh,                               
                                      CvMemStorage*  storage,
                                      IplImage*      tmp );
// end gradient runs block
///////////////////////////////////////////////////////////



/* End of file. */