Merge pull request #2254 from alalek:text_remove_nfa_code

    finds the branches corresponding to text groups by traversing this dendrogram with a stopping rule

    that combines the output of a rotation invariant text group classifier and a probabilistic measure

    for hierarchical clustering validity assessment.

    @note This mode is not supported due NFA code removal ( https://github.com/opencv/opencv_contrib/issues/2235 )

     */

    ERGROUPING_ORIENTATION_ANY

};

    #endif

#endif

#if defined(_MSC_VER)

#   pragma warning(disable:4702)  // unreachable code

#endif

namespace cv

{

namespace text

/* -------------------------------- ER Grouping Algorithm -----------------------------*/

/* ------------------------------------------------------------------------------------*/

/*  NFA approximation functions */

// ln(10)

#ifndef M_LN10

#define M_LN10     2.30258509299404568401799145468436421

#endif

// Doubles relative error factor

#define RELATIVE_ERROR_FACTOR 100.0

// Compare doubles by relative error.

static int double_equal(double a, double b)

{

    double abs_diff,aa,bb,abs_max;

    /* trivial case */

    if( a == b ) return true;

    abs_diff = fabs(a-b);

    aa = fabs(a);

    bb = fabs(b);

    abs_max = aa > bb ? aa : bb;

    /* DBL_MIN is the smallest normalized number, thus, the smallest

       number whose relative error is bounded by DBL_EPSILON. For

       smaller numbers, the same quantization steps as for DBL_MIN

       are used. Then, for smaller numbers, a meaningful "relative"

       error should be computed by dividing the difference by DBL_MIN. */

    if( abs_max < DBL_MIN ) abs_max = DBL_MIN;

    /* equal if relative error <= factor x eps */

    return (abs_diff / abs_max) <= (RELATIVE_ERROR_FACTOR * DBL_EPSILON);

}

/*

     Computes the natural logarithm of the absolute value of

     the gamma function of x using the Lanczos approximation.

     See http://www.rskey.org/gamma.htm

*/

static double log_gamma_lanczos(double x)

{

    static double q[7] = { 75122.6331530, 80916.6278952, 36308.2951477,

                           8687.24529705, 1168.92649479, 83.8676043424,

                           2.50662827511 };

    double a = (x+0.5) * log(x+5.5) - (x+5.5);

    double b = 0.0;

    int n;

    for(n=0;n<7;n++)

    {

        a -= log( x + (double) n );

        b += q[n] * pow( x, (double) n );

    }

    return a + log(b);

}

/*

     Computes the natural logarithm of the absolute value of

     the gamma function of x using Windschitl method.

     See http://www.rskey.org/gamma.htm

*/

static double log_gamma_windschitl(double x)

{

    return 0.918938533204673 + (x-0.5)*log(x) - x

           + 0.5*x*log( x*sinh(1/x) + 1/(810.0*pow(x,6.0)) );

}

/*

     Computes the natural logarithm of the absolute value of

     the gamma function of x. When x>15 use log_gamma_windschitl(),

     otherwise use log_gamma_lanczos().

*/

#define log_gamma(x) ((x)>15.0?log_gamma_windschitl(x):log_gamma_lanczos(x))

// Size of the table to store already computed inverse values.

#define TABSIZE 100000

/*

     Computes -log10(NFA).

     NFA stands for Number of False Alarms:

*/

static double NFA(int n, int k, double p, double logNT)

{

    static double inv[TABSIZE];   /* table to keep computed inverse values */

    double tolerance = 0.1;       /* an error of 10% in the result is accepted */

    double log1term,term,bin_term,mult_term,bin_tail,err,p_term;

    int i;

    if (p<=0)

        p = std::numeric_limits<double>::min();

    if (p>=1)

        p = 1 - std::numeric_limits<double>::epsilon();

    /* check parameters */

    if( n<0 || k<0 || k>n || p<=0.0 || p>=1.0 )

    {

        CV_Error(Error::StsBadArg, "erGrouping wrong n, k or p values in NFA call!");

    }

    /* trivial cases */

    if( n==0 || k==0 ) return -logNT;

    if( n==k ) return -logNT - (double) n * log10(p);

    /* probability term */

    p_term = p / (1.0-p);

    /* compute the first term of the series */

    log1term = log_gamma( (double) n + 1.0 ) - log_gamma( (double) k + 1.0 )

               - log_gamma( (double) (n-k) + 1.0 )

               + (double) k * log(p) + (double) (n-k) * log(1.0-p);

    term = exp(log1term);

    /* in some cases no more computations are needed */

    if( double_equal(term,0.0) )              /* the first term is almost zero */

    {

        if( (double) k > (double) n * p )     /* at begin or end of the tail?  */

            return -log1term / M_LN10 - logNT;  /* end: use just the first term  */

        else

            return -logNT;                      /* begin: the tail is roughly 1  */

    }

    /* compute more terms if needed */

    bin_tail = term;

    for(i=k+1;i<=n;i++)

    {

        bin_term = (double) (n-i+1) * ( i<TABSIZE ?

                    ( inv[i]!=0.0 ? inv[i] : ( inv[i] = 1.0 / (double) i ) ) :

                    1.0 / (double) i );

        mult_term = bin_term * p_term;

        term *= mult_term;

        bin_tail += term;

        if(bin_term<1.0)

        {

            err = term * ( ( 1.0 - pow( mult_term, (double) (n-i+1) ) ) /

                           (1.0-mult_term) - 1.0 );

            if( err < tolerance * fabs(-log10(bin_tail)-logNT) * bin_tail ) break;

        }

    }

    return -log10(bin_tail) - logNT;

}

// Minibox : smallest enclosing box of a set of n points in d dimensions

class Minibox {

int MaxMeaningfulClustering::nfa(float sigma, int k, int N)

{

    // use an approximation for the nfa calculations (faster)

    return -1*(int)NFA( N, k, (double) sigma, 0);

    CV_UNUSED(sigma); CV_UNUSED(k); CV_UNUSED(N);

    CV_Error(Error::StsNotImplemented, "text: NFA computation code has been removed due license conflict. Details: https://github.com/opencv/opencv_contrib/issues/2235");

}

    std::string imageName = GET_PARAM(0);

    bool anyDirection = GET_PARAM(1);

    if (anyDirection)

        throw SkipTestException("ERGROUPING_ORIENTATION_ANY mode is not supported");

    std::cout << "Image: " << imageName << std::endl;

    std::cout << "Orientation: " << (anyDirection ? "any" : "horiz") << std::endl;

    Mat src = cv::imread(findDataFile(imageName));