initial sd-vbs

initial sd-vbs

add sd-vbs

sd-vbs

31 files changed, 4136 insertions, 0 deletions

diff --git a/SD-VBS/benchmarks/mser/src/c/mser.c b/SD-VBS/benchmarks/mser/src/c/mser.c
new file mode 100644
index 0000000..d886d7a
--- /dev/null
+++ b/SD-VBS/benchmarks/mser/src/c/mser.c
@@ -0,0 +1,714 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+/***
+%   MSER  Maximally Stable Extremal Regions
+%   R=MSER(I,DELTA) computes the Maximally Stable Extremal Regions
+%   (MSER) of image I with stability threshold DELTA. I is any
+%   array of class UINT8, while DELTA is a scalar of the same class.
+%   R is an index set (of class UINT32) which enumerates the
+%   representative pixels of the detected regions.
+%
+%   A region R can be recovered from a representative pixel X as the
+%   connected component of the level set {Y:I(Y) <= I(X)} which
+%   contains X.
+***/
+
+
+#include "mser.h"
+#include <string.h>
+
+/* advance N-dimensional subscript */
+void
+adv(iArray *dims, int ndims, iArray *subs_pt)
+{
+    int d = 0 ;
+    while(d < ndims) 
+    {
+        sref(subs_pt,d) = sref(subs_pt,d) + 1;
+        if( sref(subs_pt,d)  < sref(dims,d) ) 
+            return ;
+        sref(subs_pt,d++) = 0 ;
+    }
+}
+
+/** driver **/
+I2D* mser(I2D* I, int in_delta,
+          iArray* subs_pt, iArray* nsubs_pt, iArray* strides_pt, iArray* visited_pt, iArray* dims, 
+          uiArray* joins_pt,
+          region_t* regions_pt, 
+          pair_t* pairs_pt,
+          node_t* forest_pt,
+          ulliArray* acc_pt, ulliArray* ell_pt,
+          I2D* out)
+{
+   idx_t i, rindex=0;
+   int k;
+   int nout = 1;
+   
+   int OUT_REGIONS=0;
+   int OUT_ELL = 1;
+   int OUT_PARENTS = 2;
+   int OUT_AREA = 3;
+   int BUCKETS = 256;
+   
+   //I2D* out;
+
+   int IN_I = 0;
+   int IN_DELTA = 1;   
+
+    /* configuration */
+    int verbose = 1 ;      /* be verbose                              */
+    int small_cleanup= 1 ; /* remove very small regions               */
+    int big_cleanup  = 1 ; /* remove very big regions                 */
+    int bad_cleanup  = 0 ; /* remove very bad regions                 */
+    int dup_cleanup  = 1 ; /* remove duplicates                       */
+    val_t delta ;          /* stability delta                         */
+
+    /* node value denoting a void node */
+    idx_t const node_is_void = 0xffffffff ;
+
+    //iArray*   subs_pt ;       /* N-dimensional subscript                 
+    //iArray*   nsubs_pt ;      /* diff-subscript to point to neigh.       
+//    uiArray* strides_pt ;    /* strides to move in image array          
+//    uiArray* visited_pt ;    /* flag                                    
+
+    int nel ;              /* number of image elements (pixels)       */
+    int ner = 0 ;          /* number of extremal regions              */
+    int nmer = 0 ;         /* number of maximally stable              */
+    int ndims ;            /* number of dimensions                    */
+//    iArray* dims ;           /* dimensions                              
+    int njoins = 0 ;       /* number of join ops                      */
+
+    I2D* I_pt ;    /* source image                            */
+    //pair_t*   pairs_pt ;   /* scratch buffer to sort pixels           
+//    node_t*   forest_pt ;  /* the extremal regions forest             
+//    region_t* regions_pt ; /* list of extremal regions found          
+    int regions_pt_size;
+    int pairs_pt_size;
+    int forest_pt_size;
+
+    /* ellipses fitting */
+    //ulliArray* acc_pt ;        /* accumulator to integrate region moments
+    //ulliArray* ell_pt ;        /* ellipses parameters                     
+    int    gdl ;           /* number of parameters of an ellipse      */
+    //uiArray* joins_pt ;      /* sequence of joins                       
+   
+    delta = 0;
+    delta = in_delta;
+
+    /* get dimensions */
+
+    nel = I->height*I->width;            /* number of elements of src image */
+    ndims = 2;
+    //dims = malloc(sizeof(iArray) + sizeof(int)*ndims);
+    I_pt = I;
+    
+    sref(dims,0) = I->height;
+    sref(dims,1) = I->width;
+    
+    /* allocate stuff */
+    //subs_pt = malloc(sizeof(iArray) + sizeof(int)*ndims);
+    //nsubs_pt = malloc(sizeof(iArray) + sizeof(int)*ndims);
+
+    //strides_pt = malloc(sizeof(uiArray)+sizeof(unsigned int)*ndims);
+    //visited_pt = malloc(sizeof(uiArray) + sizeof(unsigned int)*nel);
+    //joins_pt = malloc(sizeof(uiArray) + sizeof(unsigned int)*nel);
+
+    //regions_pt = (region_t*)malloc(sizeof(region_t)*nel);
+    regions_pt_size = nel;
+
+    //pairs_pt = (pair_t*)malloc(sizeof(pair_t)*nel);
+    pairs_pt_size = nel;
+
+    //forest_pt = (node_t*)malloc(sizeof(node_t)*nel);
+    forest_pt_size = nel;
+
+    /* compute strides to move into the N-dimensional image array */
+    sref(strides_pt,0) = 1;
+    for(k = 1 ; k < ndims ; ++k)
+    {
+        sref(strides_pt,k) = sref(strides_pt,k-1) * sref(dims,k-1) ;
+    }
+
+    /* sort pixels in increasing order of intensity: using Bucket Sort */
+    {
+        int unsigned buckets [BUCKETS] ;
+        memset(buckets, 0, sizeof(int unsigned)*BUCKETS) ;
+
+        for(i = 0 ; i < nel ; ++i) 
+        {
+            val_t v = asubsref(I_pt,i) ;
+            ++buckets[v] ;
+        }
+        
+        for(i = 1 ; i < BUCKETS ; ++i) 
+        {
+            arrayref(buckets,i) += arrayref(buckets,i-1) ;