mser 最大稳定极值区域(文字区域定位)算法 附完整C代码
mser 的全称:Maximally Stable Extremal Regions
第一次听说这个算法时，是来自当时部门的一个同事，
提及到他的项目用它来做文字区域的定位，对这个算法做了一些优化。
也就是中文车牌识别开源项目EasyPR的作者liuruoze,刘兄。
自那时起就有一块石头没放下，想要找个时间好好理理这个算法。
学习一些它的一些思路。
因为一般我学习算法的思路：3个做法，
第一步，编写demo示例。
第二步，进行算法移植或效果改进。
第三步，进行算法性能优化。
然后在这三个过程中，不断来回地验证，实测。
任何事情，一下子囫囵吞枣，容易呛到。
找了不少资料，mser这方面的资料还挺少。
比较不错的资料自然就是开源项目opencv以及VLFeat。
opencv用了太多依赖和封装，阅读代码非常费事。
VLFeat则友好得多。
嗯，花了点时间把mser从VLFeat抽离出来，并编写相应的测试用例。
代码注释比较详尽，写这个示例 demo 的时候，
来回翻阅官方文档无头绪，阅读代码以及注释才大致理清楚逻辑。
项目地址:https://github.com/cpuimage/mser
附完整代码:
/* * Copyright (C) 2007-12 Andrea Vedaldi and Brian Fulkerson. * All rights reserved. * This file is part of the VLFeat library and is made available under * the terms of the BSD license (see the COPYING file). */ #define MSER_DRIVER_VERSION 0.2 #define STB_IMAGE_STATIC #define STB_IMAGE_IMPLEMENTATION #include "stb_image.h" /* ref:https://github.com/nothings/stb/blob/master/stb_image.h */ #define TJE_IMPLEMENTATION #include "tiny_jpeg.h" /* ref:https://github.com/serge-rgb/TinyJPEG/blob/master/tiny_jpeg.h */ #include <stdlib.h> #include <stdio.h> /* 计时 */ #include <stdint.h> #if defined(__APPLE__) #include <mach/mach_time.h> #elif defined(_WIN32) #define WIN32_LEAN_AND_MEAN #include <windows.h> #else /* __linux */ #include <time.h> #ifndef CLOCK_MONOTONIC /* _RAW */ #define CLOCK_MONOTONIC CLOCK_REALTIME #endif #endif static uint64_t nanotimer() { static int ever = 0; #if defined(__APPLE__) static mach_timebase_info_data_t frequency; if (!ever) { if (mach_timebase_info(&frequency) != KERN_SUCCESS) { return(0); } ever = 1; } return; #elif defined(_WIN32) static LARGE_INTEGER frequency; if (!ever) { QueryPerformanceFrequency(&frequency); ever = 1; } LARGE_INTEGER t; QueryPerformanceCounter(&t); return((t.QuadPart * (uint64_t) 1e9) / frequency.QuadPart); #else /* __linux */ struct timespec t; if (!ever) { if (clock_gettime(CLOCK_MONOTONIC, &spec) != 0) { return(0); } ever = 1; } clock_gettime(CLOCK_MONOTONIC, &spec); return((t.tv_sec * (uint64_t) 1e9) + t.tv_nsec); #endif } static double now() { static uint64_t epoch = 0; if (!epoch) { epoch = nanotimer(); } return((nanotimer() - epoch) / 1e9); }; double calcElapsed(double start, double end) { double took = -start; return(took + end); } unsigned char* loadImage(const char * filename, int * width, int * height, int * depth) { unsigned char *output = stbi_load(filename, width, height, depth, 1); *depth = 1; return(output); } bool saveJpeg(const char * filename, int width, int height, int depth, unsigned char* bits) { if (!tje_encode_to_file(filename, width, height, depth, true, bits)) { fprintf(stderr, "save JPEG fail.\n"); return(false); } return(true); } /** @brief Maximum value ** ** Maximum value of the integer type ::unsigned char. **/ #define MSER_PIX_MAXVAL 256 /** @brief MSER Filter ** ** The MSER filter computes the Maximally Stable Extremal Regions of ** an image. ** ** @sa @ref mser **/ typedef struct _MserFilt MserFilt; /** @brief MSER filter statistics */ typedef struct _MserStats MserStats; /** @brief MSER filter statistics definition */ struct _MserStats { int num_extremal; /**< number of extremal regions */ int num_unstable; /**< number of unstable extremal regions */ int num_abs_unstable; /**< number of regions that failed the absolute stability test */ int num_too_big; /**< number of regions that failed the maximum size test */ int num_too_small; /**< number of regions that failed the minimum size test */ int num_duplicates; /**< number of regions that failed the duplicate test */ }; /** @name Construction and Destruction ** @{ **/ MserFilt* mser_new(int ndims, int const* dims); void mser_delete(MserFilt *f); /** @} */ /** @name Processing ** @{ **/ void mser_process(MserFilt *f, unsigned char const *im); void mser_ell_fit(MserFilt *f); /** @} */ /** @name Retrieving data ** @{ **/ unsigned int mser_get_regions_num(MserFilt const *f); unsigned int const* mser_get_regions(MserFilt const *f); float const* mser_get_ell(MserFilt const *f); unsigned int mser_get_ell_num(MserFilt const *f); unsigned int mser_get_ell_dof(MserFilt const *f); MserStats const* mser_get_stats(MserFilt const *f); /** @} */ /** @name Retrieving parameters ** @{ **/ unsigned char mser_get_delta(MserFilt const *f); float mser_get_min_area(MserFilt const *f); float mser_get_max_area(MserFilt const *f); float mser_get_max_variation(MserFilt const *f); float mser_get_min_diversity(MserFilt const *f); /** @} */ /** @name Setting parameters ** @{ **/ void mser_set_delta(MserFilt *f, unsigned char x); void mser_set_min_area(MserFilt *f, float x); void mser_set_max_area(MserFilt *f, float x); void mser_set_max_variation(MserFilt *f, float x); void mser_set_min_diversity(MserFilt *f, float x); /** @} */ /* ==================================================================== * INLINE DEFINITIONS * ================================================================== */ /** @internal ** @brief MSER accumulator data type ** ** This is a large integer type. It should be large enough to contain ** a number equal to the area (volume) of the image by the image ** width by the image height (for instance, if the image is a square ** of side 256, the maximum value is 256 x 256 x 256). **/ typedef float mser_acc; /** @internal @brief Basic region flag: null region */ #ifdef COMPILER_MSC #define MSER_VOID_NODE ( (1ui64 << 32) - 1) #else #define MSER_VOID_NODE ( (1ULL << 32) - 1) #endif /* ----------------------------------------------------------------- */ /** @internal ** @brief MSER: basic region (declaration) ** ** Extremal regions and maximally stable extremal regions are ** instances of image regions. ** ** There is an image region for each pixel of the image. Each region ** is represented by an instance of this structure. Regions are ** stored into an array in pixel order. ** ** Regions are arranged into a forest. MserReg::parent points to ** the parent node, or to the node itself if the node is a root. ** MserReg::parent is the index of the node in the node array ** (which therefore is also the index of the corresponding ** pixel). MserReg::height is the distance of the fartest leaf. If ** the node itself is a leaf, then MserReg::height is zero. ** ** MserReg::area is the area of the image region corresponding to ** this node. ** ** MserReg::region is the extremal region identifier. Not all ** regions are extremal regions however; if the region is NOT ** extremal, this field is set to .... **/ struct _MserReg { unsigned int parent; /**< points to the parent region. */ unsigned int shortcut; /**< points to a region closer to a root. */ unsigned int height; /**< region height in the forest. */ unsigned int area; /**< area of the region. */ }; /** @internal @brief MSER: basic region */ typedef struct _MserReg MserReg; /* ----------------------------------------------------------------- */ /** @internal ** @brief MSER: extremal region (declaration) ** ** Extremal regions (ER) are extracted from the region forest. Each ** region is represented by an instance of this structure. The ** structures are stored into an array, in arbitrary order. ** ** ER are arranged into a tree. @a parent points to the parent ER, or ** to itself if the ER is the root. ** ** An instance of the structure represents the extremal region of the ** level set of intensity MserExtrReg::value and containing the ** pixel MserExtReg::index. ** ** MserExtrReg::area is the area of the extremal region and ** MserExtrReg::area_top is the area of the extremal region ** containing this region in the level set of intensity ** MserExtrReg::area + @c delta. ** ** MserExtrReg::variation is the relative area variation @c ** (area_top-area)/area. ** ** MserExtrReg::max_stable is a flag signaling whether this extremal ** region is also maximally stable. **/ struct _MserExtrReg { int parent; /**< index of the parent region */ int index; /**< index of pivot pixel */ unsigned char value; /**< value of pivot pixel */ unsigned int shortcut; /**< shortcut used when building a tree */ unsigned int area; /**< area of the region */ float variation; /**< rel. area variation */ unsigned int max_stable; /**< max stable number (=0 if not maxstable) */ }; /** @internal ** @brief MSER: extremal region */ typedef struct _MserExtrReg MserExtrReg; /* ----------------------------------------------------------------- */ /** @internal ** @brief MSER filter ** @see @ref mser **/ struct _MserFilt { /** @name Image data and meta data @internal */ /*@{*/ int ndims; /**< number of dimensions */ int *dims; /**< dimensions */ int nel; /**< number of image elements (pixels) */ int *subs; /**< N-dimensional subscript */ int *dsubs; /**< another subscript */ int *strides; /**< strides to move in image data */ /*@}*/ unsigned int *perm; /**< pixel ordering */ unsigned int *joins; /**< sequence of join ops */ int njoins; /**< number of join ops */ /** @name Regions */ /*@{*/ MserReg *r; /**< basic regions */ MserExtrReg *er; /**< extremal tree */ unsigned int *mer; /**< maximally stable extremal regions */ int ner; /**< number of extremal regions */ int nmer; /**< number of maximally stable extr. reg. */ int rer; /**< size of er buffer */ int rmer; /**< size of mer buffer */ /*@}*/ /** @name Ellipsoids fitting */ /*@{*/ float *acc; /**< moment accumulator. */ float *ell; /**< ellipsoids list. */ int rell; /**< size of ell buffer */ int nell; /**< number of ellipsoids extracted */ int dof; /**< number of dof of ellipsoids. */ /*@}*/ /** @name Configuration */ /*@{*/ int verbose; /**< be verbose */ int delta; /**< delta filter parameter */ float max_area; /**< badness test parameter */ float min_area; /**< badness test parameter */ float max_variation; /**< badness test parameter */ float min_diversity; /**< minimum diversity */ /*@}*/ MserStats stats; /** run statistic */ }; /* ----------------------------------------------------------------- */ /** @brief Get delta ** @param f MSER filter. ** @return value of @c delta. **/ unsigned char mser_get_delta(MserFilt const *f) { return(f->delta); } /** @brief Set delta ** @param f MSER filter. ** @param x value of @c delta. **/ void mser_set_delta(MserFilt *f, unsigned char x) { f->delta = x; } /* ----------------------------------------------------------------- */ /** @brief Get minimum diversity ** @param f MSER filter. ** @return value of @c minimum diversity. **/ float mser_get_min_diversity(MserFilt const *f) { return(f->min_diversity); } /** @brief Set minimum diversity ** @param f MSER filter. ** @param x value of @c minimum diversity. **/ void mser_set_min_diversity(MserFilt *f, float x) { f->min_diversity = x; } /* ----------------------------------------------------------------- */ /** @brief Get statistics ** @param f MSER filter. ** @return statistics. **/ MserStats const* mser_get_stats(MserFilt const *f) { return(&f->stats); } /* ----------------------------------------------------------------- */ /** @brief Get maximum region area ** @param f MSER filter. ** @return maximum region area. **/ float mser_get_max_area(MserFilt const *f) { return(f->max_area); } /** @brief Set maximum region area ** @param f MSER filter. ** @param x maximum region area. **/ void mser_set_max_area(MserFilt *f, float x) { f->max_area = x; } /* ----------------------------------------------------------------- */ /** @brief Get minimum region area ** @param f MSER filter. ** @return minimum region area. **/ float mser_get_min_area(MserFilt const *f) { return(f->min_area); } /** @brief Set minimum region area ** @param f MSER filter. ** @param x minimum region area. **/ void mser_set_min_area(MserFilt *f, float x) { f->min_area = x; } /* ----------------------------------------------------------------- */ /** @brief Get maximum region variation ** @param f MSER filter. ** @return maximum region variation. **/ float mser_get_max_variation(MserFilt const *f) { return(f->max_variation); } /** @brief Set maximum region variation ** @param f MSER filter. ** @param x maximum region variation. **/ void mser_set_max_variation(MserFilt *f, float x) { f->max_variation = x; } /* ----------------------------------------------------------------- */ /** @brief Get maximally stable extremal regions ** @param f MSER filter. ** @return array of MSER pivots. **/ unsigned int const * mser_get_regions(MserFilt const* f) { return(f->mer); } /** @brief Get number of maximally stable extremal regions ** @param f MSER filter. ** @return number of MSERs. **/ unsigned int mser_get_regions_num(MserFilt const* f) { return(f->nmer); } /* ----------------------------------------------------------------- */ /** @brief Get ellipsoids ** @param f MSER filter. ** @return ellipsoids. **/ float const * mser_get_ell(MserFilt const* f) { return(f->ell); } /** @brief Get number of degrees of freedom of ellipsoids ** @param f MSER filter. ** @return number of degrees of freedom. **/ unsigned int mser_get_ell_dof(MserFilt const* f) { return(f->dof); } /** @brief Get number of ellipsoids ** @param f MSER filter. ** @return number of ellipsoids **/ unsigned int mser_get_ell_num(MserFilt const* f) { return(f->nell); } /*MSER */ /** ------------------------------------------------------------------- ** @brief Advance N-dimensional subscript ** ** The function increments by one the subscript @a subs indexing an ** array the @a ndims dimensions @a dims. ** ** @param ndims number of dimensions. ** @param dims dimensions. ** @param subs subscript to advance. **/ void adv(int ndims, int const *dims, int *subs) { int d = 0; while (d < ndims) { if (++subs[d] < dims[d]) return; subs[d++] = 0; } } /** ------------------------------------------------------------------- ** @brief Climb the region forest to reach aa root ** ** The function climbs the regions forest @a r starting from the node ** @a idx to the corresponding root. ** ** To speed-up the operation, the function uses the ** MserReg::shortcut field to quickly jump to the root. After the ** root is reached, all the used shortcut are updated. ** ** @param r regions' forest. ** @param idx stating node. ** @return index of the reached root. **/ unsigned int climb(MserReg* r, unsigned int idx) { unsigned int prev_idx = idx; unsigned int next_idx; unsigned int root_idx; /* move towards root to find it */ while (1) { /* next jump to the root */ next_idx = r[idx].shortcut; /* recycle shortcut to remember how we came here */ r[idx].shortcut = prev_idx; /* stop if the root is found */ if (next_idx == idx) break; /* next guy */ prev_idx = idx; idx = next_idx; } root_idx = idx; /* move backward to update shortcuts */ while (1) { /* get previously visited one */ prev_idx = r[idx].shortcut; /* update shortcut to point to the new root */ r[idx].shortcut = root_idx; /* stop if the first visited node is reached */ if (prev_idx == idx) break; /* next guy */ idx = prev_idx; } return(root_idx); } /** ------------------------------------------------------------------- ** @brief Create a new MSER filter ** ** Initializes a new MSER filter for images of the specified ** dimensions. Images are @a ndims -dimensional arrays of dimensions ** @a dims. ** ** @param ndims number of dimensions. ** @param dims dimensions. **/ MserFilt* mser_new(int ndims, int const* dims) { MserFilt* f = (MserFilt *)calloc(sizeof(MserFilt), 1); f->ndims = ndims; f->dims = (int *)malloc(sizeof(int) * ndims); f->subs = (int *)malloc(sizeof(int) * ndims); f->dsubs = (int *)malloc(sizeof(int) * ndims); f->strides = (int *)malloc(sizeof(int) * ndims); /* shortcuts */ if (f->dims != NULL && f->subs != NULL && f->dsubs != NULL && f->strides != NULL) { int k = 0; /* copy dims to f->dims */ memcpy(f->dims, dims, sizeof(int) * ndims); /* compute strides to move into the N-dimensional image array */ f->strides[0] = 1; for (k = 1; k < ndims; ++k) { f->strides[k] = f->strides[k - 1] * dims[k - 1]; } /* total number of pixels */ f->nel = f->strides[ndims - 1] * dims[ndims - 1]; /* dof of ellipsoids */ f->dof = ndims * (ndims + 1) / 2 + ndims; /* more buffers */ f->perm = (unsigned int *)malloc(sizeof(unsigned int) * f->nel); f->joins = (unsigned int *)malloc(sizeof(unsigned int) * f->nel); f->r = (MserReg *)malloc(sizeof(MserReg) * f->nel); f->er = 0; f->rer = 0; f->mer = 0; f->rmer = 0; f->ell = 0; f->rell = 0; /* other parameters */ f->delta = 5; f->max_area = 0.75f; f->min_area = 3.0f / f->nel; f->max_variation = 0.25f; f->min_diversity = 0.2f; } return(f); } /** ------------------------------------------------------------------- ** @brief Delete MSER filter ** ** The function releases the MSER filter @a f and all its resources. ** ** @param f MSER filter to be deleted. **/ void mser_delete(MserFilt* f) { if (f) { if (f->acc) free(f->acc); if (f->ell) free(f->ell); if (f->er) free(f->er); if (f->r) free(f->r); if (f->joins) free(f->joins); if (f->perm) free(f->perm); if (f->strides) free(f->strides); if (f->dsubs) free(f->dsubs); if (f->subs) free(f->subs); if (f->dims) free(f->dims); if (f->mer) free(f->mer); free(f); } } #define MAX( x, y ) ( ( (x) > (y) ) ? (x) : (y) ) /** ------------------------------------------------------------------- ** @brief Process image ** ** The functions calculates the Maximally Stable Extremal Regions ** (MSERs) of image @a im using the MSER filter @a f. ** ** The filter @a f must have been initialized to be compatible with ** the dimensions of @a im. ** ** @param f MSER filter. ** @param im image data. **/ void mser_process(MserFilt* f, unsigned char const* im) { /* shortcuts */ unsigned int nel = f->nel; unsigned int *perm = f->perm; unsigned int *joins = f->joins; int ndims = f->ndims; int *dims = f->dims; int *subs = f->subs; int *dsubs = f->dsubs; int *strides = f->strides; MserReg *r = f->r; MserExtrReg *er = f->er; unsigned int *mer = f->mer; int delta = f->delta; int njoins = 0; int ner = 0; int nmer = 0; int nbig = 0; int nsmall = 0; int nbad = 0; int ndup = 0; int i, j, k; /* delete any previosuly computed ellipsoid */ f->nell = 0; /* ----------------------------------------------------------------- * Sort pixels by intensity * -------------------------------------------------------------- */ { unsigned int buckets[MSER_PIX_MAXVAL]; /* clear buckets */ memset(buckets, 0, sizeof(unsigned int) * MSER_PIX_MAXVAL); /* compute bucket size (how many pixels for each intensity * value) */ for (i = 0; i < (int)nel; ++i) { unsigned char v = im[i]; ++buckets[v]; } /* cumulatively add bucket sizes */ for (i = 1; i < MSER_PIX_MAXVAL; ++i) { buckets[i] += buckets[i - 1]; } /* empty buckets computing pixel ordering */ for (i = nel; i >= 1; ) { unsigned char v = im[--i]; unsigned int j = --buckets[v]; perm[j] = i; } } /* initialize the forest with all void nodes */ for (i = 0; i < (int)nel; ++i) { r[i].parent = MSER_VOID_NODE; } /* ----------------------------------------------------------------- * Compute regions and count extremal regions * -------------------------------------------------------------- */ /* * In the following: * idx : index of the current pixel * val : intensity of the current pixel * r_idx : index of the root of the current pixel * n_idx : index of the neighbors of the current pixel * nr_idx : index of the root of the neighbor of the current pixel */ /* process each pixel by increasing intensity */ for (i = 0; i < (int)nel; ++i) { /* pop next node xi */ unsigned int idx = perm[i]; unsigned char val = im[idx]; unsigned int r_idx; /* add the pixel to the forest as a root for now */ r[idx].parent = idx; r[idx].shortcut = idx; r[idx].area = 1; r[idx].height = 1; r_idx = idx; /* convert the index IDX into the subscript SUBS; also initialize * DSUBS to (-1,-1,...,-1) */ { unsigned int temp = idx; for (k = ndims - 1; k >= 0; --k) { dsubs[k] = -1; subs[k] = temp / strides[k]; temp = temp % strides[k]; } } /* examine the neighbors of the current pixel */ while (1) { unsigned int n_idx = 0; int good = 1; /* * Compute the neighbor subscript as NSUBS+SUB, the * corresponding neighbor index NINDEX and check that the * neighbor is within the image domain. */ for (k = 0; k < ndims && good; ++k) { int temp = dsubs[k] + subs[k]; good &= (0 <= temp) && (temp < dims[k]); n_idx += temp * strides[k]; } /* * The neighbor should be processed if the following conditions * are met: * 1. The neighbor is within image boundaries. * 2. The neighbor is indeed different from the current node * (the opposite happens when DSUB=(0,0,...,0)). * 3. The neighbor is already in the forest, meaning that it has * already been processed. */ if (good && n_idx != idx && r[n_idx].parent != MSER_VOID_NODE) { unsigned char nr_val = 0; unsigned int nr_idx = 0; int hgt = r[r_idx].height; int n_hgt = r[nr_idx].height; /* * Now we join the two subtrees rooted at * R_IDX = ROOT( IDX) * NR_IDX = ROOT(N_IDX). * Note that R_IDX = ROOT(IDX) might change as we process more * neighbors, so we need keep updating it. */ r_idx = climb(r, idx); nr_idx = climb(r, n_idx); /* * At this point we have three possibilities: * (A) ROOT(IDX) == ROOT(NR_IDX). In this case the two trees * have already been joined and we do not do anything. * (B) I(ROOT(IDX)) == I(ROOT(NR_IDX)). In this case the pixel * IDX is extending an extremal region with the same * intensity value. Since ROOT(NR_IDX) will NOT be an * extremal region of the full image, ROOT(IDX) can be * safely added as children of ROOT(NR_IDX) if this * reduces the height according to the union rank * heuristic. * (C) I(ROOT(IDX)) > I(ROOT(NR_IDX)). In this case the pixel * IDX is starting a new extremal region. Thus ROOT(NR_IDX) * WILL be an extremal region of the final image and the * only possibility is to add ROOT(NR_IDX) as children of * ROOT(IDX), which becomes parent. */ if (r_idx != nr_idx) /* skip if (A) */ { nr_val = im[nr_idx]; if (nr_val == val && hgt < n_hgt) { /* ROOT(IDX) becomes the child */ r[r_idx].parent = nr_idx; r[r_idx].shortcut = nr_idx; r[nr_idx].area += r[r_idx].area; r[nr_idx].height = MAX(n_hgt, hgt + 1); joins[njoins++] = r_idx; } else { /* cases ROOT(IDX) becomes the parent */ r[nr_idx].parent = r_idx; r[nr_idx].shortcut = r_idx; r[r_idx].area += r[nr_idx].area; r[r_idx].height = MAX(hgt, n_hgt + 1); joins[njoins++] = nr_idx; /* count if extremal */ if (nr_val != val) ++ner; } /* check b vs c */ } /* check a vs b or c */ } /* neighbor done */ /* move to next neighbor */ k = 0; while (++dsubs[k] > 1) { dsubs[k++] = -1; if (k == ndims) goto done_all_neighbors; } } /* next neighbor */ done_all_neighbors:; } /* next pixel */ /* the last root is extremal too */ ++ner; /* save back */ f->njoins = njoins; f->stats.num_extremal = ner; /* ----------------------------------------------------------------- * Extract extremal regions * -------------------------------------------------------------- */ /* * Extremal regions are extracted and stored into the array ER. The * structure R is also updated so that .SHORTCUT indexes the * corresponding extremal region if any (otherwise it is set to * VOID). */ /* make room */ if (f->rer < ner) { if (er) free(er); f->er = er = (MserExtrReg *)malloc(sizeof(MserExtrReg) * ner); f->rer = ner; } ; /* save back */ f->nmer = ner; /* count again */ ner = 0; /* scan all regions Xi */ if (er != NULL) { for (i = 0; i < (int)nel; ++i) { /* pop next node xi */ unsigned int idx = perm[i]; unsigned char val = im[idx]; unsigned int p_idx = r[idx].parent; unsigned char p_val = im[p_idx]; /* is extremal ? */ int is_extr = (p_val > val) || idx == p_idx; if (is_extr) { /* if so, add it */ er[ner].index = idx; er[ner].parent = ner; er[ner].value = im[idx]; er[ner].area = r[idx].area; /* link this region to this extremal region */ r[idx].shortcut = ner; /* increase count */ ++ner; } else { /* link this region to void */ r[idx].shortcut = MSER_VOID_NODE; } } } /* ----------------------------------------------------------------- * Link extremal regions in a tree * -------------------------------------------------------------- */ for (i = 0; i < ner; ++i) { unsigned int idx = er[i].index; do { idx = r[idx].parent; } while (r[idx].shortcut == MSER_VOID_NODE); er[i].parent = r[idx].shortcut; er[i].shortcut = i; } /* ----------------------------------------------------------------- * Compute variability of +DELTA branches * -------------------------------------------------------------- */ /* For each extremal region Xi of value VAL we look for the biggest * parent that has value not greater than VAL+DELTA. This is dubbed * `top parent'. */ for (i = 0; i < ner; ++i) { /* Xj is the current region the region and Xj are the parents */ int top_val = er[i].value + delta; int top = er[i].shortcut; /* examine all parents */ while (1) { int next = er[top].parent; int next_val = er[next].value; /* Break if: * - there is no node above the top or * - the next node is above the top value. */ if (next == top || next_val > top_val) break; /* so next could be the top */ top = next; } /* calculate branch variation */ { int area = er[i].area; int area_top = er[top].area; er[i].variation = (float)(area_top - area) / area; er[i].max_stable = 1; } /* Optimization: since extremal regions are processed by * increasing intensity, all next extremal regions being processed * have value at least equal to the one of Xi. If any of them has * parent the parent of Xi (this comprises the parent itself), we * can safely skip most intermediate node along the branch and * skip directly to the top to start our search. */ { int parent = er[i].parent; int curr = er[parent].shortcut; er[parent].shortcut = MAX(top, curr); } } /* ----------------------------------------------------------------- * Select maximally stable branches * -------------------------------------------------------------- */ nmer = ner; for (i = 0; i < ner; ++i) { unsigned int parent = er[i].parent; unsigned char val = er[i].value; float var = er[i].variation; unsigned char p_val = er[parent].value; float p_var = er[parent].variation; unsigned int loser; /* * Notice that R_parent = R_{l+1} only if p_val = val + 1. If not, * this and the parent region coincide and there is nothing to do. */ if (p_val > val + 1) continue; /* decide which one to keep and put that in loser */ if (var < p_var) loser = parent; else loser = i; /* make loser NON maximally stable */ if (er[loser].max_stable) { --nmer; er[loser].max_stable = 0; } } f->stats.num_unstable = ner - nmer; /* ----------------------------------------------------------------- * Further filtering * -------------------------------------------------------------- */ /* It is critical for correct duplicate detection to remove regions * from the bottom (smallest one first). */ { float max_area = (float)f->max_area * nel; float min_area = (float)f->min_area * nel; float max_var = (float)f->max_variation; float min_div = (float)f->min_diversity; /* scan all extremal regions (intensity value order) */ for (i = ner - 1; i >= 0L; --i) { /* process only maximally stable extremal regions */ if (!er[i].max_stable) continue; if (er[i].variation >= max_var) { ++nbad; goto remove; } if (er[i].area > max_area) { ++nbig; goto remove; } if (er[i].area < min_area) { ++nsmall; goto remove; } /* * Remove duplicates */ if (min_div < 1.0) { unsigned int parent = er[i].parent; int area, p_area; float div; /* check all but the root mser */ if ((int)parent != i) { /* search for the maximally stable parent region */ while (!er[parent].max_stable) { unsigned int next = er[parent].parent; if (next == parent) break; parent = next; } /* Compare with the parent region; if the current and parent * regions are too similar, keep only the parent. */ area = er[i].area; p_area = er[parent].area; div = (float)(p_area - area) / (float)p_area; if (div < min_div) { ++ndup; goto remove; } } /* remove dups end */ } continue; remove: er[i].max_stable = 0; --nmer; } /* check next region */ f->stats.num_abs_unstable = nbad; f->stats.num_too_big = nbig; f->stats.num_too_small = nsmall; f->stats.num_duplicates = ndup; } /* ----------------------------------------------------------------- * Save the result * -------------------------------------------------------------- */ /* make room */ if (f->rmer < nmer) { if (mer) free(mer); f->mer = mer = (unsigned int *)malloc(sizeof(unsigned int) * nmer); f->rmer = nmer; } /* save back */ f->nmer = nmer; j = 0; if (er != NULL && mer != NULL) { for (i = 0; i < ner; ++i) { if (er[i].max_stable) mer[j++] = er[i].index; } } } /** ------------------------------------------------------------------- ** @brief Fit ellipsoids ** ** @param f MSER filter. ** ** @sa @ref mser-ell **/ void mser_ell_fit(MserFilt* f) { /* shortcuts */ int nel = f->nel; int dof = f->dof; int *dims = f->dims; int ndims = f->ndims; int *subs = f->subs; int njoins = f->njoins; unsigned int *joins = f->joins; MserReg *r = f->r; unsigned int *mer = f->mer; int nmer = f->nmer; mser_acc *acc = f->acc; mser_acc *ell = f->ell; int d, index, i, j; /* already fit ? */ if (f->nell == f->nmer) return; /* make room */ if (f->rell < f->nmer) { if (f->ell) free(f->ell); f->ell = (float *)malloc(sizeof(float) * f->nmer * f->dof); f->rell = f->nmer; } if (f->acc == 0) { f->acc = (float *)malloc(sizeof(float) * f->nel); } acc = f->acc; ell = f->ell; /* ----------------------------------------------------------------- * Integrate moments * -------------------------------------------------------------- */ /* for each dof */ for (d = 0; d < f->dof; ++d) { /* start from the upper-left pixel (0,0,...,0) */ memset(subs, 0, sizeof(int) * ndims); /* step 1: fill acc pretending that each region has only one pixel */ if (d < ndims) { /* 1-order ................................................... */ for (index = 0; index < nel; ++index) { acc[index] = (float)subs[d]; adv(ndims, dims, subs); } } else { /* 2-order ................................................... */ /* map the dof d to a second order moment E[x_i x_j] */ i = d - ndims; j = 0; while (i > j) { i -= j + 1; j++; } /* initialize acc with x_i * x_j */ for (index = 0; index < nel; ++index) { acc[index] = (float)(subs[i] * subs[j]); adv(ndims, dims, subs); } } /* step 2: integrate */ for (i = 0; i < njoins; ++i) { unsigned int index = joins[i]; unsigned int parent = r[index].parent; acc[parent] += acc[index]; } /* step 3: save back to ellpises */ for (i = 0; i < nmer; ++i) { unsigned int idx = mer[i]; ell[d + dof * i] = acc[idx]; } } /* next dof */ /* ----------------------------------------------------------------- * Compute central moments * -------------------------------------------------------------- */ for (index = 0; index < nmer; ++index) { float *pt = ell + index * dof; unsigned int idx = mer[index]; float area = (float)r[idx].area; for (d = 0; d < dof; ++d) { pt[d] /= area; if (d >= ndims) { /* remove squared mean from moment to get variance */ i = d - ndims; j = 0; while (i > j) { i -= j + 1; j++; } pt[d] -= pt[i] * pt[j]; } } } /* save back */ f->nell = nmer; } void drawEllipse(const float * region, int width, int height, int depth, unsigned char* bits, const uint8_t * color) { /* Centroid (mean) */ const float x = region[0]; const float y = region[1]; /* Covariance matrix [a b; b c] */ const float a = region[2]; const float b = region[3]; const float c = region[4]; /* Eigenvalues of the covariance matrix */ const float d = a + c; const float e = a - c; const float f = sqrtf(4.0f * b * b + e * e); const float e0 = (d + f) / 2.0f; /* First eigenvalue */ const float e1 = (d - f) / 2.0f; /* Second eigenvalue */ /* Desired norm of the eigenvectors */ const float e0sq = sqrtf(e0); const float e1sq = sqrtf(e1); /* Eigenvectors */ float v0x = e0sq; float v0y = 0.0f; float v1x = 0.0f; float v1y = e1sq; if (b) { v0x = e0 - c; v0y = b; v1x = e1 - c; v1y = b; /* Normalize the eigenvectors */ const float n0 = e0sq / sqrtf(v0x * v0x + v0y * v0y); v0x *= n0; v0y *= n0; const float n1 = e1sq / sqrtf(v1x * v1x + v1y * v1y); v1x *= n1; v1y *= n1; } for (float t = 0.0f; t < 2.0f * M_PI; t += 0.001f) { int x2 = (int)(x + (cosf(t) * v0x + sinf(t) * v1x) * 2.0f + 0.5f); int y2 = (int)(y + (cosf(t) * v0y + sinf(t) * v1y) * 2.0f + 0.5f); if ((x2 >= 0) && (x2 < width) && (y2 >= 0) && (y2 < height)) for (int i = 0; i < min(depth, 3); ++i) bits[(y2 * width + x2) * depth + i] = color[i]; } } /** @brief MSER driver entry point **/ int main(int argc, char **argv) { /* algorithm parameters */ float delta = 2; float max_area = 0.5f; float min_area = 0.0001f; float max_variation = 0.5f; float min_diversity = 0.33f; int dark_on_bright = 1; bool err = false; char err_msg[1024]; int exit_code = 0; MserFilt *filt = 0; MserFilt *filtinv = 0; unsigned int const *regions; unsigned int const *regionsinv; float const *frames; float const *framesinv; enum { ndims = 2 }; int dims[ndims]; int nregions = 0, nregionsinv = 0, nframes = 0, nframesinv = 0; int i, dof; if (argc != 3) { fprintf (stderr, "Usage: %s input.jpg output.jpg\n", argv[0]); return(-1); } char * inputfile = argv[1]; char * outputfile = argv[2]; int width; int height; int depth; unsigned char * data = loadImage(inputfile, &width, &height, &depth); unsigned char *datainv = NULL; if (!data) { err = false; snprintf(err_msg, sizeof(err_msg), "Could not allocate enough memory."); goto done; } dims[0] = width; dims[1] = height; filt = mser_new(ndims, dims); filtinv = mser_new(ndims, dims); if (!filt || !filtinv) { snprintf(err_msg, sizeof(err_msg), "Could not create an MSER filter."); goto done; } if (delta >= 0) mser_set_delta(filt, (unsigned char)delta); if (max_area >= 0) mser_set_max_area(filt, max_area); if (min_area >= 0) mser_set_min_area(filt, min_area); if (max_variation >= 0) mser_set_max_variation(filt, max_variation); if (min_diversity >= 0) mser_set_min_diversity(filt, min_diversity); if (delta >= 0) mser_set_delta(filtinv, (unsigned char)delta); if (max_area >= 0) mser_set_max_area(filtinv, max_area); if (min_area >= 0) mser_set_min_area(filtinv, min_area); if (max_variation >= 0) mser_set_max_variation(filtinv, max_variation); if (min_diversity >= 0) mser_set_min_diversity(filtinv, min_diversity); printf("mser: parameters:\n"); printf("mser: delta = %d\n", mser_get_delta(filt)); printf("mser: max_area = %g\n", mser_get_max_area(filt)); printf("mser: min_area = %g\n", mser_get_min_area(filt)); printf("mser: max_variation = %g\n", mser_get_max_variation(filt)); printf("mser: min_diversity = %g\n", mser_get_min_diversity(filt)); if (dark_on_bright) { double startTime = now(); mser_process(filt, (unsigned char *)data); double nProcessTime = calcElapsed(startTime, now()); printf("Elapsed: %d ms \n ", (int)(nProcessTime * 1000)); /* Save result ----------------------------------------------- */ nregions = mser_get_regions_num(filt); regions = mser_get_regions(filt); printf("nregions: %d \t", nregions); /* * for (i = 0; i < nregions; ++i) { * printf(" %d \t", regions[i]); * } */ mser_ell_fit(filt); nframes = mser_get_ell_num(filt); dof = mser_get_ell_dof(filt); printf("dof: %d \t", dof); printf("nframes: %d \t", nframes); /* Draw ellipses in the original image */ const uint8_t colors[3] = { 127, 127, 127 }; for (int x = 0; x < 2; ++x) { frames = mser_get_ell(filt); for (i = 0; i < nframes; ++i) { drawEllipse(frames, width, height, depth, data, colors); frames += dof; } } saveJpeg(outputfile, width, height, depth, data); } else { /* allocate buffer */ datainv = (unsigned char *)malloc(width * height * depth); for (i = 0; i < width * height * depth; i++) { datainv[i] = ~data[i]; /* 255 - data[i] */ } if (!datainv) { err = false; snprintf(err_msg, sizeof(err_msg), "Could not allocate enough memory."); goto done; } double startTime = now(); mser_process(filtinv, (unsigned char *)datainv); double nProcessTime = calcElapsed(startTime, now()); printf("Elapsed: %d ms \n ", (int)(nProcessTime * 1000)); /* Save result ----------------------------------------------- */ nregionsinv = mser_get_regions_num(filtinv); regionsinv = mser_get_regions(filtinv); /* * for (i = 0; i < nregionsinv; ++i) { * printf("%d \t ", -regionsinv[i]); * } */ mser_ell_fit(filtinv); nframesinv = mser_get_ell_num(filtinv); dof = mser_get_ell_dof(filtinv); const uint8_t colors[3] = { 0, 0, 0 }; framesinv = mser_get_ell(filtinv); for (i = 0; i < nframesinv; ++i) { drawEllipse(framesinv, width, height, depth, data, colors); framesinv += dof; } saveJpeg(outputfile, width, height, depth, data); } /* Next guy ----------------------------------------------- */ done: /* release filter */ if (filt) { mser_delete(filt); filt = 0; } if (filtinv) { mser_delete(filtinv); filtinv = 0; } /* release image data */ if (data) { free(data); data = 0; } if (datainv) { free(datainv); datainv = 0; } /* if bad print error message */ if (err) { fprintf (stderr, "mser: err: %s (%d)\n", err_msg, err); exit_code = 1; } /* quit */ return(exit_code); }
算法有两种模式，白底黑字，白字黑底，可根据具体需求进行开关。
可参照《图片文档倾斜矫正算法 附完整c代码》中判断是否为文本图片的方式进行算法思路的改进。
效果图例：
以上，再一次抛砖引玉。
若有其他相关问题或者需求也可以邮件联系俺探讨。
邮箱地址是:
gaozhihan@vip.qq.com
