/*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 "_cxcore.h"

/****************************************************************************************\
*                                     MinMaxLoc                                          *
\****************************************************************************************/
                                                                    
#define CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, cn ) \
    temptype min_val, max_val;                  \
    int min_loc = 0, max_loc = 0;               \
    int x, loc = 0, width = size.width*(cn);    \
    step /= sizeof(src[0]);                     \
                                                \
    min_val = src[0];                           \
    min_val = max_val = _toggle_( min_val )


#define CV_MINMAXLOC_EXIT( _fin_cast_macro_ )   \
    minLoc->x = min_loc;                        \
    maxLoc->x = max_loc;                        \
    minLoc->y = maxLoc->y = 0;                  \
    *minVal = _fin_cast_macro_(min_val);        \
    *maxVal = _fin_cast_macro_(max_val);        \
    return CV_OK


#define ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, cn ) \
    for( x = 0; x < width; x += (cn), loc++ )   \
    {                                           \
        temptype val = src[x];                  \
        val = _toggle_(val);                    \
                                                \
        if( val < min_val )                     \
        {                                       \
            min_val = val;                      \
            min_loc = loc;                      \
        }                                       \
        else if( val > max_val )                \
        {                                       \
            max_val = val;                      \
            max_loc = loc;                      \
        }                                       \
    }


#define ICV_DEF_MINMAXLOC_FUNC_2D( _toggle_, _fin_cast_macro_, flavor,      \
                                   srctype, temptype, extrtype )            \
IPCVAPI_IMPL( CvStatus,                                                     \
icvMinMaxIndx_##flavor##_C1R,( const srctype* src, int step, CvSize size,   \
    extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ), \
    (src, step, size, minVal, maxVal, minLoc, maxLoc) )                     \
{                                                                           \
    CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, 1 );                   \
                                                                            \
    for( ; size.height--; src += step )                                     \
    {                                                                       \
        ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, 1 );             \
    }                                                                       \
                                                                            \
    CV_MINMAXLOC_EXIT( _fin_cast_macro_ );                                  \
}


#define ICV_DEF_MINMAXLOC_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor,  \
                                       srctype, temptype, extrtype )        \
static CvStatus CV_STDCALL                                                  \
icvMinMaxIndx_##flavor##_CnCR( const srctype* src, int step,                \
                          CvSize size, int cn, int coi,                     \
                          extrtype* minVal, extrtype* maxVal,               \
                          CvPoint* minLoc, CvPoint* maxLoc )                \
{                                                                           \
    (src) += coi - 1;                                                       \
    CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, cn );                  \
                                                                            \
    for( ; size.height--; src += step )                                     \
    {                                                                       \
        ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, cn );            \
    }                                                                       \
                                                                            \
    CV_MINMAXLOC_EXIT( _fin_cast_macro_ );                                  \
}


#define ICV_DEF_MINMAXLOC_ALL_INT( flavor, srctype,             \
                                   _fin_cast_macro_, extrtype ) \
    ICV_DEF_MINMAXLOC_FUNC_2D( CV_NOP, _fin_cast_macro_, flavor,\
                               srctype, int, extrtype )         \
    ICV_DEF_MINMAXLOC_FUNC_2D_COI( CV_NOP, _fin_cast_macro_,    \
                            flavor, srctype, int, extrtype )

CV_INLINE float minmax_to_float( int val )
{
    Cv32suf v;
    v.i = CV_TOGGLE_FLT(val);
    return v.f;
}

CV_INLINE double minmax_to_double( int64 val )
{
    Cv64suf v;
    v.i = CV_TOGGLE_DBL(val);
    return v.f;
}

#define ICV_DEF_MINMAXLOC_ALL_FLT( flavor, srctype, _toggle_,           \
                                   _fin_cast_macro_, extrtype )         \
                                                                        \
    ICV_DEF_MINMAXLOC_FUNC_2D( _toggle_, _fin_cast_macro_, flavor,      \
                                srctype, srctype, extrtype )            \
    ICV_DEF_MINMAXLOC_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor,  \
                                srctype, srctype, extrtype )

ICV_DEF_MINMAXLOC_ALL_INT( 8u, uchar, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_ALL_INT( 16u, ushort, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_ALL_INT( 16s, short, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_ALL_INT( 32s, int, CV_CAST_64F, double )
ICV_DEF_MINMAXLOC_ALL_FLT( 32f, int, CV_TOGGLE_FLT, minmax_to_float, float )
ICV_DEF_MINMAXLOC_ALL_FLT( 64f, int64, CV_TOGGLE_DBL, minmax_to_double, double )


/****************************************************************************************\
*                              MinMaxLoc with mask                                       *
\****************************************************************************************/

#define CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, cn )  \
    temptype min_val = 0, max_val = 0;                              \
    int min_loc = -1, max_loc = -1;                                 \
    int x = 0, y, loc = 0, width = size.width;                      \
    step /= sizeof(src[0]);                                         \
                                                                    \
    if( width*(cn) == step && width == maskStep )                   \
    {                                                               \
        width *= size.height;                                       \
        size.height = 1;                                            \
    }                                                               \
                                                                    \
    for( y = 0; y < size.height; y++, src += step,                  \
                                      mask += maskStep )            \
    {                                                               \
        for( x = 0; x < width; x++, loc++ )                         \
            if( mask[x] != 0 )                                      \
            {                                                       \
                min_loc = max_loc = loc;                            \
                min_val = (src)[x*(cn)];                            \
                min_val = max_val = _toggle_( min_val );            \
                goto stop_scan;                                     \
            }                                                       \
    }                                                               \
                                                                    \
    stop_scan:;


#define ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, cn ) \
    for( ; x < width; x++, loc++ )      \
    {                                   \
        temptype val = src[x*(cn)];     \
        int m = mask[x] != 0;           \
        val = _toggle_(val);            \
                                        \
        if( val < min_val && m )        \
        {                               \
            min_val = val;              \
            min_loc = loc;              \
        }                               \
        else if( val > max_val && m )   \
        {                               \
            max_val = val;              \
            max_loc = loc;              \
        }                               \
    }


#define ICV_DEF_MINMAXLOC_MASK_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \
                                        srctype, temptype, extrtype )       \
IPCVAPI_IMPL( CvStatus,                                                     \
icvMinMaxIndx_##flavor##_C1MR,( const srctype* src, int step,               \
    const uchar* mask, int maskStep, CvSize size,                           \
    extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ), \
    ( src, step, mask, maskStep, size, minVal, maxVal, minLoc, maxLoc) )    \
{                                                                           \
    CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, 1 );              \
                                                                            \
    for( ; y < size.height; y++, src += step, mask += maskStep )            \
    {                                                                       \
        ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, 1 )         \
        x = 0;                                                              \
    }                                                                       \
                                                                            \
    CV_MINMAXLOC_EXIT( _fin_cast_macro_ );                                  \
}


#define ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _toggle_, _fin_cast_macro_,     \
                                    flavor, srctype, temptype, extrtype )   \
static CvStatus CV_STDCALL                                                  \
icvMinMaxIndx_##flavor##_CnCMR( const srctype* src, int step,               \
    const uchar* mask, int maskStep, CvSize size, int cn, int coi,          \
    extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc )  \
{                                                                           \
    (src) += coi - 1;                                                       \
    CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, cn );             \
                                                                            \
    for( ; y < size.height; y++, src += step, mask += maskStep )            \
    {                                                                       \
        ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, cn )        \
        x = 0;                                                              \
    }                                                                       \
                                                                            \
    CV_MINMAXLOC_EXIT( _fin_cast_macro_ );                                  \
}


#define ICV_DEF_MINMAXLOC_MASK_ALL_INT( flavor, srctype,                    \
                                        _fin_cast_macro_, extrtype )        \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D( CV_NOP, _fin_cast_macro_, flavor,       \
                                    srctype, int, extrtype )                \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( CV_NOP, _fin_cast_macro_, flavor,   \
                                    srctype, int, extrtype )

#define ICV_DEF_MINMAXLOC_MASK_ALL_FLT( flavor, srctype, _toggle_,          \
                                        _fin_cast_macro_, extrtype )        \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D( _toggle_, _fin_cast_macro_, flavor,     \
                                    srctype, srctype, extrtype )            \
    ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor, \
                                    srctype, srctype, extrtype )

ICV_DEF_MINMAXLOC_MASK_ALL_INT( 8u, uchar, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_MASK_ALL_INT( 16u, ushort, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_MASK_ALL_INT( 16s, short, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_MASK_ALL_INT( 32s, int, CV_CAST_64F, double )
ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 32f, int, CV_TOGGLE_FLT, minmax_to_float, float )
ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 64f, int64, CV_TOGGLE_DBL, minmax_to_double, double )

#define icvMinMaxIndx_8s_C1R    0
#define icvMinMaxIndx_8s_CnCR   0
#define icvMinMaxIndx_8s_C1MR   0
#define icvMinMaxIndx_8s_CnCMR  0

CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1R )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCR )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1MR )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCMR )


CV_IMPL  void
cvMinMaxLoc( const void* img, double* _minVal, double* _maxVal,
             CvPoint* _minLoc, CvPoint* _maxLoc, const void* mask )
{
    static CvFuncTable minmax_tab, minmaxcoi_tab;
    static CvFuncTable minmaxmask_tab, minmaxmaskcoi_tab;
    static int inittab = 0;

    CV_FUNCNAME("cvMinMaxLoc");

    __BEGIN__;

    int type, depth, cn, coi = 0;
    int mat_step, mask_step = 0, cont_flag;
    CvSize size;
    CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask;
    CvPoint minloc, maxloc;
    double minv = 0, maxv = 0;
    float minvf = 0.f, maxvf = 0.f;
    void *pmin = &minvf, *pmax = &maxvf;

    if( !inittab )
    {
        icvInitMinMaxIndxC1RTable( &minmax_tab );
        icvInitMinMaxIndxCnCRTable( &minmaxcoi_tab );
        icvInitMinMaxIndxC1MRTable( &minmaxmask_tab );
        icvInitMinMaxIndxCnCMRTable( &minmaxmaskcoi_tab );
        inittab = 1;
    }
    
    if( !CV_IS_MAT(mat) )
        CV_CALL( mat = cvGetMat( mat, &stub, &coi ));

    type = CV_MAT_TYPE( mat->type );
    depth = CV_MAT_DEPTH( type );
    cn = CV_MAT_CN( type );
    size = cvGetMatSize( mat );

    if( cn > 1 && coi == 0 )
        CV_ERROR( CV_StsBadArg, "" );

    if( depth == CV_32S || depth == CV_64F )
        pmin = &minv, pmax = &maxv;
    
    mat_step = mat->step;
    cont_flag = mat->type;

    if( mask )
    {
        CV_CALL( matmask = cvGetMat( matmask, &maskstub ));

        if( !CV_IS_MASK_ARR( matmask ))
            CV_ERROR( CV_StsBadMask, "" );

        if( !CV_ARE_SIZES_EQ( mat, matmask ))
            CV_ERROR( CV_StsUnmatchedSizes, "" );

        mask_step = matmask->step;
        cont_flag &= matmask->type;
    }

    if( CV_IS_MAT_CONT(cont_flag) )
    {
        size.width *= size.height;
        size.height = 1;
    }

    if( size.height == 1 )
        mat_step = mask_step = CV_STUB_STEP;

    if( !mask )
    {
        if( CV_MAT_CN(type) == 1 || coi == 0 )
        {
            CvFunc2D_1A4P func = (CvFunc2D_1A4P)(minmax_tab.fn_2d[depth]);

            if( !func )
                CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );

            IPPI_CALL( func( mat->data.ptr, mat_step, size,
                             pmin, pmax, &minloc, &maxloc ));
        }
        else
        {
            CvFunc2DnC_1A4P func = (CvFunc2DnC_1A4P)(minmaxcoi_tab.fn_2d[depth]);

            if( !func )
                CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );

            IPPI_CALL( func( mat->data.ptr, mat_step, size, cn, coi,
                             pmin, pmax, &minloc, &maxloc ));
        }
    }
    else
    {
        if( CV_MAT_CN(type) == 1 || coi == 0 )
        {
            CvFunc2D_2A4P func = (CvFunc2D_2A4P)(minmaxmask_tab.fn_2d[depth]);

            if( !func )
                CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );

            IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr,
                             mask_step, size,
                             pmin, pmax, &minloc, &maxloc ));
        }
        else
        {
            CvFunc2DnC_2A4P func = (CvFunc2DnC_2A4P)(minmaxmaskcoi_tab.fn_2d[depth]);

            if( !func )
                CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );

            IPPI_CALL( func( mat->data.ptr, mat_step,
                             matmask->data.ptr, mask_step, size, cn, coi,
                             pmin, pmax, &minloc, &maxloc ));
        }
    }

    if( matmask || _minLoc || _maxLoc )
    {
        if( minloc.x >= mat->cols )
        {
            minloc.y = minloc.x / mat->cols;
            minloc.x -= minloc.y * mat->cols;
        }

        if( maxloc.x >= mat->cols )
        {
            maxloc.y = maxloc.x / mat->cols;
            maxloc.x -= maxloc.y * mat->cols;
        }

        if( matmask && ((unsigned)minloc.x >= (unsigned)mat->cols ||
            (unsigned)minloc.y >= (unsigned)mat->rows ||
            matmask->data.ptr[minloc.y*matmask->step + minloc.x] == 0 ||
            (unsigned)maxloc.x >= (unsigned)mat->cols ||
            (unsigned)maxloc.y >= (unsigned)mat->rows ||
            matmask->data.ptr[maxloc.y*matmask->step + maxloc.x] == 0) )
        {
            minloc.x = minloc.y = maxloc.x = maxloc.y = -1;
            minv = maxv = minvf = maxvf = 0;
        }

        if( _minLoc )
            *_minLoc = minloc;

        if( _maxLoc )
            *_maxLoc = maxloc;
    }

    if( depth != CV_32S && depth != CV_64F )
    {
        minv = minvf;
        maxv = maxvf;
    }

    if( _minVal )
        *_minVal = minv;

    if( _maxVal )
        *_maxVal = maxv;

    __END__;
}

/*  End of file  */