This page explains how to interpret the graphs that are generated by doxygen.
\nConsider the following example:
/*! Invisible class because of truncation */\nclass Invisible { };\n\n/*! Truncated class, inheritance relation is hidden */\nclass Truncated : publicInvisible { };\n\n/* Class not documented with doxygen comments */\nclass Undocumented { };\n\n/*! Class that is inherited using public inheritance */\nclass PublicBase : publicTruncated { };\n\n/*! A template class */\ntemplate<class T> class Templ { };\n\n/*! Class that is inherited using protected inheritance */\nclass ProtectedBase { };\n\n/*! Class that is inherited using private inheritance */\nclass PrivateBase { };\n\n/*! Class that is used by the Inherited class */\nclass Used { };\n\n/*! Super class that inherits a number of other classes */\nclass Inherited : publicPublicBase,\n protectedProtectedBase,\n privatePrivateBase,\n publicUndocumented\n publicTempl<int>\n{\n private:\n Used *m_usedClass;\n};\n
If the MAX_DOT_GRAPH_HEIGHT tag in the configuration file is set to 240 this will result in the following graph:
\n
\n\n
\n
\nThe boxes in the above graph have the following meaning:
\n
\nA filled black box represents the struct or class for which the graph is generated.
\n
\nA box with a black border denotes a documented struct or class.
\n
\nA box with a grey border denotes an undocumented struct or class.
\n
\nA box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries.
\n
\nThe arrows have the following meaning:
\n
\nA dark blue arrow is used to visualize a public inheritance relation between two classes.
\n
\nA dark green arrow is used for protected inheritance.
\n
\nA dark red arrow is used for private inheritance.
\n
\nA purple dashed arrow is used if a class is contained or used by another class. The arrow is labeled with the variable(s) through which the pointed class or struct is accessible.
\n
\nA yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labeled with the template parameters of the instance.
\n
\nGenerated on Fri Dec 3 10:18:49 2010 for LSD by\n\n \n1.3.4 \n\n\n"
},
{
"path": "thirdparty/LSD/doc/index.html",
"content": "\n\nLSD: LSD code documentation\n\n\n\n
\nThis is an implementation of the Line Segment Detector described in the paper:
\n\"LSD: A Fast Line Segment Detector with a False Detection Control\" by Rafael Grompone von Gioi, Jeremie Jakubowicz, Jean-Michel Morel, and Gregory Randall, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 32, no. 4, pp. 722-732, April, 2010.
\nand in more details in the CMLA Technical Report:
\n\"LSD: A Line Segment Detector, Technical Report\", by Rafael Grompone von Gioi, Jeremie Jakubowicz, Jean-Michel Morel, Gregory Randall, CMLA, ENS Cachan, 2010.
\nThe version implemented here includes some further improvements described on the LSD page at www.ipol.im. That same page includes more information, including this code and an online demo version:
00001 /*----------------------------------------------------------------------------\n00002 \n00003 LSD - Line Segment Detector on digital images\n00004 \n00005 Copyright 2007-2010 rafael grompone von gioi (grompone@gmail.com)\n00006 \n00007 This program is free software: you can redistribute it and/or modify\n00008 it under the terms of the GNU Affero General Public License as\n00009 published by the Free Software Foundation, either version 3 of the\n00010 License, or (at your option) any later version.\n00011 \n00012 This program is distributed in the hope that it will be useful,\n00013 but WITHOUT ANY WARRANTY; without even the implied warranty of\n00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n00015 GNU Affero General Public License for more details.\n00016 \n00017 You should have received a copy of the GNU Affero General Public License\n00018 along with this program. If not, see <http://www.gnu.org/licenses/>.\n00019 \n00020 ----------------------------------------------------------------------------*/\n00021 \n00022 /*----------------------------------------------------------------------------*/\n00023 /** @file lsd.c\n00024 LSD module code\n00025 @author rafael grompone von gioi (grompone@gmail.com)\n00026 */\n00027 /*----------------------------------------------------------------------------*/\n00028 \n00029 /*----------------------------------------------------------------------------*/\n00030 /** @mainpage LSD code documentation\n00031 \n00032 This is an implementation of the Line Segment Detector described\n00033 in the paper:\n00034 \n00035 \"LSD: A Fast Line Segment Detector with a False Detection Control\"\n00036 by Rafael Grompone von Gioi, Jeremie Jakubowicz, Jean-Michel Morel,\n00037 and Gregory Randall, IEEE Transactions on Pattern Analysis and\n00038 Machine Intelligence, vol. 32, no. 4, pp. 722-732, April, 2010.\n00039 \n00040 and in more details in the CMLA Technical Report:\n00041 \n00042 \"LSD: A Line Segment Detector, Technical Report\",\n00043 by Rafael Grompone von Gioi, Jeremie Jakubowicz, Jean-Michel Morel,\n00044 Gregory Randall, CMLA, ENS Cachan, 2010.\n00045 \n00046 The version implemented here includes some further improvements\n00047 described on the LSD page at www.ipol.im. That same page includes\n00048 more information, including this code and an online demo version:\n00049 \n00050 http://www.ipol.im/pub/algo/gjmr_line_segment_detector\n00051 \n00052 The module's main function is lsd().\n00053 \n00054 The source code is contained in two files: lsd.h and lsd.c.\n00055 \n00056 HISTORY:\n00057 - version 1.5 - dic 2010: Changes in 'refine', -W option added,\n00058 and more comments added.\n00059 - version 1.4 - jul 2010: lsd_scale interface added and doxygen doc.\n00060 - version 1.3 - feb 2010: Multiple bug correction and improved code.\n00061 - version 1.2 - dic 2009: First full Ansi C Language version.\n00062 - version 1.1 - sep 2009: Systematic subsampling to scale 0.8 and\n00063 correction to partially handle\"angle problem\".\n00064 - version 1.0 - jan 2009: First complete Megawave2 and Ansi C Language\n00065 version.\n00066 \n00067 @author rafael grompone von gioi (grompone@gmail.com)\n00068 */\n00069 /*----------------------------------------------------------------------------*/\n00070 \n00071 #include <stdio.h>\n00072 #include <stdlib.h>\n00073 #include <math.h>\n00074 #include <limits.h>\n00075 #include <float.h>\n00076 #include \"lsd.h\"\n00077 \n00078 /** ln(10) */\n00079 #ifndef M_LN10\n00080#define M_LN10 2.30258509299404568402\n00081 #endif /* !M_LN10 */\n00082 \n00083 /** PI */\n00084 #ifndef M_PI\n00085#define M_PI 3.14159265358979323846\n00086 #endif /* !M_PI */\n00087 \n00088 #ifndef FALSE\n00089#define FALSE 0\n00090 #endif /* !FALSE */\n00091 \n00092 #ifndef TRUE\n00093#define TRUE 1\n00094 #endif /* !TRUE */\n00095 \n00096 /** Label for pixels with undefined gradient. */\n00097#define NOTDEF -1024.0\n00098 \n00099 /** 3/2 pi */\n00100#define M_3_2_PI 4.71238898038\n00101 \n00102 /** 2 pi */\n00103#define M_2__PI 6.28318530718\n00104 \n00105 /** Label for pixels not used in yet. */\n00106#define NOTUSED 0\n00107 \n00108 /** Label for pixels already used in detection. */\n00109#define USED 1\n00110 \n00111 /*----------------------------------------------------------------------------*/\n00112 /** Chained list of coordinates.\n00113 */\n00114struct coorlist\n00115 {\n00116intx,y;\n00117struct coorlist * next;\n00118 };\n00119 \n00120 /*----------------------------------------------------------------------------*/\n00121 /** A point (or pixel).\n00122 */\n00123struct point {intx,y;};\n00124 \n00125 \n00126 /*----------------------------------------------------------------------------*/\n00127 /*------------------------- Miscellaneous functions --------------------------*/\n00128 /*----------------------------------------------------------------------------*/\n00129 \n00130 /*----------------------------------------------------------------------------*/\n00131 /** Fatal error, print a message to standard-error output and exit.\n00132 */\n00133staticvoiderror(char * msg)\n00134 {\n00135 fprintf(stderr,\"LSD Error: %s\\n\",msg);\n00136 exit(EXIT_FAILURE);\n00137 }\n00138 \n00139 /*----------------------------------------------------------------------------*/\n00140 /** Doubles relative error factor\n00141 */\n00142#define RELATIVE_ERROR_FACTOR 100.0\n00143 \n00144 /*----------------------------------------------------------------------------*/\n00145 /** Compare doubles by relative error.\n00146 \n00147 The resulting rounding error after floating point computations\n00148 depend on the specific operations done. The same number computed by\n00149 different algorithms could present different rounding errors. For a\n00150 useful comparison, an estimation of the relative rounding error\n00151 should be considered and compared to a factor times EPS. The factor\n00152 should be related to the cumulated rounding error in the chain of\n00153 computation. Here, as a simplification, a fixed factor is used.\n00154 */\n00155staticintdouble_equal(double a, double b)\n00156 {\n00157 double abs_diff,aa,bb,abs_max;\n00158 \n00159 /* trivial case */\n00160 if( a == b ) returnTRUE;\n00161 \n00162 abs_diff = fabs(a-b);\n00163 aa = fabs(a);\n00164 bb = fabs(b);\n00165 abs_max = aa > bb ? aa : bb;\n00166 \n00167 /* DBL_MIN is the smallest normalized number, thus, the smallest\n00168 number whose relative error is bounded by DBL_EPSILON. For\n00169 smaller numbers, the same quantization steps as for DBL_MIN\n00170 are used. Then, for smaller numbers, a meaningful \"relative\"\n00171 error should be computed by dividing the difference by DBL_MIN. */\n00172 if( abs_max < DBL_MIN ) abs_max = DBL_MIN;\n00173 \n00174 /* equal if relative error <= factor x eps */\n00175 return (abs_diff / abs_max) <= (RELATIVE_ERROR_FACTOR * DBL_EPSILON);\n00176 }\n00177 \n00178 /*----------------------------------------------------------------------------*/\n00179 /** Computes Euclidean distance between point (x1,y1) and point (x2,y2).\n00180 */\n00181staticdoubledist(double x1, double y1, double x2, double y2)\n00182 {\n00183 return sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) );\n00184 }\n00185 \n00186 \n00187 /*----------------------------------------------------------------------------*/\n00188 /*----------------------- 'list of n-tuple' data type ------------------------*/\n00189 /*----------------------------------------------------------------------------*/\n00190 \n00191 /*----------------------------------------------------------------------------*/\n00192 /** Free memory used in n-tuple 'in'.\n00193 */\n00194voidfree_ntuple_list(ntuple_list in)\n00195 {\n00196 if( in == NULL || in->values == NULL )\n00197 error(\"free_ntuple_list: invalid n-tuple input.\");\n00198 free( (void *) in->values );\n00199 free( (void *) in );\n00200 }\n00201 \n00202 /*----------------------------------------------------------------------------*/\n00203 /** Create an n-tuple list and allocate memory for one element.\n00204 @param dim the dimension (n) of the n-tuple.\n00205 */\n00206ntuple_listnew_ntuple_list(unsignedint dim)\n00207 {\n00208 ntuple_list n_tuple;\n00209 \n00210 /* check parameters */\n00211 if( dim == 0 ) error(\"new_ntuple_list: 'dim' must be positive.\");\n00212 \n00213 /* get memory for list structure */\n00214 n_tuple = (ntuple_list) malloc( sizeof(structntuple_list_s) );\n00215 if( n_tuple == NULL ) error(\"not enough memory.\");\n00216 \n00217 /* initialize list */\n00218 n_tuple->size = 0;\n00219 n_tuple->max_size = 1;\n00220 n_tuple->dim = dim;\n00221 \n00222 /* get memory for tuples */\n00223 n_tuple->values = (double *) malloc( dim*n_tuple->max_size * sizeof(double) );\n00224 if( n_tuple->values == NULL ) error(\"not enough memory.\");\n00225 \n00226 return n_tuple;\n00227 }\n00228 \n00229 /*----------------------------------------------------------------------------*/\n00230 /** Enlarge the allocated memory of an n-tuple list.\n00231 */\n00232staticvoidenlarge_ntuple_list(ntuple_list n_tuple)\n00233 {\n00234 /* check parameters */\n00235 if( n_tuple == NULL || n_tuple->values == NULL || n_tuple->max_size == 0 )\n00236 error(\"enlarge_ntuple_list: invalid n-tuple.\");\n00237 \n00238 /* duplicate number of tuples */\n00239 n_tuple->max_size *= 2;\n00240 \n00241 /* realloc memory */\n00242 n_tuple->values = (double *) realloc( (void *) n_tuple->values,\n00243 n_tuple->dim * n_tuple->max_size * sizeof(double) );\n00244 if( n_tuple->values == NULL ) error(\"not enough memory.\");\n00245 }\n00246 \n00247 /*----------------------------------------------------------------------------*/\n00248 /** Add a 5-tuple to an n-tuple list.\n00249 */\n00250staticvoidadd_5tuple( ntuple_list out, double v1, double v2,\n00251 double v3, double v4, double v5 )\n00252 {\n00253 /* check parameters */\n00254 if( out == NULL ) error(\"add_5tuple: invalid n-tuple input.\");\n00255 if( out->dim != 5 ) error(\"add_5tuple: the n-tuple must be a 5-tuple.\");\n00256 \n00257 /* if needed, alloc more tuples to 'out' */\n00258 if( out->size == out->max_size ) enlarge_ntuple_list(out);\n00259 if( out->values == NULL ) error(\"add_5tuple: invalid n-tuple input.\");\n00260 \n00261 /* add new 5-tuple */\n00262 out->values[ out->size * out->dim + 0 ] = v1;\n00263 out->values[ out->size * out->dim + 1 ] = v2;\n00264 out->values[ out->size * out->dim + 2 ] = v3;\n00265 out->values[ out->size * out->dim + 3 ] = v4;\n00266 out->values[ out->size * out->dim + 4 ] = v5;\n00267 \n00268 /* update number of tuples counter */\n00269 out->size++;\n00270 }\n00271 \n00272 \n00273 /*----------------------------------------------------------------------------*/\n00274 /*----------------------------- Image Data Types -----------------------------*/\n00275 /*----------------------------------------------------------------------------*/\n00276 \n00277 /*----------------------------------------------------------------------------*/\n00278 /** Free memory used in image_char 'i'.\n00279 */\n00280voidfree_image_char(image_char i)\n00281 {\n00282 if( i == NULL || i->data == NULL )\n00283 error(\"free_image_char: invalid input image.\");\n00284 free( (void *) i->data );\n00285 free( (void *) i );\n00286 }\n00287 \n00288 /*----------------------------------------------------------------------------*/\n00289 /** Create a new image_char of size 'xsize' times 'ysize'.\n00290 */\n00291image_charnew_image_char(unsignedint xsize, unsignedint ysize)\n00292 {\n00293 image_char image;\n00294 \n00295 /* check parameters */\n00296 if( xsize == 0 || ysize == 0 ) error(\"new_image_char: invalid image size.\");\n00297 \n00298 /* get memory */\n00299 image = (image_char) malloc( sizeof(structimage_char_s) );\n00300 if( image == NULL ) error(\"not enough memory.\");\n00301 image->data = (unsignedchar *) calloc( (size_t) (xsize*ysize),\n00302 sizeof(unsignedchar) );\n00303 if( image->data == NULL ) error(\"not enough memory.\");\n00304 \n00305 /* set image size */\n00306 image->xsize = xsize;\n00307 image->ysize = ysize;\n00308 \n00309 return image;\n00310 }\n00311 \n00312 /*----------------------------------------------------------------------------*/\n00313 /** Create a new image_char of size 'xsize' times 'ysize',\n00314 initialized to the value 'fill_value'.\n00315 */\n00316image_charnew_image_char_ini( unsignedint xsize, unsignedint ysize,\n00317 unsignedchar fill_value )\n00318 {\n00319 image_char image = new_image_char(xsize,ysize); /* create image */\n00320 unsignedint N = xsize*ysize;\n00321 unsignedint i;\n00322 \n00323 /* check parameters */\n00324 if( image == NULL || image->data == NULL )\n00325 error(\"new_image_char_ini: invalid image.\");\n00326 \n00327 /* initialize */\n00328 for(i=0; i<N; i++) image->data[i] = fill_value;\n00329 \n00330 return image;\n00331 }\n00332 \n00333 /*----------------------------------------------------------------------------*/\n00334 /** Free memory used in image_int 'i'.\n00335 */\n00336voidfree_image_int(image_int i)\n00337 {\n00338 if( i == NULL || i->data == NULL )\n00339 error(\"free_image_int: invalid input image.\");\n00340 free( (void *) i->data );\n00341 free( (void *) i );\n00342 }\n00343 \n00344 /*----------------------------------------------------------------------------*/\n00345 /** Create a new image_int of size 'xsize' times 'ysize'.\n00346 */\n00347image_intnew_image_int(unsignedint xsize, unsignedint ysize)\n00348 {\n00349 image_int image;\n00350 \n00351 /* check parameters */\n00352 if( xsize == 0 || ysize == 0 ) error(\"new_image_int: invalid image size.\");\n00353 \n00354 /* get memory */\n00355 image = (image_int) malloc( sizeof(structimage_int_s) );\n00356 if( image == NULL ) error(\"not enough memory.\");\n00357 image->data = (int *) calloc( (size_t) (xsize*ysize), sizeof(int) );\n00358 if( image->data == NULL ) error(\"not enough memory.\");\n00359 \n00360 /* set image size */\n00361 image->xsize = xsize;\n00362 image->ysize = ysize;\n00363 \n00364 return image;\n00365 }\n00366 \n00367 /*----------------------------------------------------------------------------*/\n00368 /** Create a new image_int of size 'xsize' times 'ysize',\n00369 initialized to the value 'fill_value'.\n00370 */\n00371image_intnew_image_int_ini( unsignedint xsize, unsignedint ysize,\n00372 int fill_value )\n00373 {\n00374 image_int image = new_image_int(xsize,ysize); /* create image */\n00375 unsignedint N = xsize*ysize;\n00376 unsignedint i;\n00377 \n00378 /* initialize */\n00379 for(i=0; i<N; i++) image->data[i] = fill_value;\n00380 \n00381 return image;\n00382 }\n00383 \n00384 /*----------------------------------------------------------------------------*/\n00385 /** Free memory used in image_double 'i'.\n00386 */\n00387voidfree_image_double(image_double i)\n00388 {\n00389 if( i == NULL || i->data == NULL )\n00390 error(\"free_image_double: invalid input image.\");\n00391 free( (void *) i->data );\n00392 free( (void *) i );\n00393 }\n00394 \n00395 /*----------------------------------------------------------------------------*/\n00396 /** Create a new image_double of size 'xsize' times 'ysize'.\n00397 */\n00398image_doublenew_image_double(unsignedint xsize, unsignedint ysize)\n00399 {\n00400 image_double image;\n00401 \n00402 /* check parameters */\n00403 if( xsize == 0 || ysize == 0 ) error(\"new_image_double: invalid image size.\");\n00404 \n00405 /* get memory */\n00406 image = (image_double) malloc( sizeof(structimage_double_s) );\n00407 if( image == NULL ) error(\"not enough memory.\");\n00408 image->data = (double *) calloc( (size_t) (xsize*ysize), sizeof(double) );\n00409 if( image->data == NULL ) error(\"not enough memory.\");\n00410 \n00411 /* set image size */\n00412 image->xsize = xsize;\n00413 image->ysize = ysize;\n00414 \n00415 return image;\n00416 }\n00417 \n00418 /*----------------------------------------------------------------------------*/\n00419 /** Create a new image_double of size 'xsize' times 'ysize',\n00420 initialized to the value 'fill_value'.\n00421 */\n00422image_doublenew_image_double_ini( unsignedint xsize, unsignedint ysize,\n00423 double fill_value )\n00424 {\n00425 image_double image = new_image_double(xsize,ysize); /* create image */\n00426 unsignedint N = xsize*ysize;\n00427 unsignedint i;\n00428 \n00429 /* initialize */\n00430 for(i=0; i<N; i++) image->data[i] = fill_value;\n00431 \n00432 return image;\n00433 }\n00434 \n00435 \n00436 /*----------------------------------------------------------------------------*/\n00437 /*----------------------------- Gaussian filter ------------------------------*/\n00438 /*----------------------------------------------------------------------------*/\n00439 \n00440 /*----------------------------------------------------------------------------*/\n00441 /** Compute a Gaussian kernel of length 'kernel->dim',\n00442 standard deviation 'sigma', and centered at value 'mean'.\n00443 \n00444 For example, if mean=0.5, the Gaussian will be centered\n00445 in the middle point between values 'kernel->values[0]'\n00446 and 'kernel->values[1]'.\n00447 */\n00448staticvoidgaussian_kernel(ntuple_list kernel, double sigma, double mean)\n00449 {\n00450 double sum = 0.0;\n00451 double val;\n00452 unsignedint i;\n00453 \n00454 /* check parameters */\n00455 if( kernel == NULL || kernel->values == NULL )\n00456 error(\"gaussian_kernel: invalid n-tuple 'kernel'.\");\n00457 if( sigma <= 0.0 ) error(\"gaussian_kernel: 'sigma' must be positive.\");\n00458 \n00459 /* compute Gaussian kernel */\n00460 if( kernel->max_size < 1 ) enlarge_ntuple_list(kernel);\n00461 kernel->size = 1;\n00462 for(i=0;i<kernel->dim;i++)\n00463 {\n00464 val = ( (double) i - mean ) / sigma;\n00465 kernel->values[i] = exp( -0.5 * val * val );\n00466 sum += kernel->values[i];\n00467 }\n00468 \n00469 /* normalization */\n00470 if( sum >= 0.0 ) for(i=0;i<kernel->dim;i++) kernel->values[i] /= sum;\n00471 }\n00472 \n00473 /*----------------------------------------------------------------------------*/\n00474 /** Scale the input image 'in' by a factor 'scale' by Gaussian sub-sampling.\n00475 \n00476 For example, scale=0.8 will give a result at 80% of the original size.\n00477 \n00478 The image is convolved with a Gaussian kernel\n00479 @f[\n00480 G(x,y) = \\frac{1}{2\\pi\\sigma^2} e^{-\\frac{x^2+y^2}{2\\sigma^2}}\n00481 @f]\n00482 before the sub-sampling to prevent aliasing.\n00483 \n00484 The standard deviation sigma given by:\n00485 - sigma = sigma_scale / scale, if scale < 1.0\n00486 - sigma = sigma_scale, if scale >= 1.0\n00487 \n00488 To be able to sub-sample at non-integer steps, some interpolation\n00489 is needed. In this implementation, the interpolation is done by\n00490 the Gaussian kernel, so both operations (filtering and sampling)\n00491 are done at the same time. The Gaussian kernel is computed\n00492 centered on the coordinates of the required sample. In this way,\n00493 when applied, it gives directly the result of convolving the image\n00494 with the kernel and interpolated to that particular position.\n00495 \n00496 A fast algorithm is done using the separability of the Gaussian\n00497 kernel. Applying the 2D Gaussian kernel is equivalent to applying\n00498 first a horizontal 1D Gaussian kernel and then a vertical 1D\n00499 Gaussian kernel (or the other way round). The reason is that\n00500 @f[\n00501 G(x,y) = G(x) * G(y)\n00502 @f]\n00503 where\n00504 @f[\n00505 G(x) = \\frac{1}{\\sqrt{2\\pi}\\sigma} e^{-\\frac{x^2}{2\\sigma^2}}.\n00506 @f]\n00507 The algorithm first apply a combined Gaussian kernel and sampling\n00508 in the x axis, and then the combined Gaussian kernel and sampling\n00509 in the y axis.\n00510 */\n00511staticimage_doublegaussian_sampler( image_double in, double scale,\n00512 double sigma_scale )\n00513 {\n00514 image_double aux,out;\n00515 ntuple_list kernel;\n00516 unsignedint N,M,h,n,x,y,i;\n00517 int xc,yc,j,double_x_size,double_y_size;\n00518 double sigma,xx,yy,sum,prec;\n00519 \n00520 /* check parameters */\n00521 if( in == NULL || in->data == NULL || in->xsize == 0 || in->ysize == 0 )\n00522 error(\"gaussian_sampler: invalid image.\");\n00523 if( scale <= 0.0 ) error(\"gaussian_sampler: 'scale' must be positive.\");\n00524 if( sigma_scale <= 0.0 )\n00525 error(\"gaussian_sampler: 'sigma_scale' must be positive.\");\n00526 \n00527 /* get memory for images */\n00528 if( in->xsize * scale > (double) UINT_MAX ||\n00529 in->ysize * scale > (double) UINT_MAX )\n00530 error(\"gaussian_sampler: the output image size exceeds the handled size.\");\n00531 N = (unsignedint) floor( in->xsize * scale );\n00532 M = (unsignedint) floor( in->ysize * scale );\n00533 aux = new_image_double(N,in->ysize);\n00534 out = new_image_double(N,M);\n00535 \n00536 /* sigma, kernel size and memory for the kernel */\n00537 sigma = scale < 1.0 ? sigma_scale / scale : sigma_scale;\n00538 /*\n00539 The size of the kernel is selected to guarantee that the\n00540 the first discarded term is at least 10^prec times smaller\n00541 than the central value. For that, h should be larger than x, with\n00542 e^(-x^2/2sigma^2) = 1/10^prec.\n00543 Then,\n00544 x = sigma * sqrt( 2 * prec * ln(10) ).\n00545 */\n00546 prec = 3.0;\n00547 h = (unsignedint) ceil( sigma * sqrt( 2.0 * prec * log(10.0) ) );\n00548 n = 1+2*h; /* kernel size */\n00549 kernel = new_ntuple_list(n);\n00550 \n00551 /* auxiliary double image size variables */\n00552 double_x_size = (int) (2 * in->xsize);\n00553 double_y_size = (int) (2 * in->ysize);\n00554 \n00555 /* First subsampling: x axis */\n00556 for(x=0;x<aux->xsize;x++)\n00557 {\n00558 /*\n00559 x is the coordinate in the new image.\n00560 xx is the corresponding x-value in the original size image.\n00561 xc is the integer value, the pixel coordinate of xx.\n00562 */\n00563 xx = (double) x / scale;\n00564 /* coordinate (0.0,0.0) is in the center of pixel (0,0),\n00565 so the pixel with xc=0 get the values of xx from -0.5 to 0.5 */\n00566 xc = (int) floor( xx + 0.5 );\n00567 gaussian_kernel( kernel, sigma, (double) h + xx - (double) xc );\n00568 /* the kernel must be computed for each x because the fine\n00569 offset xx-xc is different in each case */\n00570 \n00571 for(y=0;y<aux->ysize;y++)\n00572 {\n00573 sum = 0.0;\n00574 for(i=0;i<kernel->dim;i++)\n00575 {\n00576 j = xc - h + i;\n00577 \n00578 /* symmetry boundary condition */\n00579 while( j < 0 ) j += double_x_size;\n00580 while( j >= double_x_size ) j -= double_x_size;\n00581 if( j >= (int) in->xsize ) j = double_x_size-1-j;\n00582 \n00583 sum += in->data[ j + y * in->xsize ] * kernel->values[i];\n00584 }\n00585 aux->data[ x + y * aux->xsize ] = sum;\n00586 }\n00587 }\n00588 \n00589 /* Second subsampling: y axis */\n00590 for(y=0;y<out->ysize;y++)\n00591 {\n00592 /*\n00593 y is the coordinate in the new image.\n00594 yy is the corresponding x-value in the original size image.\n00595 yc is the integer value, the pixel coordinate of xx.\n00596 */\n00597 yy = (double) y / scale;\n00598 /* coordinate (0.0,0.0) is in the center of pixel (0,0),\n00599 so the pixel with yc=0 get the values of yy from -0.5 to 0.5 */\n00600 yc = (int) floor( yy + 0.5 );\n00601 gaussian_kernel( kernel, sigma, (double) h + yy - (double) yc );\n00602 /* the kernel must be computed for each y because the fine\n00603 offset yy-yc is different in each case */\n00604 \n00605 for(x=0;x<out->xsize;x++)\n00606 {\n00607 sum = 0.0;\n00608 for(i=0;i<kernel->dim;i++)\n00609 {\n00610 j = yc - h + i;\n00611 \n00612 /* symmetry boundary condition */\n00613 while( j < 0 ) j += double_y_size;\n00614 while( j >= double_y_size ) j -= double_y_size;\n00615 if( j >= (int) in->ysize ) j = double_y_size-1-j;\n00616 \n00617 sum += aux->data[ x + j * aux->xsize ] * kernel->values[i];\n00618 }\n00619 out->data[ x + y * out->xsize ] = sum;\n00620 }\n00621 }\n00622 \n00623 /* free memory */\n00624 free_ntuple_list(kernel);\n00625 free_image_double(aux);\n00626 \n00627 return out;\n00628 }\n00629 \n00630 \n00631 /*----------------------------------------------------------------------------*/\n00632 /*--------------------------------- Gradient ---------------------------------*/\n00633 /*----------------------------------------------------------------------------*/\n00634 \n00635 /*----------------------------------------------------------------------------*/\n00636 /** Computes the direction of the level line of 'in' at each point.\n00637 \n00638 The result is:\n00639 - an image_double with the angle at each pixel, or NOTDEF if not defined.\n00640 - the image_double 'modgrad' (a pointer is passed as argument)\n00641 with the gradient magnitude at each point.\n00642 - a list of pixels 'list_p' roughly ordered by decreasing\n00643 gradient magnitude. (The order is made by classifying points\n00644 into bins by gradient magnitude. The parameters 'n_bins' and\n00645 'max_grad' specify the number of bins and the gradient modulus\n00646 at the highest bin. The pixels in the list would be in\n00647 decreasing gradient magnitude, up to a precision of the size of\n00648 the bins.)\n00649 - a pointer 'mem_p' to the memory used by 'list_p' to be able to\n00650 free the memory when it is not used anymore.\n00651 */\n00652staticimage_doublell_angle( image_double in, double threshold,\n00653 structcoorlist ** list_p, void ** mem_p,\n00654 image_double * modgrad, unsignedint n_bins,\n00655 double max_grad )\n00656 {\n00657 image_double g;\n00658 unsignedint n,p,x,y,adr,i;\n00659 double com1,com2,gx,gy,norm,norm2;\n00660 /* the rest of the variables are used for pseudo-ordering\n00661 the gradient magnitude values */\n00662 int list_count = 0;\n00663 struct coorlist * list;\n00664 struct coorlist ** range_l_s; /* array of pointers to start of bin list */\n00665 struct coorlist ** range_l_e; /* array of pointers to end of bin list */\n00666 struct coorlist * start;\n00667 struct coorlist * end;\n00668 \n00669 /* check parameters */\n00670 if( in == NULL || in->data == NULL || in->xsize == 0 || in->ysize == 0 )\n00671 error(\"ll_angle: invalid image.\");\n00672 if( threshold < 0.0 ) error(\"ll_angle: 'threshold' must be positive.\");\n00673 if( list_p == NULL ) error(\"ll_angle: NULL pointer 'list_p'.\");\n00674 if( mem_p == NULL ) error(\"ll_angle: NULL pointer 'mem_p'.\");\n00675 if( modgrad == NULL ) error(\"ll_angle: NULL pointer 'modgrad'.\");\n00676 if( n_bins == 0 ) error(\"ll_angle: 'n_bins' must be positive.\");\n00677 if( max_grad <= 0.0 ) error(\"ll_angle: 'max_grad' must be positive.\");\n00678 \n00679 /* image size shortcuts */\n00680 n = in->ysize;\n00681 p = in->xsize;\n00682 \n00683 /* allocate output image */\n00684 g = new_image_double(in->xsize,in->ysize);\n00685 \n00686 /* get memory for the image of gradient modulus */\n00687 *modgrad = new_image_double(in->xsize,in->ysize);\n00688 \n00689 /* get memory for \"ordered\" list of pixels */\n00690 list = (struct coorlist *) calloc( (size_t) (n*p), sizeof(structcoorlist) );\n00691 *mem_p = (void *) list;\n00692 range_l_s = (struct coorlist **) calloc( (size_t) n_bins,\n00693 sizeof(structcoorlist *) );\n00694 range_l_e = (struct coorlist **) calloc( (size_t) n_bins,\n00695 sizeof(structcoorlist *) );\n00696 if( list == NULL || range_l_s == NULL || range_l_e == NULL )\n00697 error(\"not enough memory.\");\n00698 for(i=0;i<n_bins;i++) range_l_s[i] = range_l_e[i] = NULL;\n00699 \n00700 /* 'undefined' on the down and right boundaries */\n00701 for(x=0;x<p;x++) g->data[(n-1)*p+x] = NOTDEF;\n00702 for(y=0;y<n;y++) g->data[p*y+p-1] = NOTDEF;\n00703 \n00704 /* compute gradient on the remaining pixels */\n00705 for(x=0;x<p-1;x++)\n00706 for(y=0;y<n-1;y++)\n00707 {\n00708 adr = y*p+x;\n00709 \n00710 /*\n00711 Norm 2 computation using 2x2 pixel window:\n00712 A B\n00713 C D\n00714 and\n00715 com1 = D-A, com2 = B-C.\n00716 Then\n00717 gx = B+D - (A+C) horizontal difference\n00718 gy = C+D - (A+B) vertical difference\n00719 com1 and com2 are just to avoid 2 additions.\n00720 */\n00721 com1 = in->data[adr+p+1] - in->data[adr];\n00722 com2 = in->data[adr+1] - in->data[adr+p];\n00723 \n00724 gx = com1+com2; /* gradient x component */\n00725 gy = com1-com2; /* gradient y component */\n00726 norm2 = gx*gx+gy*gy;\n00727 norm = sqrt( norm2 / 4.0 ); /* gradient norm */\n00728 \n00729 (*modgrad)->data[adr] = norm; /* store gradient norm */\n00730 \n00731 if( norm <= threshold ) /* norm too small, gradient no defined */\n00732 g->data[adr] = NOTDEF; /* gradient angle not defined */\n00733 else\n00734 {\n00735 /* gradient angle computation */\n00736 g->data[adr] = atan2(gx,-gy);\n00737 \n00738 /* store the point in the right bin according to its norm */\n00739 i = (unsignedint) (norm * (double) n_bins / max_grad);\n00740 if( i >= n_bins ) i = n_bins-1;\n00741 if( range_l_e[i] == NULL )\n00742 range_l_s[i] = range_l_e[i] = list+list_count++;\n00743 else\n00744 {\n00745 range_l_e[i]->next = list+list_count;\n00746 range_l_e[i] = list+list_count++;\n00747 }\n00748 range_l_e[i]->x = (int) x;\n00749 range_l_e[i]->y = (int) y;\n00750 range_l_e[i]->next = NULL;\n00751 }\n00752 }\n00753 \n00754 /* Make the list of pixels (almost) ordered by norm value.\n00755 It starts by the larger bin, so the list starts by the\n00756 pixels with higher gradient value. Pixels would be ordered\n00757 by norm value, up to a precision given by max_grad/n_bins.\n00758 */\n00759 for(i=n_bins-1; i>0 && range_l_s[i]==NULL; i--);\n00760 start = range_l_s[i];\n00761 end = range_l_e[i];\n00762 if( start != NULL )\n00763 for(i--;i>0; i--)\n00764 if( range_l_s[i] != NULL )\n00765 {\n00766 end->next = range_l_s[i];\n00767 end = range_l_e[i];\n00768 }\n00769 *list_p = start;\n00770 \n00771 /* free memory */\n00772 free( (void *) range_l_s );\n00773 free( (void *) range_l_e );\n00774 \n00775 return g;\n00776 }\n00777 \n00778 /*----------------------------------------------------------------------------*/\n00779 /** Is point (x,y) aligned to angle theta, up to precision 'prec'?\n00780 */\n00781staticintisaligned( int x, int y, image_double angles, double theta,\n00782 double prec )\n00783 {\n00784 double a;\n00785 \n00786 /* check parameters */\n00787 if( angles == NULL || angles->data == NULL )\n00788 error(\"isaligned: invalid image 'angles'.\");\n00789 if( x < 0 || y < 0 || x >= (int) angles->xsize || y >= (int) angles->ysize )\n00790 error(\"isaligned: (x,y) out of the image.\");\n00791 if( prec < 0.0 ) error(\"isaligned: 'prec' must be positive.\");\n00792 \n00793 /* angle at pixel (x,y) */\n00794 a = angles->data[ x + y * angles->xsize ];\n00795 \n00796 /* pixels whose level-line angle is not defined\n00797 are considered as NON-aligned */\n00798 if( a == NOTDEF ) returnFALSE; /* there is no need to call the function\n00799 'double_equal' here because there is\n00800 no risk of problems related to the\n00801 comparison doubles, we are only\n00802 interested in the exact NOTDEF value */\n00803 \n00804 /* it is assumed that 'theta' and 'a' are in the range [-pi,pi] */\n00805 theta -= a;\n00806 if( theta < 0.0 ) theta = -theta;\n00807 if( theta > M_3_2_PI )\n00808 {\n00809 theta -= M_2__PI;\n00810 if( theta < 0.0 ) theta = -theta;\n00811 }\n00812 \n00813 return theta < prec;\n00814 }\n00815 \n00816 /*----------------------------------------------------------------------------*/\n00817 /** Absolute value angle difference.\n00818 */\n00819staticdoubleangle_diff(double a, double b)\n00820 {\n00821 a -= b;\n00822 while( a <= -M_PI ) a += M_2__PI;\n00823 while( a > M_PI ) a -= M_2__PI;\n00824 if( a < 0.0 ) a = -a;\n00825 return a;\n00826 }\n00827 \n00828 /*----------------------------------------------------------------------------*/\n00829 /** Signed angle difference.\n00830 */\n00831staticdoubleangle_diff_signed(double a, double b)\n00832 {\n00833 a -= b;\n00834 while( a <= -M_PI ) a += M_2__PI;\n00835 while( a > M_PI ) a -= M_2__PI;\n00836 return a;\n00837 }\n00838 \n00839 \n00840 /*----------------------------------------------------------------------------*/\n00841 /*----------------------------- NFA computation ------------------------------*/\n00842 /*----------------------------------------------------------------------------*/\n00843 \n00844 /*----------------------------------------------------------------------------*/\n00845 /** Computes the natural logarithm of the absolute value of\n00846 the gamma function of x using the Lanczos approximation.\n00847 See http://www.rskey.org/gamma.htm\n00848 \n00849 The formula used is\n00850 @f[\n00851 \\Gamma(x) = \\frac{ \\sum_{n=0}^{N} q_n x^n }{ \\Pi_{n=0}^{N} (x+n) }\n00852 (x+5.5)^{x+0.5} e^{-(x+5.5)}\n00853 @f]\n00854 so\n00855 @f[\n00856 \\log\\Gamma(x) = \\log\\left( \\sum_{n=0}^{N} q_n x^n \\right)\n00857 + (x+0.5) \\log(x+5.5) - (x+5.5) - \\sum_{n=0}^{N} \\log(x+n)\n00858 @f]\n00859 and\n00860 q0 = 75122.6331530,\n00861 q1 = 80916.6278952,\n00862 q2 = 36308.2951477,\n00863 q3 = 8687.24529705,\n00864 q4 = 1168.92649479,\n00865 q5 = 83.8676043424,\n00866 q6 = 2.50662827511.\n00867 */\n00868staticdoublelog_gamma_lanczos(double x)\n00869 {\n00870 staticdouble q[7] = { 75122.6331530, 80916.6278952, 36308.2951477,\n00871 8687.24529705, 1168.92649479, 83.8676043424,\n00872 2.50662827511 };\n00873 double a = (x+0.5) * log(x+5.5) - (x+5.5);\n00874 double b = 0.0;\n00875 int n;\n00876 \n00877 for(n=0;n<7;n++)\n00878 {\n00879 a -= log( x + (double) n );\n00880 b += q[n] * pow( x, (double) n );\n00881 }\n00882 return a + log(b);\n00883 }\n00884 \n00885 /*----------------------------------------------------------------------------*/\n00886 /** Computes the natural logarithm of the absolute value of\n00887 the gamma function of x using Windschitl method.\n00888 See http://www.rskey.org/gamma.htm\n00889 \n00890 The formula used is\n00891 @f[\n00892 \\Gamma(x) = \\sqrt{\\frac{2\\pi}{x}} \\left( \\frac{x}{e}\n00893 \\sqrt{ x\\sinh(1/x) + \\frac{1}{810x^6} } \\right)^x\n00894 @f]\n00895 so\n00896 @f[\n00897 \\log\\Gamma(x) = 0.5\\log(2\\pi) + (x-0.5)\\log(x) - x\n00898 + 0.5x\\log\\left( x\\sinh(1/x) + \\frac{1}{810x^6} \\right).\n00899 @f]\n00900 This formula is a good approximation when x > 15.\n00901 */\n00902staticdoublelog_gamma_windschitl(double x)\n00903 {\n00904 return 0.918938533204673 + (x-0.5)*log(x) - x\n00905 + 0.5*x*log( x*sinh(1/x) + 1/(810.0*pow(x,6.0)) );\n00906 }\n00907 \n00908 /*----------------------------------------------------------------------------*/\n00909 /** Computes the natural logarithm of the absolute value of\n00910 the gamma function of x. When x>15 use log_gamma_windschitl(),\n00911 otherwise use log_gamma_lanczos().\n00912 */\n00913#define log_gamma(x) ((x)>15.0?log_gamma_windschitl(x):log_gamma_lanczos(x))\n00914 \n00915 /*----------------------------------------------------------------------------*/\n00916 /** Size of the table to store already computed inverse values.\n00917 */\n00918#define TABSIZE 100000\n00919 \n00920 /*----------------------------------------------------------------------------*/\n00921 /** Computes -log10(NFA).\n00922 \n00923 NFA stands for Number of False Alarms:\n00924 @f[\n00925 \\mathrm{NFA} = NT \\cdot B(n,k,p)\n00926 @f]\n00927 \n00928 - NT - number of tests\n00929 - B(n,k,p) - tail of binomial distribution with parameters n,k and p:\n00930 @f[\n00931 B(n,k,p) = \\sum_{j=k}^n\n00932 \\left(\\begin{array}{c}n\\\\j\\end{array}\\right)\n00933 p^{j} (1-p)^{n-j}\n00934 @f]\n00935 \n00936 The value -log10(NFA) is equivalent but more intuitive than NFA:\n00937 - -1 corresponds to 10 mean false alarms\n00938 - 0 corresponds to 1 mean false alarm\n00939 - 1 corresponds to 0.1 mean false alarms\n00940 - 2 corresponds to 0.01 mean false alarms\n00941 - ...\n00942 \n00943 Used this way, the bigger the value, better the detection,\n00944 and a logarithmic scale is used.\n00945 \n00946 @param n,k,p binomial parameters.\n00947 @param logNT logarithm of Number of Tests\n00948 \n00949 The computation is based in the gamma function by the following\n00950 relation:\n00951 @f[\n00952 \\left(\\begin{array}{c}n\\\\k\\end{array}\\right)\n00953 = \\frac{ \\Gamma(n+1) }{ \\Gamma(k+1) \\cdot \\Gamma(n-k+1) }.\n00954 @f]\n00955 We use efficient algorithms to compute the logarithm of\n00956 the gamma function.\n00957 \n00958 To make the computation faster, not all the sum is computed, part\n00959 of the terms are neglected based on a bound to the error obtained\n00960 (an error of 10% in the result is accepted).\n00961 */\n00962staticdoublenfa(int n, int k, double p, double logNT)\n00963 {\n00964 staticdouble inv[TABSIZE]; /* table to keep computed inverse values */\n00965 double tolerance = 0.1; /* an error of 10% in the result is accepted */\n00966 double log1term,term,bin_term,mult_term,bin_tail,err,p_term;\n00967 int i;\n00968 \n00969 /* check parameters */\n00970 if( n<0 || k<0 || k>n || p<=0.0 || p>=1.0 )\n00971 error(\"nfa: wrong n, k or p values.\");\n00972 \n00973 /* trivial cases */\n00974 if( n==0 || k==0 ) return -logNT;\n00975 if( n==k ) return -logNT - (double) n * log10(p);\n00976 \n00977 /* probability term */\n00978 p_term = p / (1.0-p);\n00979 \n00980 /* compute the first term of the series */\n00981 /*\n00982 binomial_tail(n,k,p) = sum_{i=k}^n bincoef(n,i) * p^i * (1-p)^{n-i}\n00983 where bincoef(n,i) are the binomial coefficients.\n00984 But\n00985 bincoef(n,k) = gamma(n+1) / ( gamma(k+1) * gamma(n-k+1) ).\n00986 We use this to compute the first term. Actually the log of it.\n00987 */\n00988 log1term = log_gamma( (double) n + 1.0 ) - log_gamma( (double) k + 1.0 )\n00989 - log_gamma( (double) (n-k) + 1.0 )\n00990 + (double) k * log(p) + (double) (n-k) * log(1.0-p);\n00991 term = exp(log1term);\n00992 \n00993 /* in some cases no more computations are needed */\n00994 if( double_equal(term,0.0) ) /* the first term is almost zero */\n00995 {\n00996 if( (double) k > (double) n * p ) /* at begin or end of the tail? */\n00997 return -log1term / M_LN10 - logNT; /* end: use just the first term */\n00998 else\n00999 return -logNT; /* begin: the tail is roughly 1 */\n01000 }\n01001 \n01002 /* compute more terms if needed */\n01003 bin_tail = term;\n01004 for(i=k+1;i<=n;i++)\n01005 {\n01006 /*\n01007 As\n01008 term_i = bincoef(n,i) * p^i * (1-p)^(n-i)\n01009 and\n01010 bincoef(n,i)/bincoef(n,i-1) = n-1+1 / i,\n01011 then,\n01012 term_i / term_i-1 = (n-i+1)/i * p/(1-p)\n01013 and\n01014 term_i = term_i-1 * (n-i+1)/i * p/(1-p).\n01015 1/i is stored in a table as they are computed,\n01016 because divisions are expensive.\n01017 p/(1-p) is computed only once and stored in 'p_term'.\n01018 */\n01019 bin_term = (double) (n-i+1) * ( i<TABSIZE ?\n01020 ( inv[i]!=0.0 ? inv[i] : ( inv[i] = 1.0 / (double) i ) ) :\n01021 1.0 / (double) i );\n01022 \n01023 mult_term = bin_term * p_term;\n01024 term *= mult_term;\n01025 bin_tail += term;\n01026 if(bin_term<1.0)\n01027 {\n01028 /* When bin_term<1 then mult_term_j<mult_term_i for j>i.\n01029 Then, the error on the binomial tail when truncated at\n01030 the i term can be bounded by a geometric series of form\n01031 term_i * sum mult_term_i^j. */\n01032 err = term * ( ( 1.0 - pow( mult_term, (double) (n-i+1) ) ) /\n01033 (1.0-mult_term) - 1.0 );\n01034 \n01035 /* One wants an error at most of tolerance*final_result, or:\n01036 tolerance * abs(-log10(bin_tail)-logNT).\n01037 Now, the error that can be accepted on bin_tail is\n01038 given by tolerance*final_result divided by the derivative\n01039 of -log10(x) when x=bin_tail. that is:\n01040 tolerance * abs(-log10(bin_tail)-logNT) / (1/bin_tail)\n01041 Finally, we truncate the tail if the error is less than:\n01042 tolerance * abs(-log10(bin_tail)-logNT) * bin_tail */\n01043 if( err < tolerance * fabs(-log10(bin_tail)-logNT) * bin_tail ) break;\n01044 }\n01045 }\n01046 return -log10(bin_tail) - logNT;\n01047 }\n01048 \n01049 \n01050 /*----------------------------------------------------------------------------*/\n01051 /*--------------------------- Rectangle structure ----------------------------*/\n01052 /*----------------------------------------------------------------------------*/\n01053 \n01054 /*----------------------------------------------------------------------------*/\n01055 /** Rectangle structure: line segment with width.\n01056 */\n01057struct rect\n01058 {\n01059doublex1,y1,x2,y2; /* first and second point of the line segment */\n01060doublewidth; /* rectangle width */\n01061doublex,y; /* center of the rectangle */\n01062doubletheta; /* angle */\n01063doubledx,dy; /* vector with the line segment angle */\n01064doubleprec; /* tolerance angle */\n01065doublep; /* probability of a point with angle within 'prec' */\n01066 };\n01067 \n01068 /*----------------------------------------------------------------------------*/\n01069 /** Copy one rectangle structure to another.\n01070 */\n01071staticvoidrect_copy(structrect * in, structrect * out)\n01072 {\n01073 /* check parameters */\n01074 if( in == NULL || out == NULL ) error(\"rect_copy: invalid 'in' or 'out'.\");\n01075 \n01076 /* copy values */\n01077 out->x1 = in->x1;\n01078 out->y1 = in->y1;\n01079 out->x2 = in->x2;\n01080 out->y2 = in->y2;\n01081 out->width = in->width;\n01082 out->x = in->x;\n01083 out->y = in->y;\n01084 out->theta = in->theta;\n01085 out->dx = in->dx;\n01086 out->dy = in->dy;\n01087 out->prec = in->prec;\n01088 out->p = in->p;\n01089 }\n01090 \n01091 /*----------------------------------------------------------------------------*/\n01092 /** Rectangle points iterator.\n01093 \n01094 The integer coordinates of pixels inside a rectangle are\n01095 iteratively explored. This structure keep track of the process and\n01096 functions ri_ini(), ri_inc(), ri_end(), and ri_del() are used in\n01097 the process. An example of how to use the iterator is as follows:\n01098 \\code\n01099 \n01100 struct rect * rec = XXX; // some rectangle\n01101 rect_iter * i;\n01102 for( i=ri_ini(rec); !ri_end(i); ri_inc(i) )\n01103 {\n01104 // your code, using 'i->x' and 'i->y' as coordinates\n01105 }\n01106 ri_del(i); // delete iterator\n01107 \n01108 \\endcode\n01109 The pixels are explored 'column' by 'column', where we call\n01110 'column' a set of pixels with the same x value that are inside the\n01111 rectangle. The following is an schematic representation of a\n01112 rectangle, the 'column' being explored is marked by colons, and\n01113 the current pixel being explored is 'x,y'.\n01114 \\verbatim\n01115 \n01116 vx[1],vy[1]\n01117 * *\n01118 * *\n01119 * *\n01120 * ye\n01121 * : *\n01122 vx[0],vy[0] : *\n01123 * : *\n01124 * x,y *\n01125 * : *\n01126 * : vx[2],vy[2]\n01127 * : *\n01128 y ys *\n01129 ^ * *\n01130 | * *\n01131 | * *\n01132 +---> x vx[3],vy[3]\n01133 \n01134 \\endverbatim\n01135 The first 'column' to be explored is the one with the smaller x\n01136 value. Each 'column' is explored starting from the pixel of the\n01137 'column' (inside the rectangle) with the smaller y value.\n01138 \n01139 The four corners of the rectangle are stored in order that rotates\n01140 around the corners at the arrays 'vx[]' and 'vy[]'. The first\n01141 point is always the one with smaller x value.\n01142 \n01143 'x' and 'y' are the coordinates of the pixel being explored. 'ys'\n01144 and 'ye' are the start and end values of the current column being\n01145 explored. So, 'ys' < 'ye'.\n01146 */\n01147typedefstruct\n01148 {\n01149double vx[4]; /* rectangle's corner X coordinates in circular order */\n01150double vy[4]; /* rectangle's corner Y coordinates in circular order */\n01151double ys,ye; /* start and end Y values of current 'column' */\n01152int x,y; /* coordinates of currently explored pixel */\n01153 } rect_iter;\n01154 \n01155 /*----------------------------------------------------------------------------*/\n01156 /** Interpolate y value corresponding to 'x' value given, in\n01157 the line 'x1,y1' to 'x2,y2'; if 'x1=x2' return the smaller\n01158 of 'y1' and 'y2'.\n01159 \n01160 The following restrictions are required:\n01161 - x1 <= x2\n01162 - x1 <= x\n01163 - x <= x2\n01164 */\n01165staticdoubleinter_low(double x, double x1, double y1, double x2, double y2)\n01166 {\n01167 /* check parameters */\n01168 if( x1 > x2 || x < x1 || x > x2 )\n01169 error(\"inter_low: unsuitable input, 'x1>x2' or 'x<x1' or 'x>x2'.\");\n01170 \n01171 /* interpolation */\n01172 if( double_equal(x1,x2) && y1<y2 ) return y1;\n01173 if( double_equal(x1,x2) && y1>y2 ) return y2;\n01174 return y1 + (x-x1) * (y2-y1) / (x2-x1);\n01175 }\n01176 \n01177 /*----------------------------------------------------------------------------*/\n01178 /** Interpolate y value corresponding to 'x' value given, in\n01179 the line 'x1,y1' to 'x2,y2'; if 'x1=x2' return the larger\n01180 of 'y1' and 'y2'.\n01181 \n01182 The following restrictions are required:\n01183 - x1 <= x2\n01184 - x1 <= x\n01185 - x <= x2\n01186 */\n01187staticdoubleinter_hi(double x, double x1, double y1, double x2, double y2)\n01188 {\n01189 /* check parameters */\n01190 if( x1 > x2 || x < x1 || x > x2 )\n01191 error(\"inter_hi: unsuitable input, 'x1>x2' or 'x<x1' or 'x>x2'.\");\n01192 \n01193 /* interpolation */\n01194 if( double_equal(x1,x2) && y1<y2 ) return y2;\n01195 if( double_equal(x1,x2) && y1>y2 ) return y1;\n01196 return y1 + (x-x1) * (y2-y1) / (x2-x1);\n01197 }\n01198 \n01199 /*----------------------------------------------------------------------------*/\n01200 /** Free memory used by a rectangle iterator.\n01201 */\n01202staticvoidri_del(rect_iter * iter)\n01203 {\n01204 if( iter == NULL ) error(\"ri_del: NULL iterator.\");\n01205 free( (void *) iter );\n01206 }\n01207 \n01208 /*----------------------------------------------------------------------------*/\n01209 /** Check if the iterator finished the full iteration.\n01210 \n01211 See details in \\ref rect_iter\n01212 */\n01213staticintri_end(rect_iter * i)\n01214 {\n01215 /* check input */\n01216 if( i == NULL ) error(\"ri_end: NULL iterator.\");\n01217 \n01218 /* if the current x value is larger than the larger\n01219 x value in the rectangle (vx[2]), we know the full\n01220 exploration of the rectangle is finished. */\n01221 return (double)(i->x) > i->vx[2];\n01222 }\n01223 \n01224 /*----------------------------------------------------------------------------*/\n01225 /** Increment a rectangle iterator.\n01226 \n01227 See details in \\ref rect_iter\n01228 */\n01229staticvoidri_inc(rect_iter * i)\n01230 {\n01231 /* check input */\n01232 if( i == NULL ) error(\"ri_inc: NULL iterator.\");\n01233 \n01234 /* if not at end of exploration,\n01235 increase y value for next pixel in the 'column' */\n01236 if( !ri_end(i) ) i->y++;\n01237 \n01238 /* if the end of the current 'column' is reached,\n01239 and it is not the end of exploration,\n01240 advance to the next 'column' */\n01241 while( (double) (i->y) > i->ye && !ri_end(i) )\n01242 {\n01243 /* increase x, next 'column' */\n01244 i->x++;\n01245 \n01246 /* if end of exploration, return */\n01247 if( ri_end(i) ) return;\n01248 \n01249 /* update lower y limit (start) for the new 'column'.\n01250 \n01251 We need to interpolate the y value that corresponds to the\n01252 lower side of the rectangle. The first thing is to decide if\n01253 the corresponding side is\n01254 \n01255 vx[0],vy[0] to vx[3],vy[3] or\n01256 vx[3],vy[3] to vx[2],vy[2]\n01257 \n01258 Then, the side is interpolated for the x value of the\n01259 'column'. But, if the side is vertical (as it could happen if\n01260 the rectangle is vertical and we are dealing with the first\n01261 or last 'columns') then we pick the lower value of the side\n01262 by using 'inter_low'.\n01263 */\n01264 if( (double) i->x < i->vx[3] )\n01265 i->ys = inter_low((double)i->x,i->vx[0],i->vy[0],i->vx[3],i->vy[3]);\n01266 else\n01267 i->ys = inter_low((double)i->x,i->vx[3],i->vy[3],i->vx[2],i->vy[2]);\n01268 \n01269 /* update upper y limit (end) for the new 'column'.\n01270 \n01271 We need to interpolate the y value that corresponds to the\n01272 upper side of the rectangle. The first thing is to decide if\n01273 the corresponding side is\n01274 \n01275 vx[0],vy[0] to vx[1],vy[1] or\n01276 vx[1],vy[1] to vx[2],vy[2]\n01277 \n01278 Then, the side is interpolated for the x value of the\n01279 'column'. But, if the side is vertical (as it could happen if\n01280 the rectangle is vertical and we are dealing with the first\n01281 or last 'columns') then we pick the lower value of the side\n01282 by using 'inter_low'.\n01283 */\n01284 if( (double)i->x < i->vx[1] )\n01285 i->ye = inter_hi((double)i->x,i->vx[0],i->vy[0],i->vx[1],i->vy[1]);\n01286 else\n01287 i->ye = inter_hi((double)i->x,i->vx[1],i->vy[1],i->vx[2],i->vy[2]);\n01288 \n01289 /* new y */\n01290 i->y = (int) ceil(i->ys);\n01291 }\n01292 }\n01293 \n01294 /*----------------------------------------------------------------------------*/\n01295 /** Create and initialize a rectangle iterator.\n01296 \n01297 See details in \\ref rect_iter\n01298 */\n01299staticrect_iter * ri_ini(structrect * r)\n01300 {\n01301 double vx[4],vy[4];\n01302 int n,offset;\n01303 rect_iter * i;\n01304 \n01305 /* check parameters */\n01306 if( r == NULL ) error(\"ri_ini: invalid rectangle.\");\n01307 \n01308 /* get memory */\n01309 i = (rect_iter *) malloc(sizeof(rect_iter));\n01310 if( i == NULL ) error(\"ri_ini: Not enough memory.\");\n01311 \n01312 /* build list of rectangle corners ordered\n01313 in a circular way around the rectangle */\n01314 vx[0] = r->x1 - r->dy * r->width / 2.0;\n01315 vy[0] = r->y1 + r->dx * r->width / 2.0;\n01316 vx[1] = r->x2 - r->dy * r->width / 2.0;\n01317 vy[1] = r->y2 + r->dx * r->width / 2.0;\n01318 vx[2] = r->x2 + r->dy * r->width / 2.0;\n01319 vy[2] = r->y2 - r->dx * r->width / 2.0;\n01320 vx[3] = r->x1 + r->dy * r->width / 2.0;\n01321 vy[3] = r->y1 - r->dx * r->width / 2.0;\n01322 \n01323 /* compute rotation of index of corners needed so that the first\n01324 point has the smaller x.\n01325 \n01326 if one side is vertical, thus two corners have the same smaller x\n01327 value, the one with the largest y value is selected as the first.\n01328 */\n01329 if( r->x1 < r->x2 && r->y1 <= r->y2 ) offset = 0;\n01330 elseif( r->x1 >= r->x2 && r->y1 < r->y2 ) offset = 1;\n01331 elseif( r->x1 > r->x2 && r->y1 >= r->y2 ) offset = 2;\n01332 else offset = 3;\n01333 \n01334 /* apply rotation of index. */\n01335 for(n=0; n<4; n++)\n01336 {\n01337 i->vx[n] = vx[(offset+n)%4];\n01338 i->vy[n] = vy[(offset+n)%4];\n01339 }\n01340 \n01341 /* Set a initial condition.\n01342 \n01343 The values are set to values that will cause 'ri_inc' (that will\n01344 be called immediately) to initialize correctly the first 'column'\n01345 and compute the limits 'ys' and 'ye'.\n01346 \n01347 'y' is set to the integer value of vy[0], the starting corner.\n01348 \n01349 'ys' and 'ye' are set to very small values, so 'ri_inc' will\n01350 notice that it needs to start a new 'column'.\n01351 \n01352 The smaller integer coordinate inside of the rectangle is\n01353 'ceil(vx[0])'. The current 'x' value is set to that value minus\n01354 one, so 'ri_inc' (that will increase x by one) will advance to\n01355 the first 'column'.\n01356 */\n01357 i->x = (int) ceil(i->vx[0]) - 1;\n01358 i->y = (int) ceil(i->vy[0]);\n01359 i->ys = i->ye = -DBL_MAX;\n01360 \n01361 /* advance to the first pixel */\n01362 ri_inc(i);\n01363 \n01364 return i;\n01365 }\n01366 \n01367 /*----------------------------------------------------------------------------*/\n01368 /** Compute a rectangle's NFA value.\n01369 */\n01370staticdoublerect_nfa(structrect * rec, image_double angles, double logNT)\n01371 {\n01372 rect_iter * i;\n01373 int pts = 0;\n01374 int alg = 0;\n01375 \n01376 /* check parameters */\n01377 if( rec == NULL ) error(\"rect_nfa: invalid rectangle.\");\n01378 if( angles == NULL ) error(\"rect_nfa: invalid 'angles'.\");\n01379 \n01380 /* compute the total number of pixels and of aligned points in 'rec' */\n01381 for(i=ri_ini(rec); !ri_end(i); ri_inc(i)) /* rectangle iterator */\n01382 if( i->x >= 0 && i->y >= 0 &&\n01383 i->x < (int) angles->xsize && i->y < (int) angles->ysize )\n01384 {\n01385 ++pts; /* total number of pixels counter */\n01386 if( isaligned(i->x, i->y, angles, rec->theta, rec->prec) )\n01387 ++alg; /* aligned points counter */\n01388 }\n01389 ri_del(i); /* delete iterator */\n01390 \n01391 returnnfa(pts,alg,rec->p,logNT); /* compute NFA value */\n01392 }\n01393 \n01394 \n01395 /*----------------------------------------------------------------------------*/\n01396 /*---------------------------------- Regions ---------------------------------*/\n01397 /*----------------------------------------------------------------------------*/\n01398 \n01399 /*----------------------------------------------------------------------------*/\n01400 /** Compute region's angle as the principal inertia axis of the region.\n01401 \n01402 The following is the region inertia matrix A:\n01403 @f[\n01404 \n01405 A = \\left(\\begin{array}{cc}\n01406 Ixx & Ixy \\\\\n01407 Ixy & Iyy \\\\\n01408 \\end{array}\\right)\n01409 \n01410 @f]\n01411 where\n01412 \n01413 Ixx = sum_i G(i).(y_i - cx)^2\n01414 \n01415 Iyy = sum_i G(i).(x_i - cy)^2\n01416 \n01417 Ixy = - sum_i G(i).(x_i - cx).(y_i - cy)\n01418 \n01419 and\n01420 - G(i) is the gradient norm at pixel i, used as pixel's weight.\n01421 - x_i and y_i are the coordinates of pixel i.\n01422 - cx and cy are the coordinates of the center of th region.\n01423 \n01424 lambda1 and lambda2 are the eigenvalues of matrix A,\n01425 with lambda1 >= lambda2. They are found by solving the\n01426 characteristic polynomial:\n01427 \n01428 det( lambda I - A) = 0\n01429 \n01430 that gives:\n01431 \n01432 lambda1 = ( Ixx + Iyy + sqrt( (Ixx-Iyy)^2 + 4.0*Ixy*Ixy) ) / 2\n01433 \n01434 lambda2 = ( Ixx + Iyy - sqrt( (Ixx-Iyy)^2 + 4.0*Ixy*Ixy) ) / 2\n01435 \n01436 To get the line segment direction we want to get the angle the\n01437 eigenvector assotiated to the smaller eigenvalue. We have to solve\n01438 a,b in:\n01439 \n01440 a.Ixx + b.Ixy = a.lambda2\n01441 \n01442 a.Ixy + b.Iyy = b.lambda2\n01443 \n01444 We want the angle theta = atan(b/a). It can be computed with\n01445 any of the two equations:\n01446 \n01447 theta = atan( (lambda2-Ixx) / Ixy )\n01448 \n01449 or\n01450 \n01451 theta = atan( Ixy / (lambda2-Iyy) )\n01452 \n01453 When |Ixx| > |Iyy| we use the first, otherwise the second (just to\n01454 get better numeric precision).\n01455 */\n01456staticdoubleget_theta( structpoint * reg, int reg_size, double x, double y,\n01457 image_double modgrad, double reg_angle, double prec )\n01458 {\n01459 double lambda,theta,weight;\n01460 double Ixx = 0.0;\n01461 double Iyy = 0.0;\n01462 double Ixy = 0.0;\n01463 int i;\n01464 \n01465 /* check parameters */\n01466 if( reg == NULL ) error(\"get_theta: invalid region.\");\n01467 if( reg_size <= 1 ) error(\"get_theta: region size <= 1.\");\n01468 if( modgrad == NULL || modgrad->data == NULL )\n01469 error(\"get_theta: invalid 'modgrad'.\");\n01470 if( prec < 0.0 ) error(\"get_theta: 'prec' must be positive.\");\n01471 \n01472 /* compute inertia matrix */\n01473 for(i=0; i<reg_size; i++)\n01474 {\n01475 weight = modgrad->data[ reg[i].x + reg[i].y * modgrad->xsize ];\n01476 Ixx += ( (double) reg[i].y - y ) * ( (double) reg[i].y - y ) * weight;\n01477 Iyy += ( (double) reg[i].x - x ) * ( (double) reg[i].x - x ) * weight;\n01478 Ixy -= ( (double) reg[i].x - x ) * ( (double) reg[i].y - y ) * weight;\n01479 }\n01480 if( double_equal(Ixx,0.0) && double_equal(Iyy,0.0) && double_equal(Ixy,0.0) )\n01481 error(\"get_theta: null inertia matrix.\");\n01482 \n01483 /* compute smallest eigenvalue */\n01484 lambda = 0.5 * ( Ixx + Iyy - sqrt( (Ixx-Iyy)*(Ixx-Iyy) + 4.0*Ixy*Ixy ) );\n01485 \n01486 /* compute angle */\n01487 theta = fabs(Ixx)>fabs(Iyy) ? atan2(lambda-Ixx,Ixy) : atan2(Ixy,lambda-Iyy);\n01488 \n01489 /* The previous procedure don't cares about orientation,\n01490 so it could be wrong by 180 degrees. Here is corrected if necessary. */\n01491 if( angle_diff(theta,reg_angle) > prec ) theta += M_PI;\n01492 \n01493 return theta;\n01494 }\n01495 \n01496 /*----------------------------------------------------------------------------*/\n01497 /** Computes a rectangle that covers a region of points.\n01498 */\n01499staticvoidregion2rect( structpoint * reg, int reg_size,\n01500 image_double modgrad, double reg_angle,\n01501 double prec, double p, structrect * rec )\n01502 {\n01503 double x,y,dx,dy,l,w,theta,weight,sum,l_min,l_max,w_min,w_max;\n01504 int i;\n01505 \n01506 /* check parameters */\n01507 if( reg == NULL ) error(\"region2rect: invalid region.\");\n01508 if( reg_size <= 1 ) error(\"region2rect: region size <= 1.\");\n01509 if( modgrad == NULL || modgrad->data == NULL )\n01510 error(\"region2rect: invalid image 'modgrad'.\");\n01511 if( rec == NULL ) error(\"region2rect: invalid 'rec'.\");\n01512 \n01513 /* center of the region:\n01514 \n01515 It is computed as the weighted sum of the coordinates\n01516 of all the pixels in the region. The norm of the gradient\n01517 is used as the weight of a pixel. The sum is as follows:\n01518 cx = \\sum_i G(i).x_i\n01519 cy = \\sum_i G(i).y_i\n01520 where G(i) is the norm of the gradient of pixel i\n01521 and x_i,y_i are its coordinates.\n01522 */\n01523 x = y = sum = 0.0;\n01524 for(i=0; i<reg_size; i++)\n01525 {\n01526 weight = modgrad->data[ reg[i].x + reg[i].y * modgrad->xsize ];\n01527 x += (double) reg[i].x * weight;\n01528 y += (double) reg[i].y * weight;\n01529 sum += weight;\n01530 }\n01531 if( sum <= 0.0 ) error(\"region2rect: weights sum equal to zero.\");\n01532 x /= sum;\n01533 y /= sum;\n01534 \n01535 /* theta */\n01536 theta = get_theta(reg,reg_size,x,y,modgrad,reg_angle,prec);\n01537 \n01538 /* length and width:\n01539 \n01540 'l' and 'w' are computed as the distance from the center of the\n01541 region to pixel i, projected along the rectangle axis (dx,dy) and\n01542 to the orthogonal axis (-dy,dx), respectively.\n01543 \n01544 The length of the rectangle goes from l_min to l_max, where l_min\n01545 and l_max are the minimum and maximum values of l in the region.\n01546 Analogously, the width is selected from w_min to w_max, where\n01547 w_min and w_max are the minimum and maximum of w for the pixels\n01548 in the region.\n01549 */\n01550 dx = cos(theta);\n01551 dy = sin(theta);\n01552 l_min = l_max = w_min = w_max = 0.0;\n01553 for(i=0; i<reg_size; i++)\n01554 {\n01555 l = ( (double) reg[i].x - x) * dx + ( (double) reg[i].y - y) * dy;\n01556 w = -( (double) reg[i].x - x) * dy + ( (double) reg[i].y - y) * dx;\n01557 \n01558 if( l > l_max ) l_max = l;\n01559 if( l < l_min ) l_min = l;\n01560 if( w > w_max ) w_max = w;\n01561 if( w < w_min ) w_min = w;\n01562 }\n01563 \n01564 /* store values */\n01565 rec->x1 = x + l_min * dx;\n01566 rec->y1 = y + l_min * dy;\n01567 rec->x2 = x + l_max * dx;\n01568 rec->y2 = y + l_max * dy;\n01569 rec->width = w_max - w_min;\n01570 rec->x = x;\n01571 rec->y = y;\n01572 rec->theta = theta;\n01573 rec->dx = dx;\n01574 rec->dy = dy;\n01575 rec->prec = prec;\n01576 rec->p = p;\n01577 \n01578 /* we impose a minimal width of one pixel\n01579 \n01580 A sharp horizontal or vertical step would produce a perfectly\n01581 horizontal or vertical region. The width computed would be\n01582 zero. But that corresponds to a one pixels width transition in\n01583 the image.\n01584 */\n01585 if( rec->width < 1.0 ) rec->width = 1.0;\n01586 }\n01587 \n01588 /*----------------------------------------------------------------------------*/\n01589 /** Build a region of pixels that share the same angle, up to a\n01590 tolerance 'prec', starting at point (x,y).\n01591 */\n01592staticvoidregion_grow( int x, int y, image_double angles, structpoint * reg,\n01593 int * reg_size, double * reg_angle, image_char used,\n01594 double prec )\n01595 {\n01596 double sumdx,sumdy;\n01597 int xx,yy,i;\n01598 \n01599 /* check parameters */\n01600 if( x < 0 || y < 0 || x >= (int) angles->xsize || y >= (int) angles->ysize )\n01601 error(\"region_grow: (x,y) out of the image.\");\n01602 if( angles == NULL || angles->data == NULL )\n01603 error(\"region_grow: invalid image 'angles'.\");\n01604 if( reg == NULL ) error(\"region_grow: invalid 'reg'.\");\n01605 if( reg_size == NULL ) error(\"region_grow: invalid pointer 'reg_size'.\");\n01606 if( reg_angle == NULL ) error(\"region_grow: invalid pointer 'reg_angle'.\");\n01607 if( used == NULL || used->data == NULL )\n01608 error(\"region_grow: invalid image 'used'.\");\n01609 \n01610 /* first point of the region */\n01611 *reg_size = 1;\n01612 reg[0].x = x;\n01613 reg[0].y = y;\n01614 *reg_angle = angles->data[x+y*angles->xsize]; /* region's angle */\n01615 sumdx = cos(*reg_angle);\n01616 sumdy = sin(*reg_angle);\n01617 used->data[x+y*used->xsize] = USED;\n01618 \n01619 /* try neighbors as new region points */\n01620 for(i=0; i<*reg_size; i++)\n01621 for(xx=reg[i].x-1; xx<=reg[i].x+1; xx++)\n01622 for(yy=reg[i].y-1; yy<=reg[i].y+1; yy++)\n01623 if( xx>=0 && yy>=0 && xx<(int)used->xsize && yy<(int)used->ysize &&\n01624 used->data[xx+yy*used->xsize] != USED &&\n01625 isaligned(xx,yy,angles,*reg_angle,prec) )\n01626 {\n01627 /* add point */\n01628 used->data[xx+yy*used->xsize] = USED;\n01629 reg[*reg_size].x = xx;\n01630 reg[*reg_size].y = yy;\n01631 ++(*reg_size);\n01632 \n01633 /* update region's angle */\n01634 sumdx += cos( angles->data[xx+yy*angles->xsize] );\n01635 sumdy += sin( angles->data[xx+yy*angles->xsize] );\n01636 *reg_angle = atan2(sumdy,sumdx);\n01637 }\n01638 }\n01639 \n01640 /*----------------------------------------------------------------------------*/\n01641 /** Try some rectangles variations to improve NFA value. Only if the\n01642 rectangle is not meaningful (i.e., log_nfa <= eps).\n01643 */\n01644staticdoublerect_improve( structrect * rec, image_double angles,\n01645 double logNT, double eps )\n01646 {\n01647 struct rect r;\n01648 double log_nfa,log_nfa_new;\n01649 double delta = 0.5;\n01650 double delta_2 = delta / 2.0;\n01651 int n;\n01652 \n01653 log_nfa = rect_nfa(rec,angles,logNT);\n01654 \n01655 if( log_nfa > eps ) return log_nfa;\n01656 \n01657 /* try finer precisions */\n01658 rect_copy(rec,&r);\n01659 for(n=0; n<5; n++)\n01660 {\n01661 r.p /= 2.0;\n01662 r.prec = r.p * M_PI;\n01663 log_nfa_new = rect_nfa(&r,angles,logNT);\n01664 if( log_nfa_new > log_nfa )\n01665 {\n01666 log_nfa = log_nfa_new;\n01667 rect_copy(&r,rec);\n01668 }\n01669 }\n01670 \n01671 if( log_nfa > eps ) return log_nfa;\n01672 \n01673 /* try to reduce width */\n01674 rect_copy(rec,&r);\n01675 for(n=0; n<5; n++)\n01676 {\n01677 if( (r.width - delta) >= 0.5 )\n01678 {\n01679 r.width -= delta;\n01680 log_nfa_new = rect_nfa(&r,angles,logNT);\n01681 if( log_nfa_new > log_nfa )\n01682 {\n01683 rect_copy(&r,rec);\n01684 log_nfa = log_nfa_new;\n01685 }\n01686 }\n01687 }\n01688 \n01689 if( log_nfa > eps ) return log_nfa;\n01690 \n01691 /* try to reduce one side of the rectangle */\n01692 rect_copy(rec,&r);\n01693 for(n=0; n<5; n++)\n01694 {\n01695 if( (r.width - delta) >= 0.5 )\n01696 {\n01697 r.x1 += -r.dy * delta_2;\n01698 r.y1 += r.dx * delta_2;\n01699 r.x2 += -r.dy * delta_2;\n01700 r.y2 += r.dx * delta_2;\n01701 r.width -= delta;\n01702 log_nfa_new = rect_nfa(&r,angles,logNT);\n01703 if( log_nfa_new > log_nfa )\n01704 {\n01705 rect_copy(&r,rec);\n01706 log_nfa = log_nfa_new;\n01707 }\n01708 }\n01709 }\n01710 \n01711 if( log_nfa > eps ) return log_nfa;\n01712 \n01713 /* try to reduce the other side of the rectangle */\n01714 rect_copy(rec,&r);\n01715 for(n=0; n<5; n++)\n01716 {\n01717 if( (r.width - delta) >= 0.5 )\n01718 {\n01719 r.x1 -= -r.dy * delta_2;\n01720 r.y1 -= r.dx * delta_2;\n01721 r.x2 -= -r.dy * delta_2;\n01722 r.y2 -= r.dx * delta_2;\n01723 r.width -= delta;\n01724 log_nfa_new = rect_nfa(&r,angles,logNT);\n01725 if( log_nfa_new > log_nfa )\n01726 {\n01727 rect_copy(&r,rec);\n01728 log_nfa = log_nfa_new;\n01729 }\n01730 }\n01731 }\n01732 \n01733 if( log_nfa > eps ) return log_nfa;\n01734 \n01735 /* try even finer precisions */\n01736 rect_copy(rec,&r);\n01737 for(n=0; n<5; n++)\n01738 {\n01739 r.p /= 2.0;\n01740 r.prec = r.p * M_PI;\n01741 log_nfa_new = rect_nfa(&r,angles,logNT);\n01742 if( log_nfa_new > log_nfa )\n01743 {\n01744 log_nfa = log_nfa_new;\n01745 rect_copy(&r,rec);\n01746 }\n01747 }\n01748 \n01749 return log_nfa;\n01750 }\n01751 \n01752 /*----------------------------------------------------------------------------*/\n01753 /** Reduce the region size, by elimination the points far from the\n01754 starting point, until that leads to rectangle with the right\n01755 density of region points or to discard the region if too small.\n01756 */\n01757staticintreduce_region_radius( structpoint * reg, int * reg_size,\n01758 image_double modgrad, double reg_angle,\n01759 double prec, double p, structrect * rec,\n01760 image_char used, image_double angles,\n01761 double density_th )\n01762 {\n01763 double density,rad1,rad2,rad,xc,yc;\n01764 int i;\n01765 \n01766 /* check parameters */\n01767 if( reg == NULL ) error(\"reduce_region_radius: invalid pointer 'reg'.\");\n01768 if( reg_size == NULL )\n01769 error(\"reduce_region_radius: invalid pointer 'reg_size'.\");\n01770 if( prec < 0.0 ) error(\"reduce_region_radius: 'prec' must be positive.\");\n01771 if( rec == NULL ) error(\"reduce_region_radius: invalid pointer 'rec'.\");\n01772 if( used == NULL || used->data == NULL )\n01773 error(\"reduce_region_radius: invalid image 'used'.\");\n01774 if( angles == NULL || angles->data == NULL )\n01775 error(\"reduce_region_radius: invalid image 'angles'.\");\n01776 \n01777 /* compute region points density */\n01778 density = (double) *reg_size /\n01779 ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n01780 \n01781 /* if the density criterion is satisfied there is nothing to do */\n01782 if( density >= density_th ) returnTRUE;\n01783 \n01784 /* compute region's radius */\n01785 xc = (double) reg[0].x;\n01786 yc = (double) reg[0].y;\n01787 rad1 = dist( xc, yc, rec->x1, rec->y1 );\n01788 rad2 = dist( xc, yc, rec->x2, rec->y2 );\n01789 rad = rad1 > rad2 ? rad1 : rad2;\n01790 \n01791 /* while the density criterion is not satisfied, remove farther pixels */\n01792 while( density < density_th )\n01793 {\n01794 rad *= 0.75; /* reduce region's radius to 75% of its value */\n01795 \n01796 /* remove points from the region and update 'used' map */\n01797 for(i=0; i<*reg_size; i++)\n01798 if( dist( xc, yc, (double) reg[i].x, (double) reg[i].y ) > rad )\n01799 {\n01800 /* point not kept, mark it as NOTUSED */\n01801 used->data[ reg[i].x + reg[i].y * used->xsize ] = NOTUSED;\n01802 /* remove point from the region */\n01803 reg[i].x = reg[*reg_size-1].x; /* if i==*reg_size-1 copy itself */\n01804 reg[i].y = reg[*reg_size-1].y;\n01805 --(*reg_size);\n01806 --i; /* to avoid skipping one point */\n01807 }\n01808 \n01809 /* reject if the region is too small.\n01810 2 is the minimal region size for 'region2rect' to work. */\n01811 if( *reg_size < 2 ) returnFALSE;\n01812 \n01813 /* re-compute rectangle */\n01814 region2rect(reg,*reg_size,modgrad,reg_angle,prec,p,rec);\n01815 \n01816 /* re-compute region points density */\n01817 density = (double) *reg_size /\n01818 ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n01819 }\n01820 \n01821 /* if this point is reached, the density criterion is satisfied */\n01822 returnTRUE;\n01823 }\n01824 \n01825 /*----------------------------------------------------------------------------*/\n01826 /** Refine a rectangle.\n01827 \n01828 For that, an estimation of the angle tolerance is performed by the\n01829 standard deviation of the angle at points near the region's\n01830 starting point. Then, a new region is grown starting from the same\n01831 point, but using the estimated angle tolerance. If this fails to\n01832 produce a rectangle with the right density of region points,\n01833 'reduce_region_radius' is called to try to satisfy this condition.\n01834 */\n01835staticintrefine( structpoint * reg, int * reg_size, image_double modgrad,\n01836 double reg_angle, double prec, double p, structrect * rec,\n01837 image_char used, image_double angles, double density_th )\n01838 {\n01839 double angle,ang_d,mean_angle,tau,density,xc,yc,ang_c,sum,s_sum;\n01840 int i,n;\n01841 \n01842 /* check parameters */\n01843 if( reg == NULL ) error(\"refine: invalid pointer 'reg'.\");\n01844 if( reg_size == NULL ) error(\"refine: invalid pointer 'reg_size'.\");\n01845 if( prec < 0.0 ) error(\"refine: 'prec' must be positive.\");\n01846 if( rec == NULL ) error(\"refine: invalid pointer 'rec'.\");\n01847 if( used == NULL || used->data == NULL )\n01848 error(\"refine: invalid image 'used'.\");\n01849 if( angles == NULL || angles->data == NULL )\n01850 error(\"refine: invalid image 'angles'.\");\n01851 \n01852 /* compute region points density */\n01853 density = (double) *reg_size /\n01854 ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n01855 \n01856 /* if the density criterion is satisfied there is nothing to do */\n01857 if( density >= density_th ) returnTRUE;\n01858 \n01859 /*------ First try: reduce angle tolerance ------*/\n01860 \n01861 /* compute the new mean angle and tolerance */\n01862 xc = (double) reg[0].x;\n01863 yc = (double) reg[0].y;\n01864 ang_c = angles->data[ reg[0].x + reg[0].y * angles->xsize ];\n01865 sum = s_sum = 0.0;\n01866 n = 0;\n01867 for(i=0; i<*reg_size; i++)\n01868 {\n01869 used->data[ reg[i].x + reg[i].y * used->xsize ] = NOTUSED;\n01870 if( dist( xc, yc, (double) reg[i].x, (double) reg[i].y ) < rec->width )\n01871 {\n01872 angle = angles->data[ reg[i].x + reg[i].y * angles->xsize ];\n01873 ang_d = angle_diff_signed(angle,ang_c);\n01874 sum += ang_d;\n01875 s_sum += ang_d * ang_d;\n01876 ++n;\n01877 }\n01878 }\n01879 mean_angle = sum / (double) n;\n01880 tau = 2.0 * sqrt( (s_sum - 2.0 * mean_angle * sum) / (double) n\n01881 + mean_angle*mean_angle ); /* 2 * standard deviation */\n01882 \n01883 /* find a new region from the same starting point and new angle tolerance */\n01884 region_grow(reg[0].x,reg[0].y,angles,reg,reg_size,®_angle,used,tau);\n01885 \n01886 /* if the region is too small, reject */\n01887 if( *reg_size < 2 ) returnFALSE;\n01888 \n01889 /* re-compute rectangle */\n01890 region2rect(reg,*reg_size,modgrad,reg_angle,prec,p,rec);\n01891 \n01892 /* re-compute region points density */\n01893 density = (double) *reg_size /\n01894 ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n01895 \n01896 /*------ Second try: reduce region radius ------*/\n01897 if( density < density_th )\n01898 returnreduce_region_radius( reg, reg_size, modgrad, reg_angle, prec, p,\n01899 rec, used, angles, density_th );\n01900 \n01901 /* if this point is reached, the density criterion is satisfied */\n01902 returnTRUE;\n01903 }\n01904 \n01905 \n01906 /*----------------------------------------------------------------------------*/\n01907 /*-------------------------- Line Segment Detector ---------------------------*/\n01908 /*----------------------------------------------------------------------------*/\n01909 \n01910 /*----------------------------------------------------------------------------*/\n01911 /** LSD full interface.\n01912 */\n01913ntuple_listLineSegmentDetection( image_double image, double scale,\n01914 double sigma_scale, double quant,\n01915 double ang_th, double eps, double density_th,\n01916 int n_bins, double max_grad,\n01917 image_int * region )\n01918 {\n01919 ntuple_list out = new_ntuple_list(5);\n01920 image_double scaled_image,angles,modgrad;\n01921 image_char used;\n01922 struct coorlist * list_p;\n01923 void * mem_p;\n01924 struct rect rec;\n01925 struct point * reg;\n01926 int reg_size,min_reg_size,i;\n01927 unsignedint xsize,ysize;\n01928 double rho,reg_angle,prec,p,log_nfa,logNT;\n01929 int ls_count = 0; /* line segments are numbered 1,2,3,... */\n01930 \n01931 \n01932 /* check parameters */\n01933 if( image==NULL || image->data==NULL || image->xsize==0 || image->ysize==0 )\n01934 error(\"invalid image input.\");\n01935 if( scale <= 0.0 ) error(\"'scale' value must be positive.\");\n01936 if( sigma_scale <= 0.0 ) error(\"'sigma_scale' value must be positive.\");\n01937 if( quant < 0.0 ) error(\"'quant' value must be positive.\");\n01938 if( ang_th <= 0.0 || ang_th >= 180.0 )\n01939 error(\"'ang_th' value must be in the range (0,180).\");\n01940 if( density_th < 0.0 || density_th > 1.0 )\n01941 error(\"'density_th' value must be in the range [0,1].\");\n01942 if( n_bins <= 0 ) error(\"'n_bins' value must be positive.\");\n01943 if( max_grad <= 0.0 ) error(\"'max_grad' value must be positive.\");\n01944 \n01945 \n01946 /* angle tolerance */\n01947 prec = M_PI * ang_th / 180.0;\n01948 p = ang_th / 180.0;\n01949 rho = quant / sin(prec); /* gradient magnitude threshold */\n01950 \n01951 \n01952 /* scale image (if necessary) and compute angle at each pixel */\n01953 if( scale != 1.0 )\n01954 {\n01955 scaled_image = gaussian_sampler( image, scale, sigma_scale );\n01956 angles = ll_angle( scaled_image, rho, &list_p, &mem_p,\n01957 &modgrad, (unsignedint) n_bins, max_grad );\n01958 free_image_double(scaled_image);\n01959 }\n01960 else\n01961 angles = ll_angle( image, rho, &list_p, &mem_p, &modgrad,\n01962 (unsignedint) n_bins, max_grad );\n01963 xsize = angles->xsize;\n01964 ysize = angles->ysize;\n01965 logNT = 5.0 * ( log10( (double) xsize ) + log10( (double) ysize ) ) / 2.0;\n01966 min_reg_size = (int) (-logNT/log10(p)); /* minimal number of points in region\n01967 that can give a meaningful event */\n01968 \n01969 \n01970 /* initialize some structures */\n01971 if( region != NULL ) /* image to output pixel region number, if asked */\n01972 *region = new_image_int_ini(angles->xsize,angles->ysize,0);\n01973 used = new_image_char_ini(xsize,ysize,NOTUSED);\n01974 reg = (struct point *) calloc( (size_t) (xsize*ysize), sizeof(structpoint) );\n01975 if( reg == NULL ) error(\"not enough memory!\");\n01976 \n01977 \n01978 /* search for line segments */\n01979 for(; list_p != NULL; list_p = list_p->next )\n01980 if( used->data[ list_p->x + list_p->y * used->xsize ] == NOTUSED &&\n01981 angles->data[ list_p->x + list_p->y * angles->xsize ] != NOTDEF )\n01982 /* there is no risk of double comparison problems here\n01983 because we are only interested in the exact NOTDEF value */\n01984 {\n01985 /* find the region of connected point and ~equal angle */\n01986 region_grow( list_p->x, list_p->y, angles, reg, ®_size,\n01987 ®_angle, used, prec );\n01988 \n01989 /* reject small regions */\n01990 if( reg_size < min_reg_size ) continue;\n01991 \n01992 /* construct rectangular approximation for the region */\n01993 region2rect(reg,reg_size,modgrad,reg_angle,prec,p,&rec);\n01994 \n01995 /* Check if the rectangle exceeds the minimal density of\n01996 region points. If not, try to improve the region.\n01997 The rectangle will be rejected if the final one does\n01998 not fulfill the minimal density condition.\n01999 This is an addition to the original LSD algorithm published in\n02000 \"LSD: A Fast Line Segment Detector with a False Detection Control\"\n02001 by R. Grompone von Gioi, J. Jakubowicz, J.M. Morel, and G. Randall.\n02002 The original algorithm is obtained with density_th = 0.0.\n02003 */\n02004 if( !refine( reg, ®_size, modgrad, reg_angle,\n02005 prec, p, &rec, used, angles, density_th ) ) continue;\n02006 \n02007 /* compute NFA value */\n02008 log_nfa = rect_improve(&rec,angles,logNT,eps);\n02009 if( log_nfa <= eps ) continue;\n02010 \n02011 /* A New Line Segment was found! */\n02012 ++ls_count; /* increase line segment counter */\n02013 \n02014 /*\n02015 The gradient was computed with a 2x2 mask, its value corresponds to\n02016 points with an offset of (0.5,0.5), that should be added to output.\n02017 The coordinates origin is at the center of pixel (0,0).\n02018 */\n02019 rec.x1 += 0.5; rec.y1 += 0.5;\n02020 rec.x2 += 0.5; rec.y2 += 0.5;\n02021 \n02022 /* scale the result values if a subsampling was performed */\n02023 if( scale != 1.0 )\n02024 {\n02025 rec.x1 /= scale; rec.y1 /= scale;\n02026 rec.x2 /= scale; rec.y2 /= scale;\n02027 rec.width /= scale;\n02028 }\n02029 \n02030 /* add line segment found to output */\n02031 add_5tuple(out, rec.x1, rec.y1, rec.x2, rec.y2, rec.width);\n02032 \n02033 /* add region number to 'region' image if needed */\n02034 if( region != NULL )\n02035 for(i=0; i<reg_size; i++)\n02036 (*region)->data[reg[i].x+reg[i].y*(*region)->xsize] = ls_count;\n02037 }\n02038 \n02039 \n02040 /* free memory */\n02041 free_image_double(angles);\n02042 free_image_double(modgrad);\n02043 free_image_char(used);\n02044 free( (void *) reg );\n02045 free( (void *) mem_p );\n02046 \n02047 return out;\n02048 }\n02049 \n02050 /*----------------------------------------------------------------------------*/\n02051 /** LSD Simple Interface with Scale.\n02052 */\n02053ntuple_listlsd_scale(image_double image, double scale)\n02054 {\n02055 /* LSD parameters */\n02056 double sigma_scale = 0.6; /* Sigma for Gaussian filter is computed as\n02057 sigma = sigma_scale/scale. */\n02058 double quant = 2.0; /* Bound to the quantization error on the\n02059 gradient norm. */\n02060 double ang_th = 22.5; /* Gradient angle tolerance in degrees. */\n02061 double eps = 0.0; /* Detection threshold, -log10(NFA). */\n02062 double density_th = 0.7; /* Minimal density of region points in rectangle. */\n02063 int n_bins = 1024; /* Number of bins in pseudo-ordering of gradient\n02064 modulus. */\n02065 double max_grad = 255.0; /* Gradient modulus in the highest bin. The\n02066 default value corresponds to the highest\n02067 gradient modulus on images with gray\n02068 levels in [0,255]. */\n02069 \n02070 returnLineSegmentDetection( image, scale, sigma_scale, quant, ang_th, eps,\n02071 density_th, n_bins, max_grad, NULL );\n02072 }\n02073 \n02074 /*----------------------------------------------------------------------------*/\n02075 /** LSD Simple Interface.\n02076 */\n02077ntuple_listlsd(image_double image)\n02078 {\n02079 /* LSD parameters */\n02080 double scale = 0.8; /* Scale the image by Gaussian filter to 'scale'. */\n02081 \n02082 returnlsd_scale(image,scale);\n02083 }\n02084 /*----------------------------------------------------------------------------*/\n
Generated on Fri Dec 3 10:18:18 2010 for LSD by\n\n \n1.3.4 \n\n\n"
},
{
"path": "thirdparty/LSD/doc/lsd_8c.html",
"content": "\n\nLSD: lsd.c File Reference\n\n\n\n
Reduce the region size, by elimination the points far from the starting point, until that leads to rectangle with the right density of region points or to discard the region if too small.
00820 {\n00821 a -= b;\n00822 while( a <= -M_PI ) a += M_2__PI;\n00823 while( a > M_PI ) a -= M_2__PI;\n00824 if( a < 0.0 ) a = -a;\n00825 return a;\n00826 }\n
\nThe resulting rounding error after floating point computations depend on the specific operations done. The same number computed by different algorithms could present different rounding errors. For a useful comparison, an estimation of the relative rounding error should be considered and compared to a factor times EPS. The factor should be related to the cumulated rounding error in the chain of computation. Here, as a simplification, a fixed factor is used. \n
00156 {\n00157 double abs_diff,aa,bb,abs_max;\n00158 \n00159 /* trivial case */\n00160 if( a == b ) returnTRUE;\n00161 \n00162 abs_diff = fabs(a-b);\n00163 aa = fabs(a);\n00164 bb = fabs(b);\n00165 abs_max = aa > bb ? aa : bb;\n00166 \n00167 /* DBL_MIN is the smallest normalized number, thus, the smallest\n00168 number whose relative error is bounded by DBL_EPSILON. For\n00169 smaller numbers, the same quantization steps as for DBL_MIN\n00170 are used. Then, for smaller numbers, a meaningful \"relative\"\n00171 error should be computed by dividing the difference by DBL_MIN. */\n00172 if( abs_max < DBL_MIN ) abs_max = DBL_MIN;\n00173 \n00174 /* equal if relative error <= factor x eps */\n00175 return (abs_diff / abs_max) <= (RELATIVE_ERROR_FACTOR * DBL_EPSILON);\n00176 }\n
\nScale the input image 'in' by a factor 'scale' by Gaussian sub-sampling. \n
\nFor example, scale=0.8 will give a result at 80% of the original size.
\nThe image is convolved with a Gaussian kernel
\n\n
\n before the sub-sampling to prevent aliasing.
\nThe standard deviation sigma given by:
\n
sigma = sigma_scale / scale, if scale < 1.0
sigma = sigma_scale, if scale >= 1.0
\n
\nTo be able to sub-sample at non-integer steps, some interpolation is needed. In this implementation, the interpolation is done by the Gaussian kernel, so both operations (filtering and sampling) are done at the same time. The Gaussian kernel is computed centered on the coordinates of the required sample. In this way, when applied, it gives directly the result of convolving the image with the kernel and interpolated to that particular position.
\nA fast algorithm is done using the separability of the Gaussian kernel. Applying the 2D Gaussian kernel is equivalent to applying first a horizontal 1D Gaussian kernel and then a vertical 1D Gaussian kernel (or the other way round). The reason is that
\n\n
\n where
\n\n
\n The algorithm first apply a combined Gaussian kernel and sampling in the x axis, and then the combined Gaussian kernel and sampling in the y axis. \n
00513 {\n00514 image_double aux,out;\n00515 ntuple_list kernel;\n00516 unsignedint N,M,h,n,x,y,i;\n00517 int xc,yc,j,double_x_size,double_y_size;\n00518 double sigma,xx,yy,sum,prec;\n00519 \n00520 /* check parameters */\n00521 if( in == NULL || in->data == NULL || in->xsize == 0 || in->ysize == 0 )\n00522 error(\"gaussian_sampler: invalid image.\");\n00523 if( scale <= 0.0 ) error(\"gaussian_sampler: 'scale' must be positive.\");\n00524 if( sigma_scale <= 0.0 )\n00525 error(\"gaussian_sampler: 'sigma_scale' must be positive.\");\n00526 \n00527 /* get memory for images */\n00528 if( in->xsize * scale > (double) UINT_MAX ||\n00529 in->ysize * scale > (double) UINT_MAX )\n00530 error(\"gaussian_sampler: the output image size exceeds the handled size.\");\n00531 N = (unsignedint) floor( in->xsize * scale );\n00532 M = (unsignedint) floor( in->ysize * scale );\n00533 aux = new_image_double(N,in->ysize);\n00534 out = new_image_double(N,M);\n00535 \n00536 /* sigma, kernel size and memory for the kernel */\n00537 sigma = scale < 1.0 ? sigma_scale / scale : sigma_scale;\n00538 /*\n00539 The size of the kernel is selected to guarantee that the\n00540 the first discarded term is at least 10^prec times smaller\n00541 than the central value. For that, h should be larger than x, with\n00542 e^(-x^2/2sigma^2) = 1/10^prec.\n00543 Then,\n00544 x = sigma * sqrt( 2 * prec * ln(10) ).\n00545 */\n00546 prec = 3.0;\n00547 h = (unsignedint) ceil( sigma * sqrt( 2.0 * prec * log(10.0) ) );\n00548 n = 1+2*h; /* kernel size */\n00549 kernel = new_ntuple_list(n);\n00550 \n00551 /* auxiliary double image size variables */\n00552 double_x_size = (int) (2 * in->xsize);\n00553 double_y_size = (int) (2 * in->ysize);\n00554 \n00555 /* First subsampling: x axis */\n00556 for(x=0;x<aux->xsize;x++)\n00557 {\n00558 /*\n00559 x is the coordinate in the new image.\n00560 xx is the corresponding x-value in the original size image.\n00561 xc is the integer value, the pixel coordinate of xx.\n00562 */\n00563 xx = (double) x / scale;\n00564 /* coordinate (0.0,0.0) is in the center of pixel (0,0),\n00565 so the pixel with xc=0 get the values of xx from -0.5 to 0.5 */\n00566 xc = (int) floor( xx + 0.5 );\n00567 gaussian_kernel( kernel, sigma, (double) h + xx - (double) xc );\n00568 /* the kernel must be computed for each x because the fine\n00569 offset xx-xc is different in each case */\n00570 \n00571 for(y=0;y<aux->ysize;y++)\n00572 {\n00573 sum = 0.0;\n00574 for(i=0;i<kernel->dim;i++)\n00575 {\n00576 j = xc - h + i;\n00577 \n00578 /* symmetry boundary condition */\n00579 while( j < 0 ) j += double_x_size;\n00580 while( j >= double_x_size ) j -= double_x_size;\n00581 if( j >= (int) in->xsize ) j = double_x_size-1-j;\n00582 \n00583 sum += in->data[ j + y * in->xsize ] * kernel->values[i];\n00584 }\n00585 aux->data[ x + y * aux->xsize ] = sum;\n00586 }\n00587 }\n00588 \n00589 /* Second subsampling: y axis */\n00590 for(y=0;y<out->ysize;y++)\n00591 {\n00592 /*\n00593 y is the coordinate in the new image.\n00594 yy is the corresponding x-value in the original size image.\n00595 yc is the integer value, the pixel coordinate of xx.\n00596 */\n00597 yy = (double) y / scale;\n00598 /* coordinate (0.0,0.0) is in the center of pixel (0,0),\n00599 so the pixel with yc=0 get the values of yy from -0.5 to 0.5 */\n00600 yc = (int) floor( yy + 0.5 );\n00601 gaussian_kernel( kernel, sigma, (double) h + yy - (double) yc );\n00602 /* the kernel must be computed for each y because the fine\n00603 offset yy-yc is different in each case */\n00604 \n00605 for(x=0;x<out->xsize;x++)\n00606 {\n00607 sum = 0.0;\n00608 for(i=0;i<kernel->dim;i++)\n00609 {\n00610 j = yc - h + i;\n00611 \n00612 /* symmetry boundary condition */\n00613 while( j < 0 ) j += double_y_size;\n00614 while( j >= double_y_size ) j -= double_y_size;\n00615 if( j >= (int) in->ysize ) j = double_y_size-1-j;\n00616 \n00617 sum += aux->data[ x + j * aux->xsize ] * kernel->values[i];\n00618 }\n00619 out->data[ x + y * out->xsize ] = sum;\n00620 }\n00621 }\n00622 \n00623 /* free memory */\n00624 free_ntuple_list(kernel);\n00625 free_image_double(aux);\n00626 \n00627 return out;\n00628 }\n
00783 {\n00784 double a;\n00785 \n00786 /* check parameters */\n00787 if( angles == NULL || angles->data == NULL )\n00788 error(\"isaligned: invalid image 'angles'.\");\n00789 if( x < 0 || y < 0 || x >= (int) angles->xsize || y >= (int) angles->ysize )\n00790 error(\"isaligned: (x,y) out of the image.\");\n00791 if( prec < 0.0 ) error(\"isaligned: 'prec' must be positive.\");\n00792 \n00793 /* angle at pixel (x,y) */\n00794 a = angles->data[ x + y * angles->xsize ];\n00795 \n00796 /* pixels whose level-line angle is not defined\n00797 are considered as NON-aligned */\n00798 if( a == NOTDEF ) returnFALSE; /* there is no need to call the function\n00799 'double_equal' here because there is\n00800 no risk of problems related to the\n00801 comparison doubles, we are only\n00802 interested in the exact NOTDEF value */\n00803 \n00804 /* it is assumed that 'theta' and 'a' are in the range [-pi,pi] */\n00805 theta -= a;\n00806 if( theta < 0.0 ) theta = -theta;\n00807 if( theta > M_3_2_PI )\n00808 {\n00809 theta -= M_2__PI;\n00810 if( theta < 0.0 ) theta = -theta;\n00811 }\n00812 \n00813 return theta < prec;\n00814 }\n
When different than 1.0, LSD will scale the image by Gaussian filtering. Example: is scale=0.8, the input image will be subsampled to 80% of its size, and then the line segment detector will be applied. Suggested value: 0.8
\n
sigma_scale
When scale!=1.0, the sigma of the Gaussian filter is: sigma = sigma_scale / scale, if scale < 1.0 sigma = sigma_scale, if scale >= 1.0 Suggested value: 0.6
\n
quant
Bound to the quantization error on the gradient norm. Example: if gray level is quantized to integer steps, the gradient (computed by finite differences) error due to quantization will be bounded by 2.0, as the worst case is when the error are 1 and -1, that gives an error of 2.0. Suggested value: 2.0
\n
ang_th
Gradient angle tolerance in the region growing algorithm, in degrees. Suggested value: 22.5
\n
eps
Detection threshold, -log10(NFA). The bigger, the more strict the detector is, and will result in less detections. (Note that the 'minus sign' makes that this behavior is opposite to the one of NFA.) The value -log10(NFA) is equivalent but more intuitive than NFA:
\n
-1.0 corresponds to 10 mean false alarms
0.0 corresponds to 1 mean false alarm
1.0 corresponds to 0.1 mean false alarms
2.0 corresponds to 0.01 mean false alarms
\nSuggested value: 0.0
\n
density_th
Minimal proportion of region points in a rectangle. Suggested value: 0.7
\n
n_bins
Number of bins used in the pseudo-ordering of gradient modulus. Suggested value: 1024
\n
max_grad
Gradient modulus in the highest bin. For example, for images with integer gray levels in [0,255], the maximum possible gradient value is 255.0. Suggested value: 255.0
\n
region
Optional output: an int image where the pixels used in some line support region are marked. Unused pixels have the value '0' while the used ones have the number of the line segment, numbered 1,2,3,... If desired, a non NULL pointer to an image_int should be used. The resulting image has the size of the image used for the processing, that is, the size of the input image scaled by the given factor 'scale'. Suggested value: NULL
\n
\n
\n
Returns:
A 5-tuple list, where each 5-tuple corresponds to a detected line segment. The five values are:
\n
x1,y1,x2,y2,width
\nfor a line segment from (x1,y1) to (x2,y2) and a width 'width'.
01918 {\n01919 ntuple_list out = new_ntuple_list(5);\n01920 image_double scaled_image,angles,modgrad;\n01921 image_char used;\n01922 struct coorlist * list_p;\n01923 void * mem_p;\n01924 struct rect rec;\n01925 struct point * reg;\n01926 int reg_size,min_reg_size,i;\n01927 unsignedint xsize,ysize;\n01928 double rho,reg_angle,prec,p,log_nfa,logNT;\n01929 int ls_count = 0; /* line segments are numbered 1,2,3,... */\n01930 \n01931 \n01932 /* check parameters */\n01933 if( image==NULL || image->data==NULL || image->xsize==0 || image->ysize==0 )\n01934 error(\"invalid image input.\");\n01935 if( scale <= 0.0 ) error(\"'scale' value must be positive.\");\n01936 if( sigma_scale <= 0.0 ) error(\"'sigma_scale' value must be positive.\");\n01937 if( quant < 0.0 ) error(\"'quant' value must be positive.\");\n01938 if( ang_th <= 0.0 || ang_th >= 180.0 )\n01939 error(\"'ang_th' value must be in the range (0,180).\");\n01940 if( density_th < 0.0 || density_th > 1.0 )\n01941 error(\"'density_th' value must be in the range [0,1].\");\n01942 if( n_bins <= 0 ) error(\"'n_bins' value must be positive.\");\n01943 if( max_grad <= 0.0 ) error(\"'max_grad' value must be positive.\");\n01944 \n01945 \n01946 /* angle tolerance */\n01947 prec = M_PI * ang_th / 180.0;\n01948 p = ang_th / 180.0;\n01949 rho = quant / sin(prec); /* gradient magnitude threshold */\n01950 \n01951 \n01952 /* scale image (if necessary) and compute angle at each pixel */\n01953 if( scale != 1.0 )\n01954 {\n01955 scaled_image = gaussian_sampler( image, scale, sigma_scale );\n01956 angles = ll_angle( scaled_image, rho, &list_p, &mem_p,\n01957 &modgrad, (unsignedint) n_bins, max_grad );\n01958 free_image_double(scaled_image);\n01959 }\n01960 else\n01961 angles = ll_angle( image, rho, &list_p, &mem_p, &modgrad,\n01962 (unsignedint) n_bins, max_grad );\n01963 xsize = angles->xsize;\n01964 ysize = angles->ysize;\n01965 logNT = 5.0 * ( log10( (double) xsize ) + log10( (double) ysize ) ) / 2.0;\n01966 min_reg_size = (int) (-logNT/log10(p)); /* minimal number of points in region\n01967 that can give a meaningful event */\n01968 \n01969 \n01970 /* initialize some structures */\n01971 if( region != NULL ) /* image to output pixel region number, if asked */\n01972 *region = new_image_int_ini(angles->xsize,angles->ysize,0);\n01973 used = new_image_char_ini(xsize,ysize,NOTUSED);\n01974 reg = (struct point *) calloc( (size_t) (xsize*ysize), sizeof(structpoint) );\n01975 if( reg == NULL ) error(\"not enough memory!\");\n01976 \n01977 \n01978 /* search for line segments */\n01979 for(; list_p != NULL; list_p = list_p->next )\n01980 if( used->data[ list_p->x + list_p->y * used->xsize ] == NOTUSED &&\n01981 angles->data[ list_p->x + list_p->y * angles->xsize ] != NOTDEF )\n01982 /* there is no risk of double comparison problems here\n01983 because we are only interested in the exact NOTDEF value */\n01984 {\n01985 /* find the region of connected point and ~equal angle */\n01986 region_grow( list_p->x, list_p->y, angles, reg, ®_size,\n01987 ®_angle, used, prec );\n01988 \n01989 /* reject small regions */\n01990 if( reg_size < min_reg_size ) continue;\n01991 \n01992 /* construct rectangular approximation for the region */\n01993 region2rect(reg,reg_size,modgrad,reg_angle,prec,p,&rec);\n01994 \n01995 /* Check if the rectangle exceeds the minimal density of\n01996 region points. If not, try to improve the region.\n01997 The rectangle will be rejected if the final one does\n01998 not fulfill the minimal density condition.\n01999 This is an addition to the original LSD algorithm published in\n02000 \"LSD: A Fast Line Segment Detector with a False Detection Control\"\n02001 by R. Grompone von Gioi, J. Jakubowicz, J.M. Morel, and G. Randall.\n02002 The original algorithm is obtained with density_th = 0.0.\n02003 */\n02004 if( !refine( reg, ®_size, modgrad, reg_angle,\n02005 prec, p, &rec, used, angles, density_th ) ) continue;\n02006 \n02007 /* compute NFA value */\n02008 log_nfa = rect_improve(&rec,angles,logNT,eps);\n02009 if( log_nfa <= eps ) continue;\n02010 \n02011 /* A New Line Segment was found! */\n02012 ++ls_count; /* increase line segment counter */\n02013 \n02014 /*\n02015 The gradient was computed with a 2x2 mask, its value corresponds to\n02016 points with an offset of (0.5,0.5), that should be added to output.\n02017 The coordinates origin is at the center of pixel (0,0).\n02018 */\n02019 rec.x1 += 0.5; rec.y1 += 0.5;\n02020 rec.x2 += 0.5; rec.y2 += 0.5;\n02021 \n02022 /* scale the result values if a subsampling was performed */\n02023 if( scale != 1.0 )\n02024 {\n02025 rec.x1 /= scale; rec.y1 /= scale;\n02026 rec.x2 /= scale; rec.y2 /= scale;\n02027 rec.width /= scale;\n02028 }\n02029 \n02030 /* add line segment found to output */\n02031 add_5tuple(out, rec.x1, rec.y1, rec.x2, rec.y2, rec.width);\n02032 \n02033 /* add region number to 'region' image if needed */\n02034 if( region != NULL )\n02035 for(i=0; i<reg_size; i++)\n02036 (*region)->data[reg[i].x+reg[i].y*(*region)->xsize] = ls_count;\n02037 }\n02038 \n02039 \n02040 /* free memory */\n02041 free_image_double(angles);\n02042 free_image_double(modgrad);\n02043 free_image_char(used);\n02044 free( (void *) reg );\n02045 free( (void *) mem_p );\n02046 \n02047 return out;\n02048 }\n
\nComputes the direction of the level line of 'in' at each point. \n
\nThe result is:
\n
an image_double with the angle at each pixel, or NOTDEF if not defined.
the image_double 'modgrad' (a pointer is passed as argument) with the gradient magnitude at each point.
a list of pixels 'list_p' roughly ordered by decreasing gradient magnitude. (The order is made by classifying points into bins by gradient magnitude. The parameters 'n_bins' and 'max_grad' specify the number of bins and the gradient modulus at the highest bin. The pixels in the list would be in decreasing gradient magnitude, up to a precision of the size of the bins.)
a pointer 'mem_p' to the memory used by 'list_p' to be able to free the memory when it is not used anymore.
When different than 1.0, LSD will scale the image by Gaussian filtering. Example: is scale=0.8, the input image will be subsampled to 80% of its size, and then the line segment detector will be applied. Suggested value: 0.8
00207 {\n00208 ntuple_list n_tuple;\n00209 \n00210 /* check parameters */\n00211 if( dim == 0 ) error(\"new_ntuple_list: 'dim' must be positive.\");\n00212 \n00213 /* get memory for list structure */\n00214 n_tuple = (ntuple_list) malloc( sizeof(structntuple_list_s) );\n00215 if( n_tuple == NULL ) error(\"not enough memory.\");\n00216 \n00217 /* initialize list */\n00218 n_tuple->size = 0;\n00219 n_tuple->max_size = 1;\n00220 n_tuple->dim = dim;\n00221 \n00222 /* get memory for tuples */\n00223 n_tuple->values = (double *) malloc( dim*n_tuple->max_size * sizeof(double) );\n00224 if( n_tuple->values == NULL ) error(\"not enough memory.\");\n00225 \n00226 return n_tuple;\n00227 }\n
\n
\n
\n\n
\nHere is the call graph for this function:
\n\n
\n
\n
\n
\n
\n
\n
double nfa
\n
(
\n
int
\n
n,
\n
\n
\n
\n
\n
int
\n
k,
\n
\n
\n
\n
\n
double
\n
p,
\n
\n
\n
\n
\n
double
\n
logNT
\n
\n
\n
\n
)
\n
[static]
\n
\n\n
\n
\n
\n
\n
\n
\n
\n \n
\n
\n\n
\nComputes -log10(NFA). \n
\nNFA stands for Number of False Alarms:
\n\n
\n
\n
\n
NT - number of tests
B(n,k,p) - tail of binomial distribution with parameters n,k and p:
\n\n
\n
\n
\nThe value -log10(NFA) is equivalent but more intuitive than NFA:
\n
-1 corresponds to 10 mean false alarms
0 corresponds to 1 mean false alarm
1 corresponds to 0.1 mean false alarms
2 corresponds to 0.01 mean false alarms
...
\n
\nUsed this way, the bigger the value, better the detection, and a logarithmic scale is used.
\n
Parameters:
\n
\n
n,k,p
binomial parameters.
\n
logNT
logarithm of Number of Tests
\n
\n
\nThe computation is based in the gamma function by the following relation:
\n\n
\n We use efficient algorithms to compute the logarithm of the gamma function.
\nTo make the computation faster, not all the sum is computed, part of the terms are neglected based on a bound to the error obtained (an error of 10% in the result is accepted). \n
00963 {\n00964 staticdouble inv[TABSIZE]; /* table to keep computed inverse values */\n00965 double tolerance = 0.1; /* an error of 10% in the result is accepted */\n00966 double log1term,term,bin_term,mult_term,bin_tail,err,p_term;\n00967 int i;\n00968 \n00969 /* check parameters */\n00970 if( n<0 || k<0 || k>n || p<=0.0 || p>=1.0 )\n00971 error(\"nfa: wrong n, k or p values.\");\n00972 \n00973 /* trivial cases */\n00974 if( n==0 || k==0 ) return -logNT;\n00975 if( n==k ) return -logNT - (double) n * log10(p);\n00976 \n00977 /* probability term */\n00978 p_term = p / (1.0-p);\n00979 \n00980 /* compute the first term of the series */\n00981 /*\n00982 binomial_tail(n,k,p) = sum_{i=k}^n bincoef(n,i) * p^i * (1-p)^{n-i}\n00983 where bincoef(n,i) are the binomial coefficients.\n00984 But\n00985 bincoef(n,k) = gamma(n+1) / ( gamma(k+1) * gamma(n-k+1) ).\n00986 We use this to compute the first term. Actually the log of it.\n00987 */\n00988 log1term = log_gamma( (double) n + 1.0 ) - log_gamma( (double) k + 1.0 )\n00989 - log_gamma( (double) (n-k) + 1.0 )\n00990 + (double) k * log(p) + (double) (n-k) * log(1.0-p);\n00991 term = exp(log1term);\n00992 \n00993 /* in some cases no more computations are needed */\n00994 if( double_equal(term,0.0) ) /* the first term is almost zero */\n00995 {\n00996 if( (double) k > (double) n * p ) /* at begin or end of the tail? */\n00997 return -log1term / M_LN10 - logNT; /* end: use just the first term */\n00998 else\n00999 return -logNT; /* begin: the tail is roughly 1 */\n01000 }\n01001 \n01002 /* compute more terms if needed */\n01003 bin_tail = term;\n01004 for(i=k+1;i<=n;i++)\n01005 {\n01006 /*\n01007 As\n01008 term_i = bincoef(n,i) * p^i * (1-p)^(n-i)\n01009 and\n01010 bincoef(n,i)/bincoef(n,i-1) = n-1+1 / i,\n01011 then,\n01012 term_i / term_i-1 = (n-i+1)/i * p/(1-p)\n01013 and\n01014 term_i = term_i-1 * (n-i+1)/i * p/(1-p).\n01015 1/i is stored in a table as they are computed,\n01016 because divisions are expensive.\n01017 p/(1-p) is computed only once and stored in 'p_term'.\n01018 */\n01019 bin_term = (double) (n-i+1) * ( i<TABSIZE ?\n01020 ( inv[i]!=0.0 ? inv[i] : ( inv[i] = 1.0 / (double) i ) ) :\n01021 1.0 / (double) i );\n01022 \n01023 mult_term = bin_term * p_term;\n01024 term *= mult_term;\n01025 bin_tail += term;\n01026 if(bin_term<1.0)\n01027 {\n01028 /* When bin_term<1 then mult_term_j<mult_term_i for j>i.\n01029 Then, the error on the binomial tail when truncated at\n01030 the i term can be bounded by a geometric series of form\n01031 term_i * sum mult_term_i^j. */\n01032 err = term * ( ( 1.0 - pow( mult_term, (double) (n-i+1) ) ) /\n01033 (1.0-mult_term) - 1.0 );\n01034 \n01035 /* One wants an error at most of tolerance*final_result, or:\n01036 tolerance * abs(-log10(bin_tail)-logNT).\n01037 Now, the error that can be accepted on bin_tail is\n01038 given by tolerance*final_result divided by the derivative\n01039 of -log10(x) when x=bin_tail. that is:\n01040 tolerance * abs(-log10(bin_tail)-logNT) / (1/bin_tail)\n01041 Finally, we truncate the tail if the error is less than:\n01042 tolerance * abs(-log10(bin_tail)-logNT) * bin_tail */\n01043 if( err < tolerance * fabs(-log10(bin_tail)-logNT) * bin_tail ) break;\n01044 }\n01045 }\n01046 return -log10(bin_tail) - logNT;\n01047 }\n
\nReduce the region size, by elimination the points far from the starting point, until that leads to rectangle with the right density of region points or to discard the region if too small. \n
01762 {\n01763 double density,rad1,rad2,rad,xc,yc;\n01764 int i;\n01765 \n01766 /* check parameters */\n01767 if( reg == NULL ) error(\"reduce_region_radius: invalid pointer 'reg'.\");\n01768 if( reg_size == NULL )\n01769 error(\"reduce_region_radius: invalid pointer 'reg_size'.\");\n01770 if( prec < 0.0 ) error(\"reduce_region_radius: 'prec' must be positive.\");\n01771 if( rec == NULL ) error(\"reduce_region_radius: invalid pointer 'rec'.\");\n01772 if( used == NULL || used->data == NULL )\n01773 error(\"reduce_region_radius: invalid image 'used'.\");\n01774 if( angles == NULL || angles->data == NULL )\n01775 error(\"reduce_region_radius: invalid image 'angles'.\");\n01776 \n01777 /* compute region points density */\n01778 density = (double) *reg_size /\n01779 ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n01780 \n01781 /* if the density criterion is satisfied there is nothing to do */\n01782 if( density >= density_th ) returnTRUE;\n01783 \n01784 /* compute region's radius */\n01785 xc = (double) reg[0].x;\n01786 yc = (double) reg[0].y;\n01787 rad1 = dist( xc, yc, rec->x1, rec->y1 );\n01788 rad2 = dist( xc, yc, rec->x2, rec->y2 );\n01789 rad = rad1 > rad2 ? rad1 : rad2;\n01790 \n01791 /* while the density criterion is not satisfied, remove farther pixels */\n01792 while( density < density_th )\n01793 {\n01794 rad *= 0.75; /* reduce region's radius to 75% of its value */\n01795 \n01796 /* remove points from the region and update 'used' map */\n01797 for(i=0; i<*reg_size; i++)\n01798 if( dist( xc, yc, (double) reg[i].x, (double) reg[i].y ) > rad )\n01799 {\n01800 /* point not kept, mark it as NOTUSED */\n01801 used->data[ reg[i].x + reg[i].y * used->xsize ] = NOTUSED;\n01802 /* remove point from the region */\n01803 reg[i].x = reg[*reg_size-1].x; /* if i==*reg_size-1 copy itself */\n01804 reg[i].y = reg[*reg_size-1].y;\n01805 --(*reg_size);\n01806 --i; /* to avoid skipping one point */\n01807 }\n01808 \n01809 /* reject if the region is too small.\n01810 2 is the minimal region size for 'region2rect' to work. */\n01811 if( *reg_size < 2 ) returnFALSE;\n01812 \n01813 /* re-compute rectangle */\n01814 region2rect(reg,*reg_size,modgrad,reg_angle,prec,p,rec);\n01815 \n01816 /* re-compute region points density */\n01817 density = (double) *reg_size /\n01818 ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n01819 }\n01820 \n01821 /* if this point is reached, the density criterion is satisfied */\n01822 returnTRUE;\n01823 }\n
\nFor that, an estimation of the angle tolerance is performed by the standard deviation of the angle at points near the region's starting point. Then, a new region is grown starting from the same point, but using the estimated angle tolerance. If this fails to produce a rectangle with the right density of region points, 'reduce_region_radius' is called to try to satisfy this condition. \n
01502 {\n01503 double x,y,dx,dy,l,w,theta,weight,sum,l_min,l_max,w_min,w_max;\n01504 int i;\n01505 \n01506 /* check parameters */\n01507 if( reg == NULL ) error(\"region2rect: invalid region.\");\n01508 if( reg_size <= 1 ) error(\"region2rect: region size <= 1.\");\n01509 if( modgrad == NULL || modgrad->data == NULL )\n01510 error(\"region2rect: invalid image 'modgrad'.\");\n01511 if( rec == NULL ) error(\"region2rect: invalid 'rec'.\");\n01512 \n01513 /* center of the region:\n01514 \n01515 It is computed as the weighted sum of the coordinates\n01516 of all the pixels in the region. The norm of the gradient\n01517 is used as the weight of a pixel. The sum is as follows:\n01518 cx = \\sum_i G(i).x_i\n01519 cy = \\sum_i G(i).y_i\n01520 where G(i) is the norm of the gradient of pixel i\n01521 and x_i,y_i are its coordinates.\n01522 */\n01523 x = y = sum = 0.0;\n01524 for(i=0; i<reg_size; i++)\n01525 {\n01526 weight = modgrad->data[ reg[i].x + reg[i].y * modgrad->xsize ];\n01527 x += (double) reg[i].x * weight;\n01528 y += (double) reg[i].y * weight;\n01529 sum += weight;\n01530 }\n01531 if( sum <= 0.0 ) error(\"region2rect: weights sum equal to zero.\");\n01532 x /= sum;\n01533 y /= sum;\n01534 \n01535 /* theta */\n01536 theta = get_theta(reg,reg_size,x,y,modgrad,reg_angle,prec);\n01537 \n01538 /* length and width:\n01539 \n01540 'l' and 'w' are computed as the distance from the center of the\n01541 region to pixel i, projected along the rectangle axis (dx,dy) and\n01542 to the orthogonal axis (-dy,dx), respectively.\n01543 \n01544 The length of the rectangle goes from l_min to l_max, where l_min\n01545 and l_max are the minimum and maximum values of l in the region.\n01546 Analogously, the width is selected from w_min to w_max, where\n01547 w_min and w_max are the minimum and maximum of w for the pixels\n01548 in the region.\n01549 */\n01550 dx = cos(theta);\n01551 dy = sin(theta);\n01552 l_min = l_max = w_min = w_max = 0.0;\n01553 for(i=0; i<reg_size; i++)\n01554 {\n01555 l = ( (double) reg[i].x - x) * dx + ( (double) reg[i].y - y) * dy;\n01556 w = -( (double) reg[i].x - x) * dy + ( (double) reg[i].y - y) * dx;\n01557 \n01558 if( l > l_max ) l_max = l;\n01559 if( l < l_min ) l_min = l;\n01560 if( w > w_max ) w_max = w;\n01561 if( w < w_min ) w_min = w;\n01562 }\n01563 \n01564 /* store values */\n01565 rec->x1 = x + l_min * dx;\n01566 rec->y1 = y + l_min * dy;\n01567 rec->x2 = x + l_max * dx;\n01568 rec->y2 = y + l_max * dy;\n01569 rec->width = w_max - w_min;\n01570 rec->x = x;\n01571 rec->y = y;\n01572 rec->theta = theta;\n01573 rec->dx = dx;\n01574 rec->dy = dy;\n01575 rec->prec = prec;\n01576 rec->p = p;\n01577 \n01578 /* we impose a minimal width of one pixel\n01579 \n01580 A sharp horizontal or vertical step would produce a perfectly\n01581 horizontal or vertical region. The width computed would be\n01582 zero. But that corresponds to a one pixels width transition in\n01583 the image.\n01584 */\n01585 if( rec->width < 1.0 ) rec->width = 1.0;\n01586 }\n
01214 {\n01215 /* check input */\n01216 if( i == NULL ) error(\"ri_end: NULL iterator.\");\n01217 \n01218 /* if the current x value is larger than the larger\n01219 x value in the rectangle (vx[2]), we know the full\n01220 exploration of the rectangle is finished. */\n01221 return (double)(i->x) > i->vx[2];\n01222 }\n
01230 {\n01231 /* check input */\n01232 if( i == NULL ) error(\"ri_inc: NULL iterator.\");\n01233 \n01234 /* if not at end of exploration,\n01235 increase y value for next pixel in the 'column' */\n01236 if( !ri_end(i) ) i->y++;\n01237 \n01238 /* if the end of the current 'column' is reached,\n01239 and it is not the end of exploration,\n01240 advance to the next 'column' */\n01241 while( (double) (i->y) > i->ye && !ri_end(i) )\n01242 {\n01243 /* increase x, next 'column' */\n01244 i->x++;\n01245 \n01246 /* if end of exploration, return */\n01247 if( ri_end(i) ) return;\n01248 \n01249 /* update lower y limit (start) for the new 'column'.\n01250 \n01251 We need to interpolate the y value that corresponds to the\n01252 lower side of the rectangle. The first thing is to decide if\n01253 the corresponding side is\n01254 \n01255 vx[0],vy[0] to vx[3],vy[3] or\n01256 vx[3],vy[3] to vx[2],vy[2]\n01257 \n01258 Then, the side is interpolated for the x value of the\n01259 'column'. But, if the side is vertical (as it could happen if\n01260 the rectangle is vertical and we are dealing with the first\n01261 or last 'columns') then we pick the lower value of the side\n01262 by using 'inter_low'.\n01263 */\n01264 if( (double) i->x < i->vx[3] )\n01265 i->ys = inter_low((double)i->x,i->vx[0],i->vy[0],i->vx[3],i->vy[3]);\n01266 else\n01267 i->ys = inter_low((double)i->x,i->vx[3],i->vy[3],i->vx[2],i->vy[2]);\n01268 \n01269 /* update upper y limit (end) for the new 'column'.\n01270 \n01271 We need to interpolate the y value that corresponds to the\n01272 upper side of the rectangle. The first thing is to decide if\n01273 the corresponding side is\n01274 \n01275 vx[0],vy[0] to vx[1],vy[1] or\n01276 vx[1],vy[1] to vx[2],vy[2]\n01277 \n01278 Then, the side is interpolated for the x value of the\n01279 'column'. But, if the side is vertical (as it could happen if\n01280 the rectangle is vertical and we are dealing with the first\n01281 or last 'columns') then we pick the lower value of the side\n01282 by using 'inter_low'.\n01283 */\n01284 if( (double)i->x < i->vx[1] )\n01285 i->ye = inter_hi((double)i->x,i->vx[0],i->vy[0],i->vx[1],i->vy[1]);\n01286 else\n01287 i->ye = inter_hi((double)i->x,i->vx[1],i->vy[1],i->vx[2],i->vy[2]);\n01288 \n01289 /* new y */\n01290 i->y = (int) ceil(i->ys);\n01291 }\n01292 }\n
01300 {\n01301 double vx[4],vy[4];\n01302 int n,offset;\n01303 rect_iter * i;\n01304 \n01305 /* check parameters */\n01306 if( r == NULL ) error(\"ri_ini: invalid rectangle.\");\n01307 \n01308 /* get memory */\n01309 i = (rect_iter *) malloc(sizeof(rect_iter));\n01310 if( i == NULL ) error(\"ri_ini: Not enough memory.\");\n01311 \n01312 /* build list of rectangle corners ordered\n01313 in a circular way around the rectangle */\n01314 vx[0] = r->x1 - r->dy * r->width / 2.0;\n01315 vy[0] = r->y1 + r->dx * r->width / 2.0;\n01316 vx[1] = r->x2 - r->dy * r->width / 2.0;\n01317 vy[1] = r->y2 + r->dx * r->width / 2.0;\n01318 vx[2] = r->x2 + r->dy * r->width / 2.0;\n01319 vy[2] = r->y2 - r->dx * r->width / 2.0;\n01320 vx[3] = r->x1 + r->dy * r->width / 2.0;\n01321 vy[3] = r->y1 - r->dx * r->width / 2.0;\n01322 \n01323 /* compute rotation of index of corners needed so that the first\n01324 point has the smaller x.\n01325 \n01326 if one side is vertical, thus two corners have the same smaller x\n01327 value, the one with the largest y value is selected as the first.\n01328 */\n01329 if( r->x1 < r->x2 && r->y1 <= r->y2 ) offset = 0;\n01330 elseif( r->x1 >= r->x2 && r->y1 < r->y2 ) offset = 1;\n01331 elseif( r->x1 > r->x2 && r->y1 >= r->y2 ) offset = 2;\n01332 else offset = 3;\n01333 \n01334 /* apply rotation of index. */\n01335 for(n=0; n<4; n++)\n01336 {\n01337 i->vx[n] = vx[(offset+n)%4];\n01338 i->vy[n] = vy[(offset+n)%4];\n01339 }\n01340 \n01341 /* Set a initial condition.\n01342 \n01343 The values are set to values that will cause 'ri_inc' (that will\n01344 be called immediately) to initialize correctly the first 'column'\n01345 and compute the limits 'ys' and 'ye'.\n01346 \n01347 'y' is set to the integer value of vy[0], the starting corner.\n01348 \n01349 'ys' and 'ye' are set to very small values, so 'ri_inc' will\n01350 notice that it needs to start a new 'column'.\n01351 \n01352 The smaller integer coordinate inside of the rectangle is\n01353 'ceil(vx[0])'. The current 'x' value is set to that value minus\n01354 one, so 'ri_inc' (that will increase x by one) will advance to\n01355 the first 'column'.\n01356 */\n01357 i->x = (int) ceil(i->vx[0]) - 1;\n01358 i->y = (int) ceil(i->vy[0]);\n01359 i->ys = i->ye = -DBL_MAX;\n01360 \n01361 /* advance to the first pixel */\n01362 ri_inc(i);\n01363 \n01364 return i;\n01365 }\n
\n
\n
\n\n
\nHere is the call graph for this function:
\n\nGenerated on Fri Dec 3 10:18:38 2010 for LSD by\n\n \n1.3.4 \n\n\n"
},
{
"path": "thirdparty/LSD/doc/lsd_8h-source.html",
"content": "\n\nLSD: lsd.h Source File\n\n\n\n
00001 /*----------------------------------------------------------------------------\n00002 \n00003 LSD - Line Segment Detector on digital images\n00004 \n00005 Copyright 2007-2010 rafael grompone von gioi (grompone@gmail.com)\n00006 \n00007 This program is free software: you can redistribute it and/or modify\n00008 it under the terms of the GNU Affero General Public License as\n00009 published by the Free Software Foundation, either version 3 of the\n00010 License, or (at your option) any later version.\n00011 \n00012 This program is distributed in the hope that it will be useful,\n00013 but WITHOUT ANY WARRANTY; without even the implied warranty of\n00014 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n00015 GNU Affero General Public License for more details.\n00016 \n00017 You should have received a copy of the GNU Affero General Public License\n00018 along with this program. If not, see <http://www.gnu.org/licenses/>.\n00019 \n00020 ----------------------------------------------------------------------------*/\n00021 \n00022 /*----------------------------------------------------------------------------*/\n00023 /** @file lsd.h\n00024 LSD module header\n00025 @author rafael grompone von gioi (grompone@gmail.com)\n00026 */\n00027 /*----------------------------------------------------------------------------*/\n00028 #ifndef LSD_HEADER\n00029 #define LSD_HEADER\n00030 \n00031 \n00032 /*----------------------------------------------------------------------------*/\n00033 /*----------------------- 'list of n-tuple' data type ------------------------*/\n00034 /*----------------------------------------------------------------------------*/\n00035 /** 'list of n-tuple' data type\n00036 \n00037 The i component, of the n-tuple number j, of an n-tuple list 'ntl'\n00038 is accessed with:\n00039 \n00040 ntl->values[ i + j * ntl->dim ]\n00041 \n00042 The dimension of the n-tuple (n) is:\n00043 \n00044 ntl->dim\n00045 \n00046 The number of number of n-tuples in the list is:\n00047 \n00048 ntl->size\n00049 \n00050 The maximum number of n-tuples that can be stored in the\n00051 list with the allocated memory at a given time is given by:\n00052 \n00053 ntl->max_size\n00054 */\n00055typedefstruct ntuple_list_s\n00056 {\n00057unsignedintsize;\n00058unsignedintmax_size;\n00059unsignedintdim;\n00060double * values;\n00061 } * ntuple_list;\n00062 \n00063 voidfree_ntuple_list(ntuple_list in);\n00064 ntuple_listnew_ntuple_list(unsignedint dim);\n00065 \n00066 \n00067 /*----------------------------------------------------------------------------*/\n00068 /*----------------------------- Image Data Types -----------------------------*/\n00069 /*----------------------------------------------------------------------------*/\n00070 \n00071 /*----------------------------------------------------------------------------*/\n00072 /** char image data type\n00073 \n00074 The pixel value at (x,y) is accessed by:\n00075 \n00076 image->data[ x + y * image->xsize ]\n00077 \n00078 with x and y integer.\n00079 */\n00080typedefstruct image_char_s\n00081 {\n00082unsignedchar * data;\n00083unsignedintxsize,ysize;\n00084 } * image_char;\n00085 \n00086 voidfree_image_char(image_char i);\n00087 image_charnew_image_char(unsignedint xsize, unsignedint ysize);\n00088 image_charnew_image_char_ini( unsignedint xsize, unsignedint ysize,\n00089 unsignedchar fill_value );\n00090 \n00091 /*----------------------------------------------------------------------------*/\n00092 /** int image data type\n00093 \n00094 The pixel value at (x,y) is accessed by:\n00095 \n00096 image->data[ x + y * image->xsize ]\n00097 \n00098 with x and y integer.\n00099 */\n00100typedefstruct image_int_s\n00101 {\n00102int * data;\n00103unsignedintxsize,ysize;\n00104 } * image_int;\n00105 \n00106 voidfree_image_int(image_int i);\n00107 image_intnew_image_int(unsignedint xsize, unsignedint ysize);\n00108 image_intnew_image_int_ini( unsignedint xsize, unsignedint ysize,\n00109 int fill_value );\n00110 \n00111 /*----------------------------------------------------------------------------*/\n00112 /** double image data type\n00113 \n00114 The pixel value at (x,y) is accessed by:\n00115 \n00116 image->data[ x + y * image->xsize ]\n00117 \n00118 with x and y integer.\n00119 */\n00120typedefstruct image_double_s\n00121 {\n00122double * data;\n00123unsignedintxsize,ysize;\n00124 } * image_double;\n00125 \n00126 voidfree_image_double(image_double i);\n00127 image_doublenew_image_double(unsignedint xsize, unsignedint ysize);\n00128 image_doublenew_image_double_ini( unsignedint xsize, unsignedint ysize,\n00129 double fill_value );\n00130 \n00131 \n00132 /*----------------------------------------------------------------------------*/\n00133 /*-------------------------- Line Segment Detector ---------------------------*/\n00134 /*----------------------------------------------------------------------------*/\n00135 \n00136 /*----------------------------------------------------------------------------*/\n00137 /* LSD Full Interface */\n00138 /*----------------------------------------------------------------------------*/\n00139 /** LSD Full Interface\n00140 \n00141 @param image Input image.\n00142 \n00143 @param scale When different than 1.0, LSD will scale the image by\n00144 Gaussian filtering.\n00145 Example: is scale=0.8, the input image will be subsampled\n00146 to 80% of its size, and then the line segment detector\n00147 will be applied.\n00148 Suggested value: 0.8\n00149 \n00150 @param sigma_scale When scale!=1.0, the sigma of the Gaussian filter is:\n00151 sigma = sigma_scale / scale, if scale < 1.0\n00152 sigma = sigma_scale, if scale >= 1.0\n00153 Suggested value: 0.6\n00154 \n00155 @param quant Bound to the quantization error on the gradient norm.\n00156 Example: if gray level is quantized to integer steps,\n00157 the gradient (computed by finite differences) error\n00158 due to quantization will be bounded by 2.0, as the\n00159 worst case is when the error are 1 and -1, that\n00160 gives an error of 2.0.\n00161 Suggested value: 2.0\n00162 \n00163 @param ang_th Gradient angle tolerance in the region growing\n00164 algorithm, in degrees.\n00165 Suggested value: 22.5\n00166 \n00167 @param eps Detection threshold, -log10(NFA).\n00168 The bigger, the more strict the detector is,\n00169 and will result in less detections.\n00170 (Note that the 'minus sign' makes that this\n00171 behavior is opposite to the one of NFA.)\n00172 The value -log10(NFA) is equivalent but more\n00173 intuitive than NFA:\n00174 - -1.0 corresponds to 10 mean false alarms\n00175 - 0.0 corresponds to 1 mean false alarm\n00176 - 1.0 corresponds to 0.1 mean false alarms\n00177 - 2.0 corresponds to 0.01 mean false alarms\n00178 .\n00179 Suggested value: 0.0\n00180 \n00181 @param density_th Minimal proportion of region points in a rectangle.\n00182 Suggested value: 0.7\n00183 \n00184 @param n_bins Number of bins used in the pseudo-ordering of gradient\n00185 modulus.\n00186 Suggested value: 1024\n00187 \n00188 @param max_grad Gradient modulus in the highest bin. For example,\n00189 for images with integer gray levels in [0,255],\n00190 the maximum possible gradient value is 255.0.\n00191 Suggested value: 255.0\n00192 \n00193 @param region Optional output: an int image where the pixels used\n00194 in some line support region are marked. Unused pixels\n00195 have the value '0' while the used ones have the\n00196 number of the line segment, numbered 1,2,3,...\n00197 If desired, a non NULL pointer to an image_int should\n00198 be used. The resulting image has the size of the image\n00199 used for the processing, that is, the size of the input\n00200 image scaled by the given factor 'scale'.\n00201 Suggested value: NULL\n00202 \n00203 @return A 5-tuple list, where each 5-tuple corresponds to a\n00204 detected line segment. The five values are:\n00205 - x1,y1,x2,y2,width\n00206 .\n00207 for a line segment from (x1,y1) to (x2,y2) and\n00208 a width 'width'.\n00209 */\n00210 ntuple_listLineSegmentDetection( image_double image, double scale,\n00211 double sigma_scale, double quant,\n00212 double ang_th, double eps, double density_th,\n00213 int n_bins, double max_grad,\n00214 image_int * region );\n00215 \n00216 /*----------------------------------------------------------------------------*/\n00217 /* LSD Simple Interface with Scale */\n00218 /*----------------------------------------------------------------------------*/\n00219 /** LSD Simple Interface with Scale\n00220 \n00221 @param image Input image.\n00222 \n00223 @param scale When different than 1.0, LSD will scale the image by\n00224 Gaussian filtering.\n00225 Example: is scale=0.8, the input image will be subsampled\n00226 to 80% of its size, and then the line segment detector\n00227 will be applied.\n00228 Suggested value: 0.8\n00229 \n00230 @return a 5-tuple list of detected line segments.\n00231 */\n00232 ntuple_listlsd_scale(image_double image, double scale);\n00233 \n00234 /*----------------------------------------------------------------------------*/\n00235 /* LSD Simple Interface */\n00236 /*----------------------------------------------------------------------------*/\n00237 /** LSD Simple Interface\n00238 \n00239 @param image Input image.\n00240 \n00241 @return a 5-tuple list of detected line segments.\n00242 */\n00243 ntuple_listlsd(image_double image);\n00244 \n00245 #endif /* !LSD_HEADER */\n00246 /*----------------------------------------------------------------------------*/\n
Generated on Fri Dec 3 10:18:18 2010 for LSD by\n\n \n1.3.4 \n\n\n"
},
{
"path": "thirdparty/LSD/doc/lsd_8h.html",
"content": "\n\nLSD: lsd.h File Reference\n\n\n\n
When different than 1.0, LSD will scale the image by Gaussian filtering. Example: is scale=0.8, the input image will be subsampled to 80% of its size, and then the line segment detector will be applied. Suggested value: 0.8
\n
sigma_scale
When scale!=1.0, the sigma of the Gaussian filter is: sigma = sigma_scale / scale, if scale < 1.0 sigma = sigma_scale, if scale >= 1.0 Suggested value: 0.6
\n
quant
Bound to the quantization error on the gradient norm. Example: if gray level is quantized to integer steps, the gradient (computed by finite differences) error due to quantization will be bounded by 2.0, as the worst case is when the error are 1 and -1, that gives an error of 2.0. Suggested value: 2.0
\n
ang_th
Gradient angle tolerance in the region growing algorithm, in degrees. Suggested value: 22.5
\n
eps
Detection threshold, -log10(NFA). The bigger, the more strict the detector is, and will result in less detections. (Note that the 'minus sign' makes that this behavior is opposite to the one of NFA.) The value -log10(NFA) is equivalent but more intuitive than NFA:
\n
-1.0 corresponds to 10 mean false alarms
0.0 corresponds to 1 mean false alarm
1.0 corresponds to 0.1 mean false alarms
2.0 corresponds to 0.01 mean false alarms
\nSuggested value: 0.0
\n
density_th
Minimal proportion of region points in a rectangle. Suggested value: 0.7
\n
n_bins
Number of bins used in the pseudo-ordering of gradient modulus. Suggested value: 1024
\n
max_grad
Gradient modulus in the highest bin. For example, for images with integer gray levels in [0,255], the maximum possible gradient value is 255.0. Suggested value: 255.0
\n
region
Optional output: an int image where the pixels used in some line support region are marked. Unused pixels have the value '0' while the used ones have the number of the line segment, numbered 1,2,3,... If desired, a non NULL pointer to an image_int should be used. The resulting image has the size of the image used for the processing, that is, the size of the input image scaled by the given factor 'scale'. Suggested value: NULL
\n
\n
\n
Returns:
A 5-tuple list, where each 5-tuple corresponds to a detected line segment. The five values are:
\n
x1,y1,x2,y2,width
\nfor a line segment from (x1,y1) to (x2,y2) and a width 'width'.
01918 {\n01919 ntuple_list out = new_ntuple_list(5);\n01920 image_double scaled_image,angles,modgrad;\n01921 image_char used;\n01922 struct coorlist * list_p;\n01923 void * mem_p;\n01924 struct rect rec;\n01925 struct point * reg;\n01926 int reg_size,min_reg_size,i;\n01927 unsignedint xsize,ysize;\n01928 double rho,reg_angle,prec,p,log_nfa,logNT;\n01929 int ls_count = 0; /* line segments are numbered 1,2,3,... */\n01930 \n01931 \n01932 /* check parameters */\n01933 if( image==NULL || image->data==NULL || image->xsize==0 || image->ysize==0 )\n01934 error(\"invalid image input.\");\n01935 if( scale <= 0.0 ) error(\"'scale' value must be positive.\");\n01936 if( sigma_scale <= 0.0 ) error(\"'sigma_scale' value must be positive.\");\n01937 if( quant < 0.0 ) error(\"'quant' value must be positive.\");\n01938 if( ang_th <= 0.0 || ang_th >= 180.0 )\n01939 error(\"'ang_th' value must be in the range (0,180).\");\n01940 if( density_th < 0.0 || density_th > 1.0 )\n01941 error(\"'density_th' value must be in the range [0,1].\");\n01942 if( n_bins <= 0 ) error(\"'n_bins' value must be positive.\");\n01943 if( max_grad <= 0.0 ) error(\"'max_grad' value must be positive.\");\n01944 \n01945 \n01946 /* angle tolerance */\n01947 prec = M_PI * ang_th / 180.0;\n01948 p = ang_th / 180.0;\n01949 rho = quant / sin(prec); /* gradient magnitude threshold */\n01950 \n01951 \n01952 /* scale image (if necessary) and compute angle at each pixel */\n01953 if( scale != 1.0 )\n01954 {\n01955 scaled_image = gaussian_sampler( image, scale, sigma_scale );\n01956 angles = ll_angle( scaled_image, rho, &list_p, &mem_p,\n01957 &modgrad, (unsignedint) n_bins, max_grad );\n01958 free_image_double(scaled_image);\n01959 }\n01960 else\n01961 angles = ll_angle( image, rho, &list_p, &mem_p, &modgrad,\n01962 (unsignedint) n_bins, max_grad );\n01963 xsize = angles->xsize;\n01964 ysize = angles->ysize;\n01965 logNT = 5.0 * ( log10( (double) xsize ) + log10( (double) ysize ) ) / 2.0;\n01966 min_reg_size = (int) (-logNT/log10(p)); /* minimal number of points in region\n01967 that can give a meaningful event */\n01968 \n01969 \n01970 /* initialize some structures */\n01971 if( region != NULL ) /* image to output pixel region number, if asked */\n01972 *region = new_image_int_ini(angles->xsize,angles->ysize,0);\n01973 used = new_image_char_ini(xsize,ysize,NOTUSED);\n01974 reg = (struct point *) calloc( (size_t) (xsize*ysize), sizeof(structpoint) );\n01975 if( reg == NULL ) error(\"not enough memory!\");\n01976 \n01977 \n01978 /* search for line segments */\n01979 for(; list_p != NULL; list_p = list_p->next )\n01980 if( used->data[ list_p->x + list_p->y * used->xsize ] == NOTUSED &&\n01981 angles->data[ list_p->x + list_p->y * angles->xsize ] != NOTDEF )\n01982 /* there is no risk of double comparison problems here\n01983 because we are only interested in the exact NOTDEF value */\n01984 {\n01985 /* find the region of connected point and ~equal angle */\n01986 region_grow( list_p->x, list_p->y, angles, reg, ®_size,\n01987 ®_angle, used, prec );\n01988 \n01989 /* reject small regions */\n01990 if( reg_size < min_reg_size ) continue;\n01991 \n01992 /* construct rectangular approximation for the region */\n01993 region2rect(reg,reg_size,modgrad,reg_angle,prec,p,&rec);\n01994 \n01995 /* Check if the rectangle exceeds the minimal density of\n01996 region points. If not, try to improve the region.\n01997 The rectangle will be rejected if the final one does\n01998 not fulfill the minimal density condition.\n01999 This is an addition to the original LSD algorithm published in\n02000 \"LSD: A Fast Line Segment Detector with a False Detection Control\"\n02001 by R. Grompone von Gioi, J. Jakubowicz, J.M. Morel, and G. Randall.\n02002 The original algorithm is obtained with density_th = 0.0.\n02003 */\n02004 if( !refine( reg, ®_size, modgrad, reg_angle,\n02005 prec, p, &rec, used, angles, density_th ) ) continue;\n02006 \n02007 /* compute NFA value */\n02008 log_nfa = rect_improve(&rec,angles,logNT,eps);\n02009 if( log_nfa <= eps ) continue;\n02010 \n02011 /* A New Line Segment was found! */\n02012 ++ls_count; /* increase line segment counter */\n02013 \n02014 /*\n02015 The gradient was computed with a 2x2 mask, its value corresponds to\n02016 points with an offset of (0.5,0.5), that should be added to output.\n02017 The coordinates origin is at the center of pixel (0,0).\n02018 */\n02019 rec.x1 += 0.5; rec.y1 += 0.5;\n02020 rec.x2 += 0.5; rec.y2 += 0.5;\n02021 \n02022 /* scale the result values if a subsampling was performed */\n02023 if( scale != 1.0 )\n02024 {\n02025 rec.x1 /= scale; rec.y1 /= scale;\n02026 rec.x2 /= scale; rec.y2 /= scale;\n02027 rec.width /= scale;\n02028 }\n02029 \n02030 /* add line segment found to output */\n02031 add_5tuple(out, rec.x1, rec.y1, rec.x2, rec.y2, rec.width);\n02032 \n02033 /* add region number to 'region' image if needed */\n02034 if( region != NULL )\n02035 for(i=0; i<reg_size; i++)\n02036 (*region)->data[reg[i].x+reg[i].y*(*region)->xsize] = ls_count;\n02037 }\n02038 \n02039 \n02040 /* free memory */\n02041 free_image_double(angles);\n02042 free_image_double(modgrad);\n02043 free_image_char(used);\n02044 free( (void *) reg );\n02045 free( (void *) mem_p );\n02046 \n02047 return out;\n02048 }\n
When different than 1.0, LSD will scale the image by Gaussian filtering. Example: is scale=0.8, the input image will be subsampled to 80% of its size, and then the line segment detector will be applied. Suggested value: 0.8
\nThe integer coordinates of pixels inside a rectangle are iteratively explored. This structure keep track of the process and functions ri_ini(), ri_inc(), ri_end(), and ri_del() are used in the process. An example of how to use the iterator is as follows:
struct rect * rec = XXX; // some rectangle\n rect_iter * i;\n for( i=ri_ini(rec); !ri_end(i); ri_inc(i) )\n {\n // your code, using 'i->x' and 'i->y' as coordinates\n }\n ri_del(i); // delete iterator\n
The pixels are explored 'column' by 'column', where we call 'column' a set of pixels with the same x value that are inside the rectangle. The following is an schematic representation of a rectangle, the 'column' being explored is marked by colons, and the current pixel being explored is 'x,y'.
The first 'column' to be explored is the one with the smaller x value. Each 'column' is explored starting from the pixel of the 'column' (inside the rectangle) with the smaller y value.
\nThe four corners of the rectangle are stored in order that rotates around the corners at the arrays 'vx[]' and 'vy[]'. The first point is always the one with smaller x value.
\n'x' and 'y' are the coordinates of the pixel being explored. 'ys' and 'ye' are the start and end values of the current column being explored. So, 'ys' < 'ye'. \n
\nGenerated on Fri Dec 3 10:18:49 2010 for LSD by\n\n \n1.3.4 \n\n\n"
},
{
"path": "thirdparty/LSD/doxygen.config",
"content": "# Doxyfile 1.3.4\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org) for a project\n#\n# All text after a hash (#) is considered a comment and will be ignored\n# The format is:\n# TAG = value [value, ...]\n# For lists items can also be appended using:\n# TAG += value [value, ...]\n# Values that contain spaces should be placed between quotes (\" \")\n\n#---------------------------------------------------------------------------\n# Project related configuration options\n#---------------------------------------------------------------------------\n\n# The PROJECT_NAME tag is a single word (or a sequence of words surrounded \n# by quotes) that should identify the project.\n\nPROJECT_NAME = LSD\n\n# The PROJECT_NUMBER tag can be used to enter a project or revision number. \n# This could be handy for archiving the generated documentation or \n# if some version control system is used.\n\nPROJECT_NUMBER = \n\n# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) \n# base path where the generated documentation will be put. \n# If a relative path is entered, it will be relative to the location \n# where doxygen was started. If left blank the current directory will be used.\n\nOUTPUT_DIRECTORY = \n\n# The OUTPUT_LANGUAGE tag is used to specify the language in which all \n# documentation generated by doxygen is written. Doxygen will use this \n# information to generate all constant output in the proper language. \n# The default language is English, other supported languages are: \n# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch, \n# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en \n# (Japanese with English messages), Korean, Norwegian, Polish, Portuguese, \n# Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian.\n\nOUTPUT_LANGUAGE = English\n\n# This tag can be used to specify the encoding used in the generated output. \n# The encoding is not always determined by the language that is chosen, \n# but also whether or not the output is meant for Windows or non-Windows users. \n# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES \n# forces the Windows encoding (this is the default for the Windows binary), \n# whereas setting the tag to NO uses a Unix-style encoding (the default for \n# all platforms other than Windows).\n\nUSE_WINDOWS_ENCODING = NO\n\n# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will \n# include brief member descriptions after the members that are listed in \n# the file and class documentation (similar to JavaDoc). \n# Set to NO to disable this.\n\nBRIEF_MEMBER_DESC = YES\n\n# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend \n# the brief description of a member or function before the detailed description. \n# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the \n# brief descriptions will be completely suppressed.\n\nREPEAT_BRIEF = YES\n\n# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then \n# Doxygen will generate a detailed section even if there is only a brief \n# description.\n\nALWAYS_DETAILED_SEC = NO\n\n# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited \n# members of a class in the documentation of that class as if those members were \n# ordinary class members. Constructors, destructors and assignment operators of \n# the base classes will not be shown.\n\nINLINE_INHERITED_MEMB = NO\n\n# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full \n# path before files name in the file list and in the header files. If set \n# to NO the shortest path that makes the file name unique will be used.\n\nFULL_PATH_NAMES = NO\n\n# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag \n# can be used to strip a user-defined part of the path. Stripping is \n# only done if one of the specified strings matches the left-hand part of \n# the path. It is allowed to use relative paths in the argument list.\n\nSTRIP_FROM_PATH = \n\n# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter \n# (but less readable) file names. This can be useful is your file systems \n# doesn't support long names like on DOS, Mac, or CD-ROM.\n\nSHORT_NAMES = NO\n\n# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen \n# will interpret the first line (until the first dot) of a JavaDoc-style \n# comment as the brief description. If set to NO, the JavaDoc \n# comments will behave just like the Qt-style comments (thus requiring an \n# explict @brief command for a brief description.\n\nJAVADOC_AUTOBRIEF = YES\n\n# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen \n# treat a multi-line C++ special comment block (i.e. a block of //! or /// \n# comments) as a brief description. This used to be the default behaviour. \n# The new default is to treat a multi-line C++ comment block as a detailed \n# description. Set this tag to YES if you prefer the old behaviour instead.\n\nMULTILINE_CPP_IS_BRIEF = NO\n\n# If the DETAILS_AT_TOP tag is set to YES then Doxygen \n# will output the detailed description near the top, like JavaDoc.\n# If set to NO, the detailed description appears after the member \n# documentation.\n\nDETAILS_AT_TOP = YES\n\n# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented \n# member inherits the documentation from any documented member that it \n# reimplements.\n\nINHERIT_DOCS = YES\n\n# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC \n# tag is set to YES, then doxygen will reuse the documentation of the first \n# member in the group (if any) for the other members of the group. By default \n# all members of a group must be documented explicitly.\n\nDISTRIBUTE_GROUP_DOC = NO\n\n# The TAB_SIZE tag can be used to set the number of spaces in a tab. \n# Doxygen uses this value to replace tabs by spaces in code fragments.\n\nTAB_SIZE = 8\n\n# This tag can be used to specify a number of aliases that acts \n# as commands in the documentation. An alias has the form \"name=value\". \n# For example adding \"sideeffect=\\par Side Effects:\\n\" will allow you to \n# put the command \\sideeffect (or @sideeffect) in the documentation, which \n# will result in a user-defined paragraph with heading \"Side Effects:\". \n# You can put \\n's in the value part of an alias to insert newlines.\n\nALIASES = \n\n# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources \n# only. Doxygen will then generate output that is more tailored for C. \n# For instance, some of the names that are used will be different. The list \n# of all members will be omitted, etc.\n\nOPTIMIZE_OUTPUT_FOR_C = YES\n\n# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources \n# only. Doxygen will then generate output that is more tailored for Java. \n# For instance, namespaces will be presented as packages, qualified scopes \n# will look different, etc.\n\nOPTIMIZE_OUTPUT_JAVA = NO\n\n# Set the SUBGROUPING tag to YES (the default) to allow class member groups of \n# the same type (for instance a group of public functions) to be put as a \n# subgroup of that type (e.g. under the Public Functions section). Set it to \n# NO to prevent subgrouping. Alternatively, this can be done per class using \n# the \\nosubgrouping command.\n\nSUBGROUPING = YES\n\n#---------------------------------------------------------------------------\n# Build related configuration options\n#---------------------------------------------------------------------------\n\n# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in \n# documentation are documented, even if no documentation was available. \n# Private class members and static file members will be hidden unless \n# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES\n\nEXTRACT_ALL = YES\n\n# If the EXTRACT_PRIVATE tag is set to YES all private members of a class \n# will be included in the documentation.\n\nEXTRACT_PRIVATE = YES\n\n# If the EXTRACT_STATIC tag is set to YES all static members of a file \n# will be included in the documentation.\n\nEXTRACT_STATIC = YES\n\n# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) \n# defined locally in source files will be included in the documentation. \n# If set to NO only classes defined in header files are included.\n\nEXTRACT_LOCAL_CLASSES = YES\n\n# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all \n# undocumented members of documented classes, files or namespaces. \n# If set to NO (the default) these members will be included in the \n# various overviews, but no documentation section is generated. \n# This option has no effect if EXTRACT_ALL is enabled.\n\nHIDE_UNDOC_MEMBERS = NO\n\n# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all \n# undocumented classes that are normally visible in the class hierarchy. \n# If set to NO (the default) these classes will be included in the various \n# overviews. This option has no effect if EXTRACT_ALL is enabled.\n\nHIDE_UNDOC_CLASSES = NO\n\n# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all \n# friend (class|struct|union) declarations. \n# If set to NO (the default) these declarations will be included in the \n# documentation.\n\nHIDE_FRIEND_COMPOUNDS = NO\n\n# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any \n# documentation blocks found inside the body of a function. \n# If set to NO (the default) these blocks will be appended to the \n# function's detailed documentation block.\n\nHIDE_IN_BODY_DOCS = NO\n\n# The INTERNAL_DOCS tag determines if documentation \n# that is typed after a \\internal command is included. If the tag is set \n# to NO (the default) then the documentation will be excluded. \n# Set it to YES to include the internal documentation.\n\nINTERNAL_DOCS = NO\n\n# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate \n# file names in lower-case letters. If set to YES upper-case letters are also \n# allowed. This is useful if you have classes or files whose names only differ \n# in case and if your file system supports case sensitive file names. Windows \n# users are advised to set this option to NO.\n\nCASE_SENSE_NAMES = YES\n\n# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen \n# will show members with their full class and namespace scopes in the \n# documentation. If set to YES the scope will be hidden.\n\nHIDE_SCOPE_NAMES = NO\n\n# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen \n# will put a list of the files that are included by a file in the documentation \n# of that file.\n\nSHOW_INCLUDE_FILES = YES\n\n# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] \n# is inserted in the documentation for inline members.\n\nINLINE_INFO = YES\n\n# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen \n# will sort the (detailed) documentation of file and class members \n# alphabetically by member name. If set to NO the members will appear in \n# declaration order.\n\nSORT_MEMBER_DOCS = YES\n\n# The GENERATE_TODOLIST tag can be used to enable (YES) or \n# disable (NO) the todo list. This list is created by putting \\todo \n# commands in the documentation.\n\nGENERATE_TODOLIST = YES\n\n# The GENERATE_TESTLIST tag can be used to enable (YES) or \n# disable (NO) the test list. This list is created by putting \\test \n# commands in the documentation.\n\nGENERATE_TESTLIST = YES\n\n# The GENERATE_BUGLIST tag can be used to enable (YES) or \n# disable (NO) the bug list. This list is created by putting \\bug \n# commands in the documentation.\n\nGENERATE_BUGLIST = YES\n\n# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or \n# disable (NO) the deprecated list. This list is created by putting \n# \\deprecated commands in the documentation.\n\nGENERATE_DEPRECATEDLIST= YES\n\n# The ENABLED_SECTIONS tag can be used to enable conditional \n# documentation sections, marked by \\if sectionname ... \\endif.\n\nENABLED_SECTIONS = \n\n# The MAX_INITIALIZER_LINES tag determines the maximum number of lines \n# the initial value of a variable or define consists of for it to appear in \n# the documentation. If the initializer consists of more lines than specified \n# here it will be hidden. Use a value of 0 to hide initializers completely. \n# The appearance of the initializer of individual variables and defines in the \n# documentation can be controlled using \\showinitializer or \\hideinitializer \n# command in the documentation regardless of this setting.\n\nMAX_INITIALIZER_LINES = 30\n\n# Set the SHOW_USED_FILES tag to NO to disable the list of files generated \n# at the bottom of the documentation of classes and structs. If set to YES the \n# list will mention the files that were used to generate the documentation.\n\nSHOW_USED_FILES = YES\n\n#---------------------------------------------------------------------------\n# configuration options related to warning and progress messages\n#---------------------------------------------------------------------------\n\n# The QUIET tag can be used to turn on/off the messages that are generated \n# by doxygen. Possible values are YES and NO. If left blank NO is used.\n\nQUIET = NO\n\n# The WARNINGS tag can be used to turn on/off the warning messages that are \n# generated by doxygen. Possible values are YES and NO. If left blank \n# NO is used.\n\nWARNINGS = YES\n\n# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings \n# for undocumented members. If EXTRACT_ALL is set to YES then this flag will \n# automatically be disabled.\n\nWARN_IF_UNDOCUMENTED = YES\n\n# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for \n# potential errors in the documentation, such as not documenting some \n# parameters in a documented function, or documenting parameters that \n# don't exist or using markup commands wrongly.\n\nWARN_IF_DOC_ERROR = YES\n\n# The WARN_FORMAT tag determines the format of the warning messages that \n# doxygen can produce. The string should contain the $file, $line, and $text \n# tags, which will be replaced by the file and line number from which the \n# warning originated and the warning text.\n\nWARN_FORMAT = \"$file:$line: $text\"\n\n# The WARN_LOGFILE tag can be used to specify a file to which warning \n# and error messages should be written. If left blank the output is written \n# to stderr.\n\nWARN_LOGFILE = \n\n#---------------------------------------------------------------------------\n# configuration options related to the input files\n#---------------------------------------------------------------------------\n\n# The INPUT tag can be used to specify the files and/or directories that contain \n# documented source files. You may enter file names like \"myfile.cpp\" or \n# directories like \"/usr/src/myproject\". Separate the files or directories \n# with spaces.\n\nINPUT = lsd.h lsd.c\n\n# If the value of the INPUT tag contains directories, you can use the \n# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp \n# and *.h) to filter out the source-files in the directories. If left \n# blank the following patterns are tested: \n# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp \n# *.h++ *.idl *.odl *.cs *.php *.php3 *.inc\n\nFILE_PATTERNS = \n\n# The RECURSIVE tag can be used to turn specify whether or not subdirectories \n# should be searched for input files as well. Possible values are YES and NO. \n# If left blank NO is used.\n\nRECURSIVE = NO\n\n# The EXCLUDE tag can be used to specify files and/or directories that should \n# excluded from the INPUT source files. This way you can easily exclude a \n# subdirectory from a directory tree whose root is specified with the INPUT tag.\n\nEXCLUDE = \n\n# The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories \n# that are symbolic links (a Unix filesystem feature) are excluded from the input.\n\nEXCLUDE_SYMLINKS = NO\n\n# If the value of the INPUT tag contains directories, you can use the \n# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude \n# certain files from those directories.\n\nEXCLUDE_PATTERNS = \n\n# The EXAMPLE_PATH tag can be used to specify one or more files or \n# directories that contain example code fragments that are included (see \n# the \\include command).\n\nEXAMPLE_PATH = \n\n# If the value of the EXAMPLE_PATH tag contains directories, you can use the \n# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp \n# and *.h) to filter out the source-files in the directories. If left \n# blank all files are included.\n\nEXAMPLE_PATTERNS = \n\n# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be \n# searched for input files to be used with the \\include or \\dontinclude \n# commands irrespective of the value of the RECURSIVE tag. \n# Possible values are YES and NO. If left blank NO is used.\n\nEXAMPLE_RECURSIVE = NO\n\n# The IMAGE_PATH tag can be used to specify one or more files or \n# directories that contain image that are included in the documentation (see \n# the \\image command).\n\nIMAGE_PATH = \n\n# The INPUT_FILTER tag can be used to specify a program that doxygen should \n# invoke to filter for each input file. Doxygen will invoke the filter program \n# by executing (via popen()) the command , where \n# is the value of the INPUT_FILTER tag, and is the name of an \n# input file. Doxygen will then use the output that the filter program writes \n# to standard output.\n\nINPUT_FILTER = \n\n# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using \n# INPUT_FILTER) will be used to filter the input files when producing source \n# files to browse (i.e. when SOURCE_BROWSER is set to YES).\n\nFILTER_SOURCE_FILES = NO\n\n#---------------------------------------------------------------------------\n# configuration options related to source browsing\n#---------------------------------------------------------------------------\n\n# If the SOURCE_BROWSER tag is set to YES then a list of source files will \n# be generated. Documented entities will be cross-referenced with these sources.\n\nSOURCE_BROWSER = YES\n\n# Setting the INLINE_SOURCES tag to YES will include the body \n# of functions and classes directly in the documentation.\n\nINLINE_SOURCES = YES\n\n# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct \n# doxygen to hide any special comment blocks from generated source code \n# fragments. Normal C and C++ comments will always remain visible.\n\nSTRIP_CODE_COMMENTS = NO\n\n# If the REFERENCED_BY_RELATION tag is set to YES (the default) \n# then for each documented function all documented \n# functions referencing it will be listed.\n\nREFERENCED_BY_RELATION = YES\n\n# If the REFERENCES_RELATION tag is set to YES (the default) \n# then for each documented function all documented entities \n# called/used by that function will be listed.\n\nREFERENCES_RELATION = YES\n\n# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen \n# will generate a verbatim copy of the header file for each class for \n# which an include is specified. Set to NO to disable this.\n\nVERBATIM_HEADERS = YES\n\n#---------------------------------------------------------------------------\n# configuration options related to the alphabetical class index\n#---------------------------------------------------------------------------\n\n# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index \n# of all compounds will be generated. Enable this if the project \n# contains a lot of classes, structs, unions or interfaces.\n\nALPHABETICAL_INDEX = NO\n\n# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then \n# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns \n# in which this list will be split (can be a number in the range [1..20])\n\nCOLS_IN_ALPHA_INDEX = 5\n\n# In case all classes in a project start with a common prefix, all \n# classes will be put under the same header in the alphabetical index. \n# The IGNORE_PREFIX tag can be used to specify one or more prefixes that \n# should be ignored while generating the index headers.\n\nIGNORE_PREFIX = \n\n#---------------------------------------------------------------------------\n# configuration options related to the HTML output\n#---------------------------------------------------------------------------\n\n# If the GENERATE_HTML tag is set to YES (the default) Doxygen will \n# generate HTML output.\n\nGENERATE_HTML = YES\n\n# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. \n# If a relative path is entered the value of OUTPUT_DIRECTORY will be \n# put in front of it. If left blank `html' will be used as the default path.\n\nHTML_OUTPUT = doc\n\n# The HTML_FILE_EXTENSION tag can be used to specify the file extension for \n# each generated HTML page (for example: .htm,.php,.asp). If it is left blank \n# doxygen will generate files with .html extension.\n\nHTML_FILE_EXTENSION = .html\n\n# The HTML_HEADER tag can be used to specify a personal HTML header for \n# each generated HTML page. If it is left blank doxygen will generate a \n# standard header.\n\nHTML_HEADER = \n\n# The HTML_FOOTER tag can be used to specify a personal HTML footer for \n# each generated HTML page. If it is left blank doxygen will generate a \n# standard footer.\n\nHTML_FOOTER = \n\n# The HTML_STYLESHEET tag can be used to specify a user-defined cascading \n# style sheet that is used by each HTML page. It can be used to \n# fine-tune the look of the HTML output. If the tag is left blank doxygen \n# will generate a default style sheet\n\nHTML_STYLESHEET = \n\n# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, \n# files or namespaces will be aligned in HTML using tables. If set to \n# NO a bullet list will be used.\n\nHTML_ALIGN_MEMBERS = YES\n\n# If the GENERATE_HTMLHELP tag is set to YES, additional index files \n# will be generated that can be used as input for tools like the \n# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) \n# of the generated HTML documentation.\n\nGENERATE_HTMLHELP = NO\n\n# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can \n# be used to specify the file name of the resulting .chm file. You \n# can add a path in front of the file if the result should not be \n# written to the html output dir.\n\nCHM_FILE = \n\n# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can \n# be used to specify the location (absolute path including file name) of \n# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run \n# the HTML help compiler on the generated index.hhp.\n\nHHC_LOCATION = \n\n# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag \n# controls if a separate .chi index file is generated (YES) or that \n# it should be included in the master .chm file (NO).\n\nGENERATE_CHI = NO\n\n# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag \n# controls whether a binary table of contents is generated (YES) or a \n# normal table of contents (NO) in the .chm file.\n\nBINARY_TOC = NO\n\n# The TOC_EXPAND flag can be set to YES to add extra items for group members \n# to the contents of the HTML help documentation and to the tree view.\n\nTOC_EXPAND = NO\n\n# The DISABLE_INDEX tag can be used to turn on/off the condensed index at \n# top of each HTML page. The value NO (the default) enables the index and \n# the value YES disables it.\n\nDISABLE_INDEX = NO\n\n# This tag can be used to set the number of enum values (range [1..20]) \n# that doxygen will group on one line in the generated HTML documentation.\n\nENUM_VALUES_PER_LINE = 4\n\n# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be\n# generated containing a tree-like index structure (just like the one that \n# is generated for HTML Help). For this to work a browser that supports \n# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, \n# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are \n# probably better off using the HTML help feature.\n\nGENERATE_TREEVIEW = NO\n\n# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be \n# used to set the initial width (in pixels) of the frame in which the tree \n# is shown.\n\nTREEVIEW_WIDTH = 180\n\n#---------------------------------------------------------------------------\n# configuration options related to the LaTeX output\n#---------------------------------------------------------------------------\n\n# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will \n# generate Latex output.\n\nGENERATE_LATEX = NO\n\n# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. \n# If a relative path is entered the value of OUTPUT_DIRECTORY will be \n# put in front of it. If left blank `latex' will be used as the default path.\n\nLATEX_OUTPUT = latex\n\n# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be \n# invoked. If left blank `latex' will be used as the default command name.\n\nLATEX_CMD_NAME = latex\n\n# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to \n# generate index for LaTeX. If left blank `makeindex' will be used as the \n# default command name.\n\nMAKEINDEX_CMD_NAME = makeindex\n\n# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact \n# LaTeX documents. This may be useful for small projects and may help to \n# save some trees in general.\n\nCOMPACT_LATEX = NO\n\n# The PAPER_TYPE tag can be used to set the paper type that is used \n# by the printer. Possible values are: a4, a4wide, letter, legal and \n# executive. If left blank a4wide will be used.\n\nPAPER_TYPE = a4wide\n\n# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX \n# packages that should be included in the LaTeX output.\n\nEXTRA_PACKAGES = \n\n# The LATEX_HEADER tag can be used to specify a personal LaTeX header for \n# the generated latex document. The header should contain everything until \n# the first chapter. If it is left blank doxygen will generate a \n# standard header. Notice: only use this tag if you know what you are doing!\n\nLATEX_HEADER = \n\n# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated \n# is prepared for conversion to pdf (using ps2pdf). The pdf file will \n# contain links (just like the HTML output) instead of page references \n# This makes the output suitable for online browsing using a pdf viewer.\n\nPDF_HYPERLINKS = NO\n\n# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of \n# plain latex in the generated Makefile. Set this option to YES to get a \n# higher quality PDF documentation.\n\nUSE_PDFLATEX = NO\n\n# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\\\batchmode. \n# command to the generated LaTeX files. This will instruct LaTeX to keep \n# running if errors occur, instead of asking the user for help. \n# This option is also used when generating formulas in HTML.\n\nLATEX_BATCHMODE = NO\n\n# If LATEX_HIDE_INDICES is set to YES then doxygen will not \n# include the index chapters (such as File Index, Compound Index, etc.) \n# in the output.\n\nLATEX_HIDE_INDICES = NO\n\n#---------------------------------------------------------------------------\n# configuration options related to the RTF output\n#---------------------------------------------------------------------------\n\n# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output \n# The RTF output is optimised for Word 97 and may not look very pretty with \n# other RTF readers or editors.\n\nGENERATE_RTF = NO\n\n# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. \n# If a relative path is entered the value of OUTPUT_DIRECTORY will be \n# put in front of it. If left blank `rtf' will be used as the default path.\n\nRTF_OUTPUT = rtf\n\n# If the COMPACT_RTF tag is set to YES Doxygen generates more compact \n# RTF documents. This may be useful for small projects and may help to \n# save some trees in general.\n\nCOMPACT_RTF = NO\n\n# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated \n# will contain hyperlink fields. The RTF file will \n# contain links (just like the HTML output) instead of page references. \n# This makes the output suitable for online browsing using WORD or other \n# programs which support those fields. \n# Note: wordpad (write) and others do not support links.\n\nRTF_HYPERLINKS = NO\n\n# Load stylesheet definitions from file. Syntax is similar to doxygen's \n# config file, i.e. a series of assigments. You only have to provide \n# replacements, missing definitions are set to their default value.\n\nRTF_STYLESHEET_FILE = \n\n# Set optional variables used in the generation of an rtf document. \n# Syntax is similar to doxygen's config file.\n\nRTF_EXTENSIONS_FILE = \n\n#---------------------------------------------------------------------------\n# configuration options related to the man page output\n#---------------------------------------------------------------------------\n\n# If the GENERATE_MAN tag is set to YES (the default) Doxygen will \n# generate man pages\n\nGENERATE_MAN = NO\n\n# The MAN_OUTPUT tag is used to specify where the man pages will be put. \n# If a relative path is entered the value of OUTPUT_DIRECTORY will be \n# put in front of it. If left blank `man' will be used as the default path.\n\nMAN_OUTPUT = man\n\n# The MAN_EXTENSION tag determines the extension that is added to \n# the generated man pages (default is the subroutine's section .3)\n\nMAN_EXTENSION = .3\n\n# If the MAN_LINKS tag is set to YES and Doxygen generates man output, \n# then it will generate one additional man file for each entity \n# documented in the real man page(s). These additional files \n# only source the real man page, but without them the man command \n# would be unable to find the correct page. The default is NO.\n\nMAN_LINKS = NO\n\n#---------------------------------------------------------------------------\n# configuration options related to the XML output\n#---------------------------------------------------------------------------\n\n# If the GENERATE_XML tag is set to YES Doxygen will \n# generate an XML file that captures the structure of \n# the code including all documentation. Note that this \n# feature is still experimental and incomplete at the \n# moment.\n\nGENERATE_XML = NO\n\n# The XML_OUTPUT tag is used to specify where the XML pages will be put. \n# If a relative path is entered the value of OUTPUT_DIRECTORY will be \n# put in front of it. If left blank `xml' will be used as the default path.\n\nXML_OUTPUT = xml\n\n# The XML_SCHEMA tag can be used to specify an XML schema, \n# which can be used by a validating XML parser to check the \n# syntax of the XML files.\n\nXML_SCHEMA = \n\n# The XML_DTD tag can be used to specify an XML DTD, \n# which can be used by a validating XML parser to check the \n# syntax of the XML files.\n\nXML_DTD = \n\n#---------------------------------------------------------------------------\n# configuration options for the AutoGen Definitions output\n#---------------------------------------------------------------------------\n\n# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will \n# generate an AutoGen Definitions (see autogen.sf.net) file \n# that captures the structure of the code including all \n# documentation. Note that this feature is still experimental \n# and incomplete at the moment.\n\nGENERATE_AUTOGEN_DEF = NO\n\n#---------------------------------------------------------------------------\n# configuration options related to the Perl module output\n#---------------------------------------------------------------------------\n\n# If the GENERATE_PERLMOD tag is set to YES Doxygen will \n# generate a Perl module file that captures the structure of \n# the code including all documentation. Note that this \n# feature is still experimental and incomplete at the \n# moment.\n\nGENERATE_PERLMOD = NO\n\n# If the PERLMOD_LATEX tag is set to YES Doxygen will generate \n# the necessary Makefile rules, Perl scripts and LaTeX code to be able \n# to generate PDF and DVI output from the Perl module output.\n\nPERLMOD_LATEX = NO\n\n# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be \n# nicely formatted so it can be parsed by a human reader. This is useful \n# if you want to understand what is going on. On the other hand, if this \n# tag is set to NO the size of the Perl module output will be much smaller \n# and Perl will parse it just the same.\n\nPERLMOD_PRETTY = YES\n\n# The names of the make variables in the generated doxyrules.make file \n# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. \n# This is useful so different doxyrules.make files included by the same \n# Makefile don't overwrite each other's variables.\n\nPERLMOD_MAKEVAR_PREFIX = \n\n#---------------------------------------------------------------------------\n# Configuration options related to the preprocessor \n#---------------------------------------------------------------------------\n\n# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will \n# evaluate all C-preprocessor directives found in the sources and include \n# files.\n\nENABLE_PREPROCESSING = YES\n\n# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro \n# names in the source code. If set to NO (the default) only conditional \n# compilation will be performed. Macro expansion can be done in a controlled \n# way by setting EXPAND_ONLY_PREDEF to YES.\n\nMACRO_EXPANSION = NO\n\n# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES \n# then the macro expansion is limited to the macros specified with the \n# PREDEFINED and EXPAND_AS_PREDEFINED tags.\n\nEXPAND_ONLY_PREDEF = NO\n\n# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files \n# in the INCLUDE_PATH (see below) will be search if a #include is found.\n\nSEARCH_INCLUDES = YES\n\n# The INCLUDE_PATH tag can be used to specify one or more directories that \n# contain include files that are not input files but should be processed by \n# the preprocessor.\n\nINCLUDE_PATH = \n\n# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard \n# patterns (like *.h and *.hpp) to filter out the header-files in the \n# directories. If left blank, the patterns specified with FILE_PATTERNS will \n# be used.\n\nINCLUDE_FILE_PATTERNS = \n\n# The PREDEFINED tag can be used to specify one or more macro names that \n# are defined before the preprocessor is started (similar to the -D option of \n# gcc). The argument of the tag is a list of macros of the form: name \n# or name=definition (no spaces). If the definition and the = are \n# omitted =1 is assumed.\n\nPREDEFINED = \n\n# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then \n# this tag can be used to specify a list of macro names that should be expanded. \n# The macro definition that is found in the sources will be used. \n# Use the PREDEFINED tag if you want to use a different macro definition.\n\nEXPAND_AS_DEFINED = \n\n# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then \n# doxygen's preprocessor will remove all function-like macros that are alone \n# on a line, have an all uppercase name, and do not end with a semicolon. Such \n# function macros are typically used for boiler-plate code, and will confuse the \n# parser if not removed.\n\nSKIP_FUNCTION_MACROS = YES\n\n#---------------------------------------------------------------------------\n# Configuration::addtions related to external references \n#---------------------------------------------------------------------------\n\n# The TAGFILES option can be used to specify one or more tagfiles. \n# Optionally an initial location of the external documentation \n# can be added for each tagfile. The format of a tag file without \n# this location is as follows: \n# TAGFILES = file1 file2 ... \n# Adding location for the tag files is done as follows: \n# TAGFILES = file1=loc1 \"file2 = loc2\" ... \n# where \"loc1\" and \"loc2\" can be relative or absolute paths or \n# URLs. If a location is present for each tag, the installdox tool \n# does not have to be run to correct the links.\n# Note that each tag file must have a unique name\n# (where the name does NOT include the path)\n# If a tag file is not located in the directory in which doxygen \n# is run, you must also specify the path to the tagfile here.\n\nTAGFILES = \n\n# When a file name is specified after GENERATE_TAGFILE, doxygen will create \n# a tag file that is based on the input files it reads.\n\nGENERATE_TAGFILE = \n\n# If the ALLEXTERNALS tag is set to YES all external classes will be listed \n# in the class index. If set to NO only the inherited external classes \n# will be listed.\n\nALLEXTERNALS = NO\n\n# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed \n# in the modules index. If set to NO, only the current project's groups will \n# be listed.\n\nEXTERNAL_GROUPS = YES\n\n# The PERL_PATH should be the absolute path and name of the perl script \n# interpreter (i.e. the result of `which perl').\n\nPERL_PATH = /usr/bin/perl\n\n#---------------------------------------------------------------------------\n# Configuration options related to the dot tool \n#---------------------------------------------------------------------------\n\n# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will \n# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base or \n# super classes. Setting the tag to NO turns the diagrams off. Note that this \n# option is superceded by the HAVE_DOT option below. This is only a fallback. It is \n# recommended to install and use dot, since it yields more powerful graphs.\n\nCLASS_DIAGRAMS = YES\n\n# If set to YES, the inheritance and collaboration graphs will hide \n# inheritance and usage relations if the target is undocumented \n# or is not a class.\n\nHIDE_UNDOC_RELATIONS = YES\n\n# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is \n# available from the path. This tool is part of Graphviz, a graph visualization \n# toolkit from AT&T and Lucent Bell Labs. The other options in this section \n# have no effect if this option is set to NO (the default)\n\nHAVE_DOT = YES\n\n# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen \n# will generate a graph for each documented class showing the direct and \n# indirect inheritance relations. Setting this tag to YES will force the \n# the CLASS_DIAGRAMS tag to NO.\n\nCLASS_GRAPH = YES\n\n# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen \n# will generate a graph for each documented class showing the direct and \n# indirect implementation dependencies (inheritance, containment, and \n# class references variables) of the class with other documented classes.\n\nCOLLABORATION_GRAPH = YES\n\n# If the UML_LOOK tag is set to YES doxygen will generate inheritance and \n# collaboration diagrams in a style similiar to the OMG's Unified Modeling \n# Language.\n\nUML_LOOK = NO\n\n# If set to YES, the inheritance and collaboration graphs will show the \n# relations between templates and their instances.\n\nTEMPLATE_RELATIONS = NO\n\n# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT \n# tags are set to YES then doxygen will generate a graph for each documented \n# file showing the direct and indirect include dependencies of the file with \n# other documented files.\n\nINCLUDE_GRAPH = YES\n\n# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and \n# HAVE_DOT tags are set to YES then doxygen will generate a graph for each \n# documented header file showing the documented files that directly or \n# indirectly include this file.\n\nINCLUDED_BY_GRAPH = YES\n\n# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will \n# generate a call dependency graph for every global function or class method. \n# Note that enabling this option will significantly increase the time of a run. \n# So in most cases it will be better to enable call graphs for selected \n# functions only using the \\callgraph command.\n\nCALL_GRAPH = YES\n\n# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen \n# will graphical hierarchy of all classes instead of a textual one.\n\nGRAPHICAL_HIERARCHY = YES\n\n# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images \n# generated by dot. Possible values are png, jpg, or gif\n# If left blank png will be used.\n\nDOT_IMAGE_FORMAT = png\n\n# The tag DOT_PATH can be used to specify the path where the dot tool can be \n# found. If left blank, it is assumed the dot tool can be found on the path.\n\nDOT_PATH = \n\n# The DOTFILE_DIRS tag can be used to specify one or more directories that \n# contain dot files that are included in the documentation (see the \n# \\dotfile command).\n\nDOTFILE_DIRS = \n\n# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width \n# (in pixels) of the graphs generated by dot. If a graph becomes larger than \n# this value, doxygen will try to truncate the graph, so that it fits within \n# the specified constraint. Beware that most browsers cannot cope with very \n# large images.\n\nMAX_DOT_GRAPH_WIDTH = 1024\n\n# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height \n# (in pixels) of the graphs generated by dot. If a graph becomes larger than \n# this value, doxygen will try to truncate the graph, so that it fits within \n# the specified constraint. Beware that most browsers cannot cope with very \n# large images.\n\nMAX_DOT_GRAPH_HEIGHT = 1024\n\n# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the \n# graphs generated by dot. A depth value of 3 means that only nodes reachable \n# from the root by following a path via at most 3 edges will be shown. Nodes that \n# lay further from the root node will be omitted. Note that setting this option to \n# 1 or 2 may greatly reduce the computation time needed for large code bases. Also \n# note that a graph may be further truncated if the graph's image dimensions are \n# not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH and MAX_DOT_GRAPH_HEIGHT). \n# If 0 is used for the depth value (the default), the graph is not depth-constrained.\n\nMAX_DOT_GRAPH_DEPTH = 0\n\n# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will \n# generate a legend page explaining the meaning of the various boxes and \n# arrows in the dot generated graphs.\n\nGENERATE_LEGEND = YES\n\n# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will \n# remove the intermediate dot files that are used to generate \n# the various graphs.\n\nDOT_CLEANUP = YES\n\n#---------------------------------------------------------------------------\n# Configuration::addtions related to the search engine \n#---------------------------------------------------------------------------\n\n# The SEARCHENGINE tag specifies whether or not a search engine should be \n# used. If set to NO the values of all tags below this one will be ignored.\n\nSEARCHENGINE = NO\n"
},
{
"path": "thirdparty/LSD/lsd.c",
"content": "/*----------------------------------------------------------------------------\n\n LSD - Line Segment Detector on digital images\n\n Copyright 2007-2010 rafael grompone von gioi (grompone@gmail.com)\n\n This program is free software: you can redistribute it and/or modify\n it under the terms of the GNU Affero General Public License as\n published by the Free Software Foundation, either version 3 of the\n License, or (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Affero General Public License for more details.\n\n You should have received a copy of the GNU Affero General Public License\n along with this program. If not, see .\n\n ----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** @file lsd.c\n LSD module code\n @author rafael grompone von gioi (grompone@gmail.com)\n */\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** @mainpage LSD code documentation\n\n This is an implementation of the Line Segment Detector described\n in the paper:\n\n \"LSD: A Fast Line Segment Detector with a False Detection Control\"\n by Rafael Grompone von Gioi, Jeremie Jakubowicz, Jean-Michel Morel,\n and Gregory Randall, IEEE Transactions on Pattern Analysis and\n Machine Intelligence, vol. 32, no. 4, pp. 722-732, April, 2010.\n\n and in more details in the CMLA Technical Report:\n\n \"LSD: A Line Segment Detector, Technical Report\",\n by Rafael Grompone von Gioi, Jeremie Jakubowicz, Jean-Michel Morel,\n Gregory Randall, CMLA, ENS Cachan, 2010.\n\n The version implemented here includes some further improvements\n described on the LSD page at www.ipol.im. That same page includes\n more information, including this code and an online demo version:\n\n http://www.ipol.im/pub/algo/gjmr_line_segment_detector\n\n The module's main function is lsd().\n\n The source code is contained in two files: lsd.h and lsd.c.\n\n HISTORY:\n - version 1.5 - dic 2010: Changes in 'refine', -W option added,\n and more comments added.\n - version 1.4 - jul 2010: lsd_scale interface added and doxygen doc.\n - version 1.3 - feb 2010: Multiple bug correction and improved code.\n - version 1.2 - dic 2009: First full Ansi C Language version.\n - version 1.1 - sep 2009: Systematic subsampling to scale 0.8 and\n correction to partially handle\"angle problem\".\n - version 1.0 - jan 2009: First complete Megawave2 and Ansi C Language\n version.\n\n @author rafael grompone von gioi (grompone@gmail.com)\n */\n/*----------------------------------------------------------------------------*/\n\n#include \n#include \n#include \n#include \n#include \n#include \"lsd.h\"\n\n/** ln(10) */\n#ifndef M_LN10\n#define M_LN10 2.30258509299404568402\n#endif /* !M_LN10 */\n\n/** PI */\n#ifndef M_PI\n#define M_PI 3.14159265358979323846\n#endif /* !M_PI */\n\n#ifndef FALSE\n#define FALSE 0\n#endif /* !FALSE */\n\n#ifndef TRUE\n#define TRUE 1\n#endif /* !TRUE */\n\n/** Label for pixels with undefined gradient. */\n#define NOTDEF -1024.0\n\n/** 3/2 pi */\n#define M_3_2_PI 4.71238898038\n\n/** 2 pi */\n#define M_2__PI 6.28318530718\n\n/** Label for pixels not used in yet. */\n#define NOTUSED 0\n\n/** Label for pixels already used in detection. */\n#define USED 1\n\n/*----------------------------------------------------------------------------*/\n/** Chained list of coordinates.\n */\nstruct coorlist\n{\n int x,y;\n struct coorlist * next;\n};\n\n/*----------------------------------------------------------------------------*/\n/** A point (or pixel).\n */\nstruct point {int x,y;};\n\n\n/*----------------------------------------------------------------------------*/\n/*------------------------- Miscellaneous functions --------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Fatal error, print a message to standard-error output and exit.\n */\nstatic void error(char * msg)\n{\n fprintf(stderr,\"LSD Error: %s\\n\",msg);\n exit(EXIT_FAILURE);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Doubles relative error factor\n */\n#define RELATIVE_ERROR_FACTOR 100.0\n\n/*----------------------------------------------------------------------------*/\n/** Compare doubles by relative error.\n\n The resulting rounding error after floating point computations\n depend on the specific operations done. The same number computed by\n different algorithms could present different rounding errors. For a\n useful comparison, an estimation of the relative rounding error\n should be considered and compared to a factor times EPS. The factor\n should be related to the cumulated rounding error in the chain of\n computation. Here, as a simplification, a fixed factor is used.\n */\nstatic int double_equal(double a, double b)\n{\n double abs_diff,aa,bb,abs_max;\n\n /* trivial case */\n if( a == b ) return TRUE;\n\n abs_diff = fabs(a-b);\n aa = fabs(a);\n bb = fabs(b);\n abs_max = aa > bb ? aa : bb;\n\n /* DBL_MIN is the smallest normalized number, thus, the smallest\n number whose relative error is bounded by DBL_EPSILON. For\n smaller numbers, the same quantization steps as for DBL_MIN\n are used. Then, for smaller numbers, a meaningful \"relative\"\n error should be computed by dividing the difference by DBL_MIN. */\n if( abs_max < DBL_MIN ) abs_max = DBL_MIN;\n\n /* equal if relative error <= factor x eps */\n return (abs_diff / abs_max) <= (RELATIVE_ERROR_FACTOR * DBL_EPSILON);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Computes Euclidean distance between point (x1,y1) and point (x2,y2).\n */\nstatic double dist(double x1, double y1, double x2, double y2)\n{\n return sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) );\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------- 'list of n-tuple' data type ------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Free memory used in n-tuple 'in'.\n */\nvoid free_ntuple_list(ntuple_list in)\n{\n if( in == NULL || in->values == NULL )\n error(\"free_ntuple_list: invalid n-tuple input.\");\n free( (void *) in->values );\n free( (void *) in );\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create an n-tuple list and allocate memory for one element.\n @param dim the dimension (n) of the n-tuple.\n */\nntuple_list new_ntuple_list(unsigned int dim)\n{\n ntuple_list n_tuple;\n\n /* check parameters */\n if( dim == 0 ) error(\"new_ntuple_list: 'dim' must be positive.\");\n\n /* get memory for list structure */\n n_tuple = (ntuple_list) malloc( sizeof(struct ntuple_list_s) );\n if( n_tuple == NULL ) error(\"not enough memory.\");\n\n /* initialize list */\n n_tuple->size = 0;\n n_tuple->max_size = 1;\n n_tuple->dim = dim;\n\n /* get memory for tuples */\n n_tuple->values = (double *) malloc( dim*n_tuple->max_size * sizeof(double) );\n if( n_tuple->values == NULL ) error(\"not enough memory.\");\n\n return n_tuple;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Enlarge the allocated memory of an n-tuple list.\n */\nstatic void enlarge_ntuple_list(ntuple_list n_tuple)\n{\n /* check parameters */\n if( n_tuple == NULL || n_tuple->values == NULL || n_tuple->max_size == 0 )\n error(\"enlarge_ntuple_list: invalid n-tuple.\");\n\n /* duplicate number of tuples */\n n_tuple->max_size *= 2;\n\n /* realloc memory */\n n_tuple->values = (double *) realloc( (void *) n_tuple->values,\n n_tuple->dim * n_tuple->max_size * sizeof(double) );\n if( n_tuple->values == NULL ) error(\"not enough memory.\");\n}\n\n/*----------------------------------------------------------------------------*/\n/** Add a 5-tuple to an n-tuple list.\n */\nstatic void add_5tuple( ntuple_list out, double v1, double v2,\n double v3, double v4, double v5 )\n{\n /* check parameters */\n if( out == NULL ) error(\"add_5tuple: invalid n-tuple input.\");\n if( out->dim != 5 ) error(\"add_5tuple: the n-tuple must be a 5-tuple.\");\n\n /* if needed, alloc more tuples to 'out' */\n if( out->size == out->max_size ) enlarge_ntuple_list(out);\n if( out->values == NULL ) error(\"add_5tuple: invalid n-tuple input.\");\n\n /* add new 5-tuple */\n out->values[ out->size * out->dim + 0 ] = v1;\n out->values[ out->size * out->dim + 1 ] = v2;\n out->values[ out->size * out->dim + 2 ] = v3;\n out->values[ out->size * out->dim + 3 ] = v4;\n out->values[ out->size * out->dim + 4 ] = v5;\n\n /* update number of tuples counter */\n out->size++;\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------------- Image Data Types -----------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Free memory used in image_char 'i'.\n */\nvoid free_image_char(image_char i)\n{\n if( i == NULL || i->data == NULL )\n error(\"free_image_char: invalid input image.\");\n free( (void *) i->data );\n free( (void *) i );\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create a new image_char of size 'xsize' times 'ysize'.\n */\nimage_char new_image_char(unsigned int xsize, unsigned int ysize)\n{\n image_char image;\n\n /* check parameters */\n if( xsize == 0 || ysize == 0 ) error(\"new_image_char: invalid image size.\");\n\n /* get memory */\n image = (image_char) malloc( sizeof(struct image_char_s) );\n if( image == NULL ) error(\"not enough memory.\");\n image->data = (unsigned char *) calloc( (size_t) (xsize*ysize),\n sizeof(unsigned char) );\n if( image->data == NULL ) error(\"not enough memory.\");\n\n /* set image size */\n image->xsize = xsize;\n image->ysize = ysize;\n\n return image;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create a new image_char of size 'xsize' times 'ysize',\n initialized to the value 'fill_value'.\n */\nimage_char new_image_char_ini( unsigned int xsize, unsigned int ysize,\n unsigned char fill_value )\n{\n image_char image = new_image_char(xsize,ysize); /* create image */\n unsigned int N = xsize*ysize;\n unsigned int i;\n\n /* check parameters */\n if( image == NULL || image->data == NULL )\n error(\"new_image_char_ini: invalid image.\");\n\n /* initialize */\n for(i=0; idata[i] = fill_value;\n\n return image;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Free memory used in image_int 'i'.\n */\nvoid free_image_int(image_int i)\n{\n if( i == NULL || i->data == NULL )\n error(\"free_image_int: invalid input image.\");\n free( (void *) i->data );\n free( (void *) i );\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create a new image_int of size 'xsize' times 'ysize'.\n */\nimage_int new_image_int(unsigned int xsize, unsigned int ysize)\n{\n image_int image;\n\n /* check parameters */\n if( xsize == 0 || ysize == 0 ) error(\"new_image_int: invalid image size.\");\n\n /* get memory */\n image = (image_int) malloc( sizeof(struct image_int_s) );\n if( image == NULL ) error(\"not enough memory.\");\n image->data = (int *) calloc( (size_t) (xsize*ysize), sizeof(int) );\n if( image->data == NULL ) error(\"not enough memory.\");\n\n /* set image size */\n image->xsize = xsize;\n image->ysize = ysize;\n\n return image;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create a new image_int of size 'xsize' times 'ysize',\n initialized to the value 'fill_value'.\n */\nimage_int new_image_int_ini( unsigned int xsize, unsigned int ysize,\n int fill_value )\n{\n image_int image = new_image_int(xsize,ysize); /* create image */\n unsigned int N = xsize*ysize;\n unsigned int i;\n\n /* initialize */\n for(i=0; idata[i] = fill_value;\n\n return image;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Free memory used in image_double 'i'.\n */\nvoid free_image_double(image_double i)\n{\n if( i == NULL || i->data == NULL )\n error(\"free_image_double: invalid input image.\");\n free( (void *) i->data );\n free( (void *) i );\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create a new image_double of size 'xsize' times 'ysize'.\n */\nimage_double new_image_double(unsigned int xsize, unsigned int ysize)\n{\n image_double image;\n\n /* check parameters */\n if( xsize == 0 || ysize == 0 ) error(\"new_image_double: invalid image size.\");\n\n /* get memory */\n image = (image_double) malloc( sizeof(struct image_double_s) );\n if( image == NULL ) error(\"not enough memory.\");\n image->data = (double *) calloc( (size_t) (xsize*ysize), sizeof(double) );\n if( image->data == NULL ) error(\"not enough memory.\");\n\n /* set image size */\n image->xsize = xsize;\n image->ysize = ysize;\n\n return image;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create a new image_double of size 'xsize' times 'ysize',\n initialized to the value 'fill_value'.\n */\nimage_double new_image_double_ini( unsigned int xsize, unsigned int ysize,\n double fill_value )\n{\n image_double image = new_image_double(xsize,ysize); /* create image */\n unsigned int N = xsize*ysize;\n unsigned int i;\n\n /* initialize */\n for(i=0; idata[i] = fill_value;\n\n return image;\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------------- Gaussian filter ------------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Compute a Gaussian kernel of length 'kernel->dim',\n standard deviation 'sigma', and centered at value 'mean'.\n\n For example, if mean=0.5, the Gaussian will be centered\n in the middle point between values 'kernel->values[0]'\n and 'kernel->values[1]'.\n */\nstatic void gaussian_kernel(ntuple_list kernel, double sigma, double mean)\n{\n double sum = 0.0;\n double val;\n unsigned int i;\n\n /* check parameters */\n if( kernel == NULL || kernel->values == NULL )\n error(\"gaussian_kernel: invalid n-tuple 'kernel'.\");\n if( sigma <= 0.0 ) error(\"gaussian_kernel: 'sigma' must be positive.\");\n\n /* compute Gaussian kernel */\n if( kernel->max_size < 1 ) enlarge_ntuple_list(kernel);\n kernel->size = 1;\n for(i=0;idim;i++)\n {\n val = ( (double) i - mean ) / sigma;\n kernel->values[i] = exp( -0.5 * val * val );\n sum += kernel->values[i];\n }\n\n /* normalization */\n if( sum >= 0.0 ) for(i=0;idim;i++) kernel->values[i] /= sum;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Scale the input image 'in' by a factor 'scale' by Gaussian sub-sampling.\n\n For example, scale=0.8 will give a result at 80% of the original size.\n\n The image is convolved with a Gaussian kernel\n @f[\n G(x,y) = \\frac{1}{2\\pi\\sigma^2} e^{-\\frac{x^2+y^2}{2\\sigma^2}}\n @f]\n before the sub-sampling to prevent aliasing.\n\n The standard deviation sigma given by:\n - sigma = sigma_scale / scale, if scale < 1.0\n - sigma = sigma_scale, if scale >= 1.0\n\n To be able to sub-sample at non-integer steps, some interpolation\n is needed. In this implementation, the interpolation is done by\n the Gaussian kernel, so both operations (filtering and sampling)\n are done at the same time. The Gaussian kernel is computed\n centered on the coordinates of the required sample. In this way,\n when applied, it gives directly the result of convolving the image\n with the kernel and interpolated to that particular position.\n\n A fast algorithm is done using the separability of the Gaussian\n kernel. Applying the 2D Gaussian kernel is equivalent to applying\n first a horizontal 1D Gaussian kernel and then a vertical 1D\n Gaussian kernel (or the other way round). The reason is that\n @f[\n G(x,y) = G(x) * G(y)\n @f]\n where\n @f[\n G(x) = \\frac{1}{\\sqrt{2\\pi}\\sigma} e^{-\\frac{x^2}{2\\sigma^2}}.\n @f]\n The algorithm first apply a combined Gaussian kernel and sampling\n in the x axis, and then the combined Gaussian kernel and sampling\n in the y axis.\n */\nstatic image_double gaussian_sampler( image_double in, double scale,\n double sigma_scale )\n{\n image_double aux,out;\n ntuple_list kernel;\n unsigned int N,M,h,n,x,y,i;\n int xc,yc,j,double_x_size,double_y_size;\n double sigma,xx,yy,sum,prec;\n\n /* check parameters */\n if( in == NULL || in->data == NULL || in->xsize == 0 || in->ysize == 0 )\n error(\"gaussian_sampler: invalid image.\");\n if( scale <= 0.0 ) error(\"gaussian_sampler: 'scale' must be positive.\");\n if( sigma_scale <= 0.0 )\n error(\"gaussian_sampler: 'sigma_scale' must be positive.\");\n\n /* get memory for images */\n if( in->xsize * scale > (double) UINT_MAX ||\n in->ysize * scale > (double) UINT_MAX )\n error(\"gaussian_sampler: the output image size exceeds the handled size.\");\n N = (unsigned int) floor( in->xsize * scale );\n M = (unsigned int) floor( in->ysize * scale );\n aux = new_image_double(N,in->ysize);\n out = new_image_double(N,M);\n\n /* sigma, kernel size and memory for the kernel */\n sigma = scale < 1.0 ? sigma_scale / scale : sigma_scale;\n /*\n The size of the kernel is selected to guarantee that the\n the first discarded term is at least 10^prec times smaller\n than the central value. For that, h should be larger than x, with\n e^(-x^2/2sigma^2) = 1/10^prec.\n Then,\n x = sigma * sqrt( 2 * prec * ln(10) ).\n */\n prec = 3.0;\n h = (unsigned int) ceil( sigma * sqrt( 2.0 * prec * log(10.0) ) );\n n = 1+2*h; /* kernel size */\n kernel = new_ntuple_list(n);\n\n /* auxiliary double image size variables */\n double_x_size = (int) (2 * in->xsize);\n double_y_size = (int) (2 * in->ysize);\n\n /* First subsampling: x axis */\n for(x=0;xxsize;x++)\n {\n /*\n x is the coordinate in the new image.\n xx is the corresponding x-value in the original size image.\n xc is the integer value, the pixel coordinate of xx.\n */\n xx = (double) x / scale;\n /* coordinate (0.0,0.0) is in the center of pixel (0,0),\n so the pixel with xc=0 get the values of xx from -0.5 to 0.5 */\n xc = (int) floor( xx + 0.5 );\n gaussian_kernel( kernel, sigma, (double) h + xx - (double) xc );\n /* the kernel must be computed for each x because the fine\n offset xx-xc is different in each case */\n\n for(y=0;yysize;y++)\n {\n sum = 0.0;\n for(i=0;idim;i++)\n {\n j = xc - h + i;\n\n /* symmetry boundary condition */\n while( j < 0 ) j += double_x_size;\n while( j >= double_x_size ) j -= double_x_size;\n if( j >= (int) in->xsize ) j = double_x_size-1-j;\n\n sum += in->data[ j + y * in->xsize ] * kernel->values[i];\n }\n aux->data[ x + y * aux->xsize ] = sum;\n }\n }\n\n /* Second subsampling: y axis */\n for(y=0;yysize;y++)\n {\n /*\n y is the coordinate in the new image.\n yy is the corresponding x-value in the original size image.\n yc is the integer value, the pixel coordinate of xx.\n */\n yy = (double) y / scale;\n /* coordinate (0.0,0.0) is in the center of pixel (0,0),\n so the pixel with yc=0 get the values of yy from -0.5 to 0.5 */\n yc = (int) floor( yy + 0.5 );\n gaussian_kernel( kernel, sigma, (double) h + yy - (double) yc );\n /* the kernel must be computed for each y because the fine\n offset yy-yc is different in each case */\n\n for(x=0;xxsize;x++)\n {\n sum = 0.0;\n for(i=0;idim;i++)\n {\n j = yc - h + i;\n\n /* symmetry boundary condition */\n while( j < 0 ) j += double_y_size;\n while( j >= double_y_size ) j -= double_y_size;\n if( j >= (int) in->ysize ) j = double_y_size-1-j;\n\n sum += aux->data[ x + j * aux->xsize ] * kernel->values[i];\n }\n out->data[ x + y * out->xsize ] = sum;\n }\n }\n\n /* free memory */\n free_ntuple_list(kernel);\n free_image_double(aux);\n\n return out;\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*--------------------------------- Gradient ---------------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Computes the direction of the level line of 'in' at each point.\n\n The result is:\n - an image_double with the angle at each pixel, or NOTDEF if not defined.\n - the image_double 'modgrad' (a pointer is passed as argument)\n with the gradient magnitude at each point.\n - a list of pixels 'list_p' roughly ordered by decreasing\n gradient magnitude. (The order is made by classifying points\n into bins by gradient magnitude. The parameters 'n_bins' and\n 'max_grad' specify the number of bins and the gradient modulus\n at the highest bin. The pixels in the list would be in\n decreasing gradient magnitude, up to a precision of the size of\n the bins.)\n - a pointer 'mem_p' to the memory used by 'list_p' to be able to\n free the memory when it is not used anymore.\n */\nstatic image_double ll_angle( image_double in, double threshold,\n struct coorlist ** list_p, void ** mem_p,\n image_double * modgrad, unsigned int n_bins,\n double max_grad )\n{\n image_double g;\n unsigned int n,p,x,y,adr,i;\n double com1,com2,gx,gy,norm,norm2;\n /* the rest of the variables are used for pseudo-ordering\n the gradient magnitude values */\n int list_count = 0;\n struct coorlist * list;\n struct coorlist ** range_l_s; /* array of pointers to start of bin list */\n struct coorlist ** range_l_e; /* array of pointers to end of bin list */\n struct coorlist * start;\n struct coorlist * end;\n\n /* check parameters */\n if( in == NULL || in->data == NULL || in->xsize == 0 || in->ysize == 0 )\n error(\"ll_angle: invalid image.\");\n if( threshold < 0.0 ) error(\"ll_angle: 'threshold' must be positive.\");\n if( list_p == NULL ) error(\"ll_angle: NULL pointer 'list_p'.\");\n if( mem_p == NULL ) error(\"ll_angle: NULL pointer 'mem_p'.\");\n if( modgrad == NULL ) error(\"ll_angle: NULL pointer 'modgrad'.\");\n if( n_bins == 0 ) error(\"ll_angle: 'n_bins' must be positive.\");\n if( max_grad <= 0.0 ) error(\"ll_angle: 'max_grad' must be positive.\");\n\n /* image size shortcuts */\n n = in->ysize;\n p = in->xsize;\n\n /* allocate output image */\n g = new_image_double(in->xsize,in->ysize);\n\n /* get memory for the image of gradient modulus */\n *modgrad = new_image_double(in->xsize,in->ysize);\n\n /* get memory for \"ordered\" list of pixels */\n list = (struct coorlist *) calloc( (size_t) (n*p), sizeof(struct coorlist) );\n *mem_p = (void *) list;\n range_l_s = (struct coorlist **) calloc( (size_t) n_bins,\n sizeof(struct coorlist *) );\n range_l_e = (struct coorlist **) calloc( (size_t) n_bins,\n sizeof(struct coorlist *) );\n if( list == NULL || range_l_s == NULL || range_l_e == NULL )\n error(\"not enough memory.\");\n for(i=0;idata[(n-1)*p+x] = NOTDEF;\n for(y=0;ydata[p*y+p-1] = NOTDEF;\n\n /* compute gradient on the remaining pixels */\n for(x=0;xdata[adr+p+1] - in->data[adr];\n com2 = in->data[adr+1] - in->data[adr+p];\n\n gx = com1+com2; /* gradient x component */\n gy = com1-com2; /* gradient y component */\n norm2 = gx*gx+gy*gy;\n norm = sqrt( norm2 / 4.0 ); /* gradient norm */\n\n (*modgrad)->data[adr] = norm; /* store gradient norm */\n\n if( norm <= threshold ) /* norm too small, gradient no defined */\n g->data[adr] = NOTDEF; /* gradient angle not defined */\n else\n {\n /* gradient angle computation */\n g->data[adr] = atan2(gx,-gy);\n\n /* store the point in the right bin according to its norm */\n i = (unsigned int) (norm * (double) n_bins / max_grad);\n if( i >= n_bins ) i = n_bins-1;\n if( range_l_e[i] == NULL )\n range_l_s[i] = range_l_e[i] = list+list_count++;\n else\n {\n range_l_e[i]->next = list+list_count;\n range_l_e[i] = list+list_count++;\n }\n range_l_e[i]->x = (int) x;\n range_l_e[i]->y = (int) y;\n range_l_e[i]->next = NULL;\n }\n }\n\n /* Make the list of pixels (almost) ordered by norm value.\n It starts by the larger bin, so the list starts by the\n pixels with higher gradient value. Pixels would be ordered\n by norm value, up to a precision given by max_grad/n_bins.\n */\n for(i=n_bins-1; i>0 && range_l_s[i]==NULL; i--);\n start = range_l_s[i];\n end = range_l_e[i];\n if( start != NULL )\n for(i--;i>0; i--)\n if( range_l_s[i] != NULL )\n {\n end->next = range_l_s[i];\n end = range_l_e[i];\n }\n *list_p = start;\n\n /* free memory */\n free( (void *) range_l_s );\n free( (void *) range_l_e );\n\n return g;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Is point (x,y) aligned to angle theta, up to precision 'prec'?\n */\nstatic int isaligned( int x, int y, image_double angles, double theta,\n double prec )\n{\n double a;\n\n /* check parameters */\n if( angles == NULL || angles->data == NULL )\n error(\"isaligned: invalid image 'angles'.\");\n if( x < 0 || y < 0 || x >= (int) angles->xsize || y >= (int) angles->ysize )\n error(\"isaligned: (x,y) out of the image.\");\n if( prec < 0.0 ) error(\"isaligned: 'prec' must be positive.\");\n\n /* angle at pixel (x,y) */\n a = angles->data[ x + y * angles->xsize ];\n\n /* pixels whose level-line angle is not defined\n are considered as NON-aligned */\n if( a == NOTDEF ) return FALSE; /* there is no need to call the function\n 'double_equal' here because there is\n no risk of problems related to the\n comparison doubles, we are only\n interested in the exact NOTDEF value */\n\n /* it is assumed that 'theta' and 'a' are in the range [-pi,pi] */\n theta -= a;\n if( theta < 0.0 ) theta = -theta;\n if( theta > M_3_2_PI )\n {\n theta -= M_2__PI;\n if( theta < 0.0 ) theta = -theta;\n }\n\n return theta < prec;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Absolute value angle difference.\n */\nstatic double angle_diff(double a, double b)\n{\n a -= b;\n while( a <= -M_PI ) a += M_2__PI;\n while( a > M_PI ) a -= M_2__PI;\n if( a < 0.0 ) a = -a;\n return a;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Signed angle difference.\n */\nstatic double angle_diff_signed(double a, double b)\n{\n a -= b;\n while( a <= -M_PI ) a += M_2__PI;\n while( a > M_PI ) a -= M_2__PI;\n return a;\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------------- NFA computation ------------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Computes the natural logarithm of the absolute value of\n the gamma function of x using the Lanczos approximation.\n See http://www.rskey.org/gamma.htm\n\n The formula used is\n @f[\n \\Gamma(x) = \\frac{ \\sum_{n=0}^{N} q_n x^n }{ \\Pi_{n=0}^{N} (x+n) }\n (x+5.5)^{x+0.5} e^{-(x+5.5)}\n @f]\n so\n @f[\n \\log\\Gamma(x) = \\log\\left( \\sum_{n=0}^{N} q_n x^n \\right)\n + (x+0.5) \\log(x+5.5) - (x+5.5) - \\sum_{n=0}^{N} \\log(x+n)\n @f]\n and\n q0 = 75122.6331530,\n q1 = 80916.6278952,\n q2 = 36308.2951477,\n q3 = 8687.24529705,\n q4 = 1168.92649479,\n q5 = 83.8676043424,\n q6 = 2.50662827511.\n */\nstatic double log_gamma_lanczos(double x)\n{\n static double q[7] = { 75122.6331530, 80916.6278952, 36308.2951477,\n 8687.24529705, 1168.92649479, 83.8676043424,\n 2.50662827511 };\n double a = (x+0.5) * log(x+5.5) - (x+5.5);\n double b = 0.0;\n int n;\n\n for(n=0;n<7;n++)\n {\n a -= log( x + (double) n );\n b += q[n] * pow( x, (double) n );\n }\n return a + log(b);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Computes the natural logarithm of the absolute value of\n the gamma function of x using Windschitl method.\n See http://www.rskey.org/gamma.htm\n\n The formula used is\n @f[\n \\Gamma(x) = \\sqrt{\\frac{2\\pi}{x}} \\left( \\frac{x}{e}\n \\sqrt{ x\\sinh(1/x) + \\frac{1}{810x^6} } \\right)^x\n @f]\n so\n @f[\n \\log\\Gamma(x) = 0.5\\log(2\\pi) + (x-0.5)\\log(x) - x\n + 0.5x\\log\\left( x\\sinh(1/x) + \\frac{1}{810x^6} \\right).\n @f]\n This formula is a good approximation when x > 15.\n */\nstatic double log_gamma_windschitl(double x)\n{\n return 0.918938533204673 + (x-0.5)*log(x) - x\n + 0.5*x*log( x*sinh(1/x) + 1/(810.0*pow(x,6.0)) );\n}\n\n/*----------------------------------------------------------------------------*/\n/** Computes the natural logarithm of the absolute value of\n the gamma function of x. When x>15 use log_gamma_windschitl(),\n otherwise use log_gamma_lanczos().\n */\n#define log_gamma(x) ((x)>15.0?log_gamma_windschitl(x):log_gamma_lanczos(x))\n\n/*----------------------------------------------------------------------------*/\n/** Size of the table to store already computed inverse values.\n */\n#define TABSIZE 100000\n\n/*----------------------------------------------------------------------------*/\n/** Computes -log10(NFA).\n\n NFA stands for Number of False Alarms:\n @f[\n \\mathrm{NFA} = NT \\cdot B(n,k,p)\n @f]\n\n - NT - number of tests\n - B(n,k,p) - tail of binomial distribution with parameters n,k and p:\n @f[\n B(n,k,p) = \\sum_{j=k}^n\n \\left(\\begin{array}{c}n\\\\j\\end{array}\\right)\n p^{j} (1-p)^{n-j}\n @f]\n\n The value -log10(NFA) is equivalent but more intuitive than NFA:\n - -1 corresponds to 10 mean false alarms\n - 0 corresponds to 1 mean false alarm\n - 1 corresponds to 0.1 mean false alarms\n - 2 corresponds to 0.01 mean false alarms\n - ...\n\n Used this way, the bigger the value, better the detection,\n and a logarithmic scale is used.\n\n @param n,k,p binomial parameters.\n @param logNT logarithm of Number of Tests\n\n The computation is based in the gamma function by the following\n relation:\n @f[\n \\left(\\begin{array}{c}n\\\\k\\end{array}\\right)\n = \\frac{ \\Gamma(n+1) }{ \\Gamma(k+1) \\cdot \\Gamma(n-k+1) }.\n @f]\n We use efficient algorithms to compute the logarithm of\n the gamma function.\n\n To make the computation faster, not all the sum is computed, part\n of the terms are neglected based on a bound to the error obtained\n (an error of 10% in the result is accepted).\n */\nstatic double nfa(int n, int k, double p, double logNT)\n{\n static double inv[TABSIZE]; /* table to keep computed inverse values */\n double tolerance = 0.1; /* an error of 10% in the result is accepted */\n double log1term,term,bin_term,mult_term,bin_tail,err,p_term;\n int i;\n\n /* check parameters */\n if( n<0 || k<0 || k>n || p<=0.0 || p>=1.0 )\n error(\"nfa: wrong n, k or p values.\");\n\n /* trivial cases */\n if( n==0 || k==0 ) return -logNT;\n if( n==k ) return -logNT - (double) n * log10(p);\n\n /* probability term */\n p_term = p / (1.0-p);\n\n /* compute the first term of the series */\n /*\n binomial_tail(n,k,p) = sum_{i=k}^n bincoef(n,i) * p^i * (1-p)^{n-i}\n where bincoef(n,i) are the binomial coefficients.\n But\n bincoef(n,k) = gamma(n+1) / ( gamma(k+1) * gamma(n-k+1) ).\n We use this to compute the first term. Actually the log of it.\n */\n log1term = log_gamma( (double) n + 1.0 ) - log_gamma( (double) k + 1.0 )\n - log_gamma( (double) (n-k) + 1.0 )\n + (double) k * log(p) + (double) (n-k) * log(1.0-p);\n term = exp(log1term);\n\n /* in some cases no more computations are needed */\n if( double_equal(term,0.0) ) /* the first term is almost zero */\n {\n if( (double) k > (double) n * p ) /* at begin or end of the tail? */\n return -log1term / M_LN10 - logNT; /* end: use just the first term */\n else\n return -logNT; /* begin: the tail is roughly 1 */\n }\n\n /* compute more terms if needed */\n bin_tail = term;\n for(i=k+1;i<=n;i++)\n {\n /*\n As\n term_i = bincoef(n,i) * p^i * (1-p)^(n-i)\n and\n bincoef(n,i)/bincoef(n,i-1) = n-1+1 / i,\n then,\n term_i / term_i-1 = (n-i+1)/i * p/(1-p)\n and\n term_i = term_i-1 * (n-i+1)/i * p/(1-p).\n 1/i is stored in a table as they are computed,\n because divisions are expensive.\n p/(1-p) is computed only once and stored in 'p_term'.\n */\n bin_term = (double) (n-i+1) * ( ii.\n Then, the error on the binomial tail when truncated at\n the i term can be bounded by a geometric series of form\n term_i * sum mult_term_i^j. */\n err = term * ( ( 1.0 - pow( mult_term, (double) (n-i+1) ) ) /\n (1.0-mult_term) - 1.0 );\n\n /* One wants an error at most of tolerance*final_result, or:\n tolerance * abs(-log10(bin_tail)-logNT).\n Now, the error that can be accepted on bin_tail is\n given by tolerance*final_result divided by the derivative\n of -log10(x) when x=bin_tail. that is:\n tolerance * abs(-log10(bin_tail)-logNT) / (1/bin_tail)\n Finally, we truncate the tail if the error is less than:\n tolerance * abs(-log10(bin_tail)-logNT) * bin_tail */\n if( err < tolerance * fabs(-log10(bin_tail)-logNT) * bin_tail ) break;\n }\n }\n return -log10(bin_tail) - logNT;\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*--------------------------- Rectangle structure ----------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Rectangle structure: line segment with width.\n */\nstruct rect\n{\n double x1,y1,x2,y2; /* first and second point of the line segment */\n double width; /* rectangle width */\n double x,y; /* center of the rectangle */\n double theta; /* angle */\n double dx,dy; /* vector with the line segment angle */\n double prec; /* tolerance angle */\n double p; /* probability of a point with angle within 'prec' */\n};\n\n/*----------------------------------------------------------------------------*/\n/** Copy one rectangle structure to another.\n */\nstatic void rect_copy(struct rect * in, struct rect * out)\n{\n /* check parameters */\n if( in == NULL || out == NULL ) error(\"rect_copy: invalid 'in' or 'out'.\");\n\n /* copy values */\n out->x1 = in->x1;\n out->y1 = in->y1;\n out->x2 = in->x2;\n out->y2 = in->y2;\n out->width = in->width;\n out->x = in->x;\n out->y = in->y;\n out->theta = in->theta;\n out->dx = in->dx;\n out->dy = in->dy;\n out->prec = in->prec;\n out->p = in->p;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Rectangle points iterator.\n\n The integer coordinates of pixels inside a rectangle are\n iteratively explored. This structure keep track of the process and\n functions ri_ini(), ri_inc(), ri_end(), and ri_del() are used in\n the process. An example of how to use the iterator is as follows:\n \\code\n\n struct rect * rec = XXX; // some rectangle\n rect_iter * i;\n for( i=ri_ini(rec); !ri_end(i); ri_inc(i) )\n {\n // your code, using 'i->x' and 'i->y' as coordinates\n }\n ri_del(i); // delete iterator\n\n \\endcode\n The pixels are explored 'column' by 'column', where we call\n 'column' a set of pixels with the same x value that are inside the\n rectangle. The following is an schematic representation of a\n rectangle, the 'column' being explored is marked by colons, and\n the current pixel being explored is 'x,y'.\n \\verbatim\n\n vx[1],vy[1]\n * *\n * *\n * *\n * ye\n * : *\n vx[0],vy[0] : *\n * : *\n * x,y *\n * : *\n * : vx[2],vy[2]\n * : *\n y ys *\n ^ * *\n | * *\n | * *\n +---> x vx[3],vy[3]\n\n \\endverbatim\n The first 'column' to be explored is the one with the smaller x\n value. Each 'column' is explored starting from the pixel of the\n 'column' (inside the rectangle) with the smaller y value.\n\n The four corners of the rectangle are stored in order that rotates\n around the corners at the arrays 'vx[]' and 'vy[]'. The first\n point is always the one with smaller x value.\n\n 'x' and 'y' are the coordinates of the pixel being explored. 'ys'\n and 'ye' are the start and end values of the current column being\n explored. So, 'ys' < 'ye'.\n */\ntypedef struct\n{\n double vx[4]; /* rectangle's corner X coordinates in circular order */\n double vy[4]; /* rectangle's corner Y coordinates in circular order */\n double ys,ye; /* start and end Y values of current 'column' */\n int x,y; /* coordinates of currently explored pixel */\n} rect_iter;\n\n/*----------------------------------------------------------------------------*/\n/** Interpolate y value corresponding to 'x' value given, in\n the line 'x1,y1' to 'x2,y2'; if 'x1=x2' return the smaller\n of 'y1' and 'y2'.\n\n The following restrictions are required:\n - x1 <= x2\n - x1 <= x\n - x <= x2\n */\nstatic double inter_low(double x, double x1, double y1, double x2, double y2)\n{\n /* check parameters */\n if( x1 > x2 || x < x1 || x > x2 )\n error(\"inter_low: unsuitable input, 'x1>x2' or 'xx2'.\");\n\n /* interpolation */\n if( double_equal(x1,x2) && y1y2 ) return y2;\n return y1 + (x-x1) * (y2-y1) / (x2-x1);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Interpolate y value corresponding to 'x' value given, in\n the line 'x1,y1' to 'x2,y2'; if 'x1=x2' return the larger\n of 'y1' and 'y2'.\n\n The following restrictions are required:\n - x1 <= x2\n - x1 <= x\n - x <= x2\n */\nstatic double inter_hi(double x, double x1, double y1, double x2, double y2)\n{\n /* check parameters */\n if( x1 > x2 || x < x1 || x > x2 )\n error(\"inter_hi: unsuitable input, 'x1>x2' or 'xx2'.\");\n\n /* interpolation */\n if( double_equal(x1,x2) && y1y2 ) return y1;\n return y1 + (x-x1) * (y2-y1) / (x2-x1);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Free memory used by a rectangle iterator.\n */\nstatic void ri_del(rect_iter * iter)\n{\n if( iter == NULL ) error(\"ri_del: NULL iterator.\");\n free( (void *) iter );\n}\n\n/*----------------------------------------------------------------------------*/\n/** Check if the iterator finished the full iteration.\n\n See details in \\ref rect_iter\n */\nstatic int ri_end(rect_iter * i)\n{\n /* check input */\n if( i == NULL ) error(\"ri_end: NULL iterator.\");\n\n /* if the current x value is larger than the larger\n x value in the rectangle (vx[2]), we know the full\n exploration of the rectangle is finished. */\n return (double)(i->x) > i->vx[2];\n}\n\n/*----------------------------------------------------------------------------*/\n/** Increment a rectangle iterator.\n\n See details in \\ref rect_iter\n */\nstatic void ri_inc(rect_iter * i)\n{\n /* check input */\n if( i == NULL ) error(\"ri_inc: NULL iterator.\");\n\n /* if not at end of exploration,\n increase y value for next pixel in the 'column' */\n if( !ri_end(i) ) i->y++;\n\n /* if the end of the current 'column' is reached,\n and it is not the end of exploration,\n advance to the next 'column' */\n while( (double) (i->y) > i->ye && !ri_end(i) )\n {\n /* increase x, next 'column' */\n i->x++;\n\n /* if end of exploration, return */\n if( ri_end(i) ) return;\n\n /* update lower y limit (start) for the new 'column'.\n\n We need to interpolate the y value that corresponds to the\n lower side of the rectangle. The first thing is to decide if\n the corresponding side is\n\n vx[0],vy[0] to vx[3],vy[3] or\n vx[3],vy[3] to vx[2],vy[2]\n\n Then, the side is interpolated for the x value of the\n 'column'. But, if the side is vertical (as it could happen if\n the rectangle is vertical and we are dealing with the first\n or last 'columns') then we pick the lower value of the side\n by using 'inter_low'.\n */\n if( (double) i->x < i->vx[3] )\n i->ys = inter_low((double)i->x,i->vx[0],i->vy[0],i->vx[3],i->vy[3]);\n else\n i->ys = inter_low((double)i->x,i->vx[3],i->vy[3],i->vx[2],i->vy[2]);\n\n /* update upper y limit (end) for the new 'column'.\n\n We need to interpolate the y value that corresponds to the\n upper side of the rectangle. The first thing is to decide if\n the corresponding side is\n\n vx[0],vy[0] to vx[1],vy[1] or\n vx[1],vy[1] to vx[2],vy[2]\n\n Then, the side is interpolated for the x value of the\n 'column'. But, if the side is vertical (as it could happen if\n the rectangle is vertical and we are dealing with the first\n or last 'columns') then we pick the lower value of the side\n by using 'inter_low'.\n */\n if( (double)i->x < i->vx[1] )\n i->ye = inter_hi((double)i->x,i->vx[0],i->vy[0],i->vx[1],i->vy[1]);\n else\n i->ye = inter_hi((double)i->x,i->vx[1],i->vy[1],i->vx[2],i->vy[2]);\n\n /* new y */\n i->y = (int) ceil(i->ys);\n }\n}\n\n/*----------------------------------------------------------------------------*/\n/** Create and initialize a rectangle iterator.\n\n See details in \\ref rect_iter\n */\nstatic rect_iter * ri_ini(struct rect * r)\n{\n double vx[4],vy[4];\n int n,offset;\n rect_iter * i;\n\n /* check parameters */\n if( r == NULL ) error(\"ri_ini: invalid rectangle.\");\n\n /* get memory */\n i = (rect_iter *) malloc(sizeof(rect_iter));\n if( i == NULL ) error(\"ri_ini: Not enough memory.\");\n\n /* build list of rectangle corners ordered\n in a circular way around the rectangle */\n vx[0] = r->x1 - r->dy * r->width / 2.0;\n vy[0] = r->y1 + r->dx * r->width / 2.0;\n vx[1] = r->x2 - r->dy * r->width / 2.0;\n vy[1] = r->y2 + r->dx * r->width / 2.0;\n vx[2] = r->x2 + r->dy * r->width / 2.0;\n vy[2] = r->y2 - r->dx * r->width / 2.0;\n vx[3] = r->x1 + r->dy * r->width / 2.0;\n vy[3] = r->y1 - r->dx * r->width / 2.0;\n\n /* compute rotation of index of corners needed so that the first\n point has the smaller x.\n\n if one side is vertical, thus two corners have the same smaller x\n value, the one with the largest y value is selected as the first.\n */\n if( r->x1 < r->x2 && r->y1 <= r->y2 ) offset = 0;\n else if( r->x1 >= r->x2 && r->y1 < r->y2 ) offset = 1;\n else if( r->x1 > r->x2 && r->y1 >= r->y2 ) offset = 2;\n else offset = 3;\n\n /* apply rotation of index. */\n for(n=0; n<4; n++)\n {\n i->vx[n] = vx[(offset+n)%4];\n i->vy[n] = vy[(offset+n)%4];\n }\n\n /* Set a initial condition.\n\n The values are set to values that will cause 'ri_inc' (that will\n be called immediately) to initialize correctly the first 'column'\n and compute the limits 'ys' and 'ye'.\n\n 'y' is set to the integer value of vy[0], the starting corner.\n\n 'ys' and 'ye' are set to very small values, so 'ri_inc' will\n notice that it needs to start a new 'column'.\n\n The smaller integer coordinate inside of the rectangle is\n 'ceil(vx[0])'. The current 'x' value is set to that value minus\n one, so 'ri_inc' (that will increase x by one) will advance to\n the first 'column'.\n */\n i->x = (int) ceil(i->vx[0]) - 1;\n i->y = (int) ceil(i->vy[0]);\n i->ys = i->ye = -DBL_MAX;\n\n /* advance to the first pixel */\n ri_inc(i);\n\n return i;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Compute a rectangle's NFA value.\n */\nstatic double rect_nfa(struct rect * rec, image_double angles, double logNT)\n{\n rect_iter * i;\n int pts = 0;\n int alg = 0;\n\n /* check parameters */\n if( rec == NULL ) error(\"rect_nfa: invalid rectangle.\");\n if( angles == NULL ) error(\"rect_nfa: invalid 'angles'.\");\n\n /* compute the total number of pixels and of aligned points in 'rec' */\n for(i=ri_ini(rec); !ri_end(i); ri_inc(i)) /* rectangle iterator */\n if( i->x >= 0 && i->y >= 0 &&\n i->x < (int) angles->xsize && i->y < (int) angles->ysize )\n {\n ++pts; /* total number of pixels counter */\n if( isaligned(i->x, i->y, angles, rec->theta, rec->prec) )\n ++alg; /* aligned points counter */\n }\n ri_del(i); /* delete iterator */\n\n return nfa(pts,alg,rec->p,logNT); /* compute NFA value */\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*---------------------------------- Regions ---------------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Compute region's angle as the principal inertia axis of the region.\n\n The following is the region inertia matrix A:\n @f[\n\n A = \\left(\\begin{array}{cc}\n Ixx & Ixy \\\\\n Ixy & Iyy \\\\\n \\end{array}\\right)\n\n @f]\n where\n\n Ixx = sum_i G(i).(y_i - cx)^2\n\n Iyy = sum_i G(i).(x_i - cy)^2\n\n Ixy = - sum_i G(i).(x_i - cx).(y_i - cy)\n\n and\n - G(i) is the gradient norm at pixel i, used as pixel's weight.\n - x_i and y_i are the coordinates of pixel i.\n - cx and cy are the coordinates of the center of th region.\n\n lambda1 and lambda2 are the eigenvalues of matrix A,\n with lambda1 >= lambda2. They are found by solving the\n characteristic polynomial:\n\n det( lambda I - A) = 0\n\n that gives:\n\n lambda1 = ( Ixx + Iyy + sqrt( (Ixx-Iyy)^2 + 4.0*Ixy*Ixy) ) / 2\n\n lambda2 = ( Ixx + Iyy - sqrt( (Ixx-Iyy)^2 + 4.0*Ixy*Ixy) ) / 2\n\n To get the line segment direction we want to get the angle the\n eigenvector assotiated to the smaller eigenvalue. We have to solve\n a,b in:\n\n a.Ixx + b.Ixy = a.lambda2\n\n a.Ixy + b.Iyy = b.lambda2\n\n We want the angle theta = atan(b/a). It can be computed with\n any of the two equations:\n\n theta = atan( (lambda2-Ixx) / Ixy )\n\n or\n\n theta = atan( Ixy / (lambda2-Iyy) )\n\n When |Ixx| > |Iyy| we use the first, otherwise the second (just to\n get better numeric precision).\n */\nstatic double get_theta( struct point * reg, int reg_size, double x, double y,\n image_double modgrad, double reg_angle, double prec )\n{\n double lambda,theta,weight;\n double Ixx = 0.0;\n double Iyy = 0.0;\n double Ixy = 0.0;\n int i;\n\n /* check parameters */\n if( reg == NULL ) error(\"get_theta: invalid region.\");\n if( reg_size <= 1 ) error(\"get_theta: region size <= 1.\");\n if( modgrad == NULL || modgrad->data == NULL )\n error(\"get_theta: invalid 'modgrad'.\");\n if( prec < 0.0 ) error(\"get_theta: 'prec' must be positive.\");\n\n /* compute inertia matrix */\n for(i=0; idata[ reg[i].x + reg[i].y * modgrad->xsize ];\n Ixx += ( (double) reg[i].y - y ) * ( (double) reg[i].y - y ) * weight;\n Iyy += ( (double) reg[i].x - x ) * ( (double) reg[i].x - x ) * weight;\n Ixy -= ( (double) reg[i].x - x ) * ( (double) reg[i].y - y ) * weight;\n }\n if( double_equal(Ixx,0.0) && double_equal(Iyy,0.0) && double_equal(Ixy,0.0) )\n error(\"get_theta: null inertia matrix.\");\n\n /* compute smallest eigenvalue */\n lambda = 0.5 * ( Ixx + Iyy - sqrt( (Ixx-Iyy)*(Ixx-Iyy) + 4.0*Ixy*Ixy ) );\n\n /* compute angle */\n theta = fabs(Ixx)>fabs(Iyy) ? atan2(lambda-Ixx,Ixy) : atan2(Ixy,lambda-Iyy);\n\n /* The previous procedure don't cares about orientation,\n so it could be wrong by 180 degrees. Here is corrected if necessary. */\n if( angle_diff(theta,reg_angle) > prec ) theta += M_PI;\n\n return theta;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Computes a rectangle that covers a region of points.\n */\nstatic void region2rect( struct point * reg, int reg_size,\n image_double modgrad, double reg_angle,\n double prec, double p, struct rect * rec )\n{\n double x,y,dx,dy,l,w,theta,weight,sum,l_min,l_max,w_min,w_max;\n int i;\n\n /* check parameters */\n if( reg == NULL ) error(\"region2rect: invalid region.\");\n if( reg_size <= 1 ) error(\"region2rect: region size <= 1.\");\n if( modgrad == NULL || modgrad->data == NULL )\n error(\"region2rect: invalid image 'modgrad'.\");\n if( rec == NULL ) error(\"region2rect: invalid 'rec'.\");\n\n /* center of the region:\n\n It is computed as the weighted sum of the coordinates\n of all the pixels in the region. The norm of the gradient\n is used as the weight of a pixel. The sum is as follows:\n cx = \\sum_i G(i).x_i\n cy = \\sum_i G(i).y_i\n where G(i) is the norm of the gradient of pixel i\n and x_i,y_i are its coordinates.\n */\n x = y = sum = 0.0;\n for(i=0; idata[ reg[i].x + reg[i].y * modgrad->xsize ];\n x += (double) reg[i].x * weight;\n y += (double) reg[i].y * weight;\n sum += weight;\n }\n if( sum <= 0.0 ) error(\"region2rect: weights sum equal to zero.\");\n x /= sum;\n y /= sum;\n\n /* theta */\n theta = get_theta(reg,reg_size,x,y,modgrad,reg_angle,prec);\n\n /* length and width:\n\n 'l' and 'w' are computed as the distance from the center of the\n region to pixel i, projected along the rectangle axis (dx,dy) and\n to the orthogonal axis (-dy,dx), respectively.\n\n The length of the rectangle goes from l_min to l_max, where l_min\n and l_max are the minimum and maximum values of l in the region.\n Analogously, the width is selected from w_min to w_max, where\n w_min and w_max are the minimum and maximum of w for the pixels\n in the region.\n */\n dx = cos(theta);\n dy = sin(theta);\n l_min = l_max = w_min = w_max = 0.0;\n for(i=0; i l_max ) l_max = l;\n if( l < l_min ) l_min = l;\n if( w > w_max ) w_max = w;\n if( w < w_min ) w_min = w;\n }\n\n /* store values */\n rec->x1 = x + l_min * dx;\n rec->y1 = y + l_min * dy;\n rec->x2 = x + l_max * dx;\n rec->y2 = y + l_max * dy;\n rec->width = w_max - w_min;\n rec->x = x;\n rec->y = y;\n rec->theta = theta;\n rec->dx = dx;\n rec->dy = dy;\n rec->prec = prec;\n rec->p = p;\n\n /* we impose a minimal width of one pixel\n\n A sharp horizontal or vertical step would produce a perfectly\n horizontal or vertical region. The width computed would be\n zero. But that corresponds to a one pixels width transition in\n the image.\n */\n if( rec->width < 1.0 ) rec->width = 1.0;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Build a region of pixels that share the same angle, up to a\n tolerance 'prec', starting at point (x,y).\n */\nstatic void region_grow( int x, int y, image_double angles, struct point * reg,\n int * reg_size, double * reg_angle, image_char used,\n double prec )\n{\n double sumdx,sumdy;\n int xx,yy,i;\n\n /* check parameters */\n if( x < 0 || y < 0 || x >= (int) angles->xsize || y >= (int) angles->ysize )\n error(\"region_grow: (x,y) out of the image.\");\n if( angles == NULL || angles->data == NULL )\n error(\"region_grow: invalid image 'angles'.\");\n if( reg == NULL ) error(\"region_grow: invalid 'reg'.\");\n if( reg_size == NULL ) error(\"region_grow: invalid pointer 'reg_size'.\");\n if( reg_angle == NULL ) error(\"region_grow: invalid pointer 'reg_angle'.\");\n if( used == NULL || used->data == NULL )\n error(\"region_grow: invalid image 'used'.\");\n\n /* first point of the region */\n *reg_size = 1;\n reg[0].x = x;\n reg[0].y = y;\n *reg_angle = angles->data[x+y*angles->xsize]; /* region's angle */\n sumdx = cos(*reg_angle);\n sumdy = sin(*reg_angle);\n used->data[x+y*used->xsize] = USED;\n\n /* try neighbors as new region points */\n for(i=0; i<*reg_size; i++)\n for(xx=reg[i].x-1; xx<=reg[i].x+1; xx++)\n for(yy=reg[i].y-1; yy<=reg[i].y+1; yy++)\n if( xx>=0 && yy>=0 && xx<(int)used->xsize && yy<(int)used->ysize &&\n used->data[xx+yy*used->xsize] != USED &&\n isaligned(xx,yy,angles,*reg_angle,prec) )\n {\n /* add point */\n used->data[xx+yy*used->xsize] = USED;\n reg[*reg_size].x = xx;\n reg[*reg_size].y = yy;\n ++(*reg_size);\n\n /* update region's angle */\n sumdx += cos( angles->data[xx+yy*angles->xsize] );\n sumdy += sin( angles->data[xx+yy*angles->xsize] );\n *reg_angle = atan2(sumdy,sumdx);\n }\n}\n\n/*----------------------------------------------------------------------------*/\n/** Try some rectangles variations to improve NFA value. Only if the\n rectangle is not meaningful (i.e., log_nfa <= eps).\n */\nstatic double rect_improve( struct rect * rec, image_double angles,\n double logNT, double eps )\n{\n struct rect r;\n double log_nfa,log_nfa_new;\n double delta = 0.5;\n double delta_2 = delta / 2.0;\n int n;\n\n log_nfa = rect_nfa(rec,angles,logNT);\n\n if( log_nfa > eps ) return log_nfa;\n\n /* try finer precisions */\n rect_copy(rec,&r);\n for(n=0; n<5; n++)\n {\n r.p /= 2.0;\n r.prec = r.p * M_PI;\n log_nfa_new = rect_nfa(&r,angles,logNT);\n if( log_nfa_new > log_nfa )\n {\n log_nfa = log_nfa_new;\n rect_copy(&r,rec);\n }\n }\n\n if( log_nfa > eps ) return log_nfa;\n\n /* try to reduce width */\n rect_copy(rec,&r);\n for(n=0; n<5; n++)\n {\n if( (r.width - delta) >= 0.5 )\n {\n r.width -= delta;\n log_nfa_new = rect_nfa(&r,angles,logNT);\n if( log_nfa_new > log_nfa )\n {\n rect_copy(&r,rec);\n log_nfa = log_nfa_new;\n }\n }\n }\n\n if( log_nfa > eps ) return log_nfa;\n\n /* try to reduce one side of the rectangle */\n rect_copy(rec,&r);\n for(n=0; n<5; n++)\n {\n if( (r.width - delta) >= 0.5 )\n {\n r.x1 += -r.dy * delta_2;\n r.y1 += r.dx * delta_2;\n r.x2 += -r.dy * delta_2;\n r.y2 += r.dx * delta_2;\n r.width -= delta;\n log_nfa_new = rect_nfa(&r,angles,logNT);\n if( log_nfa_new > log_nfa )\n {\n rect_copy(&r,rec);\n log_nfa = log_nfa_new;\n }\n }\n }\n\n if( log_nfa > eps ) return log_nfa;\n\n /* try to reduce the other side of the rectangle */\n rect_copy(rec,&r);\n for(n=0; n<5; n++)\n {\n if( (r.width - delta) >= 0.5 )\n {\n r.x1 -= -r.dy * delta_2;\n r.y1 -= r.dx * delta_2;\n r.x2 -= -r.dy * delta_2;\n r.y2 -= r.dx * delta_2;\n r.width -= delta;\n log_nfa_new = rect_nfa(&r,angles,logNT);\n if( log_nfa_new > log_nfa )\n {\n rect_copy(&r,rec);\n log_nfa = log_nfa_new;\n }\n }\n }\n\n if( log_nfa > eps ) return log_nfa;\n\n /* try even finer precisions */\n rect_copy(rec,&r);\n for(n=0; n<5; n++)\n {\n r.p /= 2.0;\n r.prec = r.p * M_PI;\n log_nfa_new = rect_nfa(&r,angles,logNT);\n if( log_nfa_new > log_nfa )\n {\n log_nfa = log_nfa_new;\n rect_copy(&r,rec);\n }\n }\n\n return log_nfa;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Reduce the region size, by elimination the points far from the\n starting point, until that leads to rectangle with the right\n density of region points or to discard the region if too small.\n */\nstatic int reduce_region_radius( struct point * reg, int * reg_size,\n image_double modgrad, double reg_angle,\n double prec, double p, struct rect * rec,\n image_char used, image_double angles,\n double density_th )\n{\n double density,rad1,rad2,rad,xc,yc;\n int i;\n\n /* check parameters */\n if( reg == NULL ) error(\"reduce_region_radius: invalid pointer 'reg'.\");\n if( reg_size == NULL )\n error(\"reduce_region_radius: invalid pointer 'reg_size'.\");\n if( prec < 0.0 ) error(\"reduce_region_radius: 'prec' must be positive.\");\n if( rec == NULL ) error(\"reduce_region_radius: invalid pointer 'rec'.\");\n if( used == NULL || used->data == NULL )\n error(\"reduce_region_radius: invalid image 'used'.\");\n if( angles == NULL || angles->data == NULL )\n error(\"reduce_region_radius: invalid image 'angles'.\");\n\n /* compute region points density */\n density = (double) *reg_size /\n ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n\n /* if the density criterion is satisfied there is nothing to do */\n if( density >= density_th ) return TRUE;\n\n /* compute region's radius */\n xc = (double) reg[0].x;\n yc = (double) reg[0].y;\n rad1 = dist( xc, yc, rec->x1, rec->y1 );\n rad2 = dist( xc, yc, rec->x2, rec->y2 );\n rad = rad1 > rad2 ? rad1 : rad2;\n\n /* while the density criterion is not satisfied, remove farther pixels */\n while( density < density_th )\n {\n rad *= 0.75; /* reduce region's radius to 75% of its value */\n\n /* remove points from the region and update 'used' map */\n for(i=0; i<*reg_size; i++)\n if( dist( xc, yc, (double) reg[i].x, (double) reg[i].y ) > rad )\n {\n /* point not kept, mark it as NOTUSED */\n used->data[ reg[i].x + reg[i].y * used->xsize ] = NOTUSED;\n /* remove point from the region */\n reg[i].x = reg[*reg_size-1].x; /* if i==*reg_size-1 copy itself */\n reg[i].y = reg[*reg_size-1].y;\n --(*reg_size);\n --i; /* to avoid skipping one point */\n }\n\n /* reject if the region is too small.\n 2 is the minimal region size for 'region2rect' to work. */\n if( *reg_size < 2 ) return FALSE;\n\n /* re-compute rectangle */\n region2rect(reg,*reg_size,modgrad,reg_angle,prec,p,rec);\n\n /* re-compute region points density */\n density = (double) *reg_size /\n ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n }\n\n /* if this point is reached, the density criterion is satisfied */\n return TRUE;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Refine a rectangle.\n\n For that, an estimation of the angle tolerance is performed by the\n standard deviation of the angle at points near the region's\n starting point. Then, a new region is grown starting from the same\n point, but using the estimated angle tolerance. If this fails to\n produce a rectangle with the right density of region points,\n 'reduce_region_radius' is called to try to satisfy this condition.\n */\nstatic int refine( struct point * reg, int * reg_size, image_double modgrad,\n double reg_angle, double prec, double p, struct rect * rec,\n image_char used, image_double angles, double density_th )\n{\n double angle,ang_d,mean_angle,tau,density,xc,yc,ang_c,sum,s_sum;\n int i,n;\n\n /* check parameters */\n if( reg == NULL ) error(\"refine: invalid pointer 'reg'.\");\n if( reg_size == NULL ) error(\"refine: invalid pointer 'reg_size'.\");\n if( prec < 0.0 ) error(\"refine: 'prec' must be positive.\");\n if( rec == NULL ) error(\"refine: invalid pointer 'rec'.\");\n if( used == NULL || used->data == NULL )\n error(\"refine: invalid image 'used'.\");\n if( angles == NULL || angles->data == NULL )\n error(\"refine: invalid image 'angles'.\");\n\n /* compute region points density */\n density = (double) *reg_size /\n ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n\n /* if the density criterion is satisfied there is nothing to do */\n if( density >= density_th ) return TRUE;\n\n /*------ First try: reduce angle tolerance ------*/\n\n /* compute the new mean angle and tolerance */\n xc = (double) reg[0].x;\n yc = (double) reg[0].y;\n ang_c = angles->data[ reg[0].x + reg[0].y * angles->xsize ];\n sum = s_sum = 0.0;\n n = 0;\n for(i=0; i<*reg_size; i++)\n {\n used->data[ reg[i].x + reg[i].y * used->xsize ] = NOTUSED;\n if( dist( xc, yc, (double) reg[i].x, (double) reg[i].y ) < rec->width )\n {\n angle = angles->data[ reg[i].x + reg[i].y * angles->xsize ];\n ang_d = angle_diff_signed(angle,ang_c);\n sum += ang_d;\n s_sum += ang_d * ang_d;\n ++n;\n }\n }\n mean_angle = sum / (double) n;\n tau = 2.0 * sqrt( (s_sum - 2.0 * mean_angle * sum) / (double) n\n + mean_angle*mean_angle ); /* 2 * standard deviation */\n\n /* find a new region from the same starting point and new angle tolerance */\n region_grow(reg[0].x,reg[0].y,angles,reg,reg_size,®_angle,used,tau);\n\n /* if the region is too small, reject */\n if( *reg_size < 2 ) return FALSE;\n\n /* re-compute rectangle */\n region2rect(reg,*reg_size,modgrad,reg_angle,prec,p,rec);\n\n /* re-compute region points density */\n density = (double) *reg_size /\n ( dist(rec->x1,rec->y1,rec->x2,rec->y2) * rec->width );\n\n /*------ Second try: reduce region radius ------*/\n if( density < density_th )\n return reduce_region_radius( reg, reg_size, modgrad, reg_angle, prec, p,\n rec, used, angles, density_th );\n\n /* if this point is reached, the density criterion is satisfied */\n return TRUE;\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*-------------------------- Line Segment Detector ---------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** LSD full interface.\n */\nntuple_list LineSegmentDetection( image_double image, double scale,\n double sigma_scale, double quant,\n double ang_th, double eps, double density_th,\n int n_bins, double max_grad,\n image_int * region )\n{\n ntuple_list out = new_ntuple_list(5);\n image_double scaled_image,angles,modgrad;\n image_char used;\n struct coorlist * list_p;\n void * mem_p;\n struct rect rec;\n struct point * reg;\n int reg_size,min_reg_size,i;\n unsigned int xsize,ysize;\n double rho,reg_angle,prec,p,log_nfa,logNT;\n int ls_count = 0; /* line segments are numbered 1,2,3,... */\n\n\n /* check parameters */\n if( image==NULL || image->data==NULL || image->xsize==0 || image->ysize==0 )\n error(\"invalid image input.\");\n if( scale <= 0.0 ) error(\"'scale' value must be positive.\");\n if( sigma_scale <= 0.0 ) error(\"'sigma_scale' value must be positive.\");\n if( quant < 0.0 ) error(\"'quant' value must be positive.\");\n if( ang_th <= 0.0 || ang_th >= 180.0 )\n error(\"'ang_th' value must be in the range (0,180).\");\n if( density_th < 0.0 || density_th > 1.0 )\n error(\"'density_th' value must be in the range [0,1].\");\n if( n_bins <= 0 ) error(\"'n_bins' value must be positive.\");\n if( max_grad <= 0.0 ) error(\"'max_grad' value must be positive.\");\n\n\n /* angle tolerance */\n prec = M_PI * ang_th / 180.0;\n p = ang_th / 180.0;\n rho = quant / sin(prec); /* gradient magnitude threshold */\n\n\n /* scale image (if necessary) and compute angle at each pixel */\n if( scale != 1.0 )\n {\n scaled_image = gaussian_sampler( image, scale, sigma_scale );\n angles = ll_angle( scaled_image, rho, &list_p, &mem_p,\n &modgrad, (unsigned int) n_bins, max_grad );\n free_image_double(scaled_image);\n }\n else\n angles = ll_angle( image, rho, &list_p, &mem_p, &modgrad,\n (unsigned int) n_bins, max_grad );\n xsize = angles->xsize;\n ysize = angles->ysize;\n logNT = 5.0 * ( log10( (double) xsize ) + log10( (double) ysize ) ) / 2.0;\n min_reg_size = (int) (-logNT/log10(p)); /* minimal number of points in region\n that can give a meaningful event */\n\n\n /* initialize some structures */\n if( region != NULL ) /* image to output pixel region number, if asked */\n *region = new_image_int_ini(angles->xsize,angles->ysize,0);\n used = new_image_char_ini(xsize,ysize,NOTUSED);\n reg = (struct point *) calloc( (size_t) (xsize*ysize), sizeof(struct point) );\n if( reg == NULL ) error(\"not enough memory!\");\n\n\n /* search for line segments */\n for(; list_p != NULL; list_p = list_p->next )\n if( used->data[ list_p->x + list_p->y * used->xsize ] == NOTUSED &&\n angles->data[ list_p->x + list_p->y * angles->xsize ] != NOTDEF )\n /* there is no risk of double comparison problems here\n because we are only interested in the exact NOTDEF value */\n {\n /* find the region of connected point and ~equal angle */\n region_grow( list_p->x, list_p->y, angles, reg, ®_size,\n ®_angle, used, prec );\n\n /* reject small regions */\n if( reg_size < min_reg_size ) continue;\n\n /* construct rectangular approximation for the region */\n region2rect(reg,reg_size,modgrad,reg_angle,prec,p,&rec);\n\n /* Check if the rectangle exceeds the minimal density of\n region points. If not, try to improve the region.\n The rectangle will be rejected if the final one does\n not fulfill the minimal density condition.\n This is an addition to the original LSD algorithm published in\n \"LSD: A Fast Line Segment Detector with a False Detection Control\"\n by R. Grompone von Gioi, J. Jakubowicz, J.M. Morel, and G. Randall.\n The original algorithm is obtained with density_th = 0.0.\n */\n if( !refine( reg, ®_size, modgrad, reg_angle,\n prec, p, &rec, used, angles, density_th ) ) continue;\n\n /* compute NFA value */\n log_nfa = rect_improve(&rec,angles,logNT,eps);\n if( log_nfa <= eps ) continue;\n\n /* A New Line Segment was found! */\n ++ls_count; /* increase line segment counter */\n\n /*\n The gradient was computed with a 2x2 mask, its value corresponds to\n points with an offset of (0.5,0.5), that should be added to output.\n The coordinates origin is at the center of pixel (0,0).\n */\n rec.x1 += 0.5; rec.y1 += 0.5;\n rec.x2 += 0.5; rec.y2 += 0.5;\n\n /* scale the result values if a subsampling was performed */\n if( scale != 1.0 )\n {\n rec.x1 /= scale; rec.y1 /= scale;\n rec.x2 /= scale; rec.y2 /= scale;\n rec.width /= scale;\n }\n\n /* add line segment found to output */\n add_5tuple(out, rec.x1, rec.y1, rec.x2, rec.y2, rec.width);\n\n /* add region number to 'region' image if needed */\n if( region != NULL )\n for(i=0; idata[reg[i].x+reg[i].y*(*region)->xsize] = ls_count;\n }\n\n\n /* free memory */\n free_image_double(angles);\n free_image_double(modgrad);\n free_image_char(used);\n free( (void *) reg );\n free( (void *) mem_p );\n\n return out;\n}\n\n/*----------------------------------------------------------------------------*/\n/** LSD Simple Interface with Scale.\n */\nntuple_list lsd_scale(image_double image, double scale)\n{\n /* LSD parameters */\n double sigma_scale = 0.6; /* Sigma for Gaussian filter is computed as\n sigma = sigma_scale/scale. */\n double quant = 2.0; /* Bound to the quantization error on the\n gradient norm. */\n double ang_th = 22.5; /* Gradient angle tolerance in degrees. */\n double eps = 0.0; /* Detection threshold, -log10(NFA). */\n double density_th = 0.7; /* Minimal density of region points in rectangle. */\n int n_bins = 1024; /* Number of bins in pseudo-ordering of gradient\n modulus. */\n double max_grad = 255.0; /* Gradient modulus in the highest bin. The\n default value corresponds to the highest\n gradient modulus on images with gray\n levels in [0,255]. */\n\n return LineSegmentDetection( image, scale, sigma_scale, quant, ang_th, eps,\n density_th, n_bins, max_grad, NULL );\n}\n\n/*----------------------------------------------------------------------------*/\n/** LSD Simple Interface.\n */\nntuple_list lsd(image_double image)\n{\n /* LSD parameters */\n double scale = 0.8; /* Scale the image by Gaussian filter to 'scale'. */\n\n return lsd_scale(image,scale);\n}\n/*----------------------------------------------------------------------------*/\n"
},
{
"path": "thirdparty/LSD/lsd.h",
"content": "/*----------------------------------------------------------------------------\n\n LSD - Line Segment Detector on digital images\n\n Copyright 2007-2010 rafael grompone von gioi (grompone@gmail.com)\n\n This program is free software: you can redistribute it and/or modify\n it under the terms of the GNU Affero General Public License as\n published by the Free Software Foundation, either version 3 of the\n License, or (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Affero General Public License for more details.\n\n You should have received a copy of the GNU Affero General Public License\n along with this program. If not, see .\n\n ----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** @file lsd.h\n LSD module header\n @author rafael grompone von gioi (grompone@gmail.com)\n */\n/*----------------------------------------------------------------------------*/\n#ifndef LSD_HEADER\n#define LSD_HEADER\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------- 'list of n-tuple' data type ------------------------*/\n/*----------------------------------------------------------------------------*/\n/** 'list of n-tuple' data type\n\n The i component, of the n-tuple number j, of an n-tuple list 'ntl'\n is accessed with:\n\n ntl->values[ i + j * ntl->dim ]\n\n The dimension of the n-tuple (n) is:\n\n ntl->dim\n\n The number of number of n-tuples in the list is:\n\n ntl->size\n\n The maximum number of n-tuples that can be stored in the\n list with the allocated memory at a given time is given by:\n\n ntl->max_size\n */\ntypedef struct ntuple_list_s\n{\n unsigned int size;\n unsigned int max_size;\n unsigned int dim;\n double * values;\n} * ntuple_list;\n\nvoid free_ntuple_list(ntuple_list in);\nntuple_list new_ntuple_list(unsigned int dim);\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------------- Image Data Types -----------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** char image data type\n\n The pixel value at (x,y) is accessed by:\n\n image->data[ x + y * image->xsize ]\n\n with x and y integer.\n */\ntypedef struct image_char_s\n{\n unsigned char * data;\n unsigned int xsize,ysize;\n} * image_char;\n\nvoid free_image_char(image_char i);\nimage_char new_image_char(unsigned int xsize, unsigned int ysize);\nimage_char new_image_char_ini( unsigned int xsize, unsigned int ysize,\n unsigned char fill_value );\n\n/*----------------------------------------------------------------------------*/\n/** int image data type\n\n The pixel value at (x,y) is accessed by:\n\n image->data[ x + y * image->xsize ]\n\n with x and y integer.\n */\ntypedef struct image_int_s\n{\n int * data;\n unsigned int xsize,ysize;\n} * image_int;\n\nvoid free_image_int(image_int i);\nimage_int new_image_int(unsigned int xsize, unsigned int ysize);\nimage_int new_image_int_ini( unsigned int xsize, unsigned int ysize,\n int fill_value );\n\n/*----------------------------------------------------------------------------*/\n/** double image data type\n\n The pixel value at (x,y) is accessed by:\n\n image->data[ x + y * image->xsize ]\n\n with x and y integer.\n */\ntypedef struct image_double_s\n{\n double * data;\n unsigned int xsize,ysize;\n} * image_double;\n\nvoid free_image_double(image_double i);\nimage_double new_image_double(unsigned int xsize, unsigned int ysize);\nimage_double new_image_double_ini( unsigned int xsize, unsigned int ysize,\n double fill_value );\n\n\n/*----------------------------------------------------------------------------*/\n/*-------------------------- Line Segment Detector ---------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/* LSD Full Interface */\n/*----------------------------------------------------------------------------*/\n/** LSD Full Interface\n\n @param image Input image.\n\n @param scale When different than 1.0, LSD will scale the image by\n Gaussian filtering.\n Example: is scale=0.8, the input image will be subsampled\n to 80% of its size, and then the line segment detector\n will be applied.\n Suggested value: 0.8\n\n @param sigma_scale When scale!=1.0, the sigma of the Gaussian filter is:\n sigma = sigma_scale / scale, if scale < 1.0\n sigma = sigma_scale, if scale >= 1.0\n Suggested value: 0.6\n\n @param quant Bound to the quantization error on the gradient norm.\n Example: if gray level is quantized to integer steps,\n the gradient (computed by finite differences) error\n due to quantization will be bounded by 2.0, as the\n worst case is when the error are 1 and -1, that\n gives an error of 2.0.\n Suggested value: 2.0\n\n @param ang_th Gradient angle tolerance in the region growing\n algorithm, in degrees.\n Suggested value: 22.5\n\n @param eps Detection threshold, -log10(NFA).\n The bigger, the more strict the detector is,\n and will result in less detections.\n (Note that the 'minus sign' makes that this\n behavior is opposite to the one of NFA.)\n The value -log10(NFA) is equivalent but more\n intuitive than NFA:\n - -1.0 corresponds to 10 mean false alarms\n - 0.0 corresponds to 1 mean false alarm\n - 1.0 corresponds to 0.1 mean false alarms\n - 2.0 corresponds to 0.01 mean false alarms\n .\n Suggested value: 0.0\n\n @param density_th Minimal proportion of region points in a rectangle.\n Suggested value: 0.7\n\n @param n_bins Number of bins used in the pseudo-ordering of gradient\n modulus.\n Suggested value: 1024\n\n @param max_grad Gradient modulus in the highest bin. For example,\n for images with integer gray levels in [0,255],\n the maximum possible gradient value is 255.0.\n Suggested value: 255.0\n\n @param region Optional output: an int image where the pixels used\n in some line support region are marked. Unused pixels\n have the value '0' while the used ones have the\n number of the line segment, numbered 1,2,3,...\n If desired, a non NULL pointer to an image_int should\n be used. The resulting image has the size of the image\n used for the processing, that is, the size of the input\n image scaled by the given factor 'scale'.\n Suggested value: NULL\n\n @return A 5-tuple list, where each 5-tuple corresponds to a\n detected line segment. The five values are:\n - x1,y1,x2,y2,width\n .\n for a line segment from (x1,y1) to (x2,y2) and\n a width 'width'.\n */\nntuple_list LineSegmentDetection( image_double image, double scale,\n double sigma_scale, double quant,\n double ang_th, double eps, double density_th,\n int n_bins, double max_grad,\n image_int * region );\n\n/*----------------------------------------------------------------------------*/\n/* LSD Simple Interface with Scale */\n/*----------------------------------------------------------------------------*/\n/** LSD Simple Interface with Scale\n\n @param image Input image.\n\n @param scale When different than 1.0, LSD will scale the image by\n Gaussian filtering.\n Example: is scale=0.8, the input image will be subsampled\n to 80% of its size, and then the line segment detector\n will be applied.\n Suggested value: 0.8\n\n @return a 5-tuple list of detected line segments.\n */\nntuple_list lsd_scale(image_double image, double scale);\n\n/*----------------------------------------------------------------------------*/\n/* LSD Simple Interface */\n/*----------------------------------------------------------------------------*/\n/** LSD Simple Interface\n\n @param image Input image.\n\n @return a 5-tuple list of detected line segments.\n */\nntuple_list lsd(image_double image);\n\n#endif /* !LSD_HEADER */\n/*----------------------------------------------------------------------------*/\n"
},
{
"path": "thirdparty/LSD/lsd_call_example.c",
"content": "#include \n#include \"lsd.h\"\n\nint main(void)\n{\n image_double image;\n ntuple_list out;\n unsigned int x,y,i,j;\n unsigned int X = 128; /* x image size */\n unsigned int Y = 128; /* y image size */\n\n /* create a simple image: left half black, right half gray */\n image = new_image_double(X,Y);\n for(x=0;xdata[ x + y * image->xsize ] = xsize);\n for(i=0;isize;i++)\n {\n for(j=0;jdim;j++)\n printf(\"%f \",out->values[ i * out->dim + j ]);\n printf(\"\\n\");\n }\n\n /* free memory */\n free_image_double(image);\n free_ntuple_list(out);\n\n return 0;\n}\n"
},
{
"path": "thirdparty/LSD/lsd_cmd.c",
"content": "/*----------------------------------------------------------------------------\n\n LSD - Line Segment Detector on digital images\n\n Copyright 2007-2010 rafael grompone von gioi (grompone@gmail.com)\n\n This program is free software: you can redistribute it and/or modify\n it under the terms of the GNU Affero General Public License as\n published by the Free Software Foundation, either version 3 of the\n License, or (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU Affero General Public License for more details.\n\n You should have received a copy of the GNU Affero General Public License\n along with this program. If not, see .\n\n ----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** @file lsd_cmd.c\n Command line interface for LSD module (Line Segment Detector).\n @author rafael grompone von gioi (grompone@gmail.com)\n */\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Definition of the command line interface. */\n#define USE \" \\\n#name: lsd \\\n#author: rafael grompone von gioi \\\n#version: 1.5 of December 3, 2010 \\\n#year: 2007-2010 \\\n#desc: Line Segment Detector \\\n#opt: scale | s | double | 0.8 | 0.0 | | \\\n Scale image by Gaussian filter before processing. \\\n#opt: sigma_coef | c | double | 0.6 | 0.0 | | \\\n Sigma for Gaussian filter is computed as sigma_coef/scale. \\\n#opt: quant | q | double | 2.0 | 0.0 | | \\\n Bound to quantization error on the gradient norm. \\\n#opt: ang_th | a | double | 22.5 | 0.0 | 180.0 | \\\n Gradient angle tolerance in degrees. \\\n#opt: eps | e | double | 0.0 | | | Detection threshold, -log10(max. NFA) \\\n#opt: density_th | d | double | 0.7 | 0.0 | 1.0 | \\\n Minimal density of region points in a rectangle to be accepted. \\\n#opt: n_bins | b | int | 1024 | 1 | | \\\n Number of bins in 'ordering' of gradient modulus. \\\n#opt: max_grad | m | double | 255.0 | 1 | | \\\n Gradient modulus in the highest bin. \\\n#opt: reg | R | str | | | | \\\n Output image showing pixels used by each detection. Scaled size. \\\n#opt: epsfile | P | str | | | | Output line segments into EPS file 'epsfile'. \\\n#opt: svgfile | S | str | | | | Output line segments into SVG file 'svgfile'. \\\n#opt: width | W | double | 1.5 | | | \\\n LS width used in EPS and SVG files. If <=0, use detected values. \\\n#req: in | | str | | | | Input image (PGM) \\\n#req: out | | str | | | | Line Segment output (ascii file: x1,y1,x2,y2,width) \\\n\"\n/*----------------------------------------------------------------------------*/\n\n#include \n#include \n#include \n#include \n#include \n#include \"lsd.h\"\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/** Fatal error, print a message to standard-error output and exit.\n */\nstatic void error(char * msg)\n{\n fprintf(stderr,\"%s\\n\",msg);\n exit(EXIT_FAILURE);\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*--------------------- Command Line interface handling ----------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n#define FIELD_LENGTH 160\n#define VERSION_OPTION \"--version\"\n\n/*----------------------------------------------------------------------------*/\n/** Structure to store one argument definition and read value.\n */\nstruct argument\n{\n char name[FIELD_LENGTH]; /* name to internally identify the argument */\n char desc[FIELD_LENGTH]; /* description */\n char id; /* letter used with '-' to use the option */\n char type; /* i=int, d=double, s=str, b=bool */\n int required;\n int assigned;\n int def_value; /* true or false, a default value is assigned? */\n char d_value[FIELD_LENGTH]; /* default value */\n char s_value[FIELD_LENGTH]; /* string found, also the value if 'str' */\n int i_value;\n double f_value;\n int min_set; /* true or false, is minimal value set? */\n double min;\n int max_set; /* true or false, is maximal value set? */\n double max;\n};\n\n/*----------------------------------------------------------------------------*/\n/** Structure to store the full set of argument definitions and its values.\n */\nstruct arguments\n{\n char name[FIELD_LENGTH];\n char author[FIELD_LENGTH];\n char version[FIELD_LENGTH];\n char desc[FIELD_LENGTH];\n char compiled[FIELD_LENGTH];\n char year[FIELD_LENGTH];\n int arg_num;\n int arg_allocated;\n struct argument * args;\n};\n\n/*----------------------------------------------------------------------------*/\n/** Free an 'arguments' structure.\n */\nstatic void free_arguments(struct arguments * arg)\n{\n free( (void *) arg->args );\n free( (void *) arg );\n}\n\n/*----------------------------------------------------------------------------*/\n/** Accepted characters in field identifier: numbers, letters and '_'.\n */\nstatic int is_id_char(int c)\n{\n return c=='_' || isalpha(c) || isdigit(c);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Read next field definition in an argument definition.\n */\nstatic char * get_next_field(char * p, char * id, char * value)\n{\n int n;\n\n /* search for field id */\n while( isspace(*p) ) ++p; /* skip spaces */\n if( *p != '#' ) error(\"Error: missing '#' in 'use description'.\");\n ++p;\n for( n=0; is_id_char(*p) && n= FIELD_LENGTH ) error(\"Error: field too long in 'use description'.\");\n id[n] = '\\0';\n if( *(p++) != ':' ) error(\"Error: missing ':' in 'use description'.\");\n\n /* search for field value */\n while( isspace(*p) ) ++p; /* skip spaces */\n for( n=0; *p != '#' && *p != '\\0' && n= FIELD_LENGTH ) error(\"Error: field too long in 'use description'.\");\n value[n] = '\\0';\n\n /* remove spaces at the end of the field */\n while( --n >= 0 && isspace(value[n]) ) value[n] = '\\0';\n\n return p;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Read next token in an argument definition.\n */\nstatic char * get_next_token(char * p, char div, char * value)\n{\n int n;\n\n if( *p == '\\0' )\n error(\"Error: argument token expected in 'use description'.\");\n\n while( isspace(*p) ) ++p; /* skip spaces */\n for( n=0; *p!=div && *p!='\\0' && n= FIELD_LENGTH ) error(\"Error: field too long in 'use description'.\");\n value[n] = '\\0';\n while( --n >= 0 && isspace(value[n]) ) value[n] = '\\0';\n\n /* remove 'div' at the end of the token, if present */\n if( *p == div ) ++p;\n\n return p;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Process one argument description.\n */\nstatic void process_new_argument(char * id, char * value,struct arguments * arg)\n{\n char token[FIELD_LENGTH];\n char * p;\n int i;\n\n /* allocate memory if needed */\n if( arg->arg_num >= arg->arg_allocated )\n {\n arg->arg_allocated *= 2;\n arg->args = (struct argument *) realloc( (void *) arg->args,\n arg->arg_allocated * sizeof(struct argument) );\n if( arg->args == NULL ) error(\"Error: not enough memory.\");\n }\n\n /* argument name */\n p = get_next_token(value,'|',arg->args[arg->arg_num].name);\n for( i=0; iarg_num; i++ )\n if( strcmp(arg->args[i].name,arg->args[arg->arg_num].name) == 0 )\n error(\"Error: argument name used twice in 'use description'.\");\n\n /* 'option' letter - to be used with '-' to identify option */\n p = get_next_token(p,'|',token);\n if( strcmp(id,\"opt\") == 0 )\n {\n arg->args[arg->arg_num].required = FALSE;\n if( strlen(token) <= 0 || strlen(token) > 1 )\n error(\"Error: invalid option letter in 'use description'.\");\n arg->args[arg->arg_num].id = token[0];\n if( !isalpha(arg->args[arg->arg_num].id) )\n error(\"Error: option id must be a letter in 'use description'.\");\n for( i=0; iarg_num; i++ )\n if( !(arg->args[i].required) &&\n arg->args[i].id == arg->args[arg->arg_num].id )\n error(\"Error: option letter used twice in 'use description'.\");\n }\n else /* must be 'req' - required argument */\n {\n arg->args[arg->arg_num].required = TRUE;\n if( strlen(token) > 0 )\n error(\"Error: unused option letter in 'use description'.\");\n arg->args[arg->arg_num].id = 0;\n }\n\n /* argument type */\n p = get_next_token(p,'|',token);\n if( strcmp(token,\"int\") == 0 ) arg->args[arg->arg_num].type = 'i';\n else if( strcmp(token,\"double\") == 0 ) arg->args[arg->arg_num].type = 'd';\n else if( strcmp(token,\"str\") == 0 ) arg->args[arg->arg_num].type = 's';\n else if( strcmp(token,\"bool\") == 0 ) arg->args[arg->arg_num].type = 'b';\n else error(\"Error: unknown argument type in 'use description'.\");\n\n /* required arguments can't be boolean */\n if( arg->args[arg->arg_num].required && arg->args[arg->arg_num].type == 'b' )\n error(\"Error: required arguments can't be boolean in 'use description'.\");\n\n /* default value */\n p = get_next_token(p,'|',token);\n if( strlen(token) > 0 )\n {\n if( arg->args[arg->arg_num].required )\n error(\"Error: default value in required argument in 'use description'.\");\n arg->args[arg->arg_num].def_value = TRUE;\n arg->args[arg->arg_num].assigned = TRUE;\n strcpy(arg->args[arg->arg_num].d_value,token);\n strcpy(arg->args[arg->arg_num].s_value,token);\n if( arg->args[arg->arg_num].type == 'i' )\n arg->args[arg->arg_num].i_value = atoi(token);\n if( arg->args[arg->arg_num].type == 'd' )\n arg->args[arg->arg_num].f_value = atof(token);\n }\n else\n {\n arg->args[arg->arg_num].def_value = FALSE;\n arg->args[arg->arg_num].s_value[0] = '\\0';\n arg->args[arg->arg_num].assigned = FALSE;\n }\n\n /* required arguments can't have default value */\n if( arg->args[arg->arg_num].required && arg->args[arg->arg_num].def_value )\n error(\"Error: required args can't have default value in 'use description'.\");\n\n /* min value */\n p = get_next_token(p,'|',token);\n if( strlen(token) > 0 )\n {\n arg->args[arg->arg_num].min_set = TRUE;\n arg->args[arg->arg_num].min = atof(token);\n }\n else\n {\n arg->args[arg->arg_num].min_set = FALSE;\n }\n\n /* max value */\n p = get_next_token(p,'|',token);\n if( strlen(token) > 0 )\n {\n arg->args[arg->arg_num].max_set = TRUE;\n arg->args[arg->arg_num].max = atof(token);\n }\n else\n {\n arg->args[arg->arg_num].max_set = FALSE;\n }\n\n /* argument description */\n p = get_next_token(p,'|',arg->args[arg->arg_num].desc);\n\n /* the field should end there */\n if( *p != '\\0' )\n error(\"Error: too many tokens in one argument in 'use description'.\");\n\n arg->arg_num++;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Process an argument definition.\n */\nstatic void process_argument_description( char * desc, struct arguments * arg )\n{\n char id[FIELD_LENGTH];\n char value[FIELD_LENGTH];\n\n /* initialize 'arg' */\n arg->name[0] = '\\0';\n arg->author[0] = '\\0';\n arg->version[0] = '\\0';\n arg->year[0] = '\\0';\n arg->desc[0] = '\\0';\n arg->compiled[0] = '\\0';\n arg->arg_num = 0;\n arg->arg_allocated = 2;\n arg->args = (struct argument *)\n malloc( arg->arg_allocated * sizeof(struct argument) );\n if( arg->args == NULL ) error(\"Error: not enough memory.\");\n\n /* assign compilation date and time */\n strcat(arg->compiled,__DATE__);\n strcat(arg->compiled,\" \");\n strcat(arg->compiled,__TIME__);\n\n /* process description */\n while( *desc != '\\0' )\n {\n desc = get_next_field(desc,id,value);\n\n if( strcmp(id,\"name\") == 0 )\n {\n if( arg->name[0] != '\\0' )\n error(\"Error: multiple 'name' fields in 'use description'.\");\n strcpy(arg->name,value);\n }\n else if( strcmp(id,\"author\") == 0 )\n {\n if( arg->author[0] != '\\0' )\n error(\"Error: multiple 'author' fields in 'use description'.\");\n strcpy(arg->author,value);\n }\n else if( strcmp(id,\"version\") == 0 )\n {\n if( arg->version[0] != '\\0' )\n error(\"Error: multiple 'version' fields in 'use description'.\");\n strcpy(arg->version,value);\n }\n else if( strcmp(id,\"year\") == 0 )\n {\n if( arg->year[0] != '\\0' )\n error(\"Error: multiple 'year' fields in 'use description'.\");\n strcpy(arg->year,value);\n }\n else if( strcmp(id,\"desc\") == 0 )\n {\n if( arg->desc[0] != '\\0' )\n error(\"Error: multiple 'desc' fields in 'use description'.\");\n strcpy(arg->desc,value);\n }\n else if( strcmp(id,\"opt\") == 0 || strcmp(id,\"req\") == 0 )\n {\n process_new_argument(id,value,arg);\n }\n else\n {\n error(\"Error: unknown token in 'use description'.\");\n }\n }\n\n /* verify required arguments */\n if( arg->name[0] == '\\0' )\n error(\"Error: program name is required in 'use description'.\");\n if( arg->author[0] == '\\0' )\n error(\"Error: author name is required in 'use description'.\");\n if( arg->version[0] == '\\0' )\n error(\"Error: version is required in 'use description'.\");\n if( arg->desc[0] == '\\0' )\n error(\"Error: program description is required in 'use description'.\");\n if( arg->year[0] == '\\0' )\n error(\"Error: year is required in 'use description'.\");\n}\n\n/*----------------------------------------------------------------------------*/\n/** Print version.\n */\nstatic void print_version(struct arguments * arg, FILE * f)\n{\n fprintf(f,\"Version %s, compiled %s\\n\",arg->version,arg->compiled);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Evaluate arguments.\n */\nstatic void evaluate_arguments(int argc, char ** argv, struct arguments * arg)\n{\n int in_required_args = FALSE;\n int n,i;\n\n if( argc <= 0 ) error(\"Error: unexpected command line: missing command.\");\n\n for( n=1; !in_required_args && n < argc; n++ )\n {\n /* when an argument do not start with \"-\" it is not optional.\n but, if the argument is just \"-\", then is a non optional\n argument with value \"-\", and will be analyzed later. */\n if( argv[n][0] != '-' || (argv[n][0]=='-' && strlen(argv[n])== 1) )\n {\n in_required_args = TRUE;\n --n;\n continue;\n }\n\n if( strlen(argv[n]) != 2 )\n {\n /* check if it is the special option 'version' */\n if( strcmp(argv[n],VERSION_OPTION) == 0 )\n {\n print_version(arg,stdout);\n free_arguments(arg);\n exit(EXIT_SUCCESS);\n }\n\n /* otherwise is a bad option */\n fprintf(stderr,\"Error: %s \",argv[n]);\n error(\"unrecognized option.\");\n }\n\n for( i=0; iarg_num; i++ )\n if( !(arg->args[i].required) && arg->args[i].id == argv[n][1] )\n {\n arg->args[i].assigned = TRUE;\n if( arg->args[i].type != 'b' )\n {\n /* go for the value */\n ++n;\n\n /* a value is expected */\n if( n >= argc )\n {\n fprintf(stderr,\"Error: in '%s': \",argv[n-1]);\n error(\"a value was expected.\");\n }\n if( strlen(argv[n]) > FIELD_LENGTH )\n {\n fprintf(stderr,\"Error: in '%s': \",argv[n-1]);\n error(\"value too long.\");\n }\n strcpy(arg->args[i].s_value,argv[n]);\n if( arg->args[i].type == 'i' )\n {\n arg->args[i].i_value = atoi(argv[n]);\n if( arg->args[i].min_set &&\n arg->args[i].i_value < (int) arg->args[i].min )\n {\n fprintf(stderr,\"Error: in '%s': \",argv[n-1]);\n error(\"value out of range.\");\n }\n if( arg->args[i].max_set &&\n arg->args[i].i_value > (int) arg->args[i].max )\n {\n fprintf(stderr,\"Error: in '%s': \",argv[n-1]);\n error(\"value out of range.\");\n }\n }\n if( arg->args[i].type == 'd' )\n {\n arg->args[i].f_value = atof(argv[n]);\n if( arg->args[i].min_set &&\n arg->args[i].f_value < arg->args[i].min )\n {\n fprintf(stderr,\"Error: in '%s': \",argv[n-1]);\n error(\"value out of range.\");\n }\n if( arg->args[i].max_set &&\n arg->args[i].f_value > arg->args[i].max )\n {\n fprintf(stderr,\"Error: in '%s': \",argv[n-1]);\n error(\"value out of range.\");\n }\n }\n }\n i = arg->arg_num; /* argument found, stop search */\n }\n }\n\n for( i=0; narg_num; i++ )\n if( arg->args[i].required )\n {\n arg->args[i].assigned = TRUE;\n strcpy(arg->args[i].s_value,argv[n]);\n if( arg->args[i].type == 'i' )\n {\n arg->args[i].i_value = atoi(argv[n]);\n if( arg->args[i].min_set &&\n arg->args[i].i_value < (int) arg->args[i].min )\n {\n fprintf(stderr,\"Error: in '%s': \",arg->args[i].name);\n error(\"value out of range.\");\n }\n if( arg->args[i].max_set &&\n arg->args[i].i_value > (int) arg->args[i].max )\n {\n fprintf(stderr,\"Error: in '%s': \",arg->args[i].name);\n error(\"value out of range.\");\n }\n }\n if( arg->args[i].type == 'd' )\n {\n arg->args[i].f_value = atof(argv[n]);\n if( arg->args[i].min_set &&\n arg->args[i].f_value < arg->args[i].min )\n {\n fprintf(stderr,\"Error: in '%s': \",arg->args[i].name);\n error(\"value out of range.\");\n }\n if( arg->args[i].max_set &&\n arg->args[i].f_value > arg->args[i].max )\n {\n fprintf(stderr,\"Error: in '%s': \",arg->args[i].name);\n error(\"value out of range.\");\n }\n }\n ++n;\n }\n}\n\n/*----------------------------------------------------------------------------*/\n/** Print command line interface help.\n */\nstatic void use(struct arguments * arg)\n{\n int i;\n\n fprintf(stderr,\"%s, %s\\n\",arg->name,arg->desc);\n fprintf(stderr,\"Copyright (c) %s %s\\n\",arg->year,arg->author);\n print_version(arg,stderr);\n fprintf(stderr,\"\\nUsage: %s\",arg->name);\n\n /* always present version option */\n fprintf(stderr,\" [%s]\",VERSION_OPTION);\n\n for(i=0;iarg_num;i++)\n if( !(arg->args[i].required) )\n {\n fprintf(stderr,\" [-%c\",arg->args[i].id);\n if( arg->args[i].type != 'b' ) fprintf(stderr,\" %s\",arg->args[i].name);\n fprintf(stderr,\"]\");\n }\n\n for(i=0;iarg_num;i++)\n if( arg->args[i].required )\n fprintf(stderr,\" %s\",arg->args[i].name);\n\n fprintf(stderr,\"\\n\\n\");\n\n /* option description */\n fprintf(stderr,\" %s\\tPrint version and compilation date/time and exit.\\n\",\n VERSION_OPTION);\n for(i=0;iarg_num;i++)\n if( !(arg->args[i].required) )\n {\n fprintf(stderr,\" -%c\",arg->args[i].id);\n if( arg->args[i].type != 'b' )\n {\n fprintf(stderr,\" %s\",arg->args[i].name);\n }\n fprintf(stderr,\"\\t%s\\n\",arg->args[i].desc);\n if( arg->args[i].type == 'i' )\n {\n fprintf(stderr,\"\\t\\t'%s' is integer\",arg->args[i].name);\n fprintf(stderr,\", range [\");\n if( arg->args[i].min_set )\n fprintf(stderr,\"%d,\",(int)arg->args[i].min);\n else fprintf(stderr,\"-inf,\");\n if( arg->args[i].max_set )\n fprintf(stderr,\"%d]\",(int)arg->args[i].max);\n else fprintf(stderr,\"inf]\");\n if( arg->args[i].def_value )\n fprintf(stderr,\", default value %d\",atoi(arg->args[i].d_value));\n fprintf(stderr,\"\\n\");\n }\n if( arg->args[i].type == 'd' )\n {\n fprintf(stderr,\"\\t\\t'%s' is double\",arg->args[i].name);\n fprintf(stderr,\", range [\");\n if( arg->args[i].min_set ) fprintf(stderr,\"%g,\",arg->args[i].min);\n else fprintf(stderr,\"-inf,\");\n if( arg->args[i].max_set ) fprintf(stderr,\"%g]\",arg->args[i].max);\n else fprintf(stderr,\"inf]\");\n if( arg->args[i].def_value )\n fprintf(stderr,\", default value %g\",atof(arg->args[i].d_value));\n fprintf(stderr,\"\\n\");\n }\n }\n\n for(i=0;iarg_num;i++)\n if( arg->args[i].required )\n {\n fprintf(stderr,\" %s\",arg->args[i].name);\n fprintf(stderr,\"\\t%s\\n\",arg->args[i].desc);\n if( arg->args[i].type == 'i' )\n {\n fprintf(stderr,\"\\t\\t'%s' is integer\",arg->args[i].name);\n fprintf(stderr,\", range [\");\n if( arg->args[i].min_set )\n fprintf(stderr,\"%d,\",(int)arg->args[i].min);\n else fprintf(stderr,\"-inf,\");\n if( arg->args[i].max_set )\n fprintf(stderr,\"%d]\",(int)arg->args[i].max);\n else fprintf(stderr,\"inf]\");\n fprintf(stderr,\"\\n\");\n }\n if( arg->args[i].type == 'd' )\n {\n fprintf(stderr,\"\\t\\t'%s' is double\",arg->args[i].name);\n fprintf(stderr,\", range [\");\n if( arg->args[i].min_set ) fprintf(stderr,\"%f,\",arg->args[i].min);\n else fprintf(stderr,\"-inf,\");\n if( arg->args[i].max_set ) fprintf(stderr,\"%f]\",arg->args[i].max);\n else fprintf(stderr,\"inf]\");\n fprintf(stderr,\"\\n\");\n }\n }\n\n fprintf(stderr,\"\\n\");\n\n free_arguments(arg);\n\n exit(EXIT_FAILURE);\n}\n\n/*----------------------------------------------------------------------------*/\n/** Process and evaluate a program arguments.\n */\nstatic struct arguments * process_arguments(char * desc, int argc, char ** argv)\n{\n struct arguments * arg;\n int i;\n\n /* get memory */\n arg = (struct arguments *) malloc(sizeof(struct arguments));\n if( arg == NULL ) error(\"Error: not enough memory.\");\n\n process_argument_description(desc,arg);\n evaluate_arguments(argc,argv,arg);\n\n /* if there are missing arguments print the 'use' information */\n for(i=0; iarg_num; i++)\n if( arg->args[i].required && !(arg->args[i].assigned) ) use(arg);\n\n return arg;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Test if an argument has a defined value.\n */\nstatic int is_assigned(struct arguments * arg, char * name)\n{\n int i;\n\n for(i=0; iarg_num; i++)\n if( strcmp(name,arg->args[i].name) == 0 ) return arg->args[i].assigned;\n error(\"Error: is_assigned: unknown argument.\");\n return -1; /* useless, just to prevent warning in strict compilers */\n}\n\n/*----------------------------------------------------------------------------*/\n/** Get the value of a string argument.\n */\nstatic char * get_str(struct arguments * arg, char * name)\n{\n int i;\n\n for(i=0; iarg_num; i++)\n if( strcmp(name,arg->args[i].name) == 0 )\n {\n if( arg->args[i].type == 's' )\n {\n if( !(arg->args[i].assigned) ) return NULL;\n return arg->args[i].s_value;\n }\n else error(\"Error: get_str: the parameter is not a double.\");\n }\n error(\"Error: get_str: unknown argument.\");\n return NULL; /* useless, just to prevent warning in strict compilers */\n}\n\n/*----------------------------------------------------------------------------*/\n/** Get the value of an integer argument.\n */\nstatic int get_int(struct arguments * arg, char * name)\n{\n int i;\n\n for(i=0; iarg_num; i++)\n if( strcmp(name,arg->args[i].name) == 0 )\n {\n if( !(arg->args[i].assigned) )\n error(\"Error: get_int: parameter not assigned.\");\n if( arg->args[i].type == 'i' ) return arg->args[i].i_value;\n else error(\"Error: get_int: the parameter is not an integer.\");\n }\n error(\"Error: get_int: unknown argument.\");\n return -1; /* useless, just to prevent warning in strict compilers */\n}\n\n/*----------------------------------------------------------------------------*/\n/** Get the value of a double argument.\n */\nstatic double get_double(struct arguments * arg, char * name)\n{\n int i;\n\n for(i=0; iarg_num; i++)\n if( strcmp(name,arg->args[i].name) == 0 )\n {\n if( !(arg->args[i].assigned) )\n error(\"Error: get_double: parameter not assigned.\");\n if( arg->args[i].type == 'd' ) return arg->args[i].f_value;\n else error(\"Error: get_double: the parameter is not a double.\");\n }\n error(\"Error: get_double: unknown argument.\");\n return -1.0; /* useless, just to prevent warning in strict compilers */\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*------------------------------ PGM image I/O -------------------------------*/\n/*----------------------------------------------------------------------------*/\n\n/*----------------------------------------------------------------------------*/\n/** Skip white characters and comments in a PGM file.\n */\nstatic void skip_whites_and_comments(FILE * f)\n{\n int c;\n do\n {\n while(isspace(c=getc(f))); /* skip spaces */\n if(c=='#') /* skip comments */\n while( c!='\\n' && c!='\\r' && c!=EOF )\n c=getc(f);\n }\n while( c == '#' || isspace(c) );\n if( c != EOF && ungetc(c,f) == EOF )\n error(\"Error: unable to 'ungetc' while reading PGM file.\");\n}\n\n/*----------------------------------------------------------------------------*/\n/** Read a ASCII number from a PGM file.\n */\nstatic unsigned int get_num(FILE * f)\n{\n unsigned int num;\n int c;\n\n while(isspace(c=getc(f)));\n if(!isdigit(c)) error(\"Error: corrupted PGM file.\");\n num = (unsigned int) (c - '0');\n while( isdigit(c=getc(f)) ) num = 10 * num + c - '0';\n if( c != EOF && ungetc(c,f) == EOF )\n error(\"Error: unable to 'ungetc' while reading PGM file.\");\n\n return num;\n}\n\n\n/*----------------------------------------------------------------------------*/\n/** Read a PGM file into an \"image_double\".\n If the name is \"-\" the file is read from standard input.\n */\nstatic image_double read_pgm_image_double(char * name)\n{\n FILE * f;\n int c,bin;\n unsigned int xsize,ysize,depth,x,y;\n image_double image;\n\n /* open file */\n if( strcmp(name,\"-\") == 0 ) f = stdin;\n else f = fopen(name,\"rb\");\n if( f == NULL ) error(\"Error: unable to open input image file.\");\n\n /* read header */\n if( getc(f) != 'P' ) error(\"Error: not a PGM file!\");\n if( (c=getc(f)) == '2' ) bin = FALSE;\n else if( c == '5' ) bin = TRUE;\n else error(\"Error: not a PGM file!\");\n skip_whites_and_comments(f);\n xsize = get_num(f); /* X size */\n skip_whites_and_comments(f);\n ysize = get_num(f); /* Y size */\n skip_whites_and_comments(f);\n depth = get_num(f); /* depth */\n if(depth==0) fprintf(stderr,\"Warning: depth=0, probably invalid PGM file\\n\");\n /* white before data */\n if(!isspace(c=getc(f))) error(\"Error: corrupted PGM file.\");\n\n /* get memory */\n image = new_image_double(xsize,ysize);\n\n /* read data */\n for(y=0;ydata[ x + y * xsize ] = bin ? (double) getc(f)\n : (double) get_num(f);\n\n /* close file if needed */\n if( f != stdin && fclose(f) == EOF )\n error(\"Error: unable to close file while reading PGM file.\");\n\n return image;\n}\n\n/*----------------------------------------------------------------------------*/\n/** Write an \"image_int\" into a PGM file.\n If the name is \"-\" the file is written to standard output.\n */\nstatic void write_pgm_image_int(image_int image, char * name)\n{\n FILE * f;\n unsigned int x,y,n;\n int v,max,min;\n\n /* check min and max values */\n max = min = 0;\n for(y=0; yysize; y++)\n for(x=0; xxsize; x++)\n {\n v = image->data[ x + y * image->xsize ];\n if( v > max ) max = v;\n if( v < min ) min = v;\n }\n if( min < 0 ) fprintf(stderr,\n \"Warning: write_pgm_image_int: negative values in '%s'.\\n\",name);\n if( max > 65535 ) fprintf(stderr,\n \"Warning: write_pgm_image_int: values exceeding 65535 in '%s'.\\n\",name);\n\n /* open file */\n if( strcmp(name,\"-\") == 0 ) f = stdout;\n else f = fopen(name,\"w\");\n if( f == NULL ) error(\"Error: unable to open output image file.\");\n\n /* write header */\n fprintf(f,\"P2\\n\");\n fprintf(f,\"%u %u\\n\",image->xsize,image->ysize);\n fprintf(f,\"%d\\n\",max);\n\n /* write data */\n for(n=0,y=0; yysize; y++)\n for(x=0; xxsize; x++)\n {\n fprintf(f,\"%d \",image->data[ x + y * image->xsize ]);\n if(++n==8) /* lines should not be longer than 70 characters */\n {\n fprintf(f,\"\\n\");\n n = 0;\n }\n }\n\n /* close file if needed */\n if( f != stdout && fclose(f) == EOF )\n error(\"Error: unable to close file while writing PGM file.\");\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------------- Write EPS File -------------------------------*/\n/*----------------------------------------------------------------------------*/\n/** Write line segments into an EPS file.\n If the name is \"-\" the file is written to standard output.\n\n According to\n\n Adobe \"Encapsulated PostScript File Format Specification\",\n Version 3.0, 1 May 1992,\n\n and\n\n Adobe \"PostScript(R) LANGUAGE REFERENCE\", third edition, 1999.\n */\nstatic void write_eps( ntuple_list segs, char * filename,\n unsigned int xsize, unsigned int ysize, double width )\n{\n FILE * eps;\n unsigned int i;\n\n /* open file */\n if( strcmp(filename,\"-\") == 0 ) eps = stdout;\n else eps = fopen(filename,\"w\");\n if( eps == NULL ) error(\"Error: unable to open EPS output file.\");\n\n /* write EPS header */\n fprintf(eps,\"%%!PS-Adobe-3.0 EPSF-3.0\\n\");\n fprintf(eps,\"%%%%BoundingBox: 0 0 %u %u\\n\",xsize,ysize);\n fprintf(eps,\"%%%%Creator: LSD, Line Segment Detector\\n\");\n fprintf(eps,\"%%%%Title: (%s)\\n\",filename);\n fprintf(eps,\"%%%%EndComments\\n\");\n\n /* write line segments */\n for(i=0;isize;i++)\n {\n fprintf( eps,\"newpath %f %f moveto %f %f lineto %f setlinewidth stroke\\n\",\n segs->values[i*segs->dim+0],\n (double) ysize - segs->values[i*segs->dim+1],\n segs->values[i*segs->dim+2],\n (double) ysize - segs->values[i*segs->dim+3],\n width <= 0.0 ? segs->values[i*segs->dim+4] : width );\n }\n\n /* close EPS file */\n fprintf(eps,\"showpage\\n\");\n fprintf(eps,\"%%%%EOF\\n\");\n if( eps != stdout && fclose(eps) == EOF )\n error(\"Error: unable to close file while writing EPS file.\");\n}\n\n\n/*----------------------------------------------------------------------------*/\n/*----------------------------- Write SVG File -------------------------------*/\n/*----------------------------------------------------------------------------*/\n/** Write line segments into a SVG file.\n If the name is \"-\" the file is written to standard output.\n*/\nstatic void write_svg( ntuple_list segs, char * filename,\n unsigned int xsize, unsigned int ysize, double width )\n{\n FILE * svg;\n unsigned int i;\n\n /* open file */\n if( strcmp(filename,\"-\") == 0 ) svg = stdout;\n else svg = fopen(filename,\"w\");\n if( svg == NULL ) error(\"Error: unable to open SVG output file.\");\n\n /* write SVG header */\n fprintf(svg,\"\\n\");\n fprintf(svg,\"\\n\");\n fprintf(svg,\"\\n\");\n if( svg != stdout && fclose(svg) == EOF )\n error(\"Error: unable to close file while writing SVG file.\");\n}\n\n\n/*----------------------------------------------------------------------------*/\n/* Main */\n/*----------------------------------------------------------------------------*/\n/** Main function call\n */\nint main(int argc, char ** argv)\n{\n struct arguments * arg = process_arguments(USE,argc,argv);\n FILE * output;\n image_double image;\n ntuple_list out;\n image_int region;\n unsigned int i,j;\n\n /* read input file */\n image = read_pgm_image_double(get_str(arg,\"in\"));\n\n /* execute LSD */\n out = LineSegmentDetection( image,\n get_double(arg,\"scale\"),\n get_double(arg,\"sigma_coef\"),\n get_double(arg,\"quant\"),\n get_double(arg,\"ang_th\"),\n get_double(arg,\"eps\"),\n get_double(arg,\"density_th\"),\n get_int(arg,\"n_bins\"),\n get_double(arg,\"max_grad\"),\n is_assigned(arg,\"reg\") ? ®ion : NULL );\n\n /* output */\n if( strcmp(get_str(arg,\"out\"),\"-\") == 0 ) output = stdout;\n else output = fopen(get_str(arg,\"out\"),\"w\");\n if( output == NULL ) error(\"Error: unable to open ASCII output file.\");\n for(i=0;isize;i++)\n {\n for(j=0;jdim;j++)\n fprintf(output,\"%f \",out->values[i*out->dim+j]);\n fprintf(output,\"\\n\");\n }\n if( output != stdout && fclose(output) == EOF ) /* close file if needed */\n error(\"Error: unable to close file while output file.\");\n\n /* store region output if needed */\n if(is_assigned(arg,\"reg\"))\n {\n write_pgm_image_int( region, get_str(arg,\"reg\") );\n free_image_int(region);\n }\n\n /* create EPS output if needed */\n if(is_assigned(arg,\"epsfile\"))\n write_eps( out, get_str(arg,\"epsfile\"), image->xsize, image->ysize,\n get_double(arg,\"width\") );\n\n /* create SVG output if needed */\n if(is_assigned(arg,\"svgfile\"))\n write_svg( out, get_str(arg,\"svgfile\"), image->xsize, image->ysize,\n get_double(arg,\"width\") );\n\n /* free memory */\n free_image_double(image);\n free_ntuple_list(out);\n free_arguments(arg);\n\n return EXIT_SUCCESS;\n}\n/*----------------------------------------------------------------------------*/\n"
},
{
"path": "thirdparty/LSWMS/CMakeLists.txt",
"content": "##############################\nPROJECT( lineSegment )\n##############################\ncmake_minimum_required (VERSION 2.6)\n\n# Packages\nfind_package( OpenCV REQUIRED )\n\n\n# Includes\ninclude_directories(\t\n\t${OPENCV_INCLUDE_DIR}\n\t${PROJECT_BINARY_DIR}\n)\n\nset(SOURCE_FILES \n\tmain.cpp\n\tLSWMS.cpp\n\tLSWMS.h\n)\n\n\n# Add executable and target link libraries\nADD_EXECUTABLE( lineSegment ${SOURCE_FILES})\nTARGET_LINK_LIBRARIES( lineSegment ${OpenCV_LIBS})\n\n\n"
},
{
"path": "thirdparty/LSWMS/LSWMS.cpp",
"content": "#include \"LSWMS.h\"\n\n#ifdef linux\n\t#include \n#endif\n\n#include \n#include \n\n#define ABS(a)\t (((a) < 0) ? -(a) : (a))\n#define NOT_A_VALID_ANGLE 5\n#define ANGLE_MARGIN\t22.5\n#define MAX_ERROR\t0.19625 // ((22.5/2)*CV_PI/180\n\nusing namespace cv;\nusing namespace std;\n\nstatic void setTo14Quads(DIR_POINT &dp)\n{\n\tif(dp.vx < 0)\n\t{\t\n\t\tdp.vx = -dp.vx;\n\t\tdp.vy = -dp.vy;\n\t}\n}\n\nLSWMS::LSWMS(const cv::Size imSize, const int R, const int numMaxLSegs, bool verbose)\n{\n\t// **********************************************\n\t// Constructor of class LSWMS (Slice Sampling Weighted\n\t// Mean-Shift)\n\t// Args:\n\t// \t-> imSize - Size of image\n\t//\t-> R - accuracy parameter\n\t// \t-> numMaxLSegs - requested number of line segments.\n\t//\t\t\tif set to 0, the algorithm finds exploring\n\t//\t\t\tthe whole image until no more line segments\n\t// \t\t\tcan be found\n\t//\t-> verbose - show messages\n\t// **********************************************\n\n\t__verbose = verbose;\n\n\t// Init variables\n\t__imSize = imSize;\n\t__imWidth = imSize.width;\n\t__imHeight = imSize.height;\n\t\n\t__R = R;\n\t__numMaxLSegs = numMaxLSegs;\n\n\t__N = 2*__R + 1;\n\n\t// Add padding it necessary\n\tif( (__imSize.width + 2*__N) % 4 != 0)\t\n\t\t__N = __N + ((__imSize.width + 2*__N) % 4)/2;\t\t\n\t\n\t__imPadSize.width = __imSize.width + 2*__N;\n\t__imPadSize.height = __imSize.height + 2*__N;\t\n\n\t// Init images\n\t__img = cv::Mat(__imSize, CV_8U);\n\t__imgPad = cv::Mat(__imPadSize, CV_8U);\n\t__roiRect = cv::Rect(__N, __N, __imSize.width, __imSize.height);\n\n\t// Mask image\n\t__M = cv::Mat(__imPadSize, CV_8U);\n\t__M.setTo(255);\n\n\t// Angle mask\n\t__A = cv::Mat(__imPadSize, CV_32F);\n\t__A.setTo(NOT_A_VALID_ANGLE);\n\t\n\t// Gradient images\n\t__G = cv::Mat(__imPadSize, CV_8U);\n\t__G.setTo(0);\n\t__Gx = cv::Mat(__imPadSize, CV_16S);\n\t__Gx.setTo(0);\n\t__Gy = cv::Mat(__imPadSize, CV_16S);\n\t__Gy.setTo(0);\n\n\t// Iterator\n\tif(__numMaxLSegs != 0)\n\t{\n\t\t__sampleIterator = std::vector(__imSize.width*__imSize.height, 0);\n\t\tfor(unsigned int k=0; k<__sampleIterator.size(); k++)\n\t\t\t__sampleIterator[k] = k;\n\n\t\tcv::randShuffle(__sampleIterator);\t\t\t\n\t}\n\t\n\t// Angular m_margin\n\t__margin = (float)(ANGLE_MARGIN*CV_PI/180);\n}\n\nint LSWMS::run(const cv::Mat &img, std::vector &lSegs, std::vector &errors)\n{\n\t// **********************************************\n\t// This function analyses the input image and finds\n\t// line segments that are stored in the given vector\n\t// Args:\n\t// \t-> img - Color or grayscale input image\n\t// \t<- lSegs - Output vector of line segments\n\t// <- errors - Output vector of angular errors\n\t// Ret:\n\t// \tRET_OK - no errors found\n\t// \tRET_ERROR - errors found\n\t// **********************************************\n\n\t// Clear line segment container\n\tlSegs.clear();\n\terrors.clear();\n\n\t// Input image to __img\n\tif(img.channels() == 3)\n\t\tcv::cvtColor(img, __img, CV_BGR2GRAY);\n\telse\n\t\t__img = img;\n\n\t// Add convolution borders\n\tcv::copyMakeBorder(__img, __imgPad, __N, __N, __N, __N, cv::BORDER_REPLICATE); // This way we avoid line segments at the boundaries of the image\n\n\t// Init Mask matrix\n\t__M.setTo(255);\n\t__imgPadROI = __M(__roiRect);\n\t__imgPadROI.setTo(0);\n\n\t// Compute Gradient map\t\t\n\t// Call to the computation of the gradient and angle maps (SOBEL)\n\tint retP = computeGradientMaps(__imgPad, __G, __Gx, __Gy);\n\tif(retP == RET_ERROR)\n\t{\n\t\tif(__verbose) {\tprintf(\"ERROR: Probability map could not be computed\\n\"); }\n\t\treturn RET_ERROR;\n\t}\t\n\n\t// Set padding to zero\n\tint NN = __N + __R;\n\tsetPaddingToZero(__Gx, NN);\n\tsetPaddingToZero(__Gy, NN);\n\tsetPaddingToZero(__G, NN);\n\n\t// Line segment finder\n\tint retLS = findLineSegments(__G, __Gx, __Gy, __A, __M, lSegs, errors);\n\treturn retLS;\n\t\n\n\treturn RET_OK;\n}\nint LSWMS::computeGradientMaps(const cv::Mat &img, cv::Mat &G, cv::Mat &Gx, cv::Mat &Gy)\n{\n\t// **********************************************\n\t// SOBEL mode\n\t//\n\t// This function obtains the gradient image (G, Gx, Gy),\n\t// and fills the angular map A.\n\t//\n\t// Args:\n\t// \t-> img - Grayscale input image\n\t// \t<- G - Gradient magnitude image\n\t// \t<- Gx - Gradient x-magnitude image\n\t// \t<- Gy - Gradient y-magnitude image\n\t// Ret:\n\t// \tRET_OK - no errors found\n\t// \tRET_ERROR - errors found\n\t// **********************************************\n\tif(__verbose) { printf(\"Compute gradient maps...\"); fflush(stdout); }\n\t\n\t// Sobel operator\n\tint ddepth = CV_16S;\n\tcv::Mat absGx, absGy;\n\n\tcv::Sobel(img, Gx, ddepth, 1, 0);\n\tconvertScaleAbs(Gx, absGx, (double)1/8);\n\n\tcv::Sobel(img, Gy, ddepth, 0, 1);\n\tconvertScaleAbs(Gy, absGy, (double)1/8);\n\n\t//cv::addWeighted(absGx, 0.5, absGy, 0.5, 0, G, CV_8U);\n\tcv::add(absGx, absGy, G);\n\n\t// Obtain the threshold\n\tcv::Scalar meanG = cv::mean(G);\n\t__meanG = (int)meanG.val[0];\n\tif(__verbose) { printf(\" computed: __meanG = %d\\n\", __meanG); }\n\n\t// Move from 2nd to 4th and from 3rd to 1st\n\t// From 2nd to 4th, \t\n\t//if( gx < 0 && gy > 0 ) {gx = -gx; gy = -gy;} // from 2 to 4\n\t//if( gx < 0 && gy < 0 ) {gx = -gx; gy = -gy;} // from 3 to 1\n\t//if( gx < 0 ) {gx = -gx; gy = -gy;}\n\tint movedCounter = 0;\n\tfor(int j=0; j<__imPadSize.height; ++j)\n\t{\n\t\tshort *ptRowGx = Gx.ptr(j);\n\t\tshort *ptRowGy = Gy.ptr(j);\n\t\tfor(int i=0; i<__imPadSize.width; ++i)\n\t\t{\n\t\t\tif(ptRowGx[i] < 0)\n\t\t\t{\n\t\t\t\tptRowGy[i] = -ptRowGy[i];\n\t\t\t\tptRowGx[i] = -ptRowGx[i];\n\t\t\t\tmovedCounter++;\n\t\t\t}\n\t\t}\n\t}\n\tif(__verbose) { printf(\"Moved %d/%d (%.2f%%) elements to 1st4th quadrant\\n\", movedCounter, __imPadSize.height*__imPadSize.width, ((double)100*movedCounter)/((double)__imPadSize.height*__imPadSize.width)); }\n\n\tif(__meanG > 0 && __meanG < 256)\n\t\treturn RET_OK;\n\telse\n\t\treturn RET_ERROR;\t\n}\nint LSWMS::findLineSegments(const cv::Mat &G, const cv::Mat &Gx, const cv::Mat &Gy, cv::Mat &A, cv::Mat &M, std::vector &lSegs, std::vector &errors)\n{\n\t// **********************************************\n\t// This function finds line segments using the \n\t// probability map P, the gradient components \n\t// Gx, and Gy and the angle map A.\n\t//\n\t// Args:\n\t// \t-> G - Gradient magnitude map\n\t// \t-> Gx - Gradient x-magnitude image\n\t// \t-> Gy - Gradient y-magnitude image\n\t//\t<- M - Mask image of visited pixels\n\t//\t<- lSegs - vector of detected line segments\n\t// <- errors - vector of angular errors\n\t// Ret:\n\t// \tRET_OK - no errors found\n\t// \tRET_ERROR - errors found\n\t// **********************************************\n\t// Loop over the image\n\tint x0, y0;\n\tint kIterator = 0;\n\n\tint imgSize = __img.cols*__img.rows;\n\n\twhile(true)\n\t{\t\t\t\t\n\t\tif (kIterator == imgSize)\n\t\t{\n\t\t\t// This is the end\n\t\t\tbreak;\n\t\t}\n\t\tif(__numMaxLSegs == 0)\n\t\t{\n\t\t\tx0 = kIterator%__img.cols;\n\t\t\ty0 = kIterator/__img.cols;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tx0 = __sampleIterator[kIterator]%__img.cols;\n\t\t\ty0 = __sampleIterator[kIterator]/__img.cols;\n\t\t}\n\t\tkIterator++;\n\t\t\n\t\t// Add padding\n\t\tx0 = x0 + __N;\n\t\ty0 = y0 + __N;\n\t\t \n\t\t// Check mask and value\n\t\tif(__M.at(y0,x0)==0 && G.at(y0,x0) > __meanG)\n\t\t{\n\t\t\t// The sample is (x0, y0)\n\t\t\tcv::Point ptOrig(x0, y0);\n\t\t\tfloat gX = (float)Gx.at(y0,x0);\n\t\t\tfloat gY = (float)Gy.at(y0,x0);\n\t\t\tDIR_POINT dpOrig(ptOrig, gX, gY);\t\t// Since it is computed from Gx, Gy, it is in 1º4º\n\n\t\t\t// Line segment generation\t\n\t\t\tfloat error = 0;\n\t\t\tif(__verbose) { printf(\"-------------------------------\\n\"); }\n\t\t\tif(__verbose) { printf(\"Try dpOrig=(%d,%d,%.2f,%.2f)...\\n\", dpOrig.pt.x, dpOrig.pt.y, dpOrig.vx, dpOrig.vy); }\n\t\t\tint retLS = lineSegmentGeneration(dpOrig, __lSeg, error);\n\n\t\t\tif( (retLS == RET_OK) && error < MAX_ERROR )\n\t\t\t{\n\t\t\t\tif(__verbose) { printf(\"lSeg generated=(%d,%d)->(%d,%d)...\\n\", __lSeg[0].x, __lSeg[0].y, __lSeg[1].x, __lSeg[1].y); }\n\t\t\t\tif(__verbose) { printf(\"-------------------------------\\n\"); }\n\t\t\t\t\n\t\t\t\tlSegs.push_back(__lSeg);\n\t\t\t\terrors.push_back((double)error);\n\t\t\t\t\n\t\t\t\tif(__numMaxLSegs != 0 && lSegs.size() >= (unsigned int)__numMaxLSegs)\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Mark as visited\n\t\t\t\tcv::Rect w(x0-__R, y0 -__R, __N, __N);\n\t\t\t\tcv::Mat roi = __M(w);\n\t\t\t\troi.setTo(255);\t\t\t\t\t\n\t\t\t}\t\t\t\n\t\t}\n\t}\t\n\n\treturn RET_OK;\n}\nint LSWMS::lineSegmentGeneration(const DIR_POINT &dpOrig, LSEG &lSeg, float &error)\n{\n\t// **********************************************\n\t// Starts at dpOrig and generates lSeg\n\t// \n\t// Args:\n\t// \t-> dpOrig - starting DIR_POINT \n\t//\t<- lSeg - detected line segment\n\t// Ret:\n\t// \tRET_OK - lSeg created\n\t// \tRET_ERROR - lSeg not created\n\t// **********************************************\n\t\n\t// Check input data\n\tif(dpOrig.pt.x < 0 || dpOrig.pt.x >= __G.cols || dpOrig.pt.y<0 || dpOrig.pt.y >= __G.rows)\n\t\treturn RET_ERROR;\n\n\t// Find best candidate with Mean-Shift\n\t// -----------------------------------------------------\n\tDIR_POINT dpCentr = dpOrig;\t\n\tif(__verbose)\n\t{\n\t\tprintf(\"\\tMean-Shift(Centr): from (%d,%d,%.2f,%.2f) to...\", dpOrig.pt.x, dpOrig.pt.y, dpOrig.vx, dpOrig.vy);\n\t\tfflush(stdout);\n\t}\n\tint retMSC = weightedMeanShift(dpOrig, dpCentr, __M); /// COMO LE PASO __M, TIENE EN CUENTA SI SE HA VISITADO O NO\n\tif(__verbose) { printf(\" (%d,%d,%.2f, %.2f)\\n\", dpCentr.pt.x, dpCentr.pt.y, dpCentr.vx, dpCentr.vy); }\n\t\t\n\tif(retMSC == RET_ERROR)\t\n\t{\n\t\tif(__verbose) { printf(\"\\tMean-Shift reached not a valid point\\n\"); }\n\t\treturn RET_ERROR;\t\n\t}\n\t\n\t// Grow in two directions from dpCentr\n\t// -----------------------------------------------------\n\tif(__verbose) { printf(\"\\tGROW 1:\"); fflush(stdout); }\n\tcv::Point pt1;\n\tfloat retG1 = grow(dpCentr, pt1, 1);\n\tfloat d1 = (float)((dpCentr.pt.x - pt1.x)*(dpCentr.pt.x - pt1.x) + (dpCentr.pt.y - pt1.y)*(dpCentr.pt.y - pt1.y));\n\tif(__verbose) { printf(\"\\tpt1(%d,%d), dist = %.2f, error=%.4f\\n\", pt1.x, pt1.y, d1, retG1); }\n\t\n\tif(__verbose) { printf(\"\\tGROW 2:\"); fflush(stdout); }\n\tcv::Point pt2;\n\tfloat retG2 = grow(dpCentr, pt2, 2);\n\tfloat d2 = (float)((dpCentr.pt.x - pt2.x)*(dpCentr.pt.x - pt2.x) + (dpCentr.pt.y - pt2.y)*(dpCentr.pt.y - pt2.y));\n\tif(__verbose) { printf(\"\\tpt2(%d,%d), dist = %.2f, error=%.4f\\n\", pt2.x, pt2.y, d2, retG2); }\n\n\tif(retG1 == -1 && retG2 == -1)\n\t\treturn RET_ERROR;\n\n\t// Select the most distant extremum\n\tif(d10)\n\t{\n\t\tdirX = dirX/norm;\n\t\tdirY = dirY/norm;\n\t\t\n\t\tDIR_POINT dpAux(dpCentr.pt, -(-dirY), -dirX);\t// DIR_POINT must be filled ALWAYS with gradient vectors\n\t\tfloat retG = grow(dpAux, pt2, 1);\n\t\terror = retG;\n\t}\n\telse\n\t{\n\t\tpt2 = dpCentr.pt;\t\n\t}\n\t\n\t// Check\n\tdirX = (float)(pt1.x -pt2.x);\n\tdirY = (float)(pt1.y -pt2.y);\n\tif( sqrt(dirX*dirX + dirY*dirY) < __N)\n\t{\n\t\tif(__verbose) { printf(\"Line segment not generated: Too short.\\n\"); }\n\t\treturn RET_ERROR;\n\t}\n\t\n\t// Output line segment\n\tif(__verbose) { printf(\"LSeg = (%d,%d)-(%d,%d)\\n\", pt2.x, pt2.y, pt1.x, pt1.y); }\n\tlSeg.clear();\n\tlSeg.push_back(cv::Point(pt2.x - 2*__R, pt2.y - 2*__R));\n\tlSeg.push_back(cv::Point(pt1.x - 2*__R, pt1.y - 2*__R));\n\t\n\t// Update visited positions matrix\n\tupdateMask(pt1,pt2);\n\treturn RET_OK;\n}\nvoid LSWMS::updateMask(cv::Point pt1, cv::Point pt2)\n{\n\t// Bresenham from one extremum to the other\n\tint x1 = pt1.x, x2 = pt2.x, y1 = pt1.y, y2 = pt2.y;\n\tint dx = ABS(x2-x1);\n\tint dy = ABS(y2-y1);\n\tint sx, sy, err, e2;\n\n\tif(x1 < x2) sx = 1; else sx = -1;\n\tif(y1 < y2) sy = 1; else sy = -1;\n\terr = dx-dy;\n\twhile(true)\n\t{\n\t\t// Current value is (x1,y1)\n\t\t// -------------------------------\n\t\t// Do...\n\t\t// Set window to \"visited=255\"\n\t\tfor(int j=y1-__R; j<=y1+__R; ++j)\n\t\t{\n\t\t\tunsigned char* ptRowM = __M.ptr(j);\n\t\t\tfor(int i=x1-__R; i<=x1+__R; ++i)\t\t\n\t\t\t\tptRowM[i] = 255;\t\t\t\t\n\t\t}\n\t\t// -------------------------------\n\t\t\n\t\t// Check end\n\t\tif (x1 == x2 && y1 == y2) break;\n\n\t\t// Update position for next iteration\n\t\te2 = 2*err;\n\t\tif(e2 > -dy) { err = err - dy; x1 = x1 + sx;}\n\t\tif(e2 < dx) { err = err + dx; y1 = y1 + sy;} \t\n\t}\n}\nint LSWMS::weightedMeanShift(const DIR_POINT &dpOrig, DIR_POINT &dpDst, const cv::Mat &M)\n{\n\t// **********************************************\n\t// Refines dpOrig and creates dpDst\n\t// \n\t// Args:\n\t// \t-> dpOrig - starting DIR_POINT \n\t//\t<- dpDst - refined DIR_POINT\n\t// Ret:\n\t// \tRET_OK - dpDst created\n\t// \tRET_ERROR - dpDst not found\n\t//\n\t// Called from \"lineSegmentGeneration\"\n\t// **********************************************\n\n\t// MAIN LOOP: loop until MS generates no movement (or dead-loop)\n\t__seeds.clear();\n\tDIR_POINT dpCurr = dpOrig;\t// The initial dp is in 1º4º\n\tdpDst = dpOrig;\n\n\twhile(true)\n\t{\n\t\t// Check point\n\t\tif(dpCurr.pt.x < 0 || dpCurr.pt.x >= __G.cols || dpCurr.pt.y<0 || dpCurr.pt.y >= __G.rows)\n\t\t\treturn RET_ERROR;\n\n\t\t// Check direction\n\t\tif(dpCurr.vx==0 && dpCurr.vy == 0)\t\n\t\t\treturn RET_ERROR;\n\n\t\t// Convert to 1º4º (maybe not needed)\n\t\tsetTo14Quads(dpCurr);\n\n\t\t// Check already visited\n\t\tif(!M.empty())\n\t\t{\n\t\t\tif(M.at(dpCurr.pt.y, dpCurr.pt.x) == 255) \n\t\t\t{\n\t\t\t\treturn RET_ERROR;\n\t\t\t}\n\t\t}\n\n\t\t// Check if previously used as seed for this MS-central (this is to avoid dead-loops)\n\t\tfor(unsigned int i=0; i<__seeds.size(); i++)\n\t\t{\n\t\t\tif(__seeds[i].x == dpCurr.pt.x && __seeds[i].y == dpCurr.pt.y)\n\t\t\t{\n\t\t\t\tdpDst = dpCurr;\n\t\t\t\treturn RET_ERROR;\n\t\t\t}\n\t\t}\t\t\n\n\t\t// Define bounds\n\t\tint xMin = dpCurr.pt.x - __R;\n\t\tint yMin = dpCurr.pt.y - __R;\n\t\tint xMax = dpCurr.pt.x + __R;\n\t\tint yMax = dpCurr.pt.y + __R;\n\t\tint offX = __R;\n\t\tint offY = __R;\n\n\t\tif( xMin < 0 || yMin < 0 || xMax >= __G.cols || yMax >= __G.rows)\n\t\t\treturn RET_ERROR;\n\t\t\n\t\t__seeds.push_back(dpCurr.pt);\n\t\t\n\t\t// Define rois\n\t\tcv::Rect roi(xMin, yMin, xMax-xMin+1, yMax-yMin+1);\n\t\tcv::Mat gBlock = cv::Mat(__G, roi);\n\t\tcv::Mat gXBlock = cv::Mat(__Gx, roi);\n\t\tcv::Mat gYBlock = cv::Mat(__Gy, roi);\n\t\tcv::Mat aBlock = cv::Mat(__A, roi);\n\t\tcv::Mat insideBlock = cv::Mat(gBlock.size(), CV_8U); // 0: outside, 1:inside\n\t\tinsideBlock.setTo(1);\n\n\t\t// Update angles (this is to compute angles only once)\n\t\tfor(int j=0; j(j,i) = atan2((float)gYBlock.at(j,i), (float)gXBlock.at(j,i));\n\t\t\t}\n\t\t}\n\n\t\t//if(__verbose) printf(\"dpCurr(%d,%d)(%.2f,%.2f)\\n\", dpCurr.pt.x, dpCurr.pt.y, dpCurr.vx, dpCurr.vy);\n\t\t\t\t\n\t\t//if(__verbose) std::cout << \"gBlock\" << gBlock << endl;\n\t\t//if(__verbose) std::cout << \"gXBlock\" << gXBlock << endl;\n\t\t//if(__verbose) std::cout << \"gYBlock\" << gYBlock << endl;\n\t\t//if(__verbose) std::cout << \"aBlock\" << aBlock << endl;\n\n\t\t// ----------------------------------\n\t\t// Angle analysis\n\t\tfloat currentAngle = atan2(dpCurr.vy, dpCurr.vx);\t// output is between (-CV_PI/2, CV_PI/2)\n\t\t//if(__verbose) printf(\"currentAngle = %.2f\\n\", currentAngle);\n\t\t// ----------------------------------\n\n\t\tfloat angleShift = 0;\n\t\tint outsideCounter = 0;\n\t\tif(currentAngle - __margin < -PI_2)\n\t\t{\n\t\t\t// Shift angles according to currentAngle to avoid discontinuities\t\t\t\n\t\t\t//if(__verbose) printf(\"shift angles since %.2f - %.2f < %.2f\\n\", currentAngle, __margin, -PI_2);\n\t\t\tangleShift = currentAngle;\n\t\t\taBlock = aBlock - currentAngle;\t\n\t\t\tcurrentAngle = 0;\n\t\t\tfloat minAngle = currentAngle - __margin;\n\t\t\tfloat maxAngle = currentAngle + __margin;\n\n\t\t\tfor(int j=0; j(j);\n\t\t\t\tuchar *ptRowGBlock = gBlock.ptr(j);\n\t\t\t\tfor(int i=0; i PI_2) ptRowABlock[i] -= (float)CV_PI;\n\t\t\t\t\tif(ptRowABlock[i] < minAngle || ptRowABlock[i] > maxAngle) \n\t\t\t\t\t{\n\t\t\t\t\t\t//ptRowGBlock[i] = -1;\n\t\t\t\t\t\tinsideBlock.at(j,i) = 0;\n\t\t\t\t\t\toutsideCounter++;\n\t\t\t\t\t}\t\n\t\t\t\t}\n\t\t\t}\t\t\n\t\t\t// Restore\n\t\t\taBlock = aBlock + angleShift;\t\n\n\n\t\t}\n\t\telse if(currentAngle + __margin > PI_2)\n\t\t{\n\t\t\t// Shift angles according to currentAngle to avoid discontinuities\n\t\t\t//if(__verbose) printf(\"shift angles since %.2f + %.2f > %.2f\\n\", currentAngle, __margin, PI_2);\n\t\t\tangleShift = currentAngle;\n\t\t\taBlock = aBlock - currentAngle;\n\t\t\tcurrentAngle = 0;\n\n\t\t\tfloat minAngle = currentAngle - __margin;\n\t\t\tfloat maxAngle = currentAngle + __margin;\n\n\t\t\tfor(int j=0; j(j);\n\t\t\t\tuchar *ptRowGBlock = gBlock.ptr(j);\n\t\t\t\tfor(int i=0; i PI_2) ptRowABlock[i] -= (float)CV_PI;\n\t\t\t\t\tif(ptRowABlock[i] < minAngle || ptRowABlock[i] > maxAngle) \n\t\t\t\t\t{\n\t\t\t\t\t\t//ptRowGBlock[i] = -1;\n\t\t\t\t\t\tinsideBlock.at(j,i) = 0;\n\t\t\t\t\t\toutsideCounter++;\n\t\t\t\t\t}\t\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Restore\n\t\t\taBlock = aBlock + angleShift;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tangleShift = 0;\n\t\t\tfloat minAngle = currentAngle - __margin;\n\t\t\tfloat maxAngle = currentAngle + __margin;\n\t\t\tfor(int j=0; j(j);\n\t\t\t\tuchar *ptRowGBlock = gBlock.ptr(j);\n\t\t\t\tfor(int i=0; i maxAngle) \n\t\t\t\t\t{\n\t\t\t\t\t\t//ptRowGBlock[i] = -1;\n\t\t\t\t\t\tinsideBlock.at(j,i) = 0;\n\t\t\t\t\t\toutsideCounter++;\n\t\t\t\t\t}\t\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t//if(__verbose) std::cout << \"insideBlock\" << insideBlock << endl;\n\t\t//if(__verbose) std::cout << \"aBlock(after computing insideBlock\" << aBlock << endl;\n\n\t\t// Check number of samples inside the bandwidth\n\t\tif(outsideCounter == (2*__R+1)*(2*__R+1))\n\t\t\treturn RET_ERROR;\n\n\t\t// New (Circular) Mean angle (weighted by G)\n\t\tfloat sumWeight = 0;\n\t\tfloat foffX = 0;\n\t\tfloat foffY = 0;\n\t\tfloat meanAngle = 0;\n\t\t\n\t\tfor(int j=0; j(j);\n\t\t\tfloat *ptRowABlock = aBlock.ptr(j);\n\n\t\t\tfor(int i=0; i(j,i) != 0)\n\t\t\t\t{\n\t\t\t\t\t// This sample is inside the Mean-Shift bandwidth\n\t\t\t\t\t// Weighted mean of positons\n\t\t\t\t\tfoffX += (float)(i+1)*ptRowGBlock[i];\t // This cannot be precomputed...\n\t\t\t\t\tfoffY += (float)(j+1)*ptRowGBlock[i];\n\t\t\t\t\t\t\t\n\t\t\t\t\t// Weighted mean of angle\n\t\t\t\t\tmeanAngle += ptRowABlock[i]*ptRowGBlock[i];\n\t\t\t\t\tsumWeight += ptRowGBlock[i];\t\t \n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfoffX /= sumWeight; foffX--;\n\t\tfoffY /= sumWeight; foffY--;\n\t\tmeanAngle /= sumWeight;\n\n\t\t//if(__verbose) printf(\"meanAngle = %.2f\\n\", meanAngle);\n\t\t\t\t\n\t\t// Check convergence (movement with respect to the center)\n\t\tif(cvRound(foffX) == offX && cvRound(foffY) == offY)\n\t\t{\n\t\t\t// Converged. Assign and return.\n\t\t\tdpDst = DIR_POINT(dpCurr.pt, cos(meanAngle), sin(meanAngle));\n\t\t\tsetTo14Quads(dpDst);\n\t\t\treturn RET_OK;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// Not converged: update dpCurr and iterate\n\t\t\tdpCurr.pt.x += cvRound(foffX) - offX;\n\t\t\tdpCurr.pt.y += cvRound(foffY) - offY;\n\t\t\tdpCurr.vx = cos(meanAngle);\n\t\t\tdpCurr.vy = sin(meanAngle);\n\t\t}\n\n\t}\t\n\n\treturn RET_OK;\n}\nfloat LSWMS::grow(const DIR_POINT &dpOrig, cv::Point &ptDst, int dir)\n{\n\t// **********************************************\n\t// Finds end-point ptDst starting from dpOrig\n\t// \n\t// Args:\n\t// \t-> dpOrig - starting DIR_POINT \n\t//\t<- ptDst - end-point\n\t//\t-> dir - growing direction (1(+) or 2(-))\n\t// Ret:\n\t// \terror - error of line segment\n\t//\n\t// Called from lineSegmentGeneration\n\t// **********************************************\t\n\tcv::Point ptEnd1, ptEnd2; //auxiliar\n\tDIR_POINT dpEnd, dpRef;\t // auxiliar\n\n\t// Init output\n\tptDst = dpOrig.pt;\n\n\t// Starting gradient vector and director vector\n\tfloat gX, gY;\n\tif(dir == 1)\n\t{\t\n\t\tgX = dpOrig.vx;\n\t\tgY = dpOrig.vy;\t\t\n\t}\n\telse if(dir == 2)\n\t{\n\t\tgX = -dpOrig.vx;\n\t\tgY = -dpOrig.vy;\n\t}\n\telse return RET_ERROR;\n\n\t// Compute currentAngle in 1º4º\n\tfloat error1 = 0;\n\tfloat growAngle, auxAngle, minAngle, maxAngle, diffAngle;\n\t//if(gX < 0)\t// In this case, direction must not be fliped to 1º4º, because otherwise the sense is lost for the second grow procedure...\n\t//{\n\t//\t// Move to 1º4º\n\t//\tgX = -gX;\n\t//\tgY = -gY;\n\t//}\n\tgrowAngle = atan2(gY, gX);\n\n\t// Starting point and angle - Bresenham\n\tcv::Point pt1 = dpOrig.pt;\n\tcv::Point pt2(pt1.x + (int)(1000*(-gY)), pt1.y + (int)(1000*(gX)));\n\tcv::clipLine(__imPadSize, pt1, pt2);\t\n\t\n\t// Loop\t- Bresenham\n\tint k1=0;\n\t\n\tint x1 = pt1.x, x2 = pt2.x, y1 = pt1.y, y2 = pt2.y;\n\tint dx = ABS(x2-x1);\n\tint dy = ABS(y2-y1);\n\tint sx, sy, err, e2;\n\n\tif(__verbose) { printf(\"From (%d,%d) to (%d,%d)...\", x1, y1, x2, y2); fflush(stdout); }\n\n\tif(x1 < x2) sx = 1; else sx = -1;\n\tif(y1 < y2) sy = 1; else sy = -1;\n\terr = dx-dy;\n\t\n\tint maxNumZeroPixels = 2*__R, countZeroPixels=0;\n\twhile(true)\n\t{\t\t\n\t\t// Current value is (x1,y1)\t\n\t\t//if(__verbose) { printf(\"\\n\\tBresenham(%d,%d)\", x1, y1); fflush(stdout); }\n\t\t// -------------------------------\n\t\t// Do...\n\t\t// Check if angle has been computed\n\t\tif(__A.at(y1,x1) != NOT_A_VALID_ANGLE)\n\t\t\tauxAngle = __A.at(y1,x1);\n\t\telse\n\t\t{\n\t\t\tauxAngle = atan2((float)__Gy.at(y1,x1), (float)__Gx.at(y1,x1));\n\t\t\t__A.at(y1,x1) = auxAngle;\n\t\t}\t\t\n\n\t\t// Check early-termination of Bresenham\t\t\n\t\tif(__G.at(y1,x1) == 0) \n\t\t{\n\t\t\t//if(__verbose) printf(\"Zero-pixel num. %d\\n\", countZeroPixels);\n\t\t\t\n\t\t\tcountZeroPixels++;\n\t\t\tif(countZeroPixels >= maxNumZeroPixels)\n\t\t\t\tbreak;\t\t// No gradient point\n\t\t\t\n\t\t}\n\t\t\n\t\t// Check angular limits\n\t\tif(growAngle - __margin < -PI_2)\t\t // e.g. currentAngle = -80º, margin = 20º\n\t\t{\n\t\t\tminAngle = growAngle - __margin + (float)CV_PI; // e.g. -80 -20 +180 = 80º\n\t\t\tmaxAngle = growAngle + __margin;\t // e.g. -80 +20 =-60º\t\n\n\t\t\tif( auxAngle < 0)\n\t\t\t{\n\t\t\t\tif( auxAngle > maxAngle ) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) > maxAngle(%.2f) && auxAngle < 0\\n\", auxAngle, maxAngle);\n\t\t\t\tdiffAngle = ABS(growAngle - auxAngle);\n\t\t\t}\n\t\t\telse // auxAngle > 0\n\t\t\t{\n\t\t\t\tif( auxAngle < minAngle) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) < minAngle(%.2f) && auxAngle > 0\\n\", auxAngle, minAngle);\n\t\t\t\tdiffAngle = ABS(growAngle - (auxAngle - (float)CV_PI));\n\t\t\t}\t\t\t\n\t\t}\n\t\telse if(growAngle + __margin > PI_2)\t\t // e.g. currentAngle = 80º, margin = 20º\n\t\t{\n\t\t\tminAngle = growAngle - __margin;\t // e.g. 80 -20 = 60º\n\t\t\tmaxAngle = growAngle + __margin - (float)CV_PI; // e.g. 80 +20 -180 = -80º\n\n\t\t\tif( auxAngle > 0 )\n\t\t\t{\n\t\t\t\tif( auxAngle < minAngle) break;\t//if(__verbose) printf(\"Early-termination: auxAngle(%.2f) < minAngle(%.2f) && auxAngle > 0\\n\", auxAngle, minAngle);\n\t\t\t\tdiffAngle = ABS(growAngle - auxAngle);\n\t\t\t}\n\t\t\telse // auxAngle < 0\n\t\t\t{\n\t\t\t\tif( auxAngle > maxAngle) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) > maxAngle(%.2f) && auxAngle < 0\\n\", auxAngle, maxAngle);\n\t\t\t\tdiffAngle = ABS(growAngle - (auxAngle + (float)CV_PI));\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\t\n\t\t\tminAngle = growAngle - __margin;\n\t\t\tmaxAngle = growAngle + __margin;\n\t\t\tif(auxAngle < minAngle || auxAngle > maxAngle) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) < minAngle(%.2f) || > maxAngle(%.2f)\\n\", auxAngle, minAngle, maxAngle);\n\t\t\t\n\t\t\tdiffAngle = ABS(growAngle - auxAngle);\n\t\t}\n\t\t\n\t\t// If arrived here, the point is valid (inside the angular limits, and with G!=0)\n\t\t//error1 += ABS(ABS(__Gx.at(y1,x1)) - ABS(gX)) +\n\t\t//\t ABS(ABS(__Gy.at(y1,x1)) - ABS(gY));\n\t\t//error1 += ABS(auxAngle - growAngle); // OJO, SI HA HABIDO DISCONTINUIDAD, ESTO NO ES CORRECTO...\n\t\terror1 += diffAngle;\n\t\tptEnd1 = cv::Point(x1,y1);\n\t\tk1++;\n\n\t\t// -------------------------------\n\t\t// Check end\n\t\tif (x1 == x2 && y1 == y2) break;\n\n\t\t// Update position for next iteration\n\t\te2 = 2*err;\n\t\tif(e2 > -dy) { err = err - dy; x1 = x1 + sx;}\n\t\tif(e2 < dx) { err = err + dx; y1 = y1 + sy;} \t\t\n\t}\n\n\t// \"k1\": how many points have been visited\n\t// \"ptEnd\": last valid point\n\tif( k1==0 ) // this means that even the closest point has not been accepted\t\n\t{\n\t\tptEnd1 = dpOrig.pt;\n\t\terror1 = (float)CV_PI;\n\t}\t\n\telse error1 /= k1;\n\tif(__verbose) { printf(\", Arrived to (%d,%d), error=%.2f\", ptEnd1.x, ptEnd1.y, error1); fflush(stdout); }\n\t\n\t// Set ptDst\n\tptDst = ptEnd1;\n\n\t// Apply Mean-Shift to refine the end point\t\n\t//if(__verbose) printf(\"Check grow movement: From (%d,%d) to (%d,%d)\\n\", dpOrig.pt.x, dpOrig.pt.y, ptEnd1.x, ptEnd1.y);\t\n\tif(__verbose) { printf(\", Dist = (%d,%d)\\n\", ABS(ptEnd1.x - dpOrig.pt.x), ABS(ptEnd1.y - dpOrig.pt.y)); }\n\tif(ABS(ptEnd1.x - dpOrig.pt.x) > __R || ABS(ptEnd1.y - dpOrig.pt.y) > __R) // ONLY IF THERE HAS BEEN (SIGNIFICANT) MOTION FROM PREVIOUS MEAN-SHIFT MAXIMA\n\t{\t\t\n\t\tint counter = 0;\n\t\twhile(true)\n\t\t{\n\t\t\tif(__verbose) { printf(\"\\tMean-Shift(Ext): from (%d,%d,%.2f,%.2f) to...\", ptEnd1.x, ptEnd1.y, gX, gY); fflush(stdout); }\n\t\t\tcounter++;\n\n\t\t\t// Mean-Shift on the initial extremum\n\t\t\t// -------------------------------------------------------------\n\t\t\tdpEnd.pt = ptEnd1; dpEnd.vx = gX; dpEnd.vy = gY;\t// gX and gY have been update in the last iter\n\t\t\tdpRef.pt = ptEnd1; dpRef.vx = gX; dpRef.vy = gY;\n\t\t\tint retMSExt = weightedMeanShift(dpEnd, dpRef);\n\n\t\t\tif(__verbose) { printf(\"(%d,%d,%.2f,%.2f)\\n\", dpRef.pt.x, dpRef.pt.y, dpRef.vx, dpRef.vy); }\n\n\t\t\tif(retMSExt == RET_ERROR)\n\t\t\t{\n\t\t\t\t// The refinement gave and incorrect value, keep last Bresenham value\n\t\t\t\tptDst = ptEnd1;\n\t\t\t\treturn RET_OK;\n\t\t\t}\n\t\t\t\n\n\t\t\t// Check motion caused by Mean-Shift\n\t\t\tif(dpRef.pt.x == dpEnd.pt.x && dpRef.pt.y == dpEnd.pt.y)\n\t\t\t{\n\t\t\t\tptDst = dpRef.pt;\n\t\t\t\treturn RET_OK;\n\t\t\t}\n\n\t\t\t// Check displacement from dpOrig\n\t\t\tgX = (float)(dpRef.pt.y - dpOrig.pt.y);\t// \tfloat dX = dpRef.x - dpOrig.x; and gX = dY;\n\t\t\tgY = (float)(dpOrig.pt.x - dpRef.pt.x);\t//\tfloat dY = dpRef.y - dpOrig.y; and gY = -dX;\n\t\t\tif(gX == 0 && gY == 0)\n\t\t\t{\t\n\t\t\t\tptDst = dpRef.pt;\n\t\t\t\treturn RET_OK;\n\t\t\t}\n\t\t\tfloat norm = sqrt(gX*gX + gY*gY);\n\t\t\tgX /= norm;\n\t\t\tgY /= norm;\t\n\n\t\t\t// New Bresenham procedure\t\n\t\t\tif(gX < 0)\n\t\t\t{\n\t\t\t\t// MOve to 1º4º\n\t\t\t\tgX = -gX;\n\t\t\t\tgY = -gY;\n\t\t\t}\n\t\t\tgrowAngle = atan2(gY, gX);\n\n\t\t\tint k2=0;\n\t\t\tfloat error2 = 0;\n\n\t\t\tpt2.x = pt1.x + (int)(1000*(-gY)); pt2.y = pt1.y + (int)(1000*(gX));\n\n\t\t\tx1 = pt1.x; x2 = pt2.x; y1 = pt1.y; y2 = pt2.y;\n\t\t\tdx = ABS(x2-x1);\t\n\t\t\tdy = ABS(y2-y1);\n\n\t\t\tif(x1 < x2) sx = 1; else sx = -1;\n\t\t\tif(y1 < y2) sy = 1; else sy = -1,\n\t\t\terr = dx-dy;\n\n\t\t\tif(__verbose) { printf(\"\\tRefined GROW: From (%d,%d) to (%d,%d)...\", x1, y1, x2, y2); fflush(stdout); }\n\t\t\twhile(true)\n\t\t\t{\n\t\t\t\t// Current value is (x1,y1)\t\n\t\t\t\t//if(__verbose) { printf(\"\\n\\tBresenham(%d,%d)\", x1, y1); fflush(stdout); }\n\t\t\t\t\n\t\t\t\t// -------------------------------\n\t\t\t\t// Do...\n\t\t\t\t// Check if angle has been computed\n\t\t\t\tif(__A.at(y1,x1) != NOT_A_VALID_ANGLE)\n\t\t\t\t\tauxAngle = __A.at(y1,x1);\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tauxAngle = atan2((float)__Gy.at(y1,x1), (float)__Gx.at(y1,x1));\n\t\t\t\t\t__A.at(y1,x1) = auxAngle;\n\t\t\t\t}\n\n\t\t\t\t// Check early-termination of Bresenham\t\t\n\t\t\t\tif(__G.at(y1,x1) == 0) \n\t\t\t\t{\n\t\t\t\t\t//if(__verbose) printf(\"Zero-pixel num. %d\\n\", countZeroPixels);\n\t\t\t\n\t\t\t\t\tcountZeroPixels++;\n\t\t\t\t\tif(countZeroPixels >= maxNumZeroPixels)\n\t\t\t\t\t\tbreak;\t\t// No gradient point\t\t\t\n\t\t\t\t}\n\t\t\n\t\t\t\t// Check angular limits\n\t\t\t\tif(growAngle - __margin < -PI_2)\t\t // e.g. currentAngle = -80º, margin = 20º\n\t\t\t\t{\n\t\t\t\t\tminAngle = growAngle - __margin + (float)CV_PI; // e.g. -80 -20 +180 = 80º\n\t\t\t\t\tmaxAngle = growAngle + __margin;\t // e.g. -80 +20 =-60º\t\n\n\t\t\t\t\tif( auxAngle < 0)\n\t\t\t\t\t{\n\t\t\t\t\t\tif( auxAngle > maxAngle ) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) > maxAngle(%.2f) && auxAngle < 0\\n\", auxAngle, maxAngle);\n\t\t\t\t\t\tdiffAngle = ABS(growAngle - auxAngle);\n\t\t\t\t\t}\n\t\t\t\t\telse // auxAngle > 0\n\t\t\t\t\t{\n\t\t\t\t\t\tif( auxAngle < minAngle) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) < minAngle(%.2f) && auxAngle > 0\\n\", auxAngle, minAngle);\n\t\t\t\t\t\tdiffAngle = ABS(growAngle - (auxAngle - (float)CV_PI));\n\t\t\t\t\t}\t\t\t\n\t\t\t\t}\n\t\t\t\telse if(growAngle + __margin > PI_2)\t\t // e.g. currentAngle = 80º, margin = 20º\n\t\t\t\t{\n\t\t\t\t\tminAngle = growAngle - __margin;\t // e.g. 80 -20 = 60º\n\t\t\t\t\tmaxAngle = growAngle + __margin - (float)CV_PI; // e.g. 80 +20 -180 = -80º\n\n\t\t\t\t\tif( auxAngle > 0 )\n\t\t\t\t\t{\n\t\t\t\t\t\tif( auxAngle < minAngle) break;\t//if(__verbose) printf(\"Early-termination: auxAngle(%.2f) < minAngle(%.2f) && auxAngle > 0\\n\", auxAngle, minAngle);\n\t\t\t\t\t\tdiffAngle = ABS(growAngle - auxAngle);\n\t\t\t\t\t}\n\t\t\t\t\telse // auxAngle < 0\n\t\t\t\t\t{\n\t\t\t\t\t\tif( auxAngle > maxAngle) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) > maxAngle(%.2f) && auxAngle < 0\\n\", auxAngle, maxAngle);\n\t\t\t\t\t\tdiffAngle = ABS(growAngle - (auxAngle + (float)CV_PI));\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\t\n\t\t\t\t\tminAngle = growAngle - __margin;\n\t\t\t\t\tmaxAngle = growAngle + __margin;\n\t\t\t\t\tif(auxAngle < minAngle || auxAngle > maxAngle) break; //if(__verbose) printf(\"Early-termination: auxAngle(%.2f) < minAngle(%.2f) || > maxAngle(%.2f)\\n\", auxAngle, minAngle, maxAngle);\n\t\t\t\n\t\t\t\t\tdiffAngle = ABS(growAngle - auxAngle);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\terror2 += diffAngle;\n\t\t\t\tptEnd2 = cv::Point(x1,y1);\n\t\t\t\tk2++;\n\t\t\t\t\n\t\t\t\t// -------------------------------\n\n\t\t\t\t// Check end\n\t\t\t\tif (x1 == x2 && y1 == y2) break;\n\n\t\t\t\t// Update position for next iteration\n\t\t\t\te2 = 2*err;\n\t\t\t\tif(e2 > -dy) { err = err - dy; x1 = x1 + sx;}\n\t\t\t\tif(e2 < dx) { err = err + dx; y1 = y1 + sy;} \t\t\n\t\t\t} // Bresenham while\n\n\t\t\t\n\t\t\t// \"k2\": how many points have been visited\n\t\t\t// \"ptEnd2\": last valid point\n\t\t\tif( k2==0 ) // this means that even the closest point has not been accepted\t\n\t\t\t{\n\t\t\t\tptEnd2 = dpOrig.pt;\n\t\t\t\terror2 = (float)CV_PI;\n\t\t\t}\t\n\t\t\telse error2 = error2 / k2;\t\t\t\n\n\t\t\tfflush(stdout);\t// Don't really know why, but this is necessary to avoid dead loops...\n\t\t\tif(__verbose) { printf(\", Arrived to (%d,%d), error=%.2f\", ptEnd2.x, ptEnd2.y, error2); fflush(stdout); }\n\t\t\tif(__verbose) { printf(\", Dist = (%d,%d)\\n\", ABS(ptEnd2.x - dpOrig.pt.x), ABS(ptEnd1.y - dpOrig.pt.y)); }\n\n\t\t\t// Compare obtained samples\n\t\t\tif(error1 <= error2)\n\t\t\t{\n\t\t\t\tptDst = ptEnd1;\n\t\t\t\treturn error1;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Update ptEnd1 with ptEnd2 because it is better and iterate\n\t\t\t\tptEnd1 = ptEnd2;\n\t\t\t\tk1 = k2;\n\t\t\t\terror1 = error2;\n\t\t\t}\t\t\n\t\t} // Mean-Shift while\n\t}\n\t//else if(__verbose)\n\t//\tprintf(\"Not enough movement\\n\");\n\n\t//return RET_OK;\n\treturn error1;\n}\n\nvoid LSWMS::setPaddingToZero(cv::Mat &img, int NN)\n{\n\tcv::rectangle(img, cv::Point(0,0), cv::Point(img.cols-1, NN-1), cv::Scalar(0), CV_FILLED);\n\tcv::rectangle(img, cv::Point(0,0), cv::Point(NN-1, img.rows-1), cv::Scalar(0), CV_FILLED);\n\tcv::rectangle(img, cv::Point(0,img.rows-NN), cv::Point(img.cols-1, img.rows-1), cv::Scalar(0), CV_FILLED);\n\tcv::rectangle(img, cv::Point(img.cols-NN,0), cv::Point(img.cols-1, img.rows-1), cv::Scalar(0), CV_FILLED);\n}\nvoid LSWMS::drawLSegs(cv::Mat &img, std::vector &lSegs, cv::Scalar color, int thickness)\n{\n\tfor(unsigned int i=0; i &lSegs, std::vector &errors, int thickness)\n{\n\tstd::vector colors;\n\tcolors.push_back(CV_RGB(255,0,0));\n\tcolors.push_back(CV_RGB(200,0,0));\n\tcolors.push_back(CV_RGB(150,0,0));\n\tcolors.push_back(CV_RGB(50,0,0));\n\n\tfor(unsigned int i=0; i LSEG;\ntypedef struct _DIR_POINT\n{\n\tcv::Point pt;\n\tfloat vx;\n\tfloat vy;\n\n\t_DIR_POINT(cv::Point _pt, float _vx, float _vy)\n\t{\n\t\tpt = _pt;\n\t\tvx = _vx;\n\t\tvy = _vy;\n\t};\n\t_DIR_POINT()\n\t{\t\n\t\tpt = cv::Point(0,0);\n\t\tvx = 0;\n\t\tvy = 0;\n\t}\n}DIR_POINT;\n\nclass LSWMS\n{\n\nprivate:\n\t//Verbose\n\tbool __verbose;\t\n\t\n\t// Sizes\n\tcv::Size __imSize, __imPadSize;\n\tint __imWidth, __imHeight;\n\n\t// Window parameters\t\n\tint __R, __N;\n\n\t// Line Segments\t\n\tLSEG __lSeg;\n\tint __numMaxLSegs;\n\n\t// Images and maps\n\tcv::Mat __img, __imgPad;\n\tcv::Rect __roiRect;\n\tcv::Mat __imgPadROI;\n\tcv::Mat __G, __Gx, __Gy;\t// Map of probability of line segments\n\tcv::Mat __M;\t\t\t// Map of visited pixels\n\tcv::Mat __A;\t\t\t// Map of angles\n\n\tcv::Mat __imAux;\t\t// For debugging\n\n\t// Thresholds and variables\n\tint __meanG;\n\tstd::vector __sampleIterator;\n\tfloat __margin;\n\n\t// Mean-Shift central\n\tstd::vector __seeds;\n\t\n\t// Functions\n\tvoid setPaddingToZero(cv::Mat &img, int NN);\n\tvoid updateMask(cv::Point pt1, cv::Point pt2);\n\n\t// SOBEL-specific functions\n\tint computeGradientMaps(const cv::Mat &img, cv::Mat &G, cv::Mat &Gx, cv::Mat &Gy);\n\n\t// General functions\n\tint findLineSegments(const cv::Mat &G, const cv::Mat &Gx, const cv::Mat &Gy, cv::Mat &A, cv::Mat &M, std::vector &lSegs, std::vector &errors);\n\tint lineSegmentGeneration(const DIR_POINT &dpOrig, LSEG &lSeg, float &error);\n\n\t// Growing and Mean-Shift\n\tfloat grow(const DIR_POINT &dpOrig, cv::Point &ptDst, int dir);\n\tint weightedMeanShift(const DIR_POINT &dpOrig, DIR_POINT &dpDst, const cv::Mat &M=cv::Mat());\n\npublic:\n\tLSWMS(const cv::Size imSize, const int R, const int numMaxLSegs=0, bool verbose=false);\n\tint run(const cv::Mat &img, std::vector &lSegs, std::vector &errors);\n\tvoid drawLSegs(cv::Mat &img, std::vector &lSegs, cv::Scalar color=CV_RGB(255,0,0), int thickness=1);\n\tvoid drawLSegs(cv::Mat &img, std::vector &lSegs, std::vector &errors, int thickness=1);\n\n};\n\n#endif // __LSWMS_H__\n"
},
{
"path": "thirdparty/LSWMS/main.cpp",
"content": "/*\n * Project: lineSegments (LSWMS Line Segment using Weighted Mean-Shift)\n *\n * File: main.cpp\n *\n * Contents: Creation, initialisation and usage of LSWMS object\n * for the detection of line segments in images or videos\n *\n * Author: Marcos Nieto \n *\n * Homepage: www.marcosnieto.net\n */\n\n#ifdef WIN32\n\t#include \n\t#include \n#endif\n\n#ifdef linux\n\t#include \n\t#include \n\t#include \n#endif\n\n#include \n\n#include \"opencv2/core/core.hpp\"\n#include \"opencv2/highgui/highgui.hpp\"\n#include \"opencv2/imgproc/imgproc.hpp\"\n\n#include \"LSWMS.h\"\n\nusing namespace std;\nusing namespace cv;\n\n// Timing\n#ifdef WIN32\n\tdouble t1, t2;\t\n#else\n\tint t1, t2;\t\n\tstruct timeval ts;\n#endif\ndouble t;\n\nvoid help()\n{\n\t cout << \"/*\\n\"\n << \" **************************************************************************************************\\n\"\n\t\t << \" * Line segment detection using WMS \\n\"\n << \" * ----------------------------------------------------\\n\"\t\t \n\t\t << \" * \\n\"\n\t\t << \" * Author:Marcos Nieto\\n\"\n\t\t << \" * www.marcosnieto.net\\n\"\n\t\t << \" * marcos.nieto.doncel@gmail.com\\n\"\n\t\t << \" * \\n\"\n\t\t << \" * Date:01/04/2012\\n\"\n\t\t << \" **************************************************************************************************\\n\"\n\t\t << \" * \\n\"\n\t\t << \" * Usage: \\n\"\t\t \t\t \n\t\t << \" *\t\t-video\t\t# Specifies video file as input (if not specified, camera is used) \\n\"\n\t\t << \" *\t\t-image\t\t# Specifies image file as input (if not specified, camera is used) \\n\"\n\t\t << \" *\t\t-verbose\t# Actives verbose: ON, OFF (default)\\n\"\n\t\t << \" *\t\t-play\t\t# ON: the video runs until the end; OFF: frame by frame (key press event)\\n\"\n\t\t << \" *\t\t-resizedWidth\t# Specifies the desired width of the image (the height is computed to keep aspect ratio)\\n\"\n\t\t << \" *\t\t-numMaxLSegs\t# Specifies the maximum number of line segments to detected.\\n\"\t\t \n\t\t << \" *\\n\"\n\t\t << \" * \t-hough\t\t# ON: Applies OpenCV HoughLinesP for comparison (PPHT)\\n\"\n\t\t << \" *\\n\"\n\t\t << \" * Example:\\n\"\n\t\t << \" *\t\tlineSegment -video myVideo.avi -verbose ON -play OFF\\n\"\n\t\t << \" *\t\tlineSegment -image myImage.jpg -resizedWidth 300 -numMaxLSegs 100\\n\"\n\t\t << \" *\t\tlineSegment -image myImage.jpg -hough ON\\n\"\n\t\t << \" * \\n\"\n\t\t << \" * Keys:\\n\"\n\t\t << \" *\t\tEsc: Quit\\n\"\n << \" */\\n\" << endl;\n}\nvoid processPPHT(cv::Mat &img, std::vector &lSegs)\n{\n\tcv::Mat imgGRAY;\n\tcv::cvtColor(img, imgGRAY, CV_RGB2GRAY);\n\tcv::Mat dst;\n\tcv::Canny(imgGRAY, dst, 20, 80, 3);\n\tstd::vector lines;\n\tcv::HoughLinesP(dst, lines, 1, CV_PI/180, 80, 30, 10);\n\n\tLSEG lSeg;\n\tcv::Point p1, p2;\n\n\tlSegs.clear();\n\n\tfor(size_t i=0; i &lSegs, cv::Scalar color)\n{\n\tfor(size_t i=0; i lSegs, lSegsPPHT;\n\tstd::vector errors;\n\n\t// Start showing help\n\thelp();\n\n\t// Parse arguments\n\tif(argc < 2)\n\t\treturn -1;\t\n\tfor(int i=1; i> inputImg;\n\t\t}\t\n\t\telse\n\t\t{\n\t\t\tprintf(\"-------------------------\\n\");\n\t\t}\t\n\n\t\tif( inputImg.empty() )\n\t\t\tbreak;\n\t\t\n\t\t// Resize to processing size\n\t\tcv::resize(inputImg, inputImg, procSize);\t\t\n\n\t\t// Color Conversion\n\t\tif(inputImg.channels() == 3)\n\t\t{\n\t\t\tcv::cvtColor(inputImg, imgGRAY, CV_BGR2GRAY);\t\n\t\t\tinputImg.copyTo(outputImg);\n\t\t\tif(usePPHT)\n\t\t\t\tinputImg.copyTo(outputImgPPHT);\t\t\t\n\t\t}\n\t\telse\n\t\t{\n\t\t\tinputImg.copyTo(imgGRAY);\n\t\t\tcv::cvtColor(inputImg, outputImg, CV_GRAY2BGR);\n\t\t\tif(usePPHT)\n\t\t\t\tcv::cvtColor(inputImg, outputImgPPHT, CV_GRAY2BGR);\t\t\t\n\t\t}\n\n\t\t// ++++++++++++++++++++++++++++++++++++++++\n\t\t// Process LSWMS\n\t\t#ifdef WIN32\n\t\t\tt1 = ::GetTickCount();\n\t\t#else\n\t\t\tgettimeofday(&ts,0);\n\t\t\tt1 = (ts.tv_sec * 1000 + (ts.tv_usec / 1000));\n\t\t#endif\n\t\tlswms.run(inputImg, lSegs, errors);\t\t\t\t\n\t\t#ifdef WIN32\n\t\t\tt2 = ::GetTickCount();\n\t\t#else\n\t\t\tgettimeofday(&ts,0);\n\t\t\tt2 = (ts.tv_sec * 1000 + (ts.tv_usec / 1000));\n\t\t#endif\t\n\n\t\t// process time = t2 - t1\t\t\n\t\tt = (double)t2-(double)t1;\n\n\t\tcv::Scalar mean, stddev;\n\t\tcv::meanStdDev(errors, mean, stddev);\n\t\tif(!stillImage)\n\t\t\tprintf(\"Fr.#%d - LSWMS: %d lines / %.0f ms , Ang.Error: (Mean, Std)=(%.2f, %.2f)(deg)\\n\", frameNum, lSegs.size(), t, mean.val[0]*180/CV_PI, stddev.val[0]*180/CV_PI);\n\t\telse\n\t\t\tprintf(\"LSWMS: %d segments\\nAngular Error: Mean = %.2f (deg), Std = %.2f (deg)\\nProcess Time = %.0f (ms)\\n\", lSegs.size(), mean.val[0]*180/CV_PI, stddev.val[0]*180/CV_PI, t);\n\t\t\n\t\t//lswms.drawLSegs(outputImg, lSegs,CV_RGB(255,0,0), 2);\t\t\t// drawing all line segments the same\n\t\tlswms.drawLSegs(outputImg, lSegs, errors);\t\t\t\t// drawing according to errors\n\t\t// ++++++++++++++++++++++++++++++++++++++++\t\t\t\t\n\n\t\t// ++++++++++++++++++++++++++++++++++++++++\t\t\t\t\n\t\tif(usePPHT)\n\t\t{\n\t\t\t// Process PPHT\n\t\t\t#ifdef WIN32\n\t\t\t\tt1 = ::GetTickCount();\n\t\t\t#else\n\t\t\t\tgettimeofday(&ts,0);\n\t\t\t\tt1 = (ts.tv_sec * 1000 + (ts.tv_usec / 1000));\n\t\t\t#endif\n\t\t\tprocessPPHT(inputImg, lSegsPPHT);\t\t\t\t\n\t\t\t#ifdef WIN32\n\t\t\t\tt2 = ::GetTickCount();\n\t\t\t#else\n\t\t\t\tgettimeofday(&ts,0);\n\t\t\t\tt2 = (ts.tv_sec * 1000 + (ts.tv_usec / 1000));\n\t\t\t#endif\n\n\t\t\t// process time = t2 - t1\t\t\n\t\t\tt = (double)t2-(double)t1;\n\n\t\t\tdrawPPHT(outputImgPPHT, lSegsPPHT, CV_RGB(0,0,255));\n\n\t\t\tif(!stillImage)\n\t\t\t\tprintf(\"Fr.#%d - PPHT: %d lines / %.0f ms\\n\", frameNum, lSegsPPHT.size(), t);\n\t\t\telse\n\t\t\t\tprintf(\"\\nPPHT: %d segments\\nProcess Time = %.0f (ms)\\n\", lSegsPPHT.size(), t);\n\t\t\t// ++++++++++++++++++++++++++++++++++++++++\t\n\t\t}\n\n\t\t// View\n\t\timshow(\"LSWMS\", outputImg);\t\n\t\tif(usePPHT)\n\t\t\timshow(\"PPHT\", outputImgPPHT);\n\n\t\tif(stillImage)\n\t\t{\n\t\t\tcv::imwrite(\"lswms.bmp\", outputImg);\n\t\t\tif(usePPHT)\n\t\t\t\tcv::imwrite(\"ppht.bmp\", outputImgPPHT);\n\t\t}\n\t\t\n\n\t\tif(playMode)\n\t\t\tcv::waitKey(1);\n\t\telse\n\t\t\tcv::waitKey(0);\n\n\t\tchar q = (char)waitKey(1);\n\t\n\t\tif( q == 27 )\n\t\t{\n\t\t\tprintf(\"\\nStopped by user request\\n\");\n\t\t\tbreak;\n\t\t}\t\n\n\t\tif(stillImage)\n\t\t\tbreak;\n\t} // main while\n\n\tif(!stillImage)\n\t\tvideo.release();\n\t\n\treturn 0;\n\n\n\n}\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/Readme.txt",
"content": "many function in the line segmentation algorithm were mex file, if you are using\nwindows or linux system, please recompile following c code into mex file.\n mexRemoveVotes_v3_scale.c\n mexVoteEdges_v3_scale.c\n the c code can be compiled by command\n mex xxxxxxxxx.c\n\nPlease use matlab coder to compile following .m file into mex file:\n hmmParameters.m\n returnLines.m\n sampleLine.m\n the matlab coder is an app in matlab to automatically compile .m code into mex file,\n The entry point for the code is demo_start_v2.m. The instruction is in following\n select No for \"Does this code use global variables?\"\n\nThe input variable type should be configurated in following\n sampleLine.m\n rho double(1x1)\n theta double(1x1)\n m double(1x1)\n n double(1x1)\n pp double(1x2)\n\n returnLines.m\n points_proj double(:infx2)\n final_labels double(1x:inf)\n\n hmmParameters.m\n exist_edge_on double(1x40)\n exist_edge_off double(1x40)\n ang_dev_on double(1x181)\n ang_dev_off double(1x181)\n node_idx double(:infx1)\n Psi_t double(2x2)\n pi_var double(2x1)\n y_h double(:infx1)\n distances double(:infx1)\n range_dis double(1x40)\n nexist_edge_on double(1x40)\n nexist_edge_off double(1x40)\n prob_on double(1x1)\n prob_off double(1x1)\n prob_stay_on double(1x1)\n prob_leave_off double(1x1)\n prob_leave_on double(1x1)\n prob_stay_off double(1x1)\n ang_dev double(:infx1)\n range_ang double(1x181)\n\n 4. Select MEX as output format also remove the _mex ending in the output file name section\n for example if you are compiling sampleLine.m, output the file name as sampleLine instead of sampleLine_mex\n\nthe line segment detector has two steps\n1. compute the kernel for the image size\n you only need to compute the kernal once for one an image size\n [kernels, kernels_flip, kernel_params] =kernelInitialization(img);\n the kernels, kernels_flip, kernel_params are the kernel parameter for the line segment algorithm below\n2. line segment detection\n [lines, fullLines] =lineSegmentation_HighRes(img,kernels, kernels_flip, kernel_params);\n the lines variable contains the detected line segmentations it arranged as\n [x1 y1 x2 y2 probability]\n The fullLines are the detected lines. It is arranged as [rho theta probability]\n\n please run the demo_start_v2.m for demonstration\n\n the code in Evaluation Code.zip are line evaluation algorithms\n run_create_contours_MCMLSD.m is the algorithm to get line segment statistics for\n MCMLSD, you can modify it to process other line segment detection algorithms\n\n run_eval_PR_4Methods.m and run_eval_PR.m process the statistical information from\n the run_create_contours_MCMLSD.m result and perform evaluations\n\n run_plot_PR.m and run_plot_PR4Methods.m plot the results in a graph\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/checkInParam.m",
"content": "function [out] = checkInput(img1,g1_mag1,g1_dir1,g1_sc1,g2_mag1,g2_sc1,g2_all1,noise1,...\n EDGE_W1,subpixelflag1,maxscale1)\n \nload('input.mat');\nout = 0;\nif ~isequal(img1, img)\n display('error img');\n out = out + 1;\nend\nif ~isequal(g1_mag1, g1_mag)\n display('error g1_mag');\n out = out + 1;\nend\nif ~isequal(g1_dir1, g1_dir)\n display('error g1_dir');\n out = out + 1;\nend\nif ~isequal(g1_sc1, g1_sc)\n display('error g1_sc');\n out = out + 1;\nend\nif ~isequal(g2_mag1, g2_mag)\n display('error g2_mag');\n out = out + 1;\nend\nif ~isequal(g2_sc1, g2_sc)\n display('error g2_sc');\n out = out + 1;\nend\nif ~isequal(g2_all1, g2_all)\n display('error g2_all');\n out = out + 1;\nend\nif noise1 ~= noise\n display('error noise'); \n out = out + 1;\nend\nif EDGE_W1 ~= edgew\n display('error EDGE_W'); \n out = out + 1;\nend\nif subpixelflag1 ~= subpixelflag\n display('error subpixelflag');\n out = out + 1;\nend\nif maxscale1 ~= scale\n display('error scale'); \n out = out + 1;\nend\n \nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/checkOutParam.m",
"content": "function [out] = checkOutParam(edge_map1,blur_map1,dark_map1,light_map1,...\n xzero1_map1,yzero1_map1,xzero2_map1,yzero2_map1) \n \nload('output.mat');\nout = 0;\nif ~isequal(edge_map1, edge_map)\n display('error edge_map');\n out = out + 1;\nend\nif ~isequal(blur_map1, blur_map)\n display('error blur_map');\n out = out + 1;\nend\nif ~isequal(dark_map1, dark_map)\n display('error dark_map');\n out = out + 1;\nend\nif ~isequal(light_map1, light_map)\n display('error light_map');\n out = out + 1;\nend\nif ~isequal(xzero1_map1, xzero1_map)\n display('error xzero1_map');\n out = out + 1;\nend\nif ~isequal(yzero1_map1, yzero1_map)\n display('error yzero1_map');\n out = out + 1;\nend\nif ~isequal(xzero2_map1, xzero2_map)\n display('error xzero2_map');\n out = out + 1;\nend\nif ~isequal(yzero2_map1, yzero2_map)\n display('error yzero2_map');\n out = out + 1;\nend \n\nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/check_save_requirements.m",
"content": "function[sfilenames] = check_save_requirements(save_flags,outputdir,etype);\n\n name1 = ['edge',etype];\n sfilenames = {name1,'blur.mat','dark.mat','light.mat',...\n 'g1mag.mat','g1dir.mat','g1scale.mat','g2mag.mat','g2scale.mat',...\n 'xzero1.mat','yzero1.mat','xzero2.mat','yzero2.mat'};\n \n\tif any(save_flags)\n \n % Output directory does not exist:\n if ((exist(outputdir) ~= 7) & (length(outputdir) ~= 0))\n mkdir(outputdir); % Create this directory \n mess1 = 'Requested output directory has been created.';\n uiwait(msgbox(mess1,'Output Directory Creation','none','modal'));\n end;\n \n if (length(outputdir) == 0)\n outputdir = 'tmp_output';\n opmessage = ['Output directory name not specified. ',...\n 'Files will be saved in directory \"tmp_output\".'];\n uiwait(msgbox(opmessage,'Output Directory Warning','warn','modal'));\n if (exist(outputdir) ~= 7)\n mkdir(outputdir);\n end;\n end;\n \n filestosave = sfilenames(find(save_flags));\n \n x = dir(outputdir);\n xx = {x.name}';\n commonfiles = intersect(filestosave,xx);\n \n if ~isempty(commonfiles)\n maxnumx = 0;\n for k = 1:1:length(xx)\n y = xx{k};\n numx = 0;\n if (length(y)>4)\n if (y(end-4)=='x')\n numx = sum(y=='x');\n end;\n end;\n if (numx > maxnumx)\n maxnumx = numx;\n end;\n end;\n assignin('base','maxnumx',maxnumx+1);\n assignin('base','commonfiles',commonfiles);\n \n% uiwait(outputdir_erase_info); % Call GUI\n% \n% changename_flag = evalin('base','changename_flag;');\n% \n% if changename_flag\n% repx = repmat('x',1,maxnumx+1);\n% for k = 1:1:length(sfilenames)\n% s = sfilenames{k};\n% s = [s(1:end-4),repx,s(end-3:end)];\n% sfilenames{k} = s;\n% end;\n% end;\n \n evalin('base','clear changename_flag maxnumx commonfiles;'); \n end; \n end;\n \n for k = 1:1:length(sfilenames)\n s = sfilenames{k};\n s = [outputdir,'/',s];\n sfilenames{k} = s;\n end;\n \nreturn;"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/convolve_2.m",
"content": "\n%##############################################################\n%\n% [cimg] = convolve_2(mimg,filt,bc)\n% \n% Convolution of two matrices with the boundaries handled \n% depending on the value of the boundary condition variable.\n% - 0 for extension convolution\n% - 1 for no overlap convolution \n%\n%##############################################################\n\nfunction[cimg] = convolve_2(mimg,filt,bc)\n\nif (bc == 0)\n \n pad_img = pad_matrix(mimg,size(filt));\n cimg = conv2(pad_img,filt,'same');\n cimg = trim_matrix(cimg,size(filt));\n \nelse\n \n cimg = conv2(mimg,filt,'same');\n\n if (size(filt,1) < size(filt,2))\n k = floor(0.5*length(filt));\n cimg(:,1:k) = 0;\n cimg(:,end-k+1:end) = 0;\n else\n k = floor(0.5*length(filt));\n cimg(1:k,:) = 0;\n cimg(end-k+1:end,:) = 0;\n end;\n \nend;\n\nreturn;\n \n\n%########################\n% Function to pad matrix:\n%########################\nfunction[r] = pad_matrix(m,d)\n\n\tif (d(1) < d(2))\n k = floor(0.5*d(2));\n ad1 = repmat(m(:,1),1,k);\n ad2 = repmat(m(:,end),1,k);\n r = [ad1 m ad2];\n\telse\n k = floor(0.5*d(1));\n ad1 = repmat(m(1,:),k,1);\n ad2 = repmat(m(end,:),k,1);\n r = [ad1; m; ad2];\n\tend;\n\nreturn;\n\n\n%#########################\n% Function to trim matrix:\n%#########################\nfunction[r] = trim_matrix(m,d)\n\n\tif (d(1) < d(2))\n k = floor(0.5*d(2));\n r = m(:,k+1:end-k);\n\telse\n k = floor(0.5*d(1));\n r = m(k+1:end-k,:);\n\tend;\n\nreturn;"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/d2gauss.m",
"content": "%################################################################\n%\n% d2gauss.m returns a 2-d Gaussian filter with kernal attributes:\n% size: n1*n2 \n% theta: CCW-angle tkernat filter rotated\n% sigma1: standard deviation of 1st gaussian\n% sigma2: standard deviation of 2nd gaussian\n%\n%################################################################\n\nfunction[kern] = d2gauss(n1,std1,n2,std2,theta,max1);\n\n[I,J] = meshgrid(1:1:n2,1:1:n1);\nIt = I - (n2+1)/2;\nJt = J - (n1+1)/2;\n\nu1 = cos(theta)*Jt' - sin(theta)*It';\nu2 = sin(theta)*Jt' + cos(theta)*It';\n\nkern = gauss(u1,std1) .* gauss(u2,std2);\n\n%############################################\n% Normalise the kernal and confine to limits:\n%############################################\nkern = kern / sqrt(sum(sum(kern.*kern)));\nmax2 = max(max(kern));\nkern = kern / (max2/max1);\n\nreturn;"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/derivative2nd.m",
"content": "%############################################################\n% \n% derivative2nd(g1dir,maxscale,noise,gauss_a,conv_type,fpath)\n%\n%############################################################\n\nfunction[g2mag,g2sc,g2all] = derivative2nd(g1dir,maxscale,noise,...\n gauss_a,conv_type);\n\nfm2 = '.ascii';\n\n%############\n% Initialise:\n%############\ng2mag = 0;\ng2sc = 0;\nnrows = size(g1dir,1);\ng2all = zeros(maxscale*nrows,size(g1dir,2));\n\nfor scale = 1:1:maxscale\n \n %#############################\n % Set scale value for filters:\n %#############################\n if (scale == 1)\n g2scaleval = '05';\n else\n g2scaleval = '1';\n end;\n \n mimg = gauss_a(:,:,scale);\n \n %kern1 = load(strcat(fpath,filesep,'gx',g2scaleval,fm2));\n kern1 = load(strcat('gx',g2scaleval,fm2));\n rc1 = convolve_2(mimg,kern1,conv_type);\n %kern2 = load(strcat(fpath,filesep,'g2y',g2scaleval,fm2));\n kern2 = load(strcat('g2y',g2scaleval,fm2));\n rc2 = convolve_2(rc1,kern2,conv_type);\n \n %kern3 = load(strcat(fpath,filesep,'gy',g2scaleval,fm2));\n kern3 = load(strcat('gy',g2scaleval,fm2));\n rc3 = convolve_2(mimg,kern3,conv_type);\n %kern4 = load(strcat(fpath,filesep,'g2x',g2scaleval,fm2));\n kern4 = load(strcat('g2x',g2scaleval,fm2));\n rc4 = convolve_2(rc3,kern4,conv_type);\n \n %kern5 = load(strcat(fpath,filesep,'g1x',g2scaleval,fm2));\n kern5 = load(strcat('g1x',g2scaleval,fm2));\n rc5 = convolve_2(mimg,kern5,conv_type);\n %kern6 = load(strcat(fpath,filesep,'g1y',g2scaleval,fm2));\n kern6 = load(strcat('g1y',g2scaleval,fm2));\n rc6 = convolve_2(rc5,kern6,conv_type);\n \n %#######################################\n % Calculate the 2nd Gaussian derivative:\n %#######################################\n g2 = g2steer(rc4,rc2,rc6,g1dir);\n \n g2all((scale-1)*nrows+1:scale*nrows,:) = g2; % For subpixel loc'n.\n \n %##############################################################\n % Augment multi-scale Gaussian directional 2nd derivative maps:\n %##############################################################\n [g2mag,g2sc] = g2scale(g2mag,g2,g2sc,scale,noise,0);\n \nend;\n\nreturn;"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/elderEdge.m",
"content": "function [edgeStruct] = elderEdge()\n%Run local scale control edge detector on image (Elder & Zucker, 1998)\n\nnoise = 1; %estimated SD of pixel noise\nimagefile='P1020177.jpg'; %name of image file. Most formats are handled. May be RGB or grayscale.\nmaxscale=5; %maximum scale, must be positive integer. Scales increase exponentially from 0.5 to 2^{maxscale-2}. \nedgew=10; %maximum edge blur (distance in pixels between extrema in the 2nd derivative)\nconss=1; %boundary condition for scalespace computation. 0 for extension, 1 for no overlap\ncongrd=0; %boundary condition for derivative computation. 0 for extension, 1 for no overlap\nsubpixelflag=0; %generate subpixel-localized edges\n%run edge detection\nedgeStruct = main_edge(imagefile,maxscale,noise,edgew,conss,congrd,subpixelflag);"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/elderEdge.m~",
"content": "function elderEdge()\n%Run local scale control edge detector on image (Elder & Zucker, 1998)\nnoise = 1; %estimated SD of pixel noise\nimagefile='img.jpg'; %name of image file\nmaxscale=5; %maximum scale, must be positive integer. Scales increase exponentially from 0.5 to 2^{maxscale-2}. \nedgew=10; %maximum edge blur (distance in pixels between extrema in the 2nd derivative)\nconss=1; %boundary condition for scalespace computation. 0 for extension, 1 for no overlap\ncongrd=0; %boundary condition for derivative computation. 0 for extension, 1 for no overlap\nsave_v = zeros(0,11); %results to save\nview_v = zeros(0,11); %results to view\n\nsave_v(1) = 1; %edge map\nsave_v(2) = 1; %blur map\nsave_v(3) = 1; %dark map\nsave_v(4) = 1; %light map\nsave_v(5) = 0; %gradient magnitude map\nsave_v(6) = 1; %gradient direction map\nsave_v(7) = 0; %gradient scale map\nsave_v(8) = 0; %2nd derivative map\nsave_v(9) = 0; %2nd derivativ scale map\nsave_v(10) = 0; %X zero crossing offset\nsave_v(11) = 0;%Y zero crossing offset\n\nview_v(1) = 0; %edge map\nview_v(2) = 0; %blur map\nview_v(3) = 0; %dark map\nview_v(4) = 0; %light map\nview_v(5) = 0; %gradient magnitude map\nview_v(6) = 0; %gradient direction map\nview_v(7) = 0; %gradient scale map\nview_v(8) = 0; %2nd derivative map\nview_v(9) = 0; %2nd derivativ scale map\nview_v(10) = 0; %X zero crossing offset\nview_v(11) = 0;%Y zero crossing offset\n\n%change this path to your own local directory for the filters\nfiltpath='~/Dropbox/code/elderlab/edge/mar03/filters';\n\nedgetype='.jpg'; %format for output edge map (.mat also allowed)\nedgelplotflag=0; %show edges on image\nimgplotflag=0; %view original image\noutputdir=pwd;\n\nsfilenames = check_save_requirements(view_v,outputdir,edgetype);\nsubpixelflag=0;\n\noutputdata=main_edge(imagefile,maxscale,noise,edgew,...\n conss,congrd,view_v,view_v,filtpath,...\n edgetype,edgelplotflag,imgplotflag,sfilenames,...\n subpixelflag);\n \nreblur=uint8(imreconandblur(1,3));\n\nimg=imread(imagefile);\nif size(img,3)==3\n img=rgb2gray(img);\nend\nimwrite(img,strcat(resultdir,'img.jpg'));\nimwrite(outputdata.edge_map,strcat(resultdir,'edge.jpg'));\nimwrite(reblur,strcat(resultdir,'recon.jpg'));"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/find_edges.c",
"content": "\n/************************************************************************************************\n* \n* Routine Name: lvedge - Detect luminance edges by selecting triads of significant \n* 2nd derivatives of opposite sign flanking a significant 1st derivative of consistent direction.\n* \n* Purpose: vgtriad\n*\t\t Detect luminance edges by selecting triads of significant\n*\t\t 2nd derivatives of opposite sign flanking a directional\n*\t\t maximum in the 1st derivative of consistent direction.\n*\n*\t\t Pixels with maximal gradient magnitude in the gradient\n*\t\t direction are considered as candidate edge pixels. The image\n*\t\t is scanned along the gradient line for pixels with significant\n*\t\t 2nd derivative of opposite sign, consistent with the edge\n*\t\t hypothesis. Scanning is terminated if the line intersects a\n*\t\t pixel with inconsistent or unreliable gradient direction, or\n*\t\t inconsistent 2nd derivative sign if a pixel of consistent sign\n*\t\t has already been detected. Otherwise, the scan selects the\n*\t\t line segment connecting the edge pixel with the maximum 2nd\n*\t\t derivative pixels. The local blur width of the blurred\n*\t\t edge is derived as well. The width is derived from the\n*\t\t distance between G2 terminators of opposite sign, based on an\n*\t\t assumption of Gaussian blur.\n*\n* Input: img - Original byte image \n* g1mag - Multi-scale gradient magnitude map \n* g1dir - Multi-Scale Gradient direction map\n* g1scale - Gradient scale map\n* g2 - Multi-Scale 2nd Derivative Map\n* g2scale - G2 Scale Map\n* noise - Estimated sensor noise\n* maxwidth - Maximum edge width detected\n* Output: gewidth - Estimate of blur scale based on edgewidth. \n* Type is VFF_TYP_FLOAT.\n* dark - Estimate of luminance on dark side of edge. \n* Type is VFF_TYP_1_BYTE.\n* light - Estimate of luminance on light side of edge\n* Returns: TRUE (1) on success, FALSE (0) on failure\n* Restrictions: Restricted to real, single-band images. \n* Does not work on explicit location data.\n* Written By: James Elder\n* Date: Oct 13, 1997\n* Verified: \n* Side Effects: \n* Examples: \n* Modifications: \n****************************************************************/\n\n#define char16_t uint16_T /*JE Sept 2014. Needed for MATLAB 2012a under OSX19.0 and Xcode 5.1 */\n#include \"mex.h\"\n#include /* NULL */\n#include \n#include \n#define notDblMtx(it) (mxIsComplex(it))\n\n\ndouble \tg2max1, /* Max G2 response of correct sign */\n \tg2max2, /* Max G2 response of incorrect sign */\n \tg2maxscale, /* Scale of max G2 response of correct sign */\n\t\txfirst, yfirst, zfirst, /* Endpoints for interpolation */\n \t/* Sensor noise threshold */\n \tk_thresh, /* Min. contrib. to linear interp. for pixel to be labeled */\n \tpixerr[6] = {9.5,8,3.5,0.25,0.04,0.0}, /* Half-range of gradient direction */\n /* uncertainty due to pixelation */\n /* as function of G1 scale. */\n \tg2thresh = 0.0000596, /* Min on sig. g2 value for interpolation */\n \tedgewidth, \t/* Estimated width of edge */\n \txend, yend; /* Estimated gradient ray termination coordinates */\n\nint \tg1len_to_max,maxg1len, \t/* Current and max number of G1 pixels supporting edge assertion */ \n \tg1max, \t/* Is current pixel directional max of gradient? */\n \tg2len, \t/* Number of G2 pixels supporting edge */\n \trows, cols, \t\t\t/* Columns in image */\n \tg1offsets[1024], \t\t/* Offsets to G1 pixels in current path */\n \tg2offsets[4], \t\t\t/* Offsets to G2 pixels in current path */\n \tedgescale = 0, \t\t\t/* Max scale of G1 or G2 response in path */\n \tacuity_problem, \t\t/* Flag to indicate 1-pixel acuity will not be obtained */\n \tzcross, /* Flag to indicate zero-crossing found */\n \tkeepoff1,keepoff2; \t\t/* Offsets to pixels from which 2nd derivative calculated */\ndouble\tG2fact1, G2fact2;\t\t/* Factor in recalculation of G2val: \"ki * pow(cos(ddiri),2)\" */\nint\t\tXx1,Xx2,Yy1,Yy2;\t\t/* Offsets returned from g2_path for subpixel method 2 */\n \ndouble KPI = 3.141593;\ndouble noise; /* Sensor noise threshold */\nFILE *f; \n\n/* Internal functions */\nint round_int(double rd);\nint g2_path(double theta,int bx,int by,double *g1mag,double *g1dir,double *g1scale,\n double *g2,double *g2scale,int g2sign);\nint compare_dir(double g1mag1,double g1dir1,int g1scale1,double g1mag2,double g1dir2,int g1scale2);\nint sign(double r);\n\nint\nfind_edges(double *img,double *g1mag,double *g1dir,double *g1scale,double *g2,\n\t\tdouble *g2scale,double *g2all,double sensor_noise,int maxwidth,int sublocflag,int maxscale,\n\t\tdouble *xout,double *xout_blur,\n\t\tdouble *xout_dark,double *xout_light,double *xout_x1zero,double *xout_y1zero,\n\t\tdouble *xout_x2zero,double *xout_y2zero)\n{\n\ndouble \ttheta; /* Either in gradient direction or against gradient direction */\nint \tx,y,i; /* Image dimensions and indices */\ndouble \t*g1magd,*g1dird,*g2d; /* Input G1 and G2 map data */\ndouble \t*imgd;\ndouble \tg2maxp,g2maxn; /* Used to detect false edge pixels */\ndouble \tg2scalep,g2scalen; /* Scale of max pos and min neg G2 responses */\ndouble \tblurvar;\ndouble \tnxend,nyend,pxend,pyend; /* Estimated gradient line terminations */ \ndouble \tnwidth,pwidth; /*distance from current pixel to g2 extrema */\ndouble \terf_const,C,D,L,meanl;\ndouble \tl,d;\n\ndouble \tnxfirst, nyfirst, pxfirst, pyfirst, pzfirst, nzfirst, xinter, yinter;\nint\t\tg2sc1, g2sc2, g2sc3, g2sc4, off_side1, off_side2, off_side3, off_side4;\nint\t\tgind;\ndouble\tG2factor1, G2factor2, G2factor3, G2factor4;\nint\t\tX1,X2,X3,X4,Y1,Y2,Y3,Y4,match_flag;\nint\t\tnewoff1,newoff2,newoff3,newoff4;\ndouble\tnew_nz,new_pz,bestsnr,bestnz,bestpz;\nstatic double g2norms[6] = {1.873,0.2443,0.0306,0.003817,0.00047715,0.0000596}; /* Thresholds */\n\nint \tcount=0; \n\ng1magd = g1mag;\ng1dird = g1dir;\n\ng2d \t= g2;\nimgd \t= img; \n\nnoise \t\t= sensor_noise;\ng2thresh \t= 5.2*g2thresh*noise; /* threshold on interpolated g2 values */\nmaxg1len \t= maxwidth*2; /* Up to 2 pixels per step */\nk_thresh \t= 0.1; /* Min coeff. in linear interp. to include pixel in edge */\nerf_const \t= 0.68268949213709;\n\nfor (i=0;i<5;i++) /* Convert pixelation uncertainty from deg. to radians */\n pixerr[i] = pixerr[i] * KPI / 180.0;\n\n/**** Order (x,y) reversed from cantata code ****/\nfor (x=0;x 0.0 && *g2d >= 0.0) /* Non-negative 2nd derivative */\n \t{\n \n\t\tacuity_problem\t= 0;\n \tg2max1 \t\t\t= 0;\n\t\tg2max2 \t\t\t= 0.0;\n\t \tg2maxscale \t\t= 0.0;\n\t \tg1len_to_max \t= 0;\n\t\tg2len \t\t\t= 0;\n\t \tzcross\t\t\t= 0;\n\t \tedgewidth \t\t= 0.0;\n \n\t\txfirst = 0.0;\n\t\tyfirst = 0.0;\n\t\tzfirst = 0.0;\n\t\tkeepoff1\t= 0;\n\t\tkeepoff2\t= 0;\n\t\tG2fact1\t\t= 0;\n\t\tG2fact2\t\t= 0;\n\n\t\t/* Find g2_path, last parameter '1' makes g2_path selective for negative G2 responses */\n\t \tg2_path(theta,x,y,g1magd,g1dird,g1scale+count,g2d,g2scale+count,1);\n\n\t \tif (g2max1 != 0.0 && g1max) /* Gradient max and found significant negative G2 response */\n\t \t{\n\n\t\t\tnxfirst\t\t= xfirst;\n\t\t\tnyfirst\t\t= yfirst;\n\t\t\tnzfirst\t\t= -zfirst;\n\n\t\t\toff_side1\t= keepoff1;\n\t\t\toff_side2\t= keepoff2;\n\t\t\tG2factor1\t= G2fact1;\n\t\t\tG2factor2\t= G2fact2;\n\t\t\tX1\t\t\t= Xx1;\n\t\t\tX2\t\t\t= Xx2;\n\t\t\tY1\t\t\t= Yy1;\n\t\t\tY2\t\t\t= Yy2;\n\n\t \t\tnxend \t\t= xend; \t/* Save estimated edge ray termination */\n\t \tnyend \t\t= yend;\n\t \tnwidth \t\t= sqrt(pow(nxend,2) + pow(nyend,2));\n\t \tg2maxn \t\t= g2max1; \t/* Save min negative G2 response */\n\t \tg2maxp \t\t= g2max2; \t/* Save max positive G2 response */\n\t \tg2scalen \t= g2maxscale; \t/* Save scale of min negative G2 response */\n\t \tg2max1 \t\t= 0.0;\n\t\t\tg2max2 \t\t= 0.0; \n\t \tg2maxscale \t= 0.0;\n\n\t \tif (theta > 0) /* Now scan opposite to gradient direction */\n\t\t \t\ttheta = theta - KPI;\n\t \telse\n\t\t \t\ttheta = theta + KPI;\n\t \n\t\t\txfirst = 0.0;\n\t\t\tyfirst = 0.0;\n\t\t\tzfirst = 0.0;\n\t\t\tkeepoff1\t= 0;\n\t\t\tkeepoff2\t= 0;\n\t\t\tG2fact1\t\t= 0;\n\t\t\tG2fact2\t\t= 0;\n\n\t\t \t/* Find g2_path, last parameter '0' makes g2_path selective for positive G2 responses */\n\t \tg2_path(theta,x,y,g1magd,g1dird,g1scale+count,g2d,g2scale+count,0);\n\n\t \tpxend \t= xend; /* Save estimated edge ray termination */\n\t \tpyend \t= yend;\n\t \tpwidth \t= sqrt(pow(pxend,2) + pow(pyend,2));\n\n\t \tif ((g2max1>g2maxp) && (g2max2>g2maxn) && g1max)\n\t \t{\n\t\t\t\tpxfirst\t\t= xfirst;\n\t\t\t\tpyfirst\t\t= yfirst;\n\t\t\t\tpzfirst\t\t= zfirst;\n\n\t\t\t\toff_side3\t= keepoff1;\n\t\t\t\toff_side4\t= keepoff2;\n\t\t\t\tG2factor3\t= G2fact1;\n\t\t\t\tG2factor4\t= G2fact2;\n\t\t\t\tX3\t\t\t= Xx1;\n\t\t\t\tX4\t\t\t= Xx2;\n\t\t\t\tY3\t\t\t= Yy1;\n\t\t\t\tY4\t\t\t= Yy2;\n\t\n\t \tif ((!acuity_problem && zcross) || (acuity_problem && fabs(pwidth-nwidth) 0.0)\n\t\t \t\t*(xout_blur+count) = sqrt(blurvar); \n\t\t \t\telse \n\t\t \t\t*(xout_blur+count) = 0.1; \n\n\t\t\t\t\tl = *(imgd+round_int(nxend)*rows+round_int(nyend));\n\t\t\t\t\td = *(imgd+round_int(pxend)*rows+round_int(pyend));\n\n\t\t \t\tif (l<=d)\n\t\t \t\t{\n\t \t\t\t\tmeanl = round_int(0.5*(l+d));\n\t\t \t\t*(xout_dark+count)\t= meanl;\n\t\t \t\t*(xout_light+count) = meanl;\n\t\t \t\t}\n\t\t \t\telse if (blurvar < 1)\n\t\t \t\t{\n\t\t \t\t*(xout_dark+count)\t= round_int(d);\n\t\t \t\t*(xout_light+count)\t= round_int(l);\n\t\t \t\t}\n\t\t \t\telse\n\t\t \t\t{\n\t\t \t\t\tC\t= (l - d) / erf_const;\n\t\t \t\t\tD\t= d - 0.5 * C * (1 - erf_const);\n\t\t \t\t\tL\t= C + D;\n\n\t\t \t\t\tif (D<0)\n\t\t\t \t\t\t*(xout_dark+count) = 0;\n\t\t \t\t\telse if (D> 255)\n\t\t\t \t\t\t*(xout_dark+count) = 255.0;\n\t\t \t\t\telse\n\t\t\t \t\t\t*(xout_dark+count) = round_int(D);\n\t\t \t\t\tif (L<0)\n\t\t\t \t\t\t*(xout_light+count)= 0;\n\t\t \t\t\telse if (L> 255)\n\t\t\t \t\t\t*(xout_light+count) = 255.0;\n\t\t \t\t\telse\n\t\t\t \t\t\t*(xout_light+count) = round_int(L);\n\t\t \t\t}\n\n\t\t\t\t\tif (sublocflag)\n\t\t\t\t\t{\n\n\t\t\t\t\t\t/* METHOD 1: Interpolate to find better estimate of zero-crossing. \n\t\t\t\t\t \t\tStore resultant x and y in *xout_xzero and *xout_yzero. */\n\t\t\t\t\t\txinter\t= (nzfirst * (pxfirst+x+1) + pzfirst * (nxfirst+x+1)) / (nzfirst + pzfirst);\n\t\t\t\t\t\tyinter\t= (nzfirst * (pyfirst+y+1) + pzfirst * (nyfirst+y+1)) / (nzfirst + pzfirst);\n\n\t\t\t\t\t\t/* Update in xout_x1zero and xout_y1zero matrices */\n\t\t\t\t\t\txinter\t= (xinter > cols) ? cols : xinter;\n\t\t\t\t\t\t*(xout_x1zero+count) = (xinter < 0) ? 0 : xinter;\n\n\t\t\t\t\t\tyinter\t= (yinter > rows) ? rows : yinter;\n\t\t\t\t\t\t*(xout_y1zero+count) = (yinter < 0) ? 0 : yinter;\n\n\n\t\t\t\t\t\t/* METHOD 2: Interpolate as with Method 1, except that scale at the\n\t\t\t\t\t\t \t4 flanking pixels must match. */\n\t\t\t\t\t\tg2sc1 = (int)*(g2scale+count+off_side1);\n\t\t\t\t\t\tg2sc2 = (int)*(g2scale+count+off_side2);\n \t\t\t\t\t\tg2sc3 = (int)*(g2scale+count+off_side3);\n \t\t\t\t\t\tg2sc4 = (int)*(g2scale+count+off_side4);\n\n\t\t\t\t\t\tif ((g2sc1==g2sc2) && (g2sc1==g2sc3) && (g2sc1==g2sc4)) /* Scales match */\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t*(xout_x2zero+count) = *(xout_x1zero+count);\n\t\t\t\t\t\t\t*(xout_y2zero+count) = *(xout_y1zero+count);\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse /* Scales do not match */\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tmatch_flag = 0;\n\t\t\t\t\t\t\tgind\t\t= 1; /* g2 scale index */\n\n\t\t\t\t\t\t\tbestsnr\t\t= 0;\n\n\t\t\t\t\t\t\twhile (!match_flag && (gind<=maxscale))\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tnewoff1\t= (x+X1) * rows * maxscale + (y+Y1) + rows * (gind-1);\n\t\t\t\t\t\t\t\tnewoff2\t= (x+X2) * rows * maxscale + (y+Y2) + rows * (gind-1);\n\t\t\t\t\t\t\t\tnewoff3\t= (x+X3) * rows * maxscale + (y+Y3) + rows * (gind-1);\n\t\t\t\t\t\t\t\tnewoff4\t= (x+X4) * rows * maxscale + (y+Y4) + rows * (gind-1);\n\n \t\t\t\t\t\t\tnew_nz\t= -G2factor1 * (*(g2all+newoff1)) - G2factor2 * (*(g2all+newoff2)); \n \t\t\t\t\t\t\tnew_pz\t= G2factor3 * (*(g2all+newoff3)) + G2factor4 * (*(g2all+newoff4)); \n\n\t\t\t\t\t\t\t\t/* If there is no scale for which all 4 are significant, will need to\n\t\t\t\t\t\t\t\t * choose the one with the best SNR, therefore store it. */\n\t\t\t\t\t\t\t\tif ((new_nz+new_pz)>bestsnr)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tbestsnr\t= new_nz + new_pz;\n\t\t\t\t\t\t\t\t\tbestnz\t= new_nz;\n\t\t\t\t\t\t\t\t\tbestpz\t= new_pz;\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t/* If new estimates exceed the threshold, have found answer */\n\t\t\t\t\t\t\t\tif ((new_nz > 5.2*noise*g2norms[gind-1]) && \n\t\t\t\t\t\t\t\t\t\t\t(new_pz > 5.2*noise*g2norms[gind-1]))\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\txinter\t= (new_nz * (pxfirst+x+1) + new_pz * (nxfirst+x+1)) / \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t(new_nz + new_pz);\n\t\t\t\t\t\t\t\t\tyinter\t= (new_nz * (pyfirst+y+1) + new_pz * (nyfirst+y+1)) / \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t(new_nz + new_pz);\n\n\t\t\t\t\t\t\t\t\tmatch_flag = 1;\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\tgind++;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t/* Use scale with best SNR if none match */\n\t\t\t\t\t\t\tif (!match_flag)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\txinter\t= (bestnz * (pxfirst+x+1) + bestpz * (nxfirst+x+1)) / bestsnr;\n\t\t\t\t\t\t\t\tyinter\t= (bestnz * (pyfirst+y+1) + bestpz * (nyfirst+y+1)) / bestsnr;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t/* Update in xout_x2zero and xout_y2zero matrices */\n\t\t\t\t\t\t\txinter\t= (xinter > cols) ? cols : xinter;\n\t\t\t\t\t\t\t*(xout_x2zero+count) = (xinter < 0) ? 0 : xinter;\n\n\t\t\t\t\t\t\tyinter\t= (yinter > rows) ? rows : yinter;\n\t\t\t\t\t\t\t*(xout_y2zero+count) = (yinter < 0) ? 0 : yinter;\n\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t \t\t}\n\t \t}\n\t \t}\n }\n count++;\n}\nreturn(1);\n}\n\n\n/****************************************************************/\nint round_int(double rd)\n{ \ndouble t1, t2;\nint\txf, xc;\n \nxf = (int)floor(rd);\nxc = (int)ceil(rd);\nt1 = fabs(rd-xf);\nt2 = fabs(rd-xc);\n\nif (t1 >= t2)\n\treturn(xc);\nelse\n\treturn(xf);\n\n}\n\n/*****************************************************************/\n/* g2_path */\nint g2_path(double theta,int bx,int by,double *g1mag,double *g1dir,double *g1scale,\n\t\t\t\t\tdouble *g2,double *g2scale,int g2signbit)\n{\nint \tx1, y1, x2, y2, dx, dy; \nint\t\toff1=0; \nint\t\toff2=0; /* Offsets and indices for linear interp. */\nint \tend_of_path; /* Flag signalling when max (min) found or continuity broken */\nint \tsame_dir1, same_dir2; \t/* Flags indicating gradient direction compatibility */\nint \tg1len, g2halflen; \t\t/* Num of G2 pixels terminating current ray */\ndouble \ttan_theta, x, y; \t\t/* Real coords of points on path */\ndouble \tg1magval, g1dirval; \t/* Gradient at centre pixel */\ndouble \tg1mag1, g1dir1, g1mag2, g1dir2; /* Gradients at pixel pair on path */\ndouble \tk1, k2; \t\t\t\t/* Linear interp. coefficients */\ndouble \tg1val, g2val; \t\t\t/* Interpolated G1 and G2 responses on path */\nint \tg1scaleval; \t\t\t/* Scale of gradient at centre pixel */\nint \tg1scale1, g1scale2, g2scale1, g2scale2; /* Scales of pixels on path */\ndouble \tddir1, ddir2; \t\t\t/* gradient dir differences along grad line. */\ndouble \tg1_prev_val, acuity, length;\nint\t\tfound_interp_flag=0;\n\n/*#########################################*/\n/* Select the 1st 2 pixels flanking the ray \n\tfrom 0 in the theta direction. */\n/*#########################################*/\n\nif (theta > 0)\n \tdy = -1;\nelse\n \tdy = 1;\n\nif (fabs(theta) < KPI*0.5)\n \tdx = 1;\nelse\n \tdx = -1;\n \nx1 = dx;\ny1 = 0;\nx2 = 0;\ny2 = dy;\n\ntan_theta = tan(theta);\n\n/* If theta < 45deg -> (x2,y2) = (dx,dy), else (x1,y1) = (dx,dy) */\nif (fabs(tan_theta) < 1)\n \tx2 = dx;\nelse\n \ty1 = dy;\n\n/* End of block */\n/*##############*/\n\nacuity \t\t= 20.0;\ng2max2 \t\t= 0.0;\ng1magval \t= (float)*g1mag;\ng1dirval \t= (float)*g1dir;\ng1scaleval \t= (int)*g1scale;\ng2val \t\t= (float)*g2;\ng1_prev_val = g1magval;\n\nif (g2val != 0.0 && sign(g2val) == g2signbit) /* sig. G2 of right sign */\n{\n\tg2maxscale \t= (float) *g2scale;\n g2max1 \t\t= g2val;\n g2offsets[g2len++] = 0;\n g2halflen \t= 1;\n\tif (!found_interp_flag)\n\t{\n\t\tG2fact1 = 1;\n\t\tG2fact2 = 0;\n\t\tXx1\t= 0;\n\t\tXx2\t= 0;\n\t\tYy1\t= 0;\n\t\tYy2\t= 0;\n\t\n\t\tzfirst\t= g2max1;\n\t\txfirst\t= 0;\n\t\tyfirst\t= 0;\n\t\tkeepoff1 = off1;\n\t\tkeepoff2 = off2;\n\t\tfound_interp_flag = 1;\n\t}\n}\nelse /* Initialize G2 variables */\n{\n g2max1 \t\t= 0.0;\n g2maxscale \t= 0.0;\n g2halflen \t= 0;\n}\n\nend_of_path = 0;\nxend = yend = 0.0;\ng1len \t\t= g1len_to_max;\ng1max \t\t= 1;\n \n\n/*#####################################\n Scan for G2 max of the correct sign, \n until length limit or interrupted \n#####################################*/\nwhile (!end_of_path && g1len < maxg1len) \n{\n \n\tif ((g2val==0.0) && (g2max1 == 0))\n\t\tacuity_problem = 1;\n\n\t/* Check if flanking pixels go out of range of image */\n if ((bx+x1<0) || (bx+x1>=cols) || (bx+x2<0) || (bx+x2>=cols) || (by+y1<0) || \n\t\t\t\t\t\t(by+y1>=rows) || (by+y2<0) || (by+y2>=rows))\n \tend_of_path = 1;\n else\n {\n \t/* Derive linear interpolation coefficients */\n \tif (x1 == x2)\n {\n \ty = -x1 * tan_theta;\n k1 = fabs(y-y2);\n k2 = fabs(y-y1);\n }\n \telse\n {\n x = -y1 / tan_theta;\n k1 = fabs(x-x2);\n k2 = fabs(x-x1);\n }\n \n\t\t/*########################################################*/\n \t/* Get G1 and G2 information for the two pixels on path */\n\t\t/*########################################################*/\n\n\t\t/**** cols and rows changed from cantata code here as Matlab processes columnwise ****/\n \toff1 \t= x1 * rows + y1;\n \toff2 \t= x2 * rows + y2;\n\n \tx \t\t= k1 * x1 + k2 * x2;\n \ty \t\t= k1 * y1 + k2 * y2;\n \tlength \t= sqrt(x*x + y*y);\n\n\n \tg1dir1 \t= *(g1dir+off1);\n \tg1dir2 \t= *(g1dir+off2);\n \tg1mag1 \t= *(g1mag+off1);\n \tg1mag2 \t= *(g1mag+off2);\n\n \tg1scale1 = (int)*(g1scale+off1);\n \tg1scale2 = (int)*(g1scale+off2);\n \tg2scale1 = (int)*(g2scale+off1);\n \tg2scale2 = (int)*(g2scale+off2);\n\n \t/* Interpolate the G1 estimate */\n \tg1val = k1 * g1mag1 + k2 * g1mag2; \n \n \tif (g1val > g1magval)\n \tg1max = 1;\n \n \t/* Pixel 1 compatible? */ \n \tsame_dir1 = compare_dir(g1magval,g1dirval,(int)g1scaleval,g1mag1,g1dir1,(int)g1scale1); \n \n \t/* Pixel 2 compatible? */ \n \tsame_dir2 = compare_dir(g1magval,g1dirval,(int)g1scaleval,g1mag2,g1dir2,(int)g1scale2); \n \n\t \tddir1 = fabs(g1dir1-g1dirval);\n\t \tddir2 = fabs(g1dir2-g1dirval);\n\n\t\t/* Interpolate the G2 estimate */\n \tg2val = k1 * pow(cos(ddir1),2) * (*(g2+off1)) + k2 * pow(cos(ddir2),2) * (*(g2+off2)); \n \n \tif ((g1len==0) && (g2val<0.0))\n\t \t\tzcross = 1;\n\n \tif ((!(g2max1==0.0 && fabs(g2val)>g2thresh && sign(g2val) == g2signbit) &&\n\t \t\t\t!((same_dir1 && k1>k_thresh) || (same_dir2 && k2>k_thresh)))\n \t\t|| (fabs(g2val) > g2thresh && (sign(g2val) != g2signbit) && zcross)\n \t\t|| ((fabs(g2val) < g2thresh) && (length > acuity)))\n\t\t{\n \tend_of_path = 1;\n \t}\n \telse if ((sign(g2val) == g2signbit) && (fabs(g2val) > fabs(g2max1)))\n {\n\t\t\tg2max1 = g2val;\n\t\t \t/* Derive scale of G2 response */\n \tif (g2scale1 == 0)\n \t\tg2maxscale = (float) g2scale2;\n \telse if (g2scale2 == 0)\n \t\tg2maxscale = (float) g2scale1;\n \t\telse\n g2maxscale = k1 * g2scale1 + k2 * g2scale2;\n\n\t\t\tg1len_to_max = g1len; \t\t/* Update g1 index */\n g2len \t\t-= g2halflen; \t/* Erase previous G2 terminators */\n g2halflen \t = 0; \n\n\t\t\tif (k1 > k_thresh) /* If path lies near this pixel, label as G2 */\n {\n \tg2offsets[g2len++] = off1;\n\t\t\t\tg2halflen++;\n }\n if (k2 > k_thresh)\n {\n\t\t\t\tg2offsets[g2len++] = off2;\n g2halflen++;\n }\n\n\t\t\txend = k1 * x1 + k2 * x2; /* Real coordinates of G2 terminator */\n yend = k1 * y1 + k2 * y2;\n\n\t\t\tif (!found_interp_flag)\n\t\t\t{\n\t\t\t\tG2fact1\t= k1 * pow(cos(ddir1),2);\n\t\t\t\tG2fact2\t= k2 * pow(cos(ddir2),2);\n\t\t\t\tXx1\t= x1;\n\t\t\t\tXx2\t= x2;\n\t\t\t\tYy1\t= y1;\n\t\t\t\tYy2\t= y2;\n\t\n\t\t\t\tzfirst\t= g2max1;\n\t\t\t\txfirst\t= xend;\n\t\t\t\tyfirst\t= yend;\n\t\t\t\tkeepoff1 = off1;\n\t\t\t\tkeepoff2 = off2;\n\t\t\t\tfound_interp_flag = 1;\n\t\t\t}\n\n\t\t}\n \telse if (((sign(g2val) != g2signbit) || g2val == 0.0) && g2max1 != 0.0) \n \t{\n \tend_of_path = 1; \n \t}\n \telse if ((sign(g2val) != g2signbit) && (fabs(g2val) > fabs(g2max2)))\n \t{\n \tg2max2 = g2val; /* Largest sig. G2 response of incorrect sign */\n \t} \n \n \tg1_prev_val = g1val;\n\n\t}\n\n if (!end_of_path)\n {\n \tif (same_dir1) /* 1st pixel in pair is compatible */\n {\n \t\tg1offsets[g1len++] = off1; /* Label as interior pixel */\n if (g1scale1 > edgescale) /* Update scale to max */\n \tedgescale = g1scale1;\n\t\t}\n if (same_dir2) /* 2nd pixel in pair is compatible */\n {\n\t g1offsets[g1len++] = off2; /* Label as interior pixel */\n \t\tif (g1scale2 > edgescale) /* Update scale to max */\n \t\tedgescale = g1scale1;\n\t\t\t/**** Is this meant to be g1scale1 or g1scale2? ****/\n }\n\n /* Step to next intersection of ray with pixel grid */\n if (x1 == x2)\n {\n \tx1 += dx;\n if (abs(y2) < fabs(x1*tan_theta))\n \ty1+= dy;\n else\n x2+= dx;\n \t}\n else\n {\n \ty2 += dy;\n if (abs(y2) > fabs(x1*tan_theta))\n \tx2+= dx;\n else\n y1+= dy;\n }\n\t}\n\n\n\n\n}\n\nif (g2maxscale > edgescale) /* Update edgescale to max of G1 and G2 scales */\n\tedgescale = (int) g2maxscale;\nedgewidth += sqrt(xend*xend + yend*yend); /* Add distance from 0 to terminator */\n\nreturn (1);\n} \n\n\n/******************************************************************************/\n/* compare_dir */\nint compare_dir(double g1mag1,double g1dir1,int g1scale1,double g1mag2,double g1dir2,int g1scale2)\n{\ndouble a1, a2; /* Pixelation uncertainty at respective scales */\ndouble ddir, tolerance; /* actual and tolerated gradient direction discrepancy */\nstatic double g1noise_norms[6] = {0.765,0.199,0.0499,0.0125,0.00312,0.00078};\n\nif (g1dir2 == 4) /* Gradient not significant */\n return(0);\n \na1 \t= pixerr[g1scale1-1];\na2 \t= pixerr[g1scale2-1];\n\nddir = fabs(g1dir1 - g1dir2);\nif (ddir > KPI)\n ddir = 2*KPI - ddir;\n \n/* tolerance is sum of half-ranges due to pixelation uncertainty \n\t\tplus the range due to sensor noise */\ntolerance = a1 + a2 + 5.2 * noise * sqrt(pow(g1noise_norms[g1scale1-1]/g1mag1,2.0)\n + pow(g1noise_norms[g1scale2-1]/g1mag2,2.0));\n \nif (ddir <= tolerance)\n \treturn(1);\n\nreturn(0);\n}\n\n\n/***************************************************************************/\n/* signbit */\nint sign(double r)\n{\n\tif (r<0)\n \treturn (1);\n \telse\n \treturn (0);\n}\n\n\n\n/******************************************************************************/\nvoid mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )\n{\n\ndouble *img;\ndouble *g1mag;\ndouble *g1dir; \ndouble *g1scale;\ndouble *g2; \ndouble *g2scale;\ndouble *g2all;\nint x_dim, y_dim;\ndouble sensor_noise;\nint maxwidth, maxscale; \nint sublocflag; \ndouble dmwidth,mxscale;\ndouble subflag;\ndouble *x;\ndouble *x_blur;\ndouble *x_dark;\ndouble *x_light;\ndouble *x_x1zero;\ndouble *x_y1zero;\ndouble *x_x2zero;\ndouble *x_y2zero;\n\nint warnings = 1;\nmxArray *arg;\ndouble *mxMat;\n\n/* copy start */\n\n\n\tif (nrhs < 11 ) \n\t\tmexErrMsgTxt(\"requres at least 11 args.\");\n \n \t/* ARG 1: IMAGE */\n \targ = prhs[0];\n \n \tif notDblMtx(arg) mexErrMsgTxt(\"IMAGE arg must be a real non-sparse matrix.\");\n \timg = mxGetPr(arg);\n \tx_dim = (int) mxGetM(arg); /* X is inner index! */\n \ty_dim = (int) mxGetN(arg);\n \trows = x_dim;\n \tcols = y_dim;\n \n \t/* ARG 2: g1mag */\n \targ = prhs[1];\n \tif notDblMtx(arg) mexErrMsgTxt(\"g1mag arg must be a real non-sparse matrix.\");\n \tg1mag = mxGetPr(arg);\n \n\n \t/* ARG 3: g1dir */\n \targ = prhs[2];\n \tif notDblMtx(arg) mexErrMsgTxt(\"g1dir arg must be a real matrix\");\n \tg1dir = mxGetPr(arg);\n\n \t/* ARG 4: g1scale */\n \targ = prhs[3];\n \tif (notDblMtx(arg)) mexErrMsgTxt(\" g1scale arg must be a int matrix\");\n \tg1scale = mxGetPr(arg);\n \n \t/* ARG 5: g2 */\n \targ = prhs[4];\n \tif notDblMtx(arg) mexErrMsgTxt(\"g2 arg must be a real matrix\");\n \tg2 = mxGetPr(arg);\n \n \t/* ARG 6: g2scale */\n \targ = prhs[5];\n \tif (notDblMtx(arg)) mexErrMsgTxt(\"g2scale arg must be a int matrix\");\n \tg2scale = mxGetPr(arg);\n \n \t/* ARG 7: g2all */\n \targ = prhs[6];\n \tif (notDblMtx(arg)) mexErrMsgTxt(\"g2all arg must be a int matrix\");\n \tg2all = mxGetPr(arg);\n \n \t/* ARG 8: sensor_noise */\n \targ = prhs[7];\n \tif notDblMtx(arg) mexErrMsgTxt(\"sensor_noise arg must be a real matrix\");\n \tif (mxGetM(arg)*mxGetN(arg) != 1)\n \tmexErrMsgTxt(\"sensor_noise arg must be a scalar\");\n \tmxMat = mxGetPr(arg);\n \tsensor_noise = *mxMat;\n \t\n \t/* ARG 9: maxwidth */\n \targ = prhs[8];\n \tif (notDblMtx(arg)) mexErrMsgTxt(\"maxwidth arg must be a int matrix\");\n \tif (mxGetM(arg)*mxGetN(arg) != 1)\n \tmexErrMsgTxt(\"maxwidth arg must be a scalar\");\n \tmxMat = mxGetPr(arg);\n \tdmwidth = *mxMat;\n \n \t/* ARG 10: subpixel */\n \targ = prhs[9];\n \tif (notDblMtx(arg)) mexErrMsgTxt(\"subpixelflag arg must be a int matrix\");\n \tif (mxGetM(arg)*mxGetN(arg) != 1)\n \tmexErrMsgTxt(\"subpixelflag arg must be a scalar\");\n \tmxMat = mxGetPr(arg);\n \tsubflag = *mxMat;\n \n \t/* ARG 11: maxscale */\n \targ = prhs[10];\n \tif (notDblMtx(arg)) mexErrMsgTxt(\"maxscale arg must be a int matrix\");\n \tif (mxGetM(arg)*mxGetN(arg) != 1)\n \tmexErrMsgTxt(\"maxscale arg must be a scalar\");\n \tmxMat = mxGetPr(arg);\n \tmxscale = *mxMat;\n \n \t/* ARG 6: WARNINGS */\n \tif (nrhs>11)\n {\n \targ = prhs[4];\n \tif notDblMtx(arg) mexErrMsgTxt(\"WARINGS arg must be a real scalar.\");\n \tif (mxGetM(arg) * mxGetN(arg) != 1)\n \tmexErrMsgTxt(\"WARNINGS arg must be a real scalar.\");\n \tmxMat = mxGetPr(arg);\n \twarnings = (int) *mxMat;\n }\n\n \tplhs[0] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[0] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx = mxGetPr(plhs[0]); \n \n \tplhs[1] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[1] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx_blur = mxGetPr(plhs[1]); \n \n \tplhs[2] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[2] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx_dark = mxGetPr(plhs[2]);\n \n \tplhs[3] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[3] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx_light = mxGetPr(plhs[3]);\n \n \tplhs[4] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[4] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx_x1zero = mxGetPr(plhs[4]);\n \n \tplhs[5] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[5] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx_y1zero = mxGetPr(plhs[5]);\n \n \tplhs[6] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[6] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx_x2zero = mxGetPr(plhs[6]);\n \n \tplhs[7] = mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);\n \tif (plhs[7] == NULL) mexErrMsgTxt(\"Cannot allocate result matrix\");\n \tx_y2zero = mxGetPr(plhs[7]);\n \n/* copy ends */\n\nmaxwidth = (int)dmwidth;\nmaxscale = (int)mxscale;\nsublocflag = (int)subflag;\n\nfind_edges(img,g1mag,g1dir,g1scale,g2,g2scale,g2all,sensor_noise,maxwidth,sublocflag,\n\t\t\tmaxscale,x,x_blur,x_dark,x_light,x_x1zero,x_y1zero,x_x2zero,x_y2zero);\n}\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/g1scale.m",
"content": "%###########################################################################\n%\n% g1scale(g1mag1,g1dir1,g1mag2,g1dir2,g1scale1,scale,noise,b_est)\n%\n% Purpose: Augments multi-scale Gaussian Gradient maps with significant \n%\t\testimates at a new scale. Pixels for which the magnitude \n%\t\tof the Gaussian gradient is under threshold in the multi-scale \n%\t\tmap (gradient magnitude input 1) but over threshold \n% \t\tat the new scale (gradient magnitude input 2) are updated \n%\t\twith the gradient magnitude, direction and scale value of \n%\t\tthe new scale.\n%\n% Input: g1mag1 - Multi-scale Gaussian gradient magnitude image\n% g1dir1 - Multi-scale Gaussian gradient direction image\n% g1mag2 - Gaussian gradient magnitude image at new scale\n% g1dir2 - Gaussian gradient direction image at new scale\n% g1scale1 - Multi-scale scale map\n% g1scale2 - Scale of new gradient estimates\n% noise - Estimated sensor noise\n% b_est - Derivatives near boundary estimated by reflecting\n% intensity function.\n% Output: g1mag1 - Integrated multi-scale gradient magnitude map\n% g1dir1 - Integrated multi-scale gradient direction map\n% g1scale1 - Integrated multi-scale scale map\n%\n%###########################################################################\n\nfunction[g1mag1,g1dir1,g1sc1] = g1scale(g1mag1,g1dir1,g1mag2,g1dir2,g1sc1,...\n scale,noise,b_est)\n\n\nnorms12\t= [0.765, 0.199, 0.0499, 0.0125, 0.00312, 0.00078];\nthresh \t= 5.6 * noise * norms12(scale);\n\nif ((scale<3) | b_est)\n krad\t= 1;\nelse\n krad \t= ceil(4.6*sqrt(pow2(2*(scale-2))-1));\nend\n \n\nif (scale == 1)\n\n g1mag1 \t= zeros(size(g1mag2));\n g1dir1 \t= 4 * ones(size(g1mag2));\n g1sc1 \t= zeros(size(g1mag2));\n\n f \t\t\t= find(g1mag2 >= thresh);\n g1mag1(f) \t= g1mag2(f);\n g1dir1(f) \t= g1dir2(f);\n g1sc1(f) \t= scale;\n\nelse\n sz = size(g1mag2);\n\n\t[i,j] \t= meshgrid(krad+1:1:sz(1)-krad,krad+1:1:sz(2)-krad);\n itrans = i';\n jtrans = j';\n if ~(isempty(itrans) | isempty(jtrans))\n \tK\t\t= sub2ind(size(g1mag2),itrans(:),jtrans(:));\n\n\t smat\t= g1sc1(krad+1:end-krad,krad+1:end-krad);\n\t mmat\t= g1mag2(krad+1:end-krad,krad+1:end-krad);\n\n \t f \t\t= find((smat==0) & (mmat>=thresh));\n\n g1mag1(K(f)) \t= g1mag2(K(f));\n g1dir1(K(f)) \t= g1dir2(K(f));\n g1sc1(K(f)) \t= scale;\n end;\nend;\n\nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/g1steer.m",
"content": "\n%######################################################################\n% \n% g1steer - Computes magnitude and direction of the gradient of the \n% luminance function based on x and y basis functions for 1st Gaussian \n% derivative.\n% \n% \n% Input: g1x - X basis for Gaussian gradient\n% g1y - Y basis for Gaussian gradient\n% Output: g1mag - Gradient Magnitude Estimate\n% g1dir - Gradient Direction Estimate\n%\n%######################################################################\n\n\nfunction[g1mag,g1dir] = g1steer(g1x,g1y)\n\ng1mag\t= zeros(size(g1x));\ng1dir\t= 4 * ones(size(g1x));\n\nf \t= find((g1x ~= 0) & (g1y ~= 0));\n\ng1dir(f) = atan2(-g1y(f),g1x(f));\ng1mag(f) = sqrt(g1y(f).^2 + g1x(f).^2);\n\nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/g2scale.m",
"content": "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% g2scale - Augments multi-scale Gaussian directional 2nd derivative maps\n% with significant estimates at a new scale. Pixels for which the magnitude\n% of the 2nd derivative is under threshold in the multi-scale map \n% (2nd derivative input 1) but over threshold at the new scale (2nd derivative\n% input 2) are updated with the 2nd derivative magnitude and scale value of the\n% new scale.\n%\n% Input: g2mag1 - Multi-scale Gaussian directional 2nd derivative image\n% g2mag2 - Gaussian directional 2nd derivative image at new scale\n% g1scale1 - Multi-scale scale map\n% noise - Estimated sensor noise\n% b_est - Estimate derivatives near boundaries?\n%\n% Output: g2mag - Integrated multi-scale directional 2nd derivative map\n% g2scale - Integrated multi-scale 2nd derivative scale map\n%\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\nfunction[g2mag1,g2sc1] = g2scale(g2mag1,g2mag2,g2sc1,scale,noise,b_est)\n\nnorms12 = [1.873 0.2443 0.0306 0.003817 0.00047715 0.0000596 0.000007455];\nthresh \t= 5.2 * noise * norms12(scale);\n\nif ((scale<3) | b_est)\n krad = 1;\nelse\n krad = ceil(4.6*sqrt(pow2(2*(scale-2))-1.0));\nend;\n\nif (scale == 1)\n\n\tg2mag1\t= zeros(size(g2mag2));\n\tg2sc1\t= zeros(size(g2mag2));\n\n f \t\t\t= find(abs(g2mag2) >= thresh);\n g2sc1(f) \t= scale;\n g2mag1(f) \t= g2mag2(f);\n\nelse\n\n \tsz = size(g2mag1); \n\t\n\t[i,j] \t= meshgrid(krad+1:sz(1)-krad,krad+1:sz(2)-krad);\n itrans = i';\n jtrans = j';\n if ~(isempty(itrans) | isempty(jtrans))\n\n\t\tK\t\t= sub2ind(size(g2mag1),itrans(:),jtrans(:));\n\t\n \tmagmat1 = g2mag1(krad+1:end-krad,krad+1:end-krad);\n \tmagmat2 = g2mag2(krad+1:end-krad,krad+1:end-krad);\n \tf \t\t= find(abs(magmat1) == 0 & abs(magmat2) >= thresh);\n\t\n \tg2mag1(K(f)) = g2mag2(K(f));\n \tg2sc1(K(f)) = scale;\n end;\nend;\n\nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/g2steer.m",
"content": "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% g2steer - Computes the second Gaussian derivative of the luminance function\n% in specified direction ( normally the Gradient direction). The three input\n% basis function are used to steer the derivative. The units of the direction\n% map are radians and the range is between -pi and pi. A value of -4 indicate\n% that no direction was measurable. The 2nd derivative is taken only for valid\n% directions.\n%\n% Input: g2x - Response map for 1st G2 basis function\n% g2y - Response map for 2nd G2 basis function\n% g2xy - Response map for 3rd G2 basis function\n% g1dir - Luminance gradient direction map\n%\n% Output: g2 - Second derivative response map\n%\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\nfunction[g2] = g2steer(g2x,g2y,g2xy,g1dir)\n\ng2\t = zeros(size(g2x));\n\nf \t\t= find((g1dir ~= 4.0) & (g2x ~= 0) & (g2xy ~= 0) & (g2y ~= 0));\ncdir \t= cos(2*g1dir);\nsdir = sin(2*g1dir);\n\ng2(f) \t= 0.5 * (1 + cdir(f)) .* g2x(f) - sdir(f) .* g2xy(f) + ...\n 0.5 * (1 - cdir(f)) .* g2y(f);\n\nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/gauss.m",
"content": "% gauss.m: Calculates Gaussian pdf values.\n\nfunction[y] = gauss(x,std)\n\ny = exp(-x.^2/(2*std^2)) / (std*sqrt(2*pi));\n\nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/gradient.m",
"content": "%############################################################\n%\n% gradient(maxscale,noise,gauss_a,conv_type,filtpath)\n% Computes non-zero gradient in the luminance function by \n% \n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\nfunction[g1mag,g1dir,g1sc] = gradient(maxscale,noise,gauss_a,...\n\t\t\t\t\t\t\t\t conv_type)\n\nfm2 \t= '.ascii';\n\n%############\n% Initialise:\n%############\ng1mag\t= 0;\ng1dir \t= 0;\ng1sc\t= 0;\n\nfor scale = 1:1:maxscale\n\n % set scale values for filters \n if (scale == 1)\n g1scaleval = '05';\n else\n g1scaleval = '1';\n end;\n \n mimg\t= gauss_a(:,:,scale);\n\n\t%#####################################################\n % Compute response of first derivative Gaussian filter \n\t%\tto the blurred image in an arbitrary direction:\n\t%#####################################################\n %kern1 \t= load(strcat(filtpath,'/gy',g1scaleval,fm2));\n kern1 \t= load(strcat('gy',g1scaleval,fm2));\n rc1 \t= convolve_2(mimg,kern1,conv_type);\n %kern2 \t= load(strcat(filtpath,'/g1x',g1scaleval,fm2));\n kern2 \t= load(strcat('g1x',g1scaleval,fm2));\n rc2 \t= convolve_2(rc1,kern2,conv_type); % x basis input\n \n %kern3 \t= load(strcat(filtpath,'/gx',g1scaleval,fm2));\n kern3 \t= load(strcat('gx',g1scaleval,fm2));\n rc3 \t= convolve_2(mimg,kern3,conv_type);\n %kern4 \t= load(strcat(filtpath,'/g1y',g1scaleval,fm2));\n kern4 \t= load(strcat('g1y',g1scaleval,fm2));\n rc4 \t= convolve_2(rc3,kern4,conv_type); % y basis input\n \n\t%###################################################\n % Calculate magnitude and direction of the gradient:\n\t%###################################################\n [m2,d2] = g1steer(rc2,rc4);\n \n omag = g1mag;\n odir = g1dir;\n osc = g1sc;\n \n\t%############################################\n % Augment multi-scale Gaussian Gradient maps:\n\t%############################################\n [g1mag,g1dir,g1sc] = g1scale(g1mag,g1dir,m2,d2,g1sc,scale,noise,0); \n \nend;\n\nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/main_edge.m",
"content": "%############################################################\n%\n% main_edge.m: Main function called from edge GUI interface.\n%\n%############################################################\n\nfunction[OutputData] = main_edge(img,scale,noise,edgew,...\n conss,congrd,subpixelflag)\n\n%#############\n% Input Image:\n%#############\nif (size(img,3)~=1)\n img = rgb2gray(img);\nend;\nimg=double(img);\n\n\n%########################\n% Compose blurred images:\n%########################\ngauss_imgs = scalespace(img,scale,conss);\n\n%########################\n% Calculate gradient map:\n%########################\n[g1_mag,g1_dir,g1_sc] = gradient(scale,noise,gauss_imgs,congrd);\n\n%##############################\n% Calculate 2nd derivative map:\n%##############################\n[g2_mag,g2_sc,g2_all] = derivative2nd(g1_dir,scale,noise,gauss_imgs,congrd);\n\n\n% save input.mat img g1_mag g1_dir g1_sc g2_mag g2_sc g2_all noise edgew subpixelflag scale\n%inparTest = checkInParam(img,g1_mag,g1_dir,g1_sc,g2_mag,g2_sc,g2_all,noise,...\n% edgew,subpixelflag,scale);\n%if inparTest > 0\n% display('stop');\n%end\n%####################\n% Calculate edge map:\n%####################\nclear find_edges\n[edge_map,blur_map,dark_map,light_map,xzero1_map,yzero1_map,xzero2_map,yzero2_map] = ...\n find_edges(img,g1_mag,g1_dir,g1_sc,g2_mag,g2_sc,g2_all,noise,...\n edgew,subpixelflag,scale);\nclear find_edges\n \n% outparTest = checkOutParam(edge_map,blur_map,dark_map,light_map,xzero1_map,yzero1_map,xzero2_map,yzero2_map); \n% if outparTest > 0\n% display('stop');\n% end\n\n%save output.mat edge_map blur_map dark_map light_map xzero1_map yzero1_map xzero2_map yzero2_map \n% Branka's code leaves dark and light as double which need rounding:\ndark_map = round(dark_map);\nlight_map = round(light_map);\n \n\n%#######################\n% Output data in struct:\n%#######################\n% OutputData = struct('edge',edge_map,'dark_map',dark_map,...\n% 'light_map',light_map,'blur_map',blur_map,...\n% 'g1mag',g1_mag,'g1dir',g1_dir,'g1scale',g1_sc,...\n% 'g2mag',g2_mag,'g2scale',g2_sc,...\n% 'x1zero',xzero1_map,'y1zero',yzero1_map,...\n% 'x2zero',xzero2_map,'y2zero',yzero2_map,...\n% 'noise',noise);\n \nOutputData = struct('edge',edge_map,'blur',blur_map,...\n 'dark',dark_map,'light',light_map,...\n 'g1mag',g1_mag,'g1dir',g1_dir,'g1scale',g1_sc,...\n 'g2mag',g2_mag,'g2scale',g2_sc,'g2_all',g2_all,...\n 'noise',noise,'xzero',xzero1_map,'yzero',yzero1_map);\n \n \n \nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/mat2hough_scale.m",
"content": "function [ r, th] = mat2hough_scale(m, n, r_max, r_res, th_res)\n% MAT2HOUGH converts matrix coordinates to Hough map values\n%\n% Inputs:\n% r_max: Maximum value r can take\n% m: vertical matrix index\n% n: horizontal matrix index\n%\n% Output:\n% r: Hough domain r value equivalent to n\n% th: Hough domain \\theta value equivalent to m\n%\n% Author:\n% Ron Tal\n%\n% Date:\n% February 16, 2009\n%\n% Description:\n% This function converts the coordinates of a matlab matrix\n% representing a Hough map, to the equivalent Hough domain\n% values\n%\n th = round2frac((m - 1) * th_res, th_res);\n r = round2frac((n - 1) * r_res - r_max, r_res);\nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/plot_edgelmap.m",
"content": "\n% Function to plot gradient direction vectors at both pixel\n% and subpixel locations:\n\nfunction[] = plot_edgelmap(img,edgemap,xzeromap,yzeromap,g1dir,...\n newarrcol,leg1,leg2,imtitle);\n\n[M,N] = size(edgemap);\n\n[I,J] = find(edgemap==255);\nK = find(edgemap==255);\n\nX = J;\nY = I;\n\n% Set arrowlength, then define: \n% (Uarrow,Varrow) = arrow lengths in (x,y) directions\n% (Xarrow,Yarrow) = arrow tail points \narrowlen = 1;\nGraddir = g1dir(K) + pi/2;\nUarrow = arrowlen * cos(Graddir);\nVarrow = -arrowlen * sin(Graddir);\n\nXtp = X - 0.5*Uarrow;\nYtp = Y - 0.5*Varrow;\n\nXarrow = xzeromap(K) - 0.5*Uarrow;\nYarrow = yzeromap(K) - 0.5*Varrow;\n\nfigure; \nimagesc(img);\naxis image;\ncolormap(gray);\nhold on;\np1 = plot(0,0);\nset(p1,'Color',[0 0 1]);\nset(p1,'Visible','off');\np2 = plot(0,0);\nset(p2,'Color',newarrcol);\nset(p2,'Visible','off');\n%q1 = quiver(Xtp,Ytp,Uarrow,Varrow,0); JE Jul08 - suppress pixel-localized\n%edges\nq2 = quiver(Xarrow,Yarrow,Uarrow,Varrow,0); %\n%set(q1,'Color',[0 0 1]);\nset(q2,'Color',newarrcol);\nL = legend([p1,p2],leg1,leg2,-1);\nset(L,'Fontsize',8);\ntwords = ['Edgels for Image ',imtitle];\ntt = title(twords);\nset(tt,'Interpreter','none');\nhold off;\n\nreturn;\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/round2frac.m",
"content": "%% round2frac() Rounds the input data to the nearest fraction\n%\n% Description: \n%\n% Takes 'data' a matrix of floats and rounds it to the nearest 'frac'\n%\n% Author:\n%\n% Ron Tal \n%\n% Date Created:\n%\n% November 4, 2008\n%\nfunction [round_data] = round2frac(data, frac)\n% if frac > 1, error('Fraction must be smaller than 1'); end\n round_data = data.*(1/frac);\n round_data = round(round_data);\n round_data = round_data.*frac;\nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/run_elderEdge.m",
"content": "clc\nclear\nclose all\nfor i = 1:9\n clear mex\n edgeStruct = elderEdge();\n \n figure;\n imshow(edgeStruct.edge_map);\n i\n length(find(edgeStruct.edge_map)) \n diffs{i} = edgeStruct.edge_map;\nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/scalespace.m",
"content": "%################################################################\n%\n% r = scalescape(mimg,maxscale,conv_type)\n%\n% Create a series of Gaussian blurred images according to a \n% given maximum scale.\n%\n% Input: mimg: image for convolution w/ Gaussian filter\n% maxscale: maximum scale value\n% conv_type: convolution type flag\n%\n% Output: blurred_imgs: maxscale blurred images\n%\n%################################################################\n\nfunction[blurred_imgs] = scalespace(mimg,maxscale,conv_type)\n\nfor scale = 1:1:maxscale\n\t\n\tif (scale < 3)\n % Image is unblurred: \n\t\tblurred_imgs(:,:,scale) = mimg;\n \n\telse\n\t % Set values for generating Gaussian filter at given scale:\n [stdd,sizz] = setvalues(scale);\n\t kern = d2gauss(sizz,stdd,1,1,0,1/(stdd*sqrt(2*pi)));\t\n\n c1mimg = convolve_2(mimg,kern,conv_type);\n\t cres = convolve_2(c1mimg,rot90(kern,3),conv_type);\n \n blurred_imgs(:,:,scale) = cres;\n\t\n\tend;\n\t\nend;\n\t\nreturn;\n\n% Results differ to cantata output for scale >= 3 in the 4th d.p."
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/code/setvalues.m",
"content": "%##########################################################################\n%\n% [stdd,sizz] = setvalues(scale)\n%\n% Set values for generating 2d Gaussian filter according to \n% input scale.\n%\n% Input: scale\n% \n% Output: stdd: std dev'n along width (along height assumed to be 1)\n% size: width of output = #columns (height assumed to be 1)\n%\n%##########################################################################\n\nfunction[stdd,sizz] = setvalues(scale);\n\nif (scale < 3)\n stdd = 1;\nelse\n stdd = sqrt((2^(scale-2))^2 - 1);\nend;\n\nsizz = 2 * ceil(4.6 * stdd) + 1;\n\nreturn;"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g1x05.ascii",
"content": "0.750938 0 -0.750938 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g1x1.ascii",
"content": "0.000535321 0.0132955 0.107982 0.241971 -0 -0.241971 -0.107982 -0.0132955 -0.000535321 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g1y05.ascii",
"content": "0.750938 \n0 \n-0.750938 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g1y1.ascii",
"content": "0.000535321 \n0.0132955 \n0.107982 \n0.241971 \n-0 \n-0.241971 \n-0.107982 \n-0.0132955 \n-0.000535321 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g2x05.ascii",
"content": "0.0594001 1.02157 -2.16194 1.02157 0.0594001 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g2x1.ascii",
"content": "0.00200744 0.0354546 0.161972 0 -0.39894 0 0.161972 0.0354546 0.00200744 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g2y05.ascii",
"content": "0.0594002 \n1.02157 \n-2.16194 \n1.02157 \n0.0594002 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/g2y1.ascii",
"content": "0.00200744 \n0.0354546 \n0.161972 \n0 \n-0.39894 \n0 \n0.161972 \n0.0354546 \n0.00200744 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/gx05.ascii",
"content": "0.157727 0.684552 0.157727 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/gx1.ascii",
"content": "0.00443185 0.053991 0.241971 0.398942 0.241971 0.053991 0.00443185 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/gy05.ascii",
"content": "0.157726 \n0.68455 \n0.157726 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/ElderZuckerEdgeDetector/filters/gy1.ascii",
"content": "0.00443185 \n0.053991 \n0.241971 \n0.398942 \n0.241971 \n0.053991 \n0.00443185 \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/computeKernel.m",
"content": "function [kern,ind]=computeKernel(e,r_max,SIGMA_X, SIGMA_TH, r_res, th_res)\n%computing the kernel for the probabilistic hough tranform\n r_th = e;\n C =[SIGMA_X^2 + (r_th^2) * (SIGMA_TH^2), r_th * (SIGMA_TH^2); r_th * (SIGMA_TH^2), SIGMA_TH^2];\n\n C_inv = inv(C);\n C_det = det(C);\n N = 1 / (2*pi * sqrt(C_det));\n R = -round2frac(3 *sqrt(C(1,1)), r_res):r_res:round2frac(3 *sqrt(C(1,1)), r_res);\n TH = -round2frac(3 * SIGMA_TH, th_res):th_res:round2frac(3 * SIGMA_TH, th_res);\n c=C_inv(1,1);\n d=C_inv(1,2);\n g=C_inv(2,1);\n f=C_inv(2,2);\n [a,b]=meshgrid(R,TH);\n vals=N * exp(-0.5*((a*c+b*g).*a+(a*d+b*f).*b));\n [r, c] = find(vals > 0.05*max(vals(:)));\n m_c = min(c) - 1;\n m_r = min(r) - 1;\n linearInd = sub2ind([length(TH),length(R)], r, c);\n kern=[c- m_c,r- m_r, vals(linearInd)];\n ind = e + r_max + 1;\n \nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/determine_hough_lines_kernel_vote_remove.m",
"content": "function [ lines, edgeStruct ] = determine_hough_lines_kernel_vote_remove( im, pp, kernels, kernels_flip, num, kernel_params, r_res, th_res, sig_bound, frac,scale_factor)\n\n \n%edge detection\nedgeStruct = main_edge(im,5,1,10,1,0,1);\n\n%find the pixel location that has edge value\nedge_index = find(edgeStruct.edge);\nedge_img_locations = [edgeStruct.xzero(edge_index),edgeStruct.yzero(edge_index)];\nedge_gradients = edgeStruct.g1dir(edge_index);\n%create a hough map\n\nmap = mexVoteEdges_v3_scale(edge_img_locations, edge_gradients, kernels, kernels_flip, r_res,th_res, pp, kernel_params,scale_factor);\n\n%iteratively extract lines from hough map\n[P] = hough_find_peaks_vote_removal(map, num, r_res, th_res, edgeStruct, kernels, kernels_flip, pp, kernel_params, 0.0917, 0.3934, sig_bound, frac, scale_factor);\n%the lines consist of [rho, theta, strength]\nlines = P(:, 1:3);\nend\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/get_all_segments_assoc_edgeremoval.m",
"content": "function [ begin_points, end_points,ls_likelihoods] = get_all_segments_assoc_edgeremoval( line_data, edgeStruct, pp, LIKE_MODEL,scale_factor)\n\nbegin_points = [];\nend_points = [];\nls_likelihoods = [];\nfor i = 1:size(line_data, 1)\n [~, begin_pointsi, end_pointsi, ~,~, ~, ~, ~, ~, likelihoods, edgeMap] = get_line_segment_DP_edgeremoval( edgeStruct, line_data(i,1), line_data(i,2), pp, LIKE_MODEL, scale_factor); \n for j = 1:size(likelihoods,2)\n begin_points = [begin_points; begin_pointsi(j,:)];\n end_points = [end_points; end_pointsi(j,:)]; \n ls_likelihoods = [ls_likelihoods; likelihoods(j)];\n end\n edgeStruct.edge = edgeMap;\nend\n\nend\n\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/get_line_segment_DP_edgeremoval.m",
"content": "function [final_labels, begin_points, end_points, begin_point, end_point, posterior, lslength, logratioposterior, ls_probDiff, likelihoods, edgemap] = get_line_segment_DP_edgeremoval( edgeStruct, rho, theta, pp, probStruct, scale_factor)\n% Description: Line segment detector that removes the edges associated with\n% each detected line segment.\n\nfinal_labels = [];\nbegin_points = []; \nend_points = [];\nbegin_point = []; \nend_point = [];\nposterior = [];\nlslength = [];\nlogratioposterior = [];\nls_probDiff = [];\n\nedgemap = edgeStruct.edge;\nedge_gradients = edgeStruct.g1dir;\nexist_edge_on = probStruct.exist_edge_on;\nexist_edge_off = probStruct.exist_edge_off;\nang_dev_on = probStruct.ang_dev_on_hist;\nang_dev_off = probStruct.ang_dev_off_hist;\nnexist_edge_on = probStruct.nexist_edge_on;\nnexist_edge_off = probStruct.nexist_edge_off;\n\n%the transition probability for the line segments\n%it is generated from sampling in the YorkUDB dataset\nprob_leave_on = 0.0051/scale_factor;\nprob_stay_on =1-prob_leave_on;\nprob_leave_off = 0.0014/scale_factor;\nprob_stay_off = 1-prob_leave_off;\nprob_on = 0.247; \nprob_off = 0.753;\n[m, n] = size(edgeStruct.edge);\n \n% GET EQUATION OF THE LINE\nX_1 = rho * cos(theta) - 2000*cos(theta+pi/2) + pp(1);\nX_2 = rho * cos(theta) + 2000*cos(theta+pi/2) + pp(1);\nY_1 = rho * sin(theta) - 2000*sin(theta+pi/2) + pp(2);\nY_2 = rho * sin(theta) + 2000*sin(theta+pi/2) + pp(2);\nM = (Y_2-Y_1)/(X_2-X_1 + 1e-7);\nb = Y_2 - X_2*M;\n\n% GET BOUNDARIES OF THE LINE IN IMAGE FRAME\np1 = [1, M + b];\np2 = [n, M*n + b];\np3 = [(1-b)/M,1];\np4 = [(m-b)/M, m];\n\npoints = [p1;p2;p3;p4];\nX = points(:,1);\nY = points(:,2);\n \nX_valid = (X <= n).*(X >= 1);\nY_valid = (Y <= m).*(Y >= 1);\np_valid = X_valid.*Y_valid;\npoints_valid = points(p_valid>0, :); %changed find to logical index\nX_l = points_valid(:,1)';\nY_l = points_valid(:,2)';\nif isempty(X_l) || isempty(Y_l)\n return;\nend\n%get the line points\nindexXY=sampleLine(rho,theta,n,m,pp);\nyy=ceil(indexXY(:,2)+pp(2));\nxx=ceil(indexXY(:,1)+pp(1));\nindex = sub2ind([m,n],yy,xx);\n\np1 = [X_l(1), Y_l(1)];\np2 = [X_l(2), Y_l(2)];\n% FIND POINTS CONSIDERED\nnode_idx=index;\ny_h = edgemap(node_idx);\n% y_h(y_h > 0) = 1;\n% FIND ORIENTATION DIF AND DIST:\nTH = pi-theta;\nif TH<0, TH=TH+pi;\nelseif TH>pi, TH=TH-pi;\nend\n\nedge_gradientsmap=edge_gradients(node_idx);\nedgeind=edge_gradientsmap < 0;\nedge_gradientsmap(edgeind) = edge_gradientsmap(edgeind) + pi;\nedgeind=edge_gradientsmap>pi;\nedge_gradientsmap(edgeind)= edge_gradientsmap(edgeind)-pi;\n\nedge_img_locations = [edgeStruct.xzero(node_idx),edgeStruct.yzero(node_idx)];\n\nang_dev = round((edge_gradientsmap - TH)*180/pi);\nang_dev(ang_dev < -90) = ang_dev(ang_dev < -90) + 180;\nang_dev(ang_dev > 90) = ang_dev(ang_dev > 90) - 180;\nrange_ang = -90:1:90;\nrange_dis = 0:0.05:5;\nloc_points = [xx, yy];\nloc_points(y_h > 0,:) = edge_img_locations(y_h > 0,:);\nif size(loc_points,1) == 0\n loc_points = [-1000, -1000];\nend\n\n\n%Get the projection of points along the line defined by p1 and p2\n[points_proj, distances] = project_point_to_line_segment_vec(p1,p2,loc_points);\n \ndistances = interp1(range_dis, range_dis, abs(distances), 'nearest');\nrange_dis = 0:0.05:1.95;\n% Eliminate GROSS OUTLIERS\nnode_idx(distances > 2) = [];\nang_dev(distances > 2) = [];\ny_h(distances > 2) = [];\npoints_proj(distances > 2,:) = [];\ndistances(distances > 2) = [];\n% SORT:\nif abs(M) > 1\n [~, idx] = sort(points_proj(:,2));\nelse\n [~, idx] = sort(points_proj(:,1));\nend\npoints_proj = points_proj(idx,:);\nnode_idx = node_idx(idx);\ndistances = distances(idx);\nang_dev = ang_dev(idx);\ny_h = y_h(idx);\n\nang_dev(y_h == 0) = NaN;\n%INIT\nbegin_point = points_proj(1,:);\nend_point = points_proj(end,:);\nPsi_t = [prob_stay_on prob_leave_off; prob_leave_on prob_stay_off];\npi_var = [prob_on; prob_off];\n[~, obslik,~,DP_table, aux_table, z]=hmmParameters(exist_edge_on,exist_edge_off,ang_dev_on,...\n ang_dev_off,node_idx,Psi_t,pi_var,y_h,distances,range_dis,nexist_edge_on,...\n nexist_edge_off,prob_on,prob_off,prob_stay_on,prob_leave_off,prob_leave_on,...\n prob_stay_off,ang_dev,range_ang);\n\n[lsjoint, lslogz,final_labels, node_on, likelihoods] = trace_Back(DP_table, aux_table, z, node_idx, obslik);\nedgemap(node_on) = 0;\n\nfinal_labels(final_labels == 2) = 0;\n% RETURN LINE SEGMENTS\n[begin_points,end_points,lslength,startpositions,endpositions]=returnLines(points_proj,final_labels);\n\n%compute p(x=0|y) for each line segment\nlogjointoff = zeros(size(begin_points,1), 1);\nfor j = 1:size(begin_points,1) %number of line segments\n for i = startpositions(j):endpositions(j)\n if startpositions(j) == 1\n transition = prob_off;\n past = 0;\n elseif i == startpositions(j)\n transition = prob_leave_on;\n past = DP_table(1,i-1);\n else\n transition = prob_stay_off;\n past = DP_table(2,i-1);\n end\n if y_h(i)\n [~, nn] = min(abs(distances(i) - range_dis));\n [~, mm] = min(abs(ang_dev(i) - range_ang));\n p_y_off_1 = exist_edge_off(nn);\n p_t_off_1 = ang_dev_off(mm);\n loc_off = p_y_off_1*p_t_off_1; %likelihood of y given x = off\n logjointoff(j) = logjointoff(j) + log(loc_off) + log(transition) + past;\n else\n [~, nn] = min(abs(distances(i) - range_dis));\n loc_off = nexist_edge_off(nn);\n logjointoff(j) = logjointoff(j) + log(loc_off) + log(transition) + past;\n end\n\n end\nend\n\nfor i = 1:size(logjointoff,1)\n if logjointoff(i) > lslogz(i) || logjointoff(i) > lsjoint(i)\n display('Error');\n end\nend\nif size(lsjoint,1) > 0\n logratioposterior = lsjoint - logjointoff; \nelse\n logratioposterior = 0;\nend\nend\n\n\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/hough_find_peaks_vote_removal.m",
"content": "%% Function P = hough_find_peaks_with_near_peak_supression(map, num_lines, NHOOD)\n% Input\n% map Hough Map\n% num_lines Maximum number of lines\n% NHOOD [R, TH] neighborhood to be\n% surpressed\n%\n% Output\n% P Hough Peaks\n%\n%\nfunction [P] = hough_find_peaks_vote_removal(map, num, r_res, th_res, edgeStruct, kernels, kernels_flip, pp, kernel_params, sig_th, sig_r, sig_bound, frac, scale_factor)\n \n % Loop until no more peaks or number of desired peaks have been\n % selected\n COUNT = 0;\n MAX_R = 400*scale_factor;\n P =[];\n edgeMap = edgeStruct.edge;\n iter = 1; \n [m,n]=size(edgeMap);\n while 1\n iter = iter + 1;\n % Find max peak:\n [maxmap,ind]=max(map(:));\n [r,c] = ind2sub(size(map), ind); \n if length(r) > 1, r = r(1); c = c(1); end\n %here are some stopping criteria \n if isempty(r)\n return; \n end\n [rho, theta] = mat2hough_scale(r, c, MAX_R, r_res, th_res);\n if ismember([rho, theta, maxmap], P, 'rows', 'legacy')\n return; \n end\n if COUNT > 0\n if (maxmap/P(1,3)) < frac \n return; \n end\n end\n % Save max peak\n P = [P; [rho theta maxmap]];\n COUNT = COUNT + 1;\n \n % If reached number of lines, return\n if size(P, 1) == num\n return; \n end\n \n %there following block of code identify the location of edges that\n %need to be removed from the hough map and edge map\n indexXY=sampleLine(rho,theta,n,m,pp);\n yy=ceil(indexXY(:,2)+pp(2));\n xx=ceil(indexXY(:,1)+pp(1));\n edge_index = sub2ind([m,n],yy,xx);\n X_1 = rho * cos(theta) - 2000*cos(theta+pi/2) + pp(1);\n X_2 = rho * cos(theta) + 2000*cos(theta+pi/2) + pp(1);\n Y_1 = rho * sin(theta) - 2000*sin(theta+pi/2) + pp(2);\n Y_2 = rho * sin(theta) + 2000*sin(theta+pi/2) + pp(2);\n M = (Y_2-Y_1)/(X_2-X_1+1e-7);\n b = Y_2 - X_2*M;\n line_eq = [M, -1, b];\n\n edge_img_locations = [edgeStruct.xzero(edge_index),edgeStruct.yzero(edge_index), ones(length(edge_index(:)),1)];\n edge_gradients = edgeStruct.g1dir(edge_index);\n \n edge_gradients2 = edge_gradients;\n indexless0=edge_gradients2 < 0;\n indexgreaterpi=edge_gradients2>pi;\n edge_gradients2(indexless0) = edge_gradients2(indexless0) + pi;\n edge_gradients2(indexgreaterpi)= edge_gradients2(indexgreaterpi)-pi;\n \n edge_gradients2 = pi - edge_gradients2;\n edgetetalesspi=edge_gradients2 - theta<-pi/2;\n edge_gradients2(edgetetalesspi)= edge_gradients2(edgetetalesspi)+pi;\n edgethetagreaterpi=edge_gradients2-theta>pi/2;\n edge_gradients2(edgethetagreaterpi)= edge_gradients2(edgethetagreaterpi)-pi;\n orientationDiff = abs(edge_gradients2 - theta);\n distances = (abs(line_eq*edge_img_locations')'/norm(line_eq(1:2)));\n \n distanceBoundary=(distances <= sig_bound*sig_r);\n edge_img_locations_remove = edge_img_locations(distanceBoundary, 1:2);\n edge_gradients_remove = edge_gradients(distanceBoundary);\n \n orientationDiff = orientationDiff(distanceBoundary);\n edge_index = edge_index(distanceBoundary);\n orientatinDiffboundary=orientationDiff <=sig_bound*sig_th;\n edge_img_locations_remove = edge_img_locations_remove(orientatinDiffboundary, :);\n edge_gradients_remove = edge_gradients_remove(orientatinDiffboundary);\n edge_index = edge_index(orientatinDiffboundary);\n \n if isempty(edge_img_locations_remove) \n break; \n end\n edgeMap(edge_index) = 0;\n %remove the detected lines from the hough map\n map=mexRemoveVotes_v3_scale(edge_img_locations_remove, edge_gradients_remove, kernels, kernels_flip, r_res, th_res, pp, kernel_params, map, scale_factor);\n\n %map = mexRemoveVotes_v3_scale(edge_img_locations_remove, edge_gradients_remove, kernels, kernels_flip, r_res, th_res, pp, kernel_params, map, scale_factor);\n\n end\nend\n\n "
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/kernelInitialization.m",
"content": "function [kernels, kernels_flip, kernel_params] =kernelInitialization(img)\n[m,n,~]=size(img);\nscale_factor = sqrt(m^2+n^2)/800; %800 is the diagnal length of 640x480 image\nmaxr = floor(400*scale_factor);\nsigmax = 0.4;\nr_res = 0.2;\nth_res = 0.002;\nsigmatheta = 5.4*(pi/180);\n[kernels, kernels_flip, kernel_params] = precompute_kernels_sparse_res2(maxr, sigmax, sigmatheta, r_res, th_res);\nend\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/lineSegmentation_HighRes.m",
"content": "function [lines, fullLines] =lineSegmentation_HighRes(img,kernels, kernels_flip, kernel_params)\n%use 640x480 image as a reference. the diagonal size of this image is 800\n%if image size 640x480 scale factor = 1\n%if image size 1280x960 scale factor = 2 ... etc.\n%the lines variable contains the detected line segmentations it arranged as\n%[x1 y1 x2 y2 probability]\n%The fullLines are the detected lines. It is arranged as [rho theta probability]\npp=[307.551305282635,251.454244960136]; %principle point\nsig_bound = 3; %threshold for the line detection\nr_res = 0.2; %the theshold for the rho\nth_res = 0.002; %the threshold for theta\n[m,n,~]=size(img);\nscale_factor = sqrt(m^2+n^2)/800; %800 is the diagnal length of 640x480 image\n%the kernel of the algorithm is calibrated on 640x480 image\n%rescale the principle point\npp(1)=pp(1)*n/640;\npp(2)=pp(2)*m/480;\n[lines, fullLines] = run_lineSegmentAlgorithm(kernels, kernels_flip, kernel_params, sig_bound, r_res, th_res, img, scale_factor,pp); \n\nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/mexfiles/hmmParameters.m",
"content": "function [alpha_t, obslik,T,DP_table, aux_table, z]=hmmParameters(exist_edge_on,exist_edge_off,ang_dev_on,...\n ang_dev_off,node_idx,Psi_t,pi_var,y_h,distances,range_dis,nexist_edge_on,...\n nexist_edge_off,prob_on,prob_off,prob_stay_on,prob_leave_off,prob_leave_on,...\n prob_stay_off,ang_dev,range_ang)\nnode_idx_length=length(node_idx);\nDP_table = zeros(2, node_idx_length);\naux_table = zeros(2, node_idx_length);\n% aux_table(1,1) = -Inf;\n% aux_table(2,1) = -Inf;\nz = zeros(node_idx_length,1); % E.A. List of log evidences: sum(log(z)) from 1:t.\nalpha_t = zeros(2,node_idx_length); %E.A. 2x1 vector (on/off) of posterior prob.: e.g. alpha_1 = [p(x=on|x); p(x=off|x)]\nobslik = zeros(2,node_idx_length); %E.A. 2x1 observation likelihood\nif y_h(1)\n [val, nn] = min(abs(distances(1) - range_dis));\n [val, mm] = min(abs(ang_dev(1) - range_ang));\n p_y_on_1 = exist_edge_on(nn);\n p_y_off_1 = exist_edge_off(nn);\n p_t_on_1 = ang_dev_on(mm);\n p_t_off_1 = ang_dev_off(mm);\n\n loc_on = p_y_on_1*p_t_on_1; %likelihood of y given x = on\n loc_off = p_y_off_1*p_t_off_1; %likelihood of y given x = off\n\n DP_table(1,1) = log(loc_on) + log(prob_on);\n DP_table(2,1) = log(loc_off) + log(prob_off);\n\n %Compute prob. of the evidence. E.A.\n obslik(:,1) = [loc_on; loc_off];\n z(1) = sum(obslik(:,1) .* pi_var);\n alpha_t(:,1) = [ loc_on * pi_var(1); loc_off * pi_var(2)] / z(1);\n\n% if (round(sum(alpha_t(:,1))) ~= 1)\n% display('Error');\n% end\n \n%% Compute log likelihood ration and evidenct -- E.A \n% log_like_ratio_list(1) = log((p_y_on_1*p_t_on_1)/(p_y_off_1*p_t_off_1)); %E.A. log likelihood ratio (1st position, edge)\n% evidence(1) = log(p_y_on_1*p_t_on_1*prob_on + p_y_off_1*p_t_off_1*prob_off);\n%% \nelse\n [val, nn] = min(abs(distances(1) - range_dis));\n\n loc_on = nexist_edge_on(nn);\n loc_off = nexist_edge_off(nn);\n\n DP_table(1,1) = log(loc_on) + log(prob_on);\n DP_table(2,1) = log(loc_off) + log(prob_off);\n\n\n %Compute prob. of the evidence. E.A.\n %psi = [loc_on; loc_off];\n obslik(:,1) = [loc_on; loc_off];\n z(1) = sum(obslik(:,1) .* pi_var);\n alpha_t(:,1) = [ loc_on * pi_var(1); loc_off * pi_var(2)] / z(1);\n %obslik(:,1) = [loc_on; loc_off];\n\n% if (round(sum(alpha_t(:,1))) ~= 1)\n% display('Error');\n% end \n% \n%% Compute log likelihood ration and evidenct -- E.A \n% log_like_ratio_list(1) = log(p_y_on_1/p_y_off_1); %E.A. log likelihood ratio (1st position, no edge) \n% evidence(1) = log(p_y_on_1*prob_on + p_y_off_1*prob_off);\n%% \nend\n\n% LOOP THROUGH\nfor i =2:node_idx_length\n if y_h(i)\n [val, nn] = min(abs(distances(i) - range_dis));\n [val, mm] = min(abs(ang_dev(i) - range_ang));\n p_y_on_1 = exist_edge_on(nn);\n p_y_off_1 = exist_edge_off(nn);\n p_t_on_1 = ang_dev_on(mm);\n p_t_off_1 = ang_dev_off(mm);\n\n loc_on = p_y_on_1*p_t_on_1; %likelihood of y given x = on\n loc_off = p_y_off_1*p_t_off_1; %likelihood of y given x = off\n\n [DP_table(1,i), aux_table(1,i)] = max([log(loc_on) + log(prob_stay_on) + DP_table(1,i-1), log(loc_on) + log(prob_leave_off) + DP_table(2,i-1)]);\n [DP_table(2,i), aux_table(2,i)] = max([log(loc_off) + log(prob_leave_on) + DP_table(1,i-1), log(loc_off) + log(prob_stay_off) + DP_table(2,i-1)]);\n\n\n %Compute prob. of the evidence. E.A. \n %psi = [loc_on; loc_off];\n obslik(:,i) = [loc_on; loc_off];\n predict = Psi_t * alpha_t(:,i-1);\n z(i) = sum(obslik(:,i) .* predict);\n alpha_t(:,i) = [ loc_on * predict(1); loc_off * predict(2)] / z(i);\n %obslik(:,i) = [loc_on; loc_off];\n\n\n\n% if (round(sum(alpha_t(:,1))) ~= 1)\n% display('Error');\n% end \n\n%% Compute log likelihood ration and evidenct -- E.A \n% log_like_ratio_list(i) = log((p_y_on_1*p_t_on_1)/(p_y_off_1*p_t_off_1)); %E.A. store likelihood \n% evidence(i) = evidence(i-1) + log(p_y_on_1*p_t_on_1*prob_stay_on + p_y_on_1*p_t_on_1*prob_stay_off + ...\n% p_y_off_1*p_t_off_1*prob_leave_on + p_y_off_1*p_t_off_1*prob_stay_off); %E.A. log evidence 1..i\n%%\n else\n [val, nn] = min(abs(distances(i) - range_dis));\n\n loc_on = nexist_edge_on(nn);\n loc_off = nexist_edge_off(nn);\n\n [DP_table(1,i), aux_table(1,i)] = max([log(loc_on) + log(prob_stay_on) + DP_table(1,i-1), log(loc_on) + log(prob_leave_off) + DP_table(2,i-1)]);\n [DP_table(2,i), aux_table(2,i)] = max([log(loc_off) + log(prob_leave_on) + DP_table(1,i-1), log(loc_off) + log(prob_stay_off) + DP_table(2,i-1)]);\n\n %Compute prob. of the evidence. E.A.\n obslik(:,i) = [loc_on; loc_off];\n predict = Psi_t * alpha_t(:,i-1);\n z(i) = sum(obslik(:,i) .* predict);\n alpha_t(:,i) = [ loc_on * predict(1); loc_off * predict(2)] / z(i);\n\n% if (round(sum(alpha_t(:,1))) ~= 1)\n% display('Error');\n% end\n\n%% Compute log likelihood ration and evidence -- E.A \n% log_like_ratio_list(i) = log(p_y_on_1/p_y_off_1); %E.A. store likelihood\n% evidence(i) = evidence(i-1) + log(p_y_on_1*prob_stay_on + p_y_on_1*prob_leave_off + ...\n% p_y_off_1*prob_leave_on + p_y_off_1*prob_stay_off); %E.A. log evidence 1..i\n%% \n end\nend\nT = size(DP_table,2);\nend"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/mexfiles/hmmParameters.prj",
"content": "\n \n \n \n false\n option.WorkingFolder.Project\n \n option.BuildFolder.Project\n \n \n true\n true\n true\n true\n option.GlobalDataSyncMethod.SyncAlways\n true\n option.DynamicMemoryAllocation.Threshold\n 65536\n 200000\n option.FilePartitionMethod.MapMFileToCFile\n true\n false\n \n false\n true\n false\n \n false\n option.VerificationMode.None\n option.VerificationStatus.Passed\n \n \n \n \n \n \n \n \n false\n 40000\n \n option.PreserveVariableNames.UserNames\n option.TargetLang.C\n true\n 10\n 200\n 4000\n true\n 64\n true\n true\n option.ConstantInputs.CheckValues\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n false\n option.WorkingFolder.Project\n \n option.BuildFolder.Project\n \n \n true\n \n \n true\n option.DynamicMemoryAllocation.Threshold\n 65536\n 200000\n \n option.FilePartitionMethod.MapMFileToCFile\n true\n \n false\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n true\n \n \n \n false\n \n \n \n false\n false\n \n \n \n \n \n \n \n \n \n \n \n \n \n true\n Automatically locate an installed toolchain\n \n \n \n \n option.target.TargetType.MatlabHost\n \n Generic\n MATLAB Host Computer\n \n true\n 8\n 16\n 32\n 64\n 64\n 32\n 64\n 64\n 64\n option.HardwareEndianness.Little\n true\n true\n option.HardwareAtomicIntegerSize.Char\n option.HardwareAtomicFloatSize.None\n option.HardwareDivisionRounding.Zero\n Generic\n MATLAB Host Computer\n \n false\n 8\n 16\n 32\n 64\n 64\n 32\n 64\n 64\n 64\n option.HardwareEndianness.Little\n true\n true\n option.HardwareAtomicIntegerSize.Char\n option.HardwareAtomicFloatSize.None\n option.HardwareDivisionRounding.Zero\n \n \n \n 40000\n \n \n \n option.PreserveVariableNames.UserNames\n option.TargetLang.C\n \n \n \n \n \n \n \n 10\n 200\n 4000\n true\n 64\n true\n true\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n option.WorkingFolder.Project\n \n option.BuildFolder.Project\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n true\n false\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n option.objective.c\n generateCode\n \n demo_start_v2\n \n \n option.UseGlobals.No\n ${PROJECT_ROOT}/hmmParameters_mex.mexmaci64\n \n true\n \n \n true\n \n \n \n \n \n \n true\n 3530211709\n \n false\n false\n \n true\n \n codegen/mex/hmmParameters\n 4179426945\n codegen/mex/hmmParameters\n 1281319812\n demo_start_v2\n \n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><checksum><includedFiles><file>/Users/yimingqian/Dropbox/My Publications/CVPR 2017/code/LineSegDet2017/code/mexfiles/hmmParameters.m</file></includedFiles><value>1634473109</value></checksum>\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><sourceModel><primarySourceFiles><file>/Users/yimingqian/Dropbox/My Publications/CVPR 2017/code/LineSegDet2017/code/mexfiles/hmmParameters.m</file></primarySourceFiles><fixedPointSourceFiles/><fixedPointSourceRegistered>false</fixedPointSourceRegistered><fixedPointSourceSelected>false</fixedPointSourceSelected></sourceModel>\n false\n false\n true\n hmmParameters_mex\n hmmParameters\n option.target.artifact.mex\n ${PROJECT_ROOT}/hmmParameters_mex.mexmaci64\n true\n false\n \n option.FixedPointMode.None\n \n \n \n 16\n 4\n 0\n fimath('RoundingMethod', 'Floor', 'OverflowAction', 'Wrap', 'ProductMode', 'FullPrecision', 'MaxProductWordLength', 128, 'SumMode', 'FullPrecision', 'MaxSumWordLength', 128)\n option.FixedPointTypeSource.SimAndDerived\n \n false\n false\n false\n false\n true\n \n \n \n \n \n \n \n \n true\n false\n _fixpt\n \n false\n false\n option.DefaultFixedPointSignedness.Automatic\n option.FixedPointTypeProposalMode.ProposeFractionLengths\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n double\n 1 x 40\n \n \n false\n false\n \n \n double\n 1 x 40\n \n \n false\n false\n \n \n double\n 1 x 181\n \n \n false\n false\n \n \n double\n 1 x 181\n \n \n false\n false\n \n \n double\n :inf x 1\n \n \n true\n false\n \n \n double\n 2 x 2\n \n \n false\n false\n \n \n double\n 2 x 1\n \n \n false\n false\n \n \n double\n :inf x 1\n \n \n true\n false\n \n \n double\n :inf x 1\n \n \n true\n false\n \n \n double\n 1 x 40\n \n \n false\n false\n \n \n double\n 1 x 40\n \n \n false\n false\n \n \n double\n 1 x 40\n \n \n false\n false\n \n \n double\n 1 x 1\n \n \n false\n false\n \n \n double\n 1 x 1\n \n \n false\n false\n \n \n double\n 1 x 1\n \n \n false\n false\n \n \n double\n 1 x 1\n \n \n false\n false\n \n \n double\n 1 x 1\n \n \n false\n false\n \n \n double\n 1 x 1\n \n \n false\n false\n \n \n double\n :inf x 1\n \n \n true\n false\n \n \n double\n 1 x 181\n \n \n false\n false\n \n \n \n \n \n /Users/yimingqian/Dropbox/My Publications/CVPR 2017/code/LineSegDet2017/demo_start_v2.m\n \n \n /Users/yimingqian/Dropbox/My Publications/CVPR 2017/code/LineSegDet2017/code/mexfiles/hmmParameters_mex.mexmaci64\n \n \n \n /Applications/MATLAB_R2015b.app\n \n \n \n \n \n \n \n \n true\n \n \n \n \n true\n \n \n \n \n true\n \n \n \n \n true\n \n \n \n \n true\n true\n false\n false\n false\n false\n false\n false\n 10.12.6\n false\n true\n maci64\n true\n \n \n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/mexfiles/mexRemoveVotes_v3_scale.c",
"content": "/*\n * Function: mexRemoveVote_v2\n *\n * Input: Kernel value matrices (regular and flipped), and dimensional\n * arguments, along with the voting map\n *\n * Output: Updated voting map\n *\n * Author: Ron Tal\n *\n *\n * Usage: Compiled and called through Matlab\n *\n */\n\n/* Include the following header files */\n# include \"mex.h\"\n#include \"matrix.h\"\n#include \n#include \n\n#define PI 3.141\n#define RMAX 400.0\n/* Input Arguments */\nextern mxArray *mxCreateSharedDataCopy(const mxArray *pr);\n\n#define\tEDG_L\tprhs[0]\n#define\tEDG_G\tprhs[1]\n#define KERN prhs[2]\n#define KERNF prhs[3]\n#define R_RES prhs[4]\n#define T_RES prhs[5]\n#define PP prhs[6]\n#define KMAX prhs[7]\n#define MAP prhs[8]\n#define SCALE prhs[9]\n\n\n/* Output Arguments */\n#define\tNMAP\tplhs[0]\n\n/* STRUCTS */\ntypedef struct \n{\n int m;\n int n;\n} matPoint;\n\ntypedef struct \n{\n double r;\n double th;\n} houghPoint;\n/* Global variables: */\n\nmwSize mmap, nmap, m_edge_loc, n_edge_loc, m_edge_grad, n_edge_grad, m_kern, m_kern_f;\ndouble* edge_loc, * edge_grad, * pp, r_res, th_res;\ndouble* map, * scale;\nmxArray* kernels, *kernels_flip, * k_max;\ndouble *outMatrix;\n\n\nint round_f (double val)\n{\n return floor(val + 0.5);\n}\ndouble round2frac(double val, double res)\n{\n double lrg = val/res;\n double rnd = (double) round_f(lrg);\n return rnd*res;\n}\nmatPoint hough2mat(double r, double th, double rres, double thres)\n{\n matPoint val;\n val.n = round_f((r + (double)RMAX**scale ) / rres + 1);\n val.m = round_f(th / thres + 1);\n return val;\n}\nhoughPoint mat2hough(int m, int n, double rres, double thres)\n{\n houghPoint val;\n val.th = round2frac(m*thres, thres);\n val.r = round2frac(n*rres - (double)RMAX**scale, rres);\n return val;\n}\nvoid houghRemoveVotes(matPoint center, mxArray * k, mxArray * k_f, mxArray * k_m)\n{\n /* Get Kernel properties */\n int i;\n int m = center.m;\n int n = center.n;\n int m_ker, n_max, m_max, n_lim_pos, n_lim_neg, m_lim_pos, m_lim_neg;\n double * kernel;\n double * kernel_flip;\n double * k_mx;\n double val;\n m_ker = mxGetM(k);\n \n kernel = mxGetPr(k);\n \n kernel_flip = mxGetPr(k_f);\n k_mx = mxGetPr(k_m);\n n_max = k_mx[0];\n m_max = k_mx[1];\n n_lim_pos = n + (n_max-1)/2 - 1;\n n_lim_neg = n - (n_max-1)/2 - 1;\n m_lim_pos = m + (m_max-1)/2 - 1;\n m_lim_neg = m - (m_max-1)/2 - 1;\n\n /* Vote for each valid kernel value */\n for (i = 0; i < m_ker; i++)\n {\n int m_on_map;\n int n_on_map;\n \n m_on_map = m_lim_neg + (int)kernel[m_ker + i] - 1;\n n_on_map = n_lim_neg + (int)kernel[i] - 1;\n \n\n /* Out of R bounds: do nothing */\n if (n_on_map <= 0 ||n_on_map >= nmap) continue;\n /* Handle wraparound in TH domain: to be added later: */\n else if( m_on_map < 0) \n { \n\n m_on_map = mmap + m_on_map ;\n n_on_map = nmap - n_on_map ;\n if (n_on_map < 0 ||n_on_map >= nmap) continue;\n if(map[(n_on_map )*mmap + m_on_map] - kernel[2*m_ker + (m_ker - i - 1)] >= 0)\n map[(n_on_map )*mmap + m_on_map] -= kernel[2*m_ker + (m_ker - i - 1)];\n \n }else if(m_on_map >= mmap)\n {\n\n m_on_map = m_on_map - mmap ;\n n_on_map = nmap - n_on_map ;\n if (map[(n_on_map )*mmap + m_on_map] - kernel[2*m_ker + (m_ker - i)] >= 0)\n map[(n_on_map )*mmap + m_on_map] -= kernel[2*m_ker + (m_ker - i)]; \n \n }\n /* No wraparound */\n else\n {\n\n if(map[(n_on_map )*mmap + m_on_map] - kernel[2*m_ker + i] >= 0)\n map[(n_on_map )*mmap + m_on_map] -= kernel[2*m_ker + i];\n }\n }\n\n \n \n}\n\n\nvoid loopThroughRemove()\n{\n int i = 0;\n for (i = 0; i < m_edge_loc;i++ )\n {\n double r, mag;\n\t\t double * kernel, * kernel_flip, * k_m, * m_l;\n\t\t int r_th, ind;\n matPoint center;\n double x = (double)edge_loc[i] - (double)pp[0];\n double y = (double)edge_loc[m_edge_loc + i] - (double)pp[1];\n double th = edge_grad[i];\n\n if (th == 4.0) continue; \n if (th < 0) th += PI;\n if (th > PI) th -= PI;\n th = PI - th;\n r = x * cos(th) + y * sin(th);\n \n th = round2frac(th, th_res);\n r = round2frac(r, r_res);\n r_th = round_f(- x * sin(th) + y * cos(th));\n\n if (r_th > (int)(400**scale)) r_th = (int)(400**scale); else if(r_th < - (int)(400**scale)) r_th = -(int)(400**scale);\n \n if (r_th == 0)\n {\n ind = 0;\n } \n else\n {\n ind = r_th + (double)RMAX**scale;\n }\n kernel = mxGetCell(kernels, ind);\n kernel_flip = mxGetCell(kernels_flip, ind);\n k_m = mxGetCell(k_max, ind);\n \n /* Center of kernel on voting map */\n center = hough2mat(r, th, r_res, th_res);\n houghRemoveVotes(center,kernel, kernel_flip, k_m); \n }\n \n \n}\n\n\nvoid mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )\n/*\n * Function: mexFunction\n *\n * Inputs: nrhs -> Integer representing the number of input arguments\n * sent from Matlab.\n *\n * prhs[] -> An mxArray structure of size nrhs holding pointers\n * to arguments sent from Matlab.\n *\n * nlhs -> Integer representing the number of output arguments\n * requested from Matlab.\n *\n * plhs[] -> An mxArray structure of size nlhs holding pointers\n * to the location of output arguments.\n *\n * Outputs: (void)\n *\n * Functionality: Analogous to a 'main' function. This function will\n * be activated by default when Matlab calls this C\n * function. Used to interface between C and Matlab,\n * as to ensure output is in the location and format\n * Matlab expecs.\n */\n{\n /* Declerations and initializations */\n\n /* Check for proper number of arguments */\n if (nrhs != 10) { \n\tmexErrMsgTxt(\"Nine input arguments required.\");\n } \n\n /* Get edge locations */\n m_edge_loc = mxGetM(EDG_L); \n n_edge_loc = mxGetN(EDG_L);\n edge_loc = mxGetPr(EDG_L);\n if (n_edge_loc != 2) { \n mexErrMsgTxt(\"Wrong edge locations format.\");\n } \n /* Get edge gradients */\n m_edge_grad = mxGetM(EDG_G); \n n_edge_grad = mxGetN(EDG_G);\n if (n_edge_grad != 1) { \n mexErrMsgTxt(\"Wrong edge gradient format.\");\n } \n if (m_edge_loc != m_edge_grad) { \n mexErrMsgTxt(\"Locations and gradients must correspond.\");\n } \n \n edge_grad = mxGetPr(EDG_G);\n /* Get pp */\n pp = mxGetPr(PP);\n scale=mxGetPr(SCALE);\n r_res = mxGetScalar(R_RES);\n th_res = mxGetScalar(T_RES);\n /* Get map*/\n nmap = (int)(800.0**scale/r_res) + 1;\n mmap = (int)(3.141/th_res) + 1;\n map = mxGetPr(MAP);\n \n /* Get Kernels*/\n m_kern = mxGetNumberOfElements(KERN); \n m_kern_f = mxGetNumberOfElements(KERNF);\n kernels = KERN;\n kernels_flip = KERNF;\n k_max = KMAX;\n loopThroughRemove();\n NMAP=mxCreateSharedDataCopy(MAP);\n return;\n}\n/*end mexFunction*/\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/mexfiles/mexVoteEdges_v3_scale.c",
"content": "/*\n * Function: mexVoteEdges_v2\n *\n * Input: Kernel value matrices (regular and flipped), and dimensional\n * arguments, along with the voting map\n *\n * Output: Updated voting map\n *\n * Author: Ron Tal\n *\n *\n * Usage: Compiled and called through Matlab\n *\n */\n\n/* Include the following header files */\n# include \"mex.h\"\n#include \"matrix.h\"\n#include \n#include \n\n\n#define PI 3.141\n#define RMAX 400.0\n/* Input Arguments */\n\n#define\tEDG_L\tprhs[0]\n#define\tEDG_G\tprhs[1]\n#define KERN prhs[2]\n#define KERNF prhs[3]\n#define R_RES prhs[4]\n#define T_RES prhs[5]\n#define PP prhs[6]\n#define KMAX prhs[7]\n#define SCALE prhs[8]\n\n\n/* Output Arguments */\n#define\tNMAP\tplhs[0]\n\n/* STRUCTS */\ntypedef struct \n{\n int m;\n int n;\n} matPoint;\n\ntypedef struct \n{\n double r;\n double th;\n} houghPoint;\n\n/* Global variables: */\n\nmwSize mmap, nmap, m_edge_loc, n_edge_loc, m_edge_grad, n_edge_grad, m_kern, m_kern_f;\ndouble* edge_loc, * edge_grad, * pp, r_res, th_res;\ndouble* map,*scale;\nmxArray* kernels, *kernels_flip, * k_max;\n\nint round_f (double val)\n{\n return floor(val + 0.5);\n}\ndouble round2frac(double val, double res)\n{\n double lrg = val/res;\n double rnd = (double) round_f(lrg);\n return rnd*res;\n}\nmatPoint hough2mat(double r, double th, double rres, double thres)\n{\n matPoint val;\n val.n = round_f((r + (double)RMAX**scale ) / rres + 1);\n val.m = round_f(th / thres + 1);\n return val;\n}\nhoughPoint mat2hough(int m, int n, double rres, double thres)\n{\n houghPoint val;\n val.th = round2frac(m*thres, thres);\n val.r = round2frac(n*rres - (double)RMAX**scale, rres);\n return val;\n}\nvoid houghVoteMap(matPoint center, mxArray * k, mxArray * k_f, mxArray * k_m, int x, int y, int r_th, int xd, int yd)\n{\n /* Get Kernel properties */\n int i;\n int m = center.m;\n int n = center.n;\n int m_ker, n_max, m_max, n_lim_pos, n_lim_neg, m_lim_pos, m_lim_neg, n_ker;\n double * kernel;\n double * kernel_flip;\n double * k_mx;\n double val;\n\tdouble kvalue; \n\tint xx, yy;\n m_ker = mxGetM(k);\n\tn_ker = mxGetN(k);\n kernel = mxGetPr(k);\n \n kernel_flip = mxGetPr(k_f);\n k_mx = mxGetPr(k_m);\n n_max = k_mx[0];\n m_max = k_mx[1];\n n_lim_pos = n + (n_max-1)/2 - 1;\n n_lim_neg = n - (n_max-1)/2 - 1;\n m_lim_pos = m + (m_max-1)/2 - 1;\n m_lim_neg = m - (m_max-1)/2 - 1;\n\txx = round_f(x + (double)pp[0]);\n\tyy = round_f(y + (double)pp[1]);\n\n /* Vote for each valid kernel value */\n for (i = 0; i < m_ker; i++)\n {\n int m_on_map;\n int n_on_map;\n \n m_on_map = m_lim_neg + (int)kernel[m_ker + i] - 1;\n n_on_map = n_lim_neg + (int)kernel[i] - 1;\n\n /* Out of R bounds: do nothing */\n if (n_on_map <= 0 ||n_on_map >= nmap) continue; \n /* Handle wraparound in TH domain: to be added later: */\n else if( m_on_map < 0) \n { \n m_on_map = mmap + m_on_map ;\n n_on_map = nmap - n_on_map ;\n if (n_on_map < 0 ||n_on_map >= nmap) continue;\n\n\t\t\tkvalue = kernel[2*m_ker + (m_ker - i - 1)]; \n map[(n_on_map )*mmap + m_on_map] += kvalue;\n \n }else if(m_on_map >= mmap)\n {\n m_on_map = m_on_map - mmap ;\n n_on_map = nmap - n_on_map ;\n\n\t\t\tkvalue = kernel[2*m_ker + (m_ker - i)]; \n map[(n_on_map )*mmap + m_on_map] += kvalue; \n \n }\n /* No wraparound */\n else\n {\n\t\t\tkvalue = kernel[2*m_ker + i]; \n map[(n_on_map )*mmap + m_on_map] += kvalue;\n }\n\n }\n\n \n}\n\n\nvoid loopThrough()\n{\n\tint xx, yy;\n\tint i = 0;\n for (i = 0; i < m_edge_loc;i++ )\n {\n double r, th;\n double * kernel, * kernel_flip, * k_m, * m_l;\n\t\t int r_th;\n matPoint center;\n\t\t int xx, yy, ind;\n \t\t \n double x = (double)edge_loc[i] - (double)pp[0];\n double y = (double)edge_loc[m_edge_loc + i] - (double)pp[1];\n \n\t\t int xd = round_f((double)edge_loc[i]);\n\t\t int yd = round_f((double)edge_loc[m_edge_loc + i]);\n\n\t\t th = edge_grad[i];\n if (th == 4.0) continue; \n if (th < 0) th += PI;\n if (th > PI) th -= PI;\n th = PI - th;\n r = x * cos(th) + y * sin(th);\n \n th = round2frac(th, th_res);\n r = round2frac(r, r_res); \n r_th = round_f(- x * sin(th) + y * cos(th));\n\n if (r_th > (int)(400**scale)) r_th = (int)(400**scale); else if(r_th < - (int)(400**scale)) r_th = -(int)(400**scale);\n \n if (r_th == 0)\n {\n ind = 0;\n } \n else\n {\n ind = r_th + (double)RMAX**scale;\n }\n kernel = mxGetCell(kernels, ind);\n kernel_flip = mxGetCell(kernels_flip, ind);\n k_m = mxGetCell(k_max, ind);\n \n /* Center of kernel on voting map */\n center = hough2mat(r, th, r_res, th_res);\n houghVoteMap(center,kernel, kernel_flip, k_m, x, y, r_th, xd, yd); \n }\n \n \n}\nvoid mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )\n/*\n * Function: mexFunction\n *\n * Inputs: nrhs -> Integer representing the number of input arguments\n * sent from Matlab.\n *\n * prhs[] -> An mxArray structure of size nrhs holding pointers\n * to arguments sent from Matlab.\n *\n * nlhs -> Integer representing the number of output arguments\n * requested from Matlab.\n *\n * plhs[] -> An mxArray structure of size nlhs holding pointers\n * to the location of output arguments.\n *\n * Outputs: (void)\n *\n * Functionality: Analogous to a 'main' function. This function will\n * be activated by default when Matlab calls this C\n * function. Used to interface between C and Matlab,\n * as to ensure output is in the location and format\n * Matlab expecs.\n */\n{\n /* Check for proper number of arguments */\n if (nrhs != 9) { \n\tmexErrMsgTxt(\"Eight input arguments required.\");\n } \n printf(\"Inside C function_v2\\n\");\n /* Get edge locations */\n m_edge_loc = mxGetM(EDG_L); \n n_edge_loc = mxGetN(EDG_L);\n edge_loc = mxGetPr(EDG_L);\n if (n_edge_loc != 2) { \n mexErrMsgTxt(\"Wrong edge locations format.\");\n } \n /* Get edge gradients */\n m_edge_grad = mxGetM(EDG_G); \n n_edge_grad = mxGetN(EDG_G);\n if (n_edge_grad != 1) { \n mexErrMsgTxt(\"Wrong edge gradient format.\");\n } \n if (m_edge_loc != m_edge_grad) { \n mexErrMsgTxt(\"Locations and gradients must correspond.\");\n } \n \n edge_grad = mxGetPr(EDG_G);\n /* Get pp */\n pp = mxGetPr(PP);\n r_res = mxGetScalar(R_RES);\n th_res = mxGetScalar(T_RES);\n scale=mxGetPr(SCALE);\n /* Get map*/\n nmap = (int)(800**scale/r_res) + 1;\n mmap = (int)(3.141/th_res) + 1;\n NMAP = mxCreateDoubleMatrix(mmap, nmap, mxREAL);\n map = mxGetPr(NMAP);\n /* Get Kernels*/\n m_kern = mxGetNumberOfElements(KERN); \n m_kern_f = mxGetNumberOfElements(KERNF);\n kernels = KERN;\n kernels_flip = KERNF;\n k_max = KMAX;\n\tloopThrough();\n return;\n}\n/*end mexFunction*/"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/mexfiles/returnLines.m",
"content": "function [begin_points,end_points,lslength,startpositions,endpositions]=returnLines(points_proj,final_labels)\ncount = 0;\non_seg = false;\nbegin_pointsT = zeros(20,2);\ncounter_begin_points=1;\nend_pointsT = zeros(20,2);\ncounter_end_points=1;\nlslengthT = zeros(20,1);\ncounter_lslength=1;\nstartpos = 0;\nstartpositionsT = zeros(20,1);\ncounter_startpositions=1;\nendpositionsT = zeros(20,1);\ncounter_endpositions=1;\n\nfor i = 1:length(final_labels);\n if ~on_seg\n if final_labels(i) == 1\n begin_pointsT(counter_begin_points,:)=points_proj(i,:);\n counter_begin_points=counter_begin_points+1;\n startpositionsT(counter_startpositions) = i;\n counter_startpositions=counter_startpositions+1;\n startpos = i;\n on_seg = true;\n count = count + 1;\n end\n elseif i == length(final_labels)\n end_pointsT(counter_end_points,:) =points_proj(i,:);\n counter_end_points=counter_end_points+1;\n endpositionsT(counter_endpositions) = i;\n counter_endpositions=counter_endpositions+1;\n lslengthT(counter_lslength) = i-startpos;\n counter_lslength=counter_lslength+1;\n on_seg = false;\n elseif final_labels(i) == 0\n end_pointsT(counter_end_points,:) = points_proj(i-1,:);\n counter_end_points=counter_end_points+1;\n endpositionsT(counter_endpositions) = i-1;\n counter_endpositions=counter_endpositions+1;\n lslengthT(counter_lslength) = i-startpos;\n counter_lslength=counter_lslength+1;\n on_seg = false;\n end\nend\n\nbegin_points = begin_pointsT(1:counter_begin_points-1,:);\nend_points =end_pointsT(1:counter_end_points-1,:);\nlslength =lslengthT(1:counter_lslength-1); \nstartpositions =startpositionsT(1:counter_startpositions);\nendpositions =endpositionsT(1:counter_endpositions-1);\n\nend\n"
},
{
"path": "thirdparty/MCMLSD/MCMLSD/code/mexfiles/returnLines.prj",
"content": "\n \n
![\"doxygen\"](\"doxygen.png\")
\n1.3.4 \n\n\n"
},
{
"path": "thirdparty/LSD/doc/doxygen.css",
"content": "H1 {\n\ttext-align: center;\n\tfont-family: Arial, Helvetica, sans-serif;\n}\nH2 {\n\tfont-family: Geneva, Arial, Helvetica, sans-serif;\n}\nCAPTION { font-weight: bold }\nDIV.qindex { width: 100%;\n background-color: #eeeeff;\n border: 4px solid #eeeeff;\n text-align: center;\n margin-bottom: 2px\n}\nA.qindex { text-decoration: none; font-weight: bold; color: #0000ee }\nA.qindex:visited { text-decoration: none; font-weight: bold; color: #0000ee }\nA.qindex:hover { text-decoration: none; background-color: #ddddff }\nA.qindexHL { text-decoration: none; font-weight: bold;\n background-color: #6666cc;\n color: #ffffff\n }\nA.qindexHL:hover { text-decoration: none; background-color: #6666cc; color: #ffffff }\nA.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff }\nA.el { text-decoration: none; font-weight: bold }\nA.elRef { font-weight: bold }\nA.code { text-decoration: none; font-weight: normal; color: #4444ee }\nA.codeRef { font-weight: normal; color: #4444ee }\nA:hover { text-decoration: none; background-color: #f2f2ff }\nDL.el { margin-left: -1cm }\nDIV.fragment {\n\twidth: 98%;\n\tborder: 1px solid #CCCCCC;\n\tbackground-color: #f5f5f5;\n\tpadding-left: 4px;\n\tmargin: 4px;\n}\nDIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px }\nTD.md { background-color: #f2f2ff; font-weight: bold; }\nTD.mdname1 { background-color: #f2f2ff; font-weight: bold; color: #602020; }\nTD.mdname { background-color: #f2f2ff; font-weight: bold; color: #602020; width: 600px; }\nDIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold }\nDIV.groupText { margin-left: 16px; font-style: italic; font-size: smaller }\nBODY {\n\tbackground: white;\n\tcolor: black;\n\tmargin-right: 20px;\n\tmargin-left: 20px;\n}\nTD.indexkey { \n background-color: #eeeeff; \n font-weight: bold; \n padding-right : 10px; \n padding-top : 2px; \n padding-left : 10px; \n padding-bottom : 2px; \n margin-left : 0px; \n margin-right : 0px; \n margin-top : 2px; \n margin-bottom : 2px \n}\nTD.indexvalue { \n background-color: #eeeeff; \n font-style: italic; \n padding-right : 10px; \n padding-top : 2px; \n padding-left : 10px; \n padding-bottom : 2px; \n margin-left : 0px; \n margin-right : 0px; \n margin-top : 2px; \n margin-bottom : 2px \n}\nTR.memlist {\n background-color: #f0f0f0; \n}\nP.formulaDsp { text-align: center; }\nIMG.formulaDsp { }\nIMG.formulaInl { vertical-align: middle; }\nSPAN.keyword { color: #008000 }\nSPAN.keywordtype { color: #604020 }\nSPAN.keywordflow { color: #e08000 }\nSPAN.comment { color: #800000 }\nSPAN.preprocessor { color: #806020 }\nSPAN.stringliteral { color: #002080 }\nSPAN.charliteral { color: #008080 }\n.mdTable {\n\tborder: 1px solid #868686;\n\tbackground-color: #f2f2ff;\n}\n.mdRow {\n\tpadding: 8px 20px;\n}\n.mdescLeft {\n\tfont-size: smaller;\n\tfont-family: Arial, Helvetica, sans-serif;\n\tbackground-color: #FAFAFA;\n\tpadding-left: 8px;\n\tborder-top: 1px none #E0E0E0;\n\tborder-right: 1px none #E0E0E0;\n\tborder-bottom: 1px none #E0E0E0;\n\tborder-left: 1px none #E0E0E0;\n\tmargin: 0px;\n}\n.mdescRight {\n\tfont-size: smaller;\n\tfont-family: Arial, Helvetica, sans-serif;\n\tfont-style: italic;\n\tbackground-color: #FAFAFA;\n\tpadding-left: 4px;\n\tborder-top: 1px none #E0E0E0;\n\tborder-right: 1px none #E0E0E0;\n\tborder-bottom: 1px none #E0E0E0;\n\tborder-left: 1px none #E0E0E0;\n\tmargin: 0px;\n\tpadding-bottom: 0px;\n\tpadding-right: 8px;\n}\n.memItemLeft {\n\tpadding: 1px 0px 0px 8px;\n\tmargin: 4px;\n\tborder-top-width: 1px;\n\tborder-right-width: 1px;\n\tborder-bottom-width: 1px;\n\tborder-left-width: 1px;\n\tborder-top-style: solid;\n\tborder-top-color: #E0E0E0;\n\tborder-right-color: #E0E0E0;\n\tborder-bottom-color: #E0E0E0;\n\tborder-left-color: #E0E0E0;\n\tborder-right-style: none;\n\tborder-bottom-style: none;\n\tborder-left-style: none;\n\tbackground-color: #FAFAFA;\n\tfont-family: Geneva, Arial, Helvetica, sans-serif;\n\tfont-size: 12px;\n}\n.memItemRight {\n\tpadding: 1px 0px 0px 8px;\n\tmargin: 4px;\n\tborder-top-width: 1px;\n\tborder-right-width: 1px;\n\tborder-bottom-width: 1px;\n\tborder-left-width: 1px;\n\tborder-top-style: solid;\n\tborder-top-color: #E0E0E0;\n\tborder-right-color: #E0E0E0;\n\tborder-bottom-color: #E0E0E0;\n\tborder-left-color: #E0E0E0;\n\tborder-right-style: none;\n\tborder-bottom-style: none;\n\tborder-left-style: none;\n\tbackground-color: #FAFAFA;\n\tfont-family: Geneva, Arial, Helvetica, sans-serif;\n\tfont-size: 13px;\n}\n.search { color: #0000ee;\n font-weight: bold;\n}\nFORM.search {\n margin-bottom: 0px;\n margin-top: 0px;\n}\nINPUT.search { font-size: 75%;\n color: #000080;\n font-weight: normal;\n background-color: #eeeeff;\n}\nTD.tiny { font-size: 75%;\n}\n"
},
{
"path": "thirdparty/LSD/doc/files.html",
"content": "\n\n![\"graph_legend.png\"](\"graph_legend.png\")
\n![\"Include](\"lsd_8c__incl.png\")
![\"\"](\"lsd_8c_a18_cgraph.png\")
![\"\"](\"lsd_8c_a17_cgraph.png\")
![\"\"](\"lsd_8c_a19_cgraph.png\")
![\"\"](\"lsd_8c_a25_cgraph.png\")
![\"\"](\"lsd_8c_a22_cgraph.png\")
![\"\"](\"lsd_8c_a15_cgraph.png\")
![\"\"](\"lsd_8c_a28_cgraph.png\")
![\"\\[](\"form_0.png\")
\n![\"\\[](\"form_1.png\")
\n![\"\\[](\"form_2.png\")
\n![\"\"](\"lsd_8c_a29_cgraph.png\")
![\"\\[](\"form_10.png\")
\n![\"\"](\"lsd_8c_a45_cgraph.png\")
![\"\"](\"lsd_8c_a39_cgraph.png\")
![\"\"](\"lsd_8c_a38_cgraph.png\")
![\"\"](\"lsd_8c_a31_cgraph.png\")
![\"\"](\"lsd_8c_a51_cgraph.png\")
![\"\"](\"lsd_8c_a30_cgraph.png\")
![\"\\[](\"form_3.png\")
\n![\"\\[](\"form_4.png\")
\n![\"\\[](\"form_5.png\")
\n![\"\\[](\"form_6.png\")
\n![\"\"](\"lsd_8c_a53_cgraph.png\")
![\"\"](\"lsd_8c_a52_cgraph.png\")
![\"\"](\"lsd_8c_a20_cgraph.png\")
![\"\"](\"lsd_8c_a21_cgraph.png\")
![\"\"](\"lsd_8c_a26_cgraph.png\")
![\"\"](\"lsd_8c_a27_cgraph.png\")
![\"\"](\"lsd_8c_a23_cgraph.png\")
![\"\"](\"lsd_8c_a24_cgraph.png\")
![\"\"](\"lsd_8c_a16_cgraph.png\")
![\"\\[](\"form_7.png\")
\n![\"\\[](\"form_8.png\")
\n![\"\\[](\"form_9.png\")
\n![\"\"](\"lsd_8c_a36_cgraph.png\")
![\"\"](\"lsd_8c_a37_cgraph.png\")
![\"\"](\"lsd_8c_a48_cgraph.png\")
![\"\"](\"lsd_8c_a44_cgraph.png\")
![\"\"](\"lsd_8c_a49_cgraph.png\")
![\"\"](\"lsd_8c_a50_cgraph.png\")
![\"\"](\"lsd_8c_a46_cgraph.png\")
![\"\"](\"lsd_8c_a47_cgraph.png\")
![\"\"](\"lsd_8c_a40_cgraph.png\")
![\"\"](\"lsd_8c_a41_cgraph.png\")
![\"\"](\"lsd_8c_a42_cgraph.png\")
![\"\"](\"lsd_8c_a43_cgraph.png\")
![\"Included](\"lsd_8h__dep__incl.png\")
![\"\"](\"lsd_8h_a6_cgraph.png\")
![\"\"](\"lsd_8h_a12_cgraph.png\")
![\"\"](\"lsd_8h_a9_cgraph.png\")
![\"\"](\"lsd_8h_a4_cgraph.png\")
![\"\"](\"lsd_8h_a15_cgraph.png\")
![\"\"](\"lsd_8h_a17_cgraph.png\")
![\"\"](\"lsd_8h_a16_cgraph.png\")
![\"\"](\"lsd_8h_a7_cgraph.png\")
![\"\"](\"lsd_8h_a8_cgraph.png\")
![\"\"](\"lsd_8h_a13_cgraph.png\")
![\"\"](\"lsd_8h_a14_cgraph.png\")
![\"\"](\"lsd_8h_a10_cgraph.png\")
![\"\"](\"lsd_8h_a11_cgraph.png\")
![\"\"](\"lsd_8h_a5_cgraph.png\")
![\"Collaboration](\"structcoorlist__coll__graph.png\")