Datasets:

---

Alignment-Lab-AI

/

Open-Web-Math

Like 6

ERROR: type should be string, got "https://doi.org/10.5201/ipol.2016.175\nTip revision: 94b07aa\nsmooth_contours.c\n/*----------------------------------------------------------------------------\n\nSmooth Contours: an unsupervised method for detecting smooth contours\nin digital images. This code is part of the following publication and\nwas subject to peer review:\n\n\"Unsupervised Smooth Contour Detection\"\nby Rafael Grompone von Gioi and Gregory Randall,\nImage Processing On Line, 2016.\nhttp://dx.doi.org/10.5201/ipol.2016.175\n\nCopyright (c) 2016 rafael grompone von gioi <grompone@gmail.com>,\nGregory Randall <randall@fing.edu.uy>\n\nSmooth Contours is free software: you can redistribute it and/or modify\nit under the terms of the GNU Affero General Public License as\n\nThis program is distributed in the hope that it will be useful,\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\nGNU Affero General Public License for more details.\n\nYou should have received a copy of the GNU Affero General Public License\nalong with this program. If not, see <http://www.gnu.org/licenses/>.\n\n----------------------------------------------------------------------------*/\n#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n#include <float.h>\n\n/*----------------------------------------------------------------------------*/\n#ifndef FALSE\n#define FALSE 0\n#endif /* !FALSE */\n\n#ifndef TRUE\n#define TRUE 1\n#endif /* !TRUE */\n\n/*----------------------------------------------------------------------------*/\n/* PI */\n#ifndef M_PI\n#define M_PI 3.14159265358979323846\n#endif /* !M_PI */\n\n/*----------------------------------------------------------------------------*/\n#define MIN(a,b) ( (a)<(b) ? (a) : (b) )\n\n/*----------------------------------------------------------------------------*/\n/* structure to store an element of the lateral regions of pixels to an arc\noperator. for each pixel it stores its value, the lateral distance to the\narc defining the operator, and to which of the two lateral regions belongs\n*/\nstruct region\n{\ndouble val; /* pixel value */\ndouble w; /* absolute value of the lateral distance to the arc */\nint reg; /* number of the lateral region to which it belongs: 1 or 2 */\n};\n\n/*----------------------------------------------------------------------------*/\n/* structure to store a parameterization of an arc of circle\n*/\nstruct arc_of_circle\n{\nint is_line_segment;\ndouble a,b,c; /* a*x+b*y+c = 0 -> line through the arc endpoints */\ndouble d; /* b*x-a*y+d = 0 -> orthogonal to previous through midpoint */\ndouble len; /* arc length */\ndouble xc,yc,radius; /* center and radius of circle containing the arc */\ndouble ang_ref,ang_span;\nint dir;\nint bbx0,bby0,bbx1,bby1; /* bounding box */\n};\n\n/*----------------------------------------------------------------------------*/\n/* fatal error, print a message to standard error and exit\n*/\nstatic void error(char * msg)\n{\nfprintf(stderr,\"error: %s\\n\",msg);\nexit(EXIT_FAILURE);\n}\n\n/*----------------------------------------------------------------------------*/\n/* memory allocation, print an error and exit if fail\n*/\nstatic void * xmalloc(size_t size)\n{\nvoid * p;\nif( size == 0 ) error(\"xmalloc: zero size\");\np = malloc(size);\nif( p == NULL ) error(\"xmalloc: out of memory\");\nreturn p;\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute a > b considering the rounding errors due to the representation\nof double numbers\n*/\nstatic int greater(double a, double b)\n{\nif( a <= b ) return FALSE; /* trivial case, return as soon as possible */\n\nif( (a-b) < 1000 * DBL_EPSILON ) return FALSE;\n\nreturn TRUE; /* greater */\n}\n\n/*----------------------------------------------------------------------------*/\n/* Euclidean distance between x1,y1 and x2,y2\n*/\nstatic double dist(double x1, double y1, double x2, double y2)\n{\nreturn sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) );\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute the error function erf using Winitzki's approximation.\n\nthe formula is given in\n\n\"A handy approximation for the error function and its inverse\"\nby Sergei Winitzki, February 6, 2008,\n\nthe error function is defined as\n\nerf(x) = 2/sqrt(pi) \\int_0^x e^{-t^2} dt\n\nand the approximation is\n\nerf(x) ~ (1 - exp(-x^2 * (4/pi + axˆ2) / (1 + ax^2) ) )^1/2\n\nwith\n\na = 8/3pi * (pi - 3) / (4 - pi)\n*/\nstatic double erf_winitzki(double x)\n{\nstatic double a = 8.0 / 3.0 / M_PI * (M_PI - 3.0) / (4.0 - M_PI);\nif( x < 0.0 ) return -erf_winitzki(-x);\nreturn sqrt( 1.0 - exp(-x*x * (4.0/M_PI + a*x*x) / (1.0 + a*x*x)) );\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute a Gaussian kernel of length n, standard deviation sigma,\nand centered at value mean.\n\nfor example, if mean=0.5, the Gaussian will be centered in the middle point\nbetween values kernel[0] and kernel[1].\n\nkernel must be allocated to a size n.\n*/\nstatic void gaussian_kernel(double * kernel, int n, double sigma, double mean)\n{\ndouble sum = 0.0;\ndouble val;\nint i;\n\n/* check input */\nif( kernel == NULL ) error(\"gaussian_kernel: kernel not allocated\");\nif( sigma <= 0.0 ) error(\"gaussian_kernel: sigma must be positive\");\n\n/* compute Gaussian kernel */\nfor(i=0; i<n; i++)\n{\nval = ( (double) i - mean ) / sigma;\nkernel[i] = exp( -0.5 * val * val );\nsum += kernel[i];\n}\n\n/* normalization */\nif( sum > 0.0 ) for(i=0; i<n; i++) kernel[i] /= sum;\n}\n\n/*----------------------------------------------------------------------------*/\n/* filter an image with a Gaussian kernel of parameter sigma. return a pointer\nto a newly allocated filtered image, of the same size as the input image.\n*/\nstatic double * gaussian_filter(double * image, int X, int Y, double sigma)\n{\nint x,y,offset,i,j,nx2,ny2,n;\ndouble * kernel;\ndouble * tmp;\ndouble * out;\ndouble val,prec;\n\n/* check input */\nif( sigma <= 0.0 ) error(\"gaussian_filter: sigma must be positive\");\nif( image == NULL || X < 1 || Y < 1 ) error(\"gaussian_filter: invalid image\");\n\n/* get memory */\ntmp = (double *) xmalloc( X * Y * sizeof(double) );\nout = (double *) xmalloc( X * Y * sizeof(double) );\n\n/* compute gaussian kernel */\n/*\nThe size of the kernel is selected to guarantee that the first discarded\nterm is at least 10^prec times smaller than the central value. For that,\nthe half size of the kernel must be larger than x, with\ne^(-x^2/2sigma^2) = 1/10^prec\nThen,\nx = sigma * sqrt( 2 * prec * ln(10) )\n*/\nprec = 3.0;\noffset = (int) ceil( sigma * sqrt( 2.0 * prec * log(10.0) ) );\nn = 1 + 2 * offset; /* kernel size */\nkernel = (double *) xmalloc( n * sizeof(double) );\ngaussian_kernel(kernel, n, sigma, (double) offset);\n\n/* auxiliary variables for the double of the image size */\nnx2 = 2*X;\nny2 = 2*Y;\n\n/* x axis convolution */\nfor(x=0; x<X; x++)\nfor(y=0; y<Y; y++)\n{\nval = 0.0;\nfor(i=0; i<n; i++)\n{\nj = x - offset + i;\n\n/* symmetry boundary condition */\nwhile(j<0) j += nx2;\nwhile(j>=nx2) j -= nx2;\nif( j >= X ) j = nx2-1-j;\n\nval += image[j+y*X] * kernel[i];\n}\ntmp[x+y*X] = val;\n}\n\n/* y axis convolution */\nfor(x=0; x<X; x++)\nfor(y=0; y<Y; y++)\n{\nval = 0.0;\nfor(i=0; i<n; i++)\n{\nj = y - offset + i;\n\n/* symmetry boundary condition */\nwhile(j<0) j += ny2;\nwhile(j>=ny2) j -= ny2;\nif( j >= Y ) j = ny2-1-j;\n\nval += tmp[x+j*X] * kernel[i];\n}\nout[x+y*X] = val;\n}\n\n/* free memory */\nfree( (void *) kernel );\nfree( (void *) tmp );\n\nreturn out;\n}\n\n/*----------------------------------------------------------------------------*/\n/* non oriented angle difference, returns a value in [0,pi]\n*/\nstatic double diff_0_pi(double a, double b)\n{\na -= b;\nwhile( a <= -M_PI ) a += 2.0 * M_PI;\nwhile( a > M_PI ) a -= 2.0 * M_PI;\nif( a < 0.0 ) a = -a;\nreturn a;\n}\n\n/*----------------------------------------------------------------------------*/\n/* return a score for chaining pixels 'from' to 'to', favoring closet point:\n= 0.0 invalid chaining\n> 0.0 valid forward chaining; the larger the value, the better the chaining\n< 0.0 valid backward chaining; the smaller the value, the better the chaining\n\ninput:\nfrom, to the two pixel IDs to evaluate their potential chaining\nEx[i], Ey[i] the sub-pixel position of point i, if i is an edge point;\nthey take values -1,-1 if i is not an edge point\nGx[i], Gy[i] the image gradient at pixel i\nX, Y the size of the image\n*/\nstatic double chain( int from, int to, double * Ex, double * Ey,\ndouble * Gx, double * Gy, int X, int Y )\n{\ndouble dx,dy;\n\n/* check input */\nif( Ex == NULL || Ey == NULL || Gx == NULL || Gy == NULL )\nerror(\"chain: invalid input\");\nif( from < 0 || to < 0 || from >= X*Y || to >= X*Y )\nerror(\"chain: one of the points is out the image\");\n\n/* check that the points are different and valid edge points,\notherwise return invalid chaining */\nif( from == to ) return 0.0; /* same pixel */\nif( Ex[from] < 0.0 || Ey[from] < 0.0 || Ex[to] < 0.0 || Ey[to] < 0.0 )\nreturn 0.0; /* one of them is not an edge point */\n\n/* in a good chaining, the gradient should be roughly orthogonal\nto the line joining the two points to be chained:\n\nGx,Gy\n| ------> dx,dy\n| thus\nfrom x-------x to ---> Gy,-Gx (orthogonal to the gradient)\n\nwhen Gy * dx - Gx * dy > 0, it corresponds to a forward chaining,\nwhen Gy * dx - Gx * dy < 0, it corresponds to a backward chaining.\n(this choice is arbitrary)\n\nfirst check that the gradient at both points to be chained agree\nin one direction, otherwise return invalid chaining.\n*/\ndx = Ex[to] - Ex[from];\ndy = Ey[to] - Ey[from];\nif( (Gy[from] * dx - Gx[from] * dy) * (Gy[to] * dx - Gx[to] * dy) <= 0.0 )\nreturn 0.0;\n\n/* return the chaining score: positive for forward chaining,\nnegative for backwards. the score is the inverse of the distance\nto the chaining point, to give preference to closer points */\nif( (Gy[from] * dx - Gx[from] * dy) >= 0.0 )\nreturn 1.0 / dist(Ex[from],Ey[from],Ex[to],Ey[to]); /* forward chaining */\nelse\nreturn -1.0 / dist(Ex[from],Ey[from],Ex[to],Ey[to]); /* backward chaining */\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute the image gradient, giving its x and y components as well as the\nmodulus. Gx, Gy, and modG must be already allocated.\n*/\nstatic void compute_gradient( double * Gx, double * Gy, double * modG,\ndouble * image, int X, int Y )\n{\nint x,y;\n\n/* check input */\nif( Gx == NULL || Gy == NULL || modG == NULL || image == NULL )\n\n/* approximate image gradient using centered differences */\nfor(x=1; x<(X-1); x++)\nfor(y=1; y<(Y-1); y++)\n{\nGx[x+y*X] = image[(x+1)+y*X] - image[(x-1)+y*X];\nGy[x+y*X] = image[x+(y+1)*X] - image[x+(y-1)*X];\nmodG[x+y*X] = sqrt( Gx[x+y*X] * Gx[x+y*X] + Gy[x+y*X] * Gy[x+y*X] );\n}\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute sub-pixel edge points using adapted Canny and Devernay methods.\n\ninput: Gx, Gy, and modG are the x and y components and modulus of the image\ngradient, respectively. X,Y is the image size.\n\noutput: Ex and Ey will have the x and y sub-pixel coordinates of the edge\npoints found, or -1 and -1 when not an edge point. Ex and Ey must be\n\na modified Canny non maximal suppression [1] is used to select edge points,\nand a modified Devernay sub-pixel correction [2] is used to improve the\nposition accuracy. in both cases, the modification boils down to using only\nvertical or horizontal non maximal suppression and sub-pixel correction.\nno threshold is used on the gradient.\n\n[1] J.F. Canny, \"A computational approach to edge detection\",\nIEEE Transactions on Pattern Analysis and Machine Intelligence,\nvol.8, no.6, pp.679-698, 1986.\n\n[2] F. Devernay, \"A Non-Maxima Suppression Method for Edge Detection\nwith Sub-Pixel Accuracy\", Rapport de recherche 2724, INRIA, Nov. 1995.\n\nthe reason for this modification is that Devernay correction is inconsistent\nfor some configurations at 45, 225, -45 or -225 degree. in edges that should\ngo exactly in the middle of a pixels like (5 pixels drawn):\n\n___\n|\n___|\n|\n___|\n|\n___|\n|\n___|\n\nthe correction terms of both sides of the perfect edge are not compatible,\nleading to edge points with \"oscillations\" like:\n\n.\n.\n\n.\n.\n\n.\n.\n\nbut the Devernay correction works very well and is very consistent when used\nto interpolate only along horizontal or vertical direction. this modified\nversion requires that a pixel, to be an edge point, must be a local maximum\nhorizontally or vertically, depending on the gradient orientation: if the\nx component of the gradient is larger than the y component, Gx > Gy, this\nmeans that the gradient is roughly horizontal and a horizontal maximum is\nrequired to be an edge point.\n\nwhen the pixel is both, a horizontal and vertical maximum, the direction\nwith largest contrast is used for the interpolation. this usually leads to\na more accurate estimation of the position.\n\nusing only horizontal or vertical interpolation may lead occasionally to\nsome missing edge points for edges at 45, 225, -45 or -225 degree. these\ndoes not happen very often and seems to be an acceptable price to pay for\nremoving the \"oscillations\" in slanted edges. moreover, as it is very rare\nto have two consecutive missing points, using a chaining strategy that looks\nslightly farther away for neighbors, the chains of edge points are recovered\nwell enough. this is done in the function chain_edge_points() below.\n*/\nstatic void compute_edge_points( double * Ex, double * Ey, double * modG,\ndouble * Gx, double * Gy, int X, int Y )\n{\nint x,y,i;\n\n/* check input */\nif( Ex == NULL || Ey == NULL || modG == NULL || Gx == NULL || Gy == NULL )\nerror(\"compute_edge_points: invalid input\");\n\n/* initialize Ex and Ey as non edge points for all pixels */\nfor(i=0; i<X*Y; i++) Ex[i] = Ey[i] = -1.0;\n\n/* explore pixels inside a 2 pixel margin (so modG[x,y +/- 1,1] is defined) */\nfor(x=2; x<(X-2); x++)\nfor(y=2; y<(Y-2); y++)\n{\nint Dx = 0; /* interpolation will be along Dx,Dy, */\nint Dy = 0; /* which will be selected below */\ndouble mod = modG[x+y*X]; /* modG at pixel */\ndouble L = modG[x-1+y*X]; /* modG at pixel on the left */\ndouble R = modG[x+1+y*X]; /* modG at pixel on the right */\ndouble U = modG[x+(y+1)*X]; /* modG at pixel up */\ndouble D = modG[x+(y-1)*X]; /* modG at pixel below */\ndouble gx = fabs( Gx[x+y*X] ); /* absolute value of Gx */\ndouble gy = fabs( Gy[x+y*X] ); /* absolute value of Gy */\n\n/* local horizontal and/or vertical maxima of the gradient modulus */\n/* it can happen that two neighbor pixels have equal value and are both\nmaxima, for example when the edge is exactly between both pixels. in\nsuch cases, as an arbitrary convention, the edge is marked on the\nleft one when an horizontal max or below when a vertical max. for\nthis the conditions are L < mod >= R and D < mod >= U,\nrespectively. the comparisons are done using the function greater()\ninstead of the operators > or >= so numbers differing only due to\nrounding errors are considered equal */\nint lHm = greater(mod,L) && !greater(R,mod); /* local horizontal max */\nint lVm = greater(mod,D) && !greater(U,mod); /* local vertical max */\n\n/* if both horizontal and vertical max, interpolate along direction of\nmax contrast; otherwise, requires max along approx gradient dir */\nif( lHm && lVm && MIN(L,R) < MIN(U,D) ) Dx = 1; /* both */\nelse if( lHm && lVm ) Dy = 1; /* both but more contrast in vert. */\nelse if( lHm && gx >= gy ) Dx = 1; /* only horizontal maximum */\nelse if( lVm && gx <= gy ) Dy = 1; /* only vertical maximum */\n\n/* Devernay sub-pixel correction [2]\n\nthe edge point position is selected as the one of the maximum of a\nunidimensional direction. the pixel must be a local maximum. so we\nhave the values:\n. b\na . |\nx = -1, |Gx| = a | | . c\nx = 0, |Gx| = b | | |\nx = 1, |Gx| = c ------------------> x\n-1 0 1\n\nthe x position of the maximum of the parabola passing through\n(-1,a), (0,b), and (1,c) is\n\noffset = (a - c) / 2(a - 2b + c)\n\nand because b >= a and b >= c, -0.5 <= offset <= 0.5\n*/\nif( Dx > 0 || Dy > 0 )\n{\n/* offset value is in [-0.5, 0.5] */\ndouble a = modG[ x-Dx + (y-Dy) * X ];\ndouble b = modG[ x + y * X ];\ndouble c = modG[ x+Dx + (y+Dy) * X ];\ndouble offset = 0.5 * (a - c) / (a - b - b + c);\n\n/* store edge point */\nEx[x+y*X] = x + offset * Dx;\nEy[x+y*X] = y + offset * Dy;\n}\n}\n}\n\n/*----------------------------------------------------------------------------*/\n/* chain edge points\n\ninput: Ex and Ey are the sub-pixel coordinates when an edge point is present\nor -1,-1 otherwise. Gx, Gy and modG are the x and y components and the\nmodulus of the image gradient, respectively. X,Y is the image size.\n\noutput: next and prev will contain the number of next and previous edge\npoints in the chain. when not chained on one of the directions, the\ncorresponding value is set to -1. next and prev must be allocated\nbefore calling.\n*/\nstatic void chain_edge_points( int * next, int * prev, double * Ex, double * Ey,\ndouble * Gx, double * Gy, int X, int Y )\n{\nint x,y,i,j,alt;\n\n/* check input */\nif( next==NULL || prev==NULL || Ex==NULL || Ey==NULL || Gx==NULL || Gy==NULL )\nerror(\"chain_edge_points: invalid input\");\n\n/* initialize next and prev as non linked */\nfor(i=0; i<X*Y; i++) next[i] = prev[i] = -1;\n\n/* try each point to make local chains */\nfor(x=2; x<(X-2); x++) /* 2 pixel margin so the tested neighbors in image */\nfor(y=2; y<(Y-2); y++)\nif( Ex[x+y*X] >= 0.0 && Ey[x+y*X] >= 0.0 ) /* must be an edge point */\n{\nint from = x+y*X; /* edge point to be chained */\ndouble fwd_s = 0.0; /* score of best forward chaining */\ndouble bck_s = 0.0; /* score of best backward chaining */\nint fwd = -1; /* edge point of best forward chaining */\nint bck = -1; /* edge point of best backward chaining */\n\n/* try all neighbors two pixels apart or less.\n\nthe detection of edge points occasionally fails to detect some\nedge points at 45, 225, -45 or -225 degree. as explained before,\nthis is small price to pay for getting accurate detections.\n\nlooking for candidates for chaining two pixels apart, in most\nsuch cases, is enough to obtain good chains of edge points that\naccurately describes the edge.\n*/\nfor(i=-2; i<=2; i++)\nfor(j=-2; j<=2; j++)\n{\nint to = x+i + (y+j)*X; /* candidate edge point to be chained */\ndouble s = chain(from,to,Ex,Ey,Gx,Gy,X,Y); /* score from-to */\n\nif( s > fwd_s ) /* a better forward chaining found */\n{\nfwd_s = s; /* set the new best forward chaining */\nfwd = to;\n}\nif( s < bck_s ) /* a better backward chaining found */\n{\nbck_s = s; /* set the new best backward chaining */\nbck = to;\n}\n}\n\n/* before making the new chain, check whether the target was\nalready chained and in that case, whether the alternative\nchaining is better than the proposed one.\n\nx alt x alt\n\\ /\n\\ /\nfrom x---------x fwd bck x---------x from\n\nwe know that the best forward chain starting at from is from-fwd.\nbut it is possible that there is an alternative chaining arriving\nat fwd that is better, such that alt-fwd is to be preferred to\nfrom-fwd. an analogous situation is possible in backward chaining,\nwhere an alternative link bck-alt may be better than bck-from.\n\nand in such case compare the scores of the proposed chaining to\nthe existing one, and keep only the best of the two.\n\nthere is an undesirable aspect of this procedure: the result may\ndepend on the order of exploration. consider the following\nconfiguration:\n\na x-------x b\n/\n/\nc x---x d with score(a-b) < score(c-b) < score(c-d)\n\nlet us consider two possible orders of exploration.\n\norder: a,b,c\nwe will first chain a-b when exploring a. when analyzing the\nbackward links of b, we will prefer c-b, and a-b will be unlinked.\nfinally, when exploring c, c-d will be preferred and c-b will be\nunlinked. the result is just c-d.\n\norder: c,b,a\nwe will first chain c-d when exploring c. then, when exploring\nthe backward connections of b, c-b will be the preferred link;\nbut because c-d was already done and has a better score, c-b\nbe created because there is no better backward linking of b.\nthe result is c-d and a-b.\n\nwe did not found yet a simple algorithm to solve this problem. by\nsimple, we mean an algorithm without two passes or the need to\nre-evaluate the chaining of points where one link is cut.\n\nfor most edge points, there is only one possible chaining and this\nproblem does not arise. but it does happen and a better solution\nis desirable.\n*/\nif( fwd >= 0 && next[from] != fwd &&\n((alt=prev[fwd]) < 0 || chain(alt,fwd,Ex,Ey,Gx,Gy,X,Y) < fwd_s) )\n{\nif( next[from] >= 0 ) /* remove previous from-x link if one */\nprev[next[from]] = -1; /* only prev requires explicit reset */\nnext[from] = fwd; /* set next of from-fwd link */\nif( alt >= 0 ) /* remove alt-fwd link if one */\nnext[alt] = -1; /* only next requires explicit reset */\nprev[fwd] = from; /* set prev of from-fwd link */\n}\nif( bck >= 0 && prev[from] != bck &&\n((alt=next[bck]) < 0 || chain(alt,bck,Ex,Ey,Gx,Gy,X,Y) > bck_s ) )\n{\nif( alt >= 0 ) /* remove bck-alt link if one */\nprev[alt] = -1; /* only prev requires explicit reset */\nnext[bck] = from; /* set next of bck-from link */\nif( prev[from] >= 0 ) /* remove previous x-from link if one */\nnext[prev[from]] = -1; /* only next requires explicit reset */\nprev[from] = bck; /* set prev of bck-from link */\n}\n}\n}\n\n/*----------------------------------------------------------------------------*/\n/* simplify a chain i-j-k-l-m into i-j-l-m when the latter is more regular\n\nnext and prev contain the number of next and previous edge points in the\nchain or -1 when not chained. Ex and Ey are the sub-pixel coordinates when\nan edge point is present or -1,-1 otherwise. Ex and Ey are the sub-pixel\ncoordinates when an edge point is present or -1,-1 otherwise.\n\nthis function modifies next and prev when simplifications are found.\n*/\nstatic void simplify_chains( int * next, int * prev, double * Ex, double * Ey,\nint X, int Y )\n{\nint i,j,k,l,m;\n\n/* check input */\nif( next == NULL || prev == NULL || Ex == NULL || Ey == NULL )\nerror(\"simplify_chains: invalid input\");\n\n/* look for chains of 5 consecutive chained edge points, i-j-k-l-m:\n\nx k\n/ \\\nx---x x---x\ni j l m\n\nwe will consider to link j directly to l, leaving k out of the chain.\nj-l is less than 2.\n\nthe latter is to avoid a general regularization of the chain. in normal\nlinking along edges, the mean distance between edge points is in the\ninterval from 1 (when horizontal or vertical) to sqrt(2) (45 degree).\nso, the mean distance between edge points at two chaining steps is\nin [2, 2*sqrt(2)]. restricting the simplifications to cases where the\ntwo step distance is less than 2, avoid regularizing normal chaining\nand concentrates on its objective of simplifying complex corners.\n\nto state the conditions to simplify the chain, let us define the following\nangles:\n\nA is angle(i-j,l-m) x---x x---x\ni j l m\n\nx\n/\nB is angle(i-j,j-k) x---x\ni j\n\nx k\n\\\nC is angle(k-l,l-m) x---x\nl m\n\nthe condition to simplify the chain is A < B and A < C\nor equivalently A < MIN(B,C).\n\nx k\n/ \\\nto sum up, a chain x---x x---x becomes x---x---x---x when the latter\ni j l m i j l m\n\nis more regular.\n*/\nfor(i=0; i<X*Y; i++) /* next[i]>=0 -> edge point, no explicit test needed */\nif( (j=next[i])>=0 && (k=next[j])>=0 && (l=next[k])>=0 && (m=next[l])>=0 &&\ndist(Ex[j],Ey[j],Ex[l],Ey[l]) < 2.0 )\n{\ndouble a = atan2( Ey[j] - Ey[i], Ex[j] - Ex[i] ); /* angle(i-j) */\ndouble b = atan2( Ey[k] - Ey[j], Ex[k] - Ex[j] ); /* angle(j-k) */\ndouble c = atan2( Ey[l] - Ey[k], Ex[l] - Ex[k] ); /* angle(k-l) */\ndouble d = atan2( Ey[m] - Ey[l], Ex[m] - Ex[l] ); /* angle(l-m) */\n\n/* if A < MIN(B,C) => simplify: link j-l, unlink j-k and k-l */\nif( diff_0_pi(a,d) < MIN( diff_0_pi(a,b), diff_0_pi(c,d) ) )\n{\nnext[j] = l;\nprev[l] = j;\nnext[k] = -1;\nprev[k] = -1;\n}\n}\n}\n\n/*----------------------------------------------------------------------------*/\n/* create a list of chained edge points composed of 3 lists\nx, y and curve_limits; it also computes N (the number of edge points) and\nM (the number of curves).\n\nx[i] and y[i] (0<=i<N) store the sub-pixel coordinates of the edge points.\ncurve_limits[j] (0<=j<=M) stores the limits of each chain in lists x and y.\n\nx, y, and curve_limits will be allocated.\n\nexample:\n\ncurve number k (0<=k<M) consists of the edge points x[i],y[i]\nfor i determined by curve_limits[k] <= i < curve_limits[k+1].\n\ncurve k is closed if x[curve_limits[k]] == x[curve_limits[k+1] - 1] and\ny[curve_limits[k]] == y[curve_limits[k+1] - 1].\n*/\nstatic void list_chained_edge_points( double ** x, double ** y, int * N,\nint ** curve_limits, int * M,\nint * next, int * prev,\ndouble * Ex, double * Ey, int X, int Y )\n{\nint i,k,n;\n\n/* initialize output: x, y, curve_limits, N, and M\n\nthere cannot be more than X*Y edge points to be put in the output list:\nedge points must be local maxima of gradient modulus, so at most half of\nthe pixels could be so. when a closed curve is found, one edge point will\nbe put twice to the output. even if all possible edge points (half of the\npixels in the image) would form one pixel closed curves (which is not\npossible) that would lead to output X*Y edge points.\n\nfor the same reason, there cannot be more than X*Y curves: the worst case\nis when all possible edge points (half of the pixels in the image) would\nform one pixel chains. in that case (which is not possible) one would need\na size for curve_limits of X*Y/2+1. so X*Y is enough.\n\n(curve_limits requires one more item than the number of curves.\na simplest example is when only one chain of length 3 is present:\ncurve_limits[0] = 0, curve_limits[1] = 3.)\n*/\n*x = (double *) xmalloc( X * Y * sizeof(double) );\n*y = (double *) xmalloc( X * Y * sizeof(double) );\n*curve_limits = (int *) xmalloc( X * Y * sizeof(int) );\n*N = 0;\n*M = 0;\n\n/* copy chained edge points to output */\nfor(i=0; i<X*Y; i++) /* prev[i]>=0 or next[i]>=0 implies edge point */\nif( prev[i] >= 0 || next[i] >= 0 )\n{\n/* a new chain found, set chain starting index to the current point\nand then increase the curve counter */\n(*curve_limits)[*M] = *N;\n++(*M);\n\n/* set k to the begining of the chain, or to i if closed curve */\nfor(k=i; (n=prev[k])>=0 && n!=i; k=n);\n\n/* follow the chain of edge points starting on k */\ndo\n{\n/* store the current point coordinates in the output lists */\n(*x)[*N] = Ex[k];\n(*y)[*N] = Ey[k];\n++(*N);\n\nn = next[k]; /* save the id of the next point in the chain */\n\nnext[k] = -1; /* unlink chains from k so it is not used again */\nprev[k] = -1;\n\n/* for closed curves, the initial point is included again as\nthe last point of the chain. actually, testing if the first\nand last points are equal is the only way to know that it is\na closed curve.\n\nto understand that this code actually repeats the first point,\nconsider a closed chain as follows: a--b\n| |\nd--c\n\nlet us say that the algorithm starts by point a. it will store\nthe coordinates of point a and then unlink a-b. then, will store\npoint b and unlink b-c, and so on. but the link d-a is still\nthere. (point a is no longer pointing backwards to d, because\nboth links are removed at each step. but d is indeed still\npointing to a.) so it will arrive at point a again and store its\ncoordinates again as last point. there, it cannot continue\nbecause the link a-b was removed, there would be no next point,\nk would be -1 and the curve is finished.\n*/\n\nk = n; /* set the current point to the next in the chain */\n}\nwhile( k >= 0 ); /* continue while there is a next point in the chain */\n}\n(*curve_limits)[*M] = *N; /* store end of the last chain */\n}\n\n/*----------------------------------------------------------------------------*/\n/* chained, sub-pixel edge detector. based on a modified Canny non-maximal\nsuppression and a modified Devernay sub-pixel correction.\n\nthe input image is assumed to be blurred as desired.\nx, y, and curve_limits will be allocated.\n\nthe output are the chained edge points given as 3 lists x, y and\ncurve_limits, as well as the number N of edge points, and the number M of\ncurves.\n\nx[i] and y[i] (0<=i<N) store the sub-pixel coordinates of the edge points.\ncurve_limits[j] (0<=j<=M) stores the limits of each chain in lists x and y.\n\nexample:\n\ncurve number k (0<=k<M) consists of the edge points x[i],y[i]\nfor i determined by curve_limits[k] <= i < curve_limits[k+1].\n\ncurve k is closed if x[curve_limits[k]] == x[curve_limits[k+1] - 1] and\ny[curve_limits[k]] == y[curve_limits[k+1] - 1].\n*/\nstatic void chained_subpixel_edge_points( double ** x, double ** y, int * N,\nint ** curve_limits, int * M,\ndouble * image, int X, int Y )\n{\ndouble * Gx = (double *) xmalloc( X * Y * sizeof(double) ); /* grad_x */\ndouble * Gy = (double *) xmalloc( X * Y * sizeof(double) ); /* grad_y */\ndouble * modG = (double *) xmalloc( X * Y * sizeof(double) ); /* |grad| */\ndouble * Ex = (double *) xmalloc( X * Y * sizeof(double) ); /* edge_x */\ndouble * Ey = (double *) xmalloc( X * Y * sizeof(double) ); /* edge_y */\nint * next = (int *) xmalloc( X * Y * sizeof(int) ); /* next point in chain */\nint * prev = (int *) xmalloc( X * Y * sizeof(int) ); /* prev point in chain */\n\ncompute_edge_points(Ex,Ey,modG,Gx,Gy,X,Y);\n\nchain_edge_points(next,prev,Ex,Ey,Gx,Gy,X,Y);\n\nsimplify_chains(next,prev,Ex,Ey,X,Y);\n\nlist_chained_edge_points(x,y,N,curve_limits,M,next,prev,Ex,Ey,X,Y);\n\n/* free memory */\nfree( (void *) Gx );\nfree( (void *) Gy );\nfree( (void *) modG );\nfree( (void *) Ex );\nfree( (void *) Ey );\nfree( (void *) next );\nfree( (void *) prev );\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute the center and radius of the circle through 3 non-aligned points\n\nthis function will set the values xc, yc, radius of the arc_of_circle\npointed by arc.\n*/\nstatic void circle_through( struct arc_of_circle * arc, double x1, double y1,\ndouble x2, double y2, double x3, double y3 )\n{\ndouble h,k,den,xxyy1,xxyy2,xxyy3;\n\n/* from http://mathforum.org/library/drmath/view/55239.html\n\nDate: 05/25/2000 at 10:45:58\nFrom: Doctor Rob\nSubject: Re: finding the coordinates of the center of a circle\n\nThanks for writing to Ask Dr. Math, Alison.\n\nLet (h,k) be the coordinates of the center of the circle, and r its\nradius. Then the equation of the circle is:\n\n(x-h)^2 + (y-k)^2 = r^2\n\nSince the three points all lie on the circle, their coordinates will\nsatisfy this equation. That gives you three equations:\n\n(x1-h)^2 + (y1-k)^2 = r^2\n(x2-h)^2 + (y2-k)^2 = r^2\n(x3-h)^2 + (y3-k)^2 = r^2\n\nin the three unknowns h, k, and r. To solve these, subtract the first\nfrom the other two. That will eliminate r, h^2, and k^2 from the last\ntwo equations, leaving you with two simultaneous linear equations in\nthe two unknowns h and k. Solve these, and you'll have the coordinates\n(h,k) of the center of the circle. Finally, set:\n\nr = sqrt[(x1-h)^2+(y1-k)^2]\n\nand you'll have everything you need to know about the circle.\n\nThis can all be done symbolically, of course, but you'll get some\npretty complicated expressions for h and k. The simplest forms of\nthese involve determinants, if you know what they are:\n\n|x1^2+y1^2 y1 1| |x1 x1^2+y1^2 1|\n|x2^2+y2^2 y2 1| |x2 x2^2+y2^2 1|\n|x3^2+y3^2 y3 1| |x3 x3^2+y3^2 1|\nh = ------------------, k = ------------------\n|x1 y1 1| |x1 y1 1|\n2*|x2 y2 1| 2*|x2 y2 1|\n|x3 y3 1| |x3 y3 1|\n*/\n\nden = x1*y2 + y1*x3 + x2*y3 - x3*y2 - x2*y1 - x1*y3; /* denominator */\nif( den == 0.0 ) error(\"the 3 points are aligned\");\n\nxxyy1 = x1*x1 + y1*y1;\nxxyy2 = x2*x2 + y2*y2;\nxxyy3 = x3*x3 + y3*y3;\n\nh = xxyy1*y2 + xxyy3*y1 + xxyy2*y3 - xxyy3*y2 - xxyy2*y1 - xxyy1*y3;\nh /= 2.0 * den;\n\nk = x1*xxyy2 + x3*xxyy1 + x2*xxyy3 - x3*xxyy2 - x2*xxyy1 - x1*xxyy3;\nk /= 2.0 * den;\n\narc->xc = h;\narc->yc = k;\n}\n\n/*----------------------------------------------------------------------------*/\n/* oriented difference of angles modulo 2pi\n*/\nstatic double diff_0_2pi(double a, double b)\n{\na -= b;\nwhile( a < 0.0 ) a += 2.0*M_PI;\nwhile( a > 2.0*M_PI ) a -= 2.0*M_PI;\nreturn a;\n}\n\n/*----------------------------------------------------------------------------*/\n/* initialize an arc structure from point i to point k in the list x[],y[] and\nwith width max_w. return TRUE if the arc is smooth up to precision sigma,\nFALSE otherwise\n*/\nstatic int smooth_segment( struct arc_of_circle * arc, double * x, double * y,\nint i, int k, double sigma, double max_w,\nint X, int Y )\n{\nint l;\nint j = i + (k-i) / 2; /* middle point */\ndouble ang_i,ang_j,ang_k;\n\n/* full circles are not handled as one arc by the validation step.\n\nthis is to avoid considering the special case of closed circles. in\npractice, the impact is minor, it only means that full circles will not be\nvalidated all together. but usually most of the partial arcs of the circle\nwill be validated, so the result would be a curve following the full\ncircle. the real risk is of losing small circles, which may have the limit\nsize where removing even one pixel leads to a reject.\n*/\nif( x[i]==x[k] && y[i]==y[k] ) return FALSE; /* exactly the same x,y values\nare repeated in closed curves,\nso in this case there is no\nrisk in using the operator ==\nto compare doubles */\n\n/* compute the parameters of the line through x[i],y[i] and x[k],y[k],\nthe orthogonal line to the previous, and len as a line segment */\narc->len = dist(x[i],y[i],x[k],y[k]); /* if arc will be re-computed later */\narc->a = -(y[k] - y[i]) / arc->len;\narc->b = (x[k] - x[i]) / arc->len;\narc->c = -arc->a*x[i] - arc->b*y[i];\narc->d = -arc->b*0.5*(x[i]+x[k]) + arc->a*0.5*(y[i]+y[k]);\n\n/* initialize bounding box */\narc->bbx0 = arc->bbx1 = (int) x[i];\narc->bby0 = arc->bby1 = (int) y[i];\n\n/* line segment or arc? decide evaluating the middle point */\nif( fabs( arc->a*x[j] + arc->b*y[j] + arc->c ) < sigma )\n{\n/* line segment */\narc->is_line_segment = TRUE;\n\n/* check that all points are not farther than sigma from the line */\nfor(l=i; l<=k; l++)\n{\n/* update bounding box */\nif( x[l] < (double) arc->bbx0 ) arc->bbx0 = (int) x[l];\nif( y[l] < (double) arc->bby0 ) arc->bby0 = (int) y[l];\nif( x[l] > (double) arc->bbx1 ) arc->bbx1 = (int) x[l];\nif( y[l] > (double) arc->bby1 ) arc->bby1 = (int) y[l];\n\nif( fabs(arc->a*x[l] + arc->b*y[l] + arc->c) > sigma )\nreturn FALSE; /* not smooth */\n}\n}\nelse\n{\n/* arc */\narc->is_line_segment = FALSE;\n\n/* compute circle center and radius */\ncircle_through(arc,x[i],y[i],x[j],y[j],x[k],y[k]);\n\n/* arc direction */\nang_i = atan2(y[i] - arc->yc, x[i] - arc->xc);\nang_j = atan2(y[j] - arc->yc, x[j] - arc->xc);\nang_k = atan2(y[k] - arc->yc, x[k] - arc->xc);\nif( diff_0_2pi(ang_j,ang_i) < diff_0_2pi(ang_k,ang_i) )\n{\narc->dir = 1; /* direction of turn of the arc */\narc->ang_span = diff_0_2pi(ang_k,ang_i); /* span */\narc->ang_ref = ang_i;\n}\nelse\n{\narc->dir = -1; /* direction of turn of the arc */\narc->ang_span = diff_0_2pi(ang_i,ang_k); /* span */\narc->ang_ref = ang_k;\n}\n\n/* compute arc length */\n\n/* check that all points are not farther than sigma from the arc */\nfor(l=i; l<=k; l++)\n{\n/* update bounding box */\nif( x[l] < (double) arc->bbx0 ) arc->bbx0 = (int) x[l];\nif( y[l] < (double) arc->bby0 ) arc->bby0 = (int) y[l];\nif( x[l] > (double) arc->bbx1 ) arc->bbx1 = (int) x[l];\nif( y[l] > (double) arc->bby1 ) arc->bby1 = (int) y[l];\n\nif( fabs(dist(x[l],y[l],arc->xc,arc->yc) - arc->radius) > sigma )\nreturn FALSE; /* not smooth */\n}\n}\n\n/* correct bounding box */\narc->bbx0 -= max_w; /* add the width of the max lateral regions */\narc->bby0 -= max_w;\narc->bbx1 += max_w + 1;\narc->bby1 += max_w + 1;\nif( arc->bbx0 < 0 ) arc->bbx0 = 0; /* keep the bounding box inside image */\nif( arc->bby0 < 0 ) arc->bby0 = 0;\nif( arc->bbx1 > X ) arc->bbx1 = X;\nif( arc->bby1 > Y ) arc->bby1 = Y;\n\nreturn TRUE; /* is smooth */\n}\n\n/*----------------------------------------------------------------------------*/\n/* get the lateral regions to an arc operator: the sub-case of a line segment\n\ninput: pointer to an image of size X,Y, a pointer to the arc operator,\nand the width of lateral region w.\n\noutput: the array pointed by reg will be filled with the elements of the\nregions. its size is returned in n.\n*/\nstatic void get_region_line( int * n, struct region * reg,\ndouble * image, int X, int Y,\nstruct arc_of_circle * arc, double w )\n{\nint x,y;\n\n/* check input */\nif( image==NULL || X<=0 || Y<=0 ) error(\"get_region_line: invalid image\");\nif( arc==NULL ) error(\"get_region_line: invalid arc\");\n\n/* count points */\n*n = 0;\nfor(x=arc->bbx0; x<arc->bbx1; x++)\nfor(y=arc->bby0; y<arc->bby1; y++)\n{\ndouble d_lat = arc->a*x + arc->b*y + arc->c;\ndouble d_lon = arc->b*x - arc->a*y + arc->d;\n\nif( fabs(d_lon) <= 0.5*arc->len && fabs(d_lat) <= w )\n{\nif( d_lat < 0.0 ) reg[*n].reg = 1;\nelse reg[*n].reg = 2;\n\nreg[*n].val = image[x+y*X];\nreg[*n].w = fabs(d_lat);\n(*n)++;\n}\n}\n}\n\n/*----------------------------------------------------------------------------*/\n/* get the lateral regions to an arc operator: the sub-case of an arc of circle\n\ninput: pointer to an image of size X,Y, a pointer to the arc operator,\nand the width of lateral region w.\n\noutput: the array pointed by reg will be filled with the elements of the\nregions. its size is returned in n.\n*/\nstatic void get_region_arc( int * n, struct region * reg,\ndouble * image, int X, int Y,\nstruct arc_of_circle * arc, double w )\n{\nint x,y;\n\n/* check input */\nif( image==NULL || X<=0 || Y<=0 ) error(\"get_region_arc: invalid image\");\nif( arc==NULL || arc->is_line_segment ) error(\"get_region_arc: invalid arc\");\n\n/* count points */\n*n = 0;\nfor(x=arc->bbx0; x<arc->bbx1; x++)\nfor(y=arc->bby0; y<arc->bby1; y++)\n{\ndouble r = dist(arc->xc, arc->yc, (double) x, (double) y);\ndouble offset = r - arc->radius;\ndouble ang = atan2(y - arc->yc, x - arc->xc);\ndouble ang_diff = diff_0_2pi(ang,arc->ang_ref);\n\n/* is the point in the angle sector? */\nif( ang_diff >= 0.0 && ang_diff <= arc->ang_span && fabs(offset) <= w )\n{\nif( (offset < 0.0 && arc->dir < 0) ||\n(offset > 0.0 && arc->dir > 0) ) reg[*n].reg = 1;\nelse reg[*n].reg = 2;\n\nreg[*n].val = image[x+y*X];\nreg[*n].w = fabs(offset);\n(*n)++;\n}\n}\n}\n\n/*----------------------------------------------------------------------------*/\n/* comparison function for type 'struct region' to be used with qsort\n*/\nstatic int comp_region(const void * a, const void * b)\n{\nif( ( (struct region *) a)->val < ( (struct region *) b)->val ) return -1;\nif( ( (struct region *) a)->val > ( (struct region *) b)->val ) return 1;\nreturn 0;\n}\n\n/*----------------------------------------------------------------------------*/\n/* get the lateral regions to an arc operator, apply the correcting term\nfor pixel quantization, and sort its elements according to pixel value\n\ninput: pointer to an image of size X,Y, a pointer to the arc operator,\nthe width of lateral region w, and the pixel quantization step Q.\n\noutput: the array pointed by reg will be filled with the elements of the\nregions. its size returned in n.\n*/\nstatic void get_region( int * n, struct region * reg,\ndouble * image, int X, int Y,\nstruct arc_of_circle * arc, double w, double Q )\n{\ndouble q_offset = 0.616793 * Q;\nint i;\n\n/* collect pixel values */\nif( arc->is_line_segment ) get_region_line(n,reg,image,X,Y,arc,w);\nelse get_region_arc(n,reg,image,X,Y,arc,w);\n\n/* compensate pixel values quantization */\nfor(i=0; i<*n; i++)\nif( reg[i].reg == 1 )\nreg[i].val += q_offset;\n\n/* sort region by value */\nqsort( (void *) reg, (size_t) *n, sizeof(struct region), &comp_region );\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute arc NFA using Mann-Whitney U test\nhttp://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test\n\ninput: X,Y is the image size, arc is a pointer to the arc, w is the width\nof the lateral regions of the current arc operator, reg is a pointer\nto the lateral regions of size n, W is the number of width used in\nthe method, and gap is the size in pixel units of the space to\nseparate both regions.\n\nreturn: log(NFA)\n*/\nstatic double arc_log_nfa( int X, int Y, struct arc_of_circle * arc, double w,\nint n, struct region * reg, int W, double gap )\n{\nint n1,n2,i,rank,sum_tied_ranks,num_tied,num_tied_r2;\n\n/* Number of Tests: NT = sqrt(XY) * XY * (4 + pi^2)/3 * l^2 * num_width\n\nXY : number of centers\nsqrt(XY) : number of arc lengths\npi*l : number of orientations of arcs of length l\n(4/pi + pi)/3 * l : number of arcs of a given length, center, orientation;\nthis includes from full circles of perimeter l,\nto straight line segments of length l.\nnum_width : number of arc width considered (counting with or\nwithout central gap as different)\n*/\ndouble logNT = 1.5 * log10( (double) X ) + 1.5 * log10( (double) Y )\n+ log10(4.6232) + 2.0 * log10( (double) arc->len )\n+ log10( (double) W );\n\n/* compute Mann-Whitney U statistic.\n\nthe elements in reg are assumed to be ordered by increasing values.\n\nthe assignation of the initial rank, the assignation of the adjusted rank,\nand the sum of ranks in region 2, all is done in one single loop.\n\nfor this there are variables to keep the value of the current tied pixel\ngroup, its size, and how many belong to region 2. each new value evaluated\ncan have the same value as in the current tied group or a larger one. if\nit is the same, it belongs to the tied group and the variables are\nupdated. if it is larger, that means that the previous tied group is\ncompleted, its adjusted rank can be assigned, and the corresponding\nquantity added to the sum of ranks in region 2. the variables are updated\nto reflect the new tied group including initially only the new pixel.\n*/\nn1 = n2 = 0;\nsum_rank_r2 = 0.0;\nrank = 0;\ntie_val = reg[0].val; /* set tied pixel group for the first pixel in reg */\nsum_tied_ranks = num_tied = num_tied_r2 = 0;\nfor(i=0; i<n; i++)\nif( reg[i].w > 0.5*gap && reg[i].w <= w ) /* evaluate only pixels inside\nthe current width */\n{\nif( greater(reg[i].val, tie_val) ) /* a new tied pixel group */\n{\n/* compute the adjusted rank and assign the rank values of region 2\nin the last tied pixel group */\nif( num_tied > 0 && num_tied_r2 > 0 )\n{\nadjusted_rank = (double) sum_tied_ranks / (double) num_tied;\nsum_rank_r2 += (double) num_tied_r2 * adjusted_rank;\n}\n\n/* initialize new tied pixel group */\ntie_val = reg[i].val;\nsum_tied_ranks = num_tied = num_tied_r2 = 0;\n}\n\n++rank; /* rank in the ordering among the pixels in the region */\nsum_tied_ranks += rank;\n++num_tied;\n\n/* count pixels in region 1 and 2 */\nif( reg[i].reg == 1 ) ++n1;\nelse\n{\n++n2;\n++num_tied_r2;\n}\n}\nif( num_tied > 0 && num_tied_r2 > 0 ) /* assign ranks of last tied group */\nsum_rank_r2 += (double) num_tied_r2 * sum_tied_ranks / num_tied;\nu = sum_rank_r2 - 0.5 * n2 * (n2 + 1.0); /* compute u value */\n\n/* compute z, a version of u with standard normal distribution, N(0,1) */\nm = 0.5 * n1 * n2;\ns = sqrt( n1 * n2 * (n1+n2+1.0) / 12.0 );\nif( n1 > 0 && n2 > 0 && s > 0.0 ) z = (u - m) / s;\nelse return logNT; /* one of the regions has no pixel => not meaningful */\n\n/* compute the p-value using the standard error function */\npvalue = 0.5 * ( 1.0 - erf_winitzki(z/sqrt(2.0)) );\nif( pvalue <= 0.0 ) /* the p-value should always be larger than zero.\nthis condition reveals a numeric overflow,\ndue to a very very small p-value. then the arc\nis meaningful => return a negative log10(NFA) */\nreturn (double) DBL_MIN_10_EXP; /* minimal negative exponent in doubles */\n\n/* return the log10(NFA) */\nreturn logNT + log10(pvalue);\n}\n\n/*----------------------------------------------------------------------------*/\n/* copy the meaningful curves from structures xx,yy,curve,NN,MM\nto structures x,y,curve_limits,N,M\n\ninput:\nxx,yy : list of point coordinates\ncurve : curve limits in lists xx,yy\nNN : number of points\nMM : number of curves\nmeaningful : status of each point (TRUE=meaningful; FALSE otherwise)\n\noutput:\nx,y : list of point coordinates\ncurve_limits : curve limits in lists x,y\nN : number of points\nM : number of curves\n\nthe output arrays x,y and curve_limits will be allocated.\n*/\nstatic void keep_meaningful_curves( double ** x, double ** y, int * N,\nint ** curve_limits, int * M,\ndouble * xx, double * yy, int NN,\nint * curve, int MM, int * meaningful )\n{\nint c,i;\n\n*N = *M = 0; /* initialize N and M to zero point, zero curve */\n\n/* if the input is empty, return NULL pointers */\nif( NN <= 0 )\n{\n*x = *y = NULL;\n*curve_limits = NULL;\nreturn;\n}\n\n/* allocate memory\nworst case: each point is kept (n points so 2n coordinates)\nand each one is one chain (n+1 limits) */\n*x = (double *) xmalloc( NN * sizeof(double) );\n*y = (double *) xmalloc( NN * sizeof(double) );\n*curve_limits = (int *) xmalloc( (NN+1) * sizeof(int) );\n\n/* create list of meaningful curves */\n(*curve_limits)[0] = 0; /* this is always right but needs to be initialized */\nfor(c=0; c<MM; c++) /* iterate on curves */\n{\nint in_chain = FALSE; /* not in a chain when starting the curve */\n\n/* iterate the points of the curve */\nfor(i=curve[c]; i<curve[c+1]; i++)\nif( meaningful[i] ) /* meaningful point, add it */\n{\nif( !in_chain ) /* new chain */\n{\nin_chain = TRUE;\n++(*M); /* increase chain counter */\n}\n(*x)[*N] = xx[i]; /* store point coordinates */\n(*y)[*N] = yy[i];\n++(*N); /* increase point counter */\n(*curve_limits)[*M] = *N; /* curve_limits[M] should contain first\npoint of following chain, which is N\nbecause is was already increased */\n}\nelse in_chain = FALSE; /* not meaningful, not in chain */\n}\n}\n\n/*----------------------------------------------------------------------------*/\n/* compute the minimal arc length that may lead to a validated detection\nfor the given image size\n\ninput: X,Y is the size of the image, max_w is the maximal width of the\nlateral regions, W is the number of widths for the lateral regions\nused in the method, and log_eps is the threshold applied to log(NFA)\n\nreturn: the minimal arc length to be evaluated\n*/\nstatic int compute_min_length(int X, int Y, double max_w, int W, double log_eps)\n{\ndouble l_nfa;\nint min_l;\n\n/* evaluate the most favorable case for each length starting in one.\nstop when NFA <= epsilon is possible */\nfor(l_nfa=DBL_MAX, min_l=1; l_nfa>=log_eps; min_l++)\n{\n/* most meaningful arc when all points are in the right order.\nthat is, u gets its maximal possible value of n*n.\nthen, z = (n*n - 0.5*n*n) / sqrt(.) = 0.5*n*n / sqrt(.) */\ndouble n = min_l * max_w;\ndouble z = 0.5*n*n / sqrt(n*n*(n+n+1.0)/12.0);\n\n/* Number of Tests: NT = sqrt(XY) * XY * (4 + pi^2)/3 * l^2 * num_width\n\nXY : number of centers\nsqrt(XY) : number of arc lengths\npi*l : number of orientations of arcs of length l\n(4/pi + pi)/3 * l : num. of arcs of a given length, center, orientation\nthis includes from full circles of perimeter l,\nto straight line segments of length l\nnum_width : number of arc width considered (counting with or\nwithout central gap as different)\n*/\ndouble logNT = 1.5 * log10( (double) X ) + 1.5 * log10( (double) Y )\n+ log10(4.6232) + 2.0 * log10( (double) min_l )\n+ log10( (double) W );\n\nl_nfa = logNT + log10( 0.5 * (1.0 - erf_winitzki(z/sqrt(2.0))) );\n}\n\nreturn min_l;\n}\n\n/*----------------------------------------------------------------------------*/\n/* Smooth Contours is an algorithm for detecting smooth contours on digital\nimages. The output contours are given as chained sub-pixel edge points.\n\nInput:\n\nimage : the input image\nX,Y : the size of the input image\nQ : the pixel quantization step\n\nOutput:\n\nx,y : lists of sub-pixel coordinates of edge points\ncurve_limits : the limits of each curve in lists x and y\nN : number of edge points\nM : number of curves\n\nThe input is a XxY graylevel image given as a pointer to an array of doubles\nsuch that image[x+y*X] is the value at coordinates x,y\n(for 0 <= x < X and 0 <= y < Y).\n\nThe output are the chained edge points given as 3 allocated lists: x, y and\ncurve_limits. Also the numbers N (size of lists x and y) and M (number of\ncurves).\n\nx[i] and y[i] (0<=i<N) store the sub-pixel coordinates of edge points.\ncurve_limits[j] (0<=j<=M) stores the limits of each chain in lists x and y.\n\nexample:\n\ncurve number k (0<=k<M) consists of the edge points x[i],y[i]\nfor i determined by curve_limits[k] <= i < curve_limits[k+1].\n\ncurve k is closed if x[curve_limits[k]] == x[curve_limits[k+1] - 1] and\ny[curve_limits[k]] == y[curve_limits[k+1] - 1].\n*/\nvoid smooth_contours( double ** x, double ** y, int * N,\nint ** curve_limits, int * M,\ndouble * image, int X, int Y, double Q )\n{\ndouble dog_rate = 1.6; /* DoG sigma rate to approx. Laplacian of Gaussian\noptimal value 1.6 [Marr-Hildreth 1980] */\ndouble sigma_step = 0.8; /* sigma to sampling step rate in Gaussian sampling\noptimal value 0.8 [Morel-Yu 2011] */\ndouble log_eps = 0.0; /* log10(epsilon), where epsilon is the mean number\nof false detections one can afford per image */\nint num_w = 3; /* number of arc widths to be tested */\ndouble fac_w = sqrt(2.0); /* arc width factor */\ndouble min_w = sqrt(2.0); /* minimal arc width */\nint W = 2 * num_w; /* there are two operators per width:\nwith and without central gap */\n\ndouble max_w = min_w * pow( fac_w, (double) num_w-1.0 );\ndouble sigma = sigma_step * sqrt( dog_rate * dog_rate - 1.0 );\nstruct region * reg = xmalloc( X * Y * sizeof(struct region) );\ndouble * diff = (double *) xmalloc( X * Y * sizeof(double) );\nint * meaningful = (int *) xmalloc( X * Y * sizeof(int) );\nint * used = (int *) xmalloc( X * Y * sizeof(int) );\ndouble * gauss;\ndouble * xx;\ndouble * yy;\nint * curve;\nstruct arc_of_circle arc;\nint i,k,n,reg_n,c,NN,MM,min_l;\ndouble w;\n\n/* compute minimal arc length that may become meaningful */\nmin_l = compute_min_length(X,Y,max_w,W,log_eps);\n\n/* filter the input image by a Gaussian filter and compute difference image */\ngauss = gaussian_filter(image, X, Y, sigma);\nfor(n=0; n<X*Y; n++) diff[n] = image[n] - gauss[n];\n\n/* compute chained edge points */\nchained_subpixel_edge_points(&xx, &yy, &NN, &curve, &MM, gauss, X, Y);\n\n/* initialize all edge points as not meaningful and not used */\nfor(n=0; n<NN; n++) meaningful[n] = used[n] = FALSE;\n\n/* a-contrario validation of curve segments approximated by local arcs */\nfor(c=0; c<MM; c++) /* iterate on curves */\nfor(i=curve[c]; i<curve[c+1]; i++) /* first point of curve segment */\nfor(k=curve[c+1]-1; (k-i)>=min_l; k--) /* last point of curve segment */\nif( !used[i] || !used[k] ) /* test segment only if one end not used */\nif( smooth_segment(&arc,xx,yy,i,k,sigma,max_w,X,Y) )\n{\n/* heuristic to speed up: mark as used center part of segment */\nfor(n=i+3; n<=(k-3); n++) used[n] = TRUE;\n\n/* get pixel values in lateral regions to the arc. to speed-up\nit is done only once, thus outside w-loop and arc_log_nfa() */\nget_region(&reg_n, reg, diff, X, Y, &arc, max_w, Q);\nif( reg_n <= 0 ) continue; /* empty region */\n\n/* lateral width loop. two gaps are tried for each: 0.0 and 1.0 */\nfor(w=min_w; w<=max_w; w*=fac_w)\nif( arc_log_nfa(X,Y,&arc,w,reg_n,reg,W,0.0) < log_eps ||\narc_log_nfa(X,Y,&arc,w,reg_n,reg,W,1.0) < log_eps )\n{\nfor(n=i; n<=k; n++) meaningful[n] = used[n] = TRUE;\nbreak; /* arc already meaningful, no need to test other w */\n}\n}\n\nkeep_meaningful_curves(x,y,N,curve_limits,M,xx,yy,NN,curve,MM,meaningful);\n\n/* free memory */\nfree( (void *) gauss );\nfree( (void *) diff );\nfree( (void *) meaningful );\nfree( (void *) used );\nfree( (void *) xx );\nfree( (void *) yy );\nfree( (void *) curve );\nfree( (void *) reg );\n}\n/*----------------------------------------------------------------------------*/"