diff --git a/README.md b/README.md
index dc191b4..1545272 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,9 @@ Information on the provided functionalities can be found in the reports
 * [D5.4 Shape grammars for almost invisible structures Software prototype v2](http://duraark.eu/wp-content/uploads/2015/08/DURAARK_D5.5.4.pdf) 
 * [D2.5 Software prototype v2, Section 4.4](http://duraark.eu/wp-content/uploads/2015/08/DURAARK_D2_5_final.pdf) (overview)
 
+### Usage
+
+Usage documentation is available [here](https://github.com/DURAARK/duraark-geometricenrichment/wiki).
 ### Dependencies
 
 The service depends on the following DURAARK components:
@@ -44,8 +47,9 @@ Our recommended stack is to install DURAARK on a Docker-compatible Linux system
 On the host you want to deploy the service execute the following steps (assuming that Docker and Docker Compose are installed and working):
 
 ```js
-> git clone https://github.com/DURAARK/duraark-geometricenrichment.git
+> git clone --recursive https://github.com/DURAARK/duraark-geometricenrichment.git
 > cd duraark-geometricenrichment
+> sudo mkdir -p /duraark-storage/sessions
 > docker-compose up -d
 ```
 
@@ -58,9 +62,10 @@ The files you want to use have to be put into the folder **/tmp/duraark/files**.
 To setup the environment follow these steps:
 
 ```js
-> git clone https://github.com/DURAARK/duraark-geometricenrichment.git
+> git clone --recursive https://github.com/DURAARK/duraark-geometricenrichment.git
 > cd duraark-geometricenrichment
 > npm install
+> mkdir -p /duraark-storage/sessions
 > docker-compose -f devenv-compose.yml build
 > docker-compose -f devenv-compose.yml up -d
 ```
diff --git a/src/api/controllers/RiseController.js b/src/api/controllers/RiseController.js
index 784eaa5..8dd2b00 100644
--- a/src/api/controllers/RiseController.js
+++ b/src/api/controllers/RiseController.js
@@ -151,6 +151,7 @@ function prepareWiregen(session) {
 }
 
 function startWiregen(session) {
+
   return new Promise(function(resolve, reject) {
     console.log('[SessionController::start Wiregen]');
     prepareWiregen(session);
@@ -158,11 +159,14 @@ function startWiregen(session) {
     wiregen.importDetections(session)
       .then(createInputSymbolList)
       .then(wiregen.createWiregenImages)
-      .then(wireGenResultSvg_grammar)
-      .then(wireGenResultSvg_hypothesis).then(function() {
+      //.then(wireGenResultSvg_grammar)
+      //.then(wireGenResultSvg_hypothesis)
+      .then(function() {
         console.log("[startWiregen::finished]");
         resolve(session);
-    });
+    }).catch(function(err) {
+        console.log('blablubb:' + err);
+      });
   });
 }
 
@@ -190,7 +194,7 @@ function createInputSymbolList(session) {
           });
         }
         console.log("imported " + session[category].length + " " + category + " symbols.");
-        console.log(JSON.stringify(session[category]));
+        //console.log(JSON.stringify(session[category]));
       });
 
       session.wiregenPath = path.join(session.workingDir, 'wiregen');
@@ -540,8 +544,123 @@ module.exports = {
         }).status(200);
       });
     });
-  }
+  },
 
+  evaluateElecdetect: function(req, res, next)
+  {    
+    var session = prepareSession(req.body.e57master);
+    var wiregen = new Wiregen();
+    prepareWiregen(session);
+    var symbol_elecdetect  = wiregen.importElecdetectSymbols(session);
+    var symbol_groundtruth = wiregen.importGroundtruthSymbols(session);
+
+    console.log('###################### Elecdetect Evaluation ###############');
+    var symbol_statistics = function(m,s) {
+      console.log('***' + m + '***');
+      for (var i in s) {
+        console.log(i + ":" + s[i].length + " symbols.");
+      }
+    };
+    symbol_statistics('Elecdetect', symbol_elecdetect);
+    symbol_statistics('Groundtruth', symbol_groundtruth);
+
+    // compare category GT (groundtruth) vs
+    //         category D (detected) in terms of
+    // comparison per wall
+    // - matches (overlapping symbols)
+    // - false positives (object in D but not in GT)
+    // - false negatives (object in GT but not in D)
+    var compare_category = function(GT, D)
+    {
+      // build wall index
+      var wallIndex = function(symbols)
+      {
+        var wi = {};
+        for (var i = 0, ie = symbols.length; i<ie; ++i)
+        {
+          s = symbols[i];
+          if (!wi[s.attributes.wallid]) {
+            wi[s.attributes.wallid] = [];
+          }
+          wi[s.attributes.wallid].push(s);
+        }
+        return wi;
+      };
+
+      var wall_gt = wallIndex(GT);
+      var wall_d  = wallIndex(D);
+
+
+      var result = {
+        'match' : 0,
+        'false_positive' : 0,
+        'false_negative' : 0
+      };
+
+      Object.keys(wall_d).forEach( function(wallid) {
+        console.log('testing ' + wallid);
+        var match_gt = {};
+        var match_d  = {};
+
+        if (wall_gt[wallid])
+        for (var i_gt = 0, i_gte = wall_gt[wallid].length; i_gt < i_gte; ++i_gt)
+        {
+          g = wall_gt[wallid][i_gt];
+          for (var i_d = 0, i_de = wall_d[wallid].length; i_d < i_de; ++i_d)
+          {
+            d = wall_d[wallid][i_d];
+
+            var A = g.attributes;
+            var B = d.attributes;
+            // detect overlap
+            var left = Math.max(A.left, B.left);
+            var top  = Math.max(A.top, B.top);
+            var right = Math.min(A.left+A.width, B.left+B.width);
+            var bottom = Math.min(A.top+A.height, B.top+B.height);
+            var areaA = A.width*A.height;
+            var areaB = B.width*B.height;
+            if ( (left < right) && (top < bottom) && Math.abs(areaA/areaB - 1.0)<0.1 )
+            {
+              var area = (right-left) * (bottom-top);
+                console.log('overlap detected: AL:' + A.left + ' AW:' + A.width + ' AT:' + A.top + ' AH' + A.height 
+                  + ' BL:' + B.left + ' BW:' + B.width + ' BT:' + B.top + ' BH' + B.height);
+                console.log('area a: ' + areaA + ' area b:' + areaB + ' relsize:' + Math.abs(areaA/areaB - 1.0) + ' area overlap:' + area);
+              if ((area / areaA) >= 0.9)
+              {
+                console.log((area / areaA) + ' => match!');
+                match_gt[i_gt] = '1';
+                match_d[i_d]   = '1';
+              }
+            }
+          }
+        }
+
+        // count matches and fals positives/negatives
+        if (wall_gt[wallid])
+        for (var i_gt = 0, i_gte = wall_gt[wallid].length; i_gt < i_gte; ++i_gt)
+        {
+          if (match_gt[i_gt] == '1')  { result.match += 1; } 
+          else                        { result.false_negative +=1; }  // gt but not detected
+        }
 
+        for (var i_d = 0, i_de = wall_d[wallid].length; i_d < i_de; ++i_d)
+        {
+          if (match_d[i_d] != '1') { result.false_positive += 1; }    // detection not present in gt
+        }
+
+      });
+
+
+      return result;
+    }
+
+    console.log('GT Sockets:' + JSON.stringify(symbol_groundtruth.Sockets));
+    console.log('D  Sockets:' + JSON.stringify(symbol_elecdetect.Sockets));
+    var sockets = compare_category(symbol_groundtruth.Sockets, symbol_elecdetect.Sockets);
+    console.log(JSON.stringify(sockets));
+    var switches = compare_category(symbol_groundtruth.Switches, symbol_elecdetect.Switches);
+    console.log(JSON.stringify(switches));
+
+  }
 
 };
diff --git a/src/bindings/wiregen/index.js b/src/bindings/wiregen/index.js
index e07603b..a441789 100644
--- a/src/bindings/wiregen/index.js
+++ b/src/bindings/wiregen/index.js
@@ -4,29 +4,19 @@ var spawn = require('child_process').spawn,
   fs = require('fs'),
   xml2js = require('xml2js');
 
-var Wiregen = module.exports = function() {
-  //this.session = session;
-};
-
-Wiregen.prototype.importDetections = function(session) {
-  session.wiregenInput = [];
-  session.Sockets = [];
-  session.Switches = [];
-
-  if (session.config.wiregen.roots) {
-    session.Roots = session.config.wiregen.roots;
-  } else {
-    session.Roots = [];
-  }
-
-  var promises = [];
-
-  if (session.useGroundtruth)
+function importGroundtruthSymbols(session) 
+{
+  var symbols = {
+    'Sockets'  : [],
+    'Switches' : [],
+    'Roots'    : []
+  };
+
+  console.log('[Wiregen::importGroundtruth]');
+
+  var walljson = JSON.parse(fs.readFileSync(session.wallfile, "utf8"));
+  for (var i=0; i<walljson.Walls.length; ++i) 
   {
-    console.log('[Wiregen::importGroundtruth]');
-    var walljson = JSON.parse(fs.readFileSync(session.wallfile, "utf8"));
-    for (var i=0; i<walljson.Walls.length; ++i) 
-    {
       var xmlparser = new xml2js.Parser();
       var wall = walljson.Walls[i];
       var svgfilename = path.join(session.workingDir, 'groundtruth', 
@@ -36,16 +26,23 @@ Wiregen.prototype.importDetections = function(session) {
       try 
       {
         hasSVG = fs.lstatSync(svgfilename).isFile();
-      } catch (err) { }
+      } catch (err) { 
+        console.log('file ' + svgfilename + ' could not be opened.');
+      }
 
       if (hasSVG)
       {
         var svgxml = fs.readFileSync(svgfilename);
-        var promise = new Promise(function(resolve, reject) {
-          xmlparser.parseString(svgxml,function(err, svg) {
-            if (err) reject(err);
-            // import symbols from SVG:
-            if (svg.svg.rect) {
+
+        xmlparser.parseString(svgxml,function(err, svg) 
+        {
+          if (err) {
+            console.log('could not parse SVG XML:' + svgfilename);
+          }
+          else 
+          {
+            if (svg.svg.rect) 
+            {
               for (j=0; j<svg.svg.rect.length; ++j)
               {
                 var rect = svg.svg.rect[j];
@@ -55,14 +52,22 @@ Wiregen.prototype.importDetections = function(session) {
                   var transform = RE.exec(rect.$.transform);
                   var sx = Number(transform[1]);
                   var sy = Number(transform[2]);
+                } else {
+                  sx = 1.0;
+                  sy = 1.0;
                 }
+                // parse width
+                var RE = /stroke-width:([^;]*);/gi;
+                var sw = RE.exec(rect.$.style);
+                var strokewidth = Number(sw[1]);
+                console.log(strokewidth);
 
                 var item = {
                   "attributes": {
-                    "left": sx*Number(rect.$.x),
-                    "top": sy*Number(rect.$.y),
-                    "width": Number(rect.$.width),
-                    "height": Number(rect.$.height),
+                    "left": sx*Number(rect.$.x)-strokewidth,
+                    "top": sy*Number(rect.$.y)-strokewidth,
+                    "width": Number(rect.$.width)+2*strokewidth,
+                    "height": Number(rect.$.height)+2*strokewidth,
                     "wallid": wall.attributes.id
                   }
                 };
@@ -72,94 +77,117 @@ Wiregen.prototype.importDetections = function(session) {
                 switch(result[1].toLowerCase()) {
                   case '0000ff' : // SOCKET
                     item.label = 'SOCKET';
-                    session.Sockets.push(item);
+                    symbols.Sockets.push(item);
                   break;
                   case '00ff00' : // SWITCH
                     item.label = 'SWITCH';
-                    session.Switches.push(item);
+                    symbols.Switches.push(item);
                   break;
                 }
-                //console.log(item);
               }
             }
-            resolve();
-          });
+          }
         });
-        promises.push(promise);
       } else {
         console.log('no groundtruth data for ' + svgfilename);
       }
     }
-  } 
-  else 
-  {
-  console.log('[Wiregen::importDetections]');
-
-  //console.log("selecimages " + JSON.stringify(session.elecDetecResultImages, null, 4));
-  _.forEach(session.elecDetecResultImages, function(n) {
-    if (n.file.substr(-4) === '.xml') {
-      var promise = new Promise(function(resolve, reject) {
-        var f = path.join(session.elecdetecResults, n.file);
-
-        fs.readFile(f, 'utf-8', function(err, contents) {
-
-          var parser = new xml2js.Parser();
-          if (err) reject(err);
+  return symbols;
+} 
 
-          var innerPrommises = [];
-          parser.parseString(contents, function(err, result) {
-            if (err) reject(err);
-            for (var position in result.Image.Object) {
+function importElecdetectSymbols(session) 
+{
+  console.log('[Wiregen::importDetections]');
+  var symbols = {
+    'Sockets'  : [],
+    'Switches' : [],
+    'Roots'    : []
+  };
 
-              var object = result.Image.Object[position];
+  _.forEach(session.elecDetecResultImages, function(n) 
+  {
+    if (n.file.substr(-4) === '.xml') 
+    {
+      var f = path.join(session.elecdetecResults, n.file);
+      console.log('importing from ' + f);
+
+      var contents = fs.readFileSync(f, 'utf-8');
+      var parser = new xml2js.Parser();
+      parser.parseString(contents, function(err, result) {
+        if (err) {
+          console.log('could not parse XML: ' + f);
+        } else {
+          for (var position in result.Image.Object) 
+          {
+            var object = result.Image.Object[position];
+            var attr = object.boundingbox[0].$;
+            var wallid = path.basename(result.Image.$.file, '.jpg').substring(session.basename.length+1);
+
+            var item = {
+              "attributes": {
+                "left": Number(attr.x),
+                "top": Number(attr.y),
+                "width": Number(attr.w),
+                "height": Number(attr.h),
+                "wallid": wallid
+              }
+            };
+            if (object.label == '1') {
+              item.label = 'SOCKET';
+              symbols.Sockets.push(item);
+
+            } else if (object.label == '2') {
+              item.label = 'SWITCH';
+              symbols.Switches.push(item);
+            }
+            console.log('new item' + JSON.stringify(item) );
 
-              var attr = object.boundingbox[0].$;
+          }
+        }
+      });
+    }
+  });
 
-              var wallid = path.basename(result.Image.$.file, '.jpg').substring(session.basename.length+1);
+  return symbols;
+}
 
-              var item = {
-                "attributes": {
-                  "left": Number(attr.x),
-                  "top": Number(attr.y),
-                  "width": Number(attr.w),
-                  "height": Number(attr.h),
-                  "wallid": wallid
-                }
-              };
-              //console.log('new item' + object.label);
+var Wiregen = module.exports = function() {
+};
 
-              if (object.label == '1') {
-                item.label = 'SOCKET';
-                session.Sockets.push(item);
+Wiregen.prototype.importElecdetectSymbols = importElecdetectSymbols;
+Wiregen.prototype.importGroundtruthSymbols = importGroundtruthSymbols;
 
-              } else if (object.label == '2') {
-                item.label = 'SWITCH';
-                session.Switches.push(item);
-              }
-            }
-            resolve();
+Wiregen.prototype.importDetections = function(session) {
+  return new Promise(function(resolve, reject) {
+    session.wiregenInput = [];
+    session.Sockets = [];
+    session.Switches = [];
 
-          });
+    var symbols;
+   
+    if (session.useGroundtruth)
+    {
+      symbols = importGroundtruthSymbols(session);
+    } 
+    else 
+    {
+      symbols = importElecdetectSymbols(session);
+    }
 
-        });
-      });
-      promises.push(promise);
+    for (group in symbols)
+    {
+      session[group] = symbols[group];
     }
-  });
-    
-  }
 
-  return Promise.all(promises).then(function(argument) {
+    // append any roots from config
+    if (session.config.wiregen.roots) {
+      session.Roots = session.Roots.concat(session.config.wiregen.roots);
+    } 
     console.log(session.Sockets.length + " sockets");
     console.log(session.Switches.length + " switches");
-    return session;
-  }).catch(function(err) {
-    console.log('Error: ' + err);
-    console.log(err.stack);
-    throw new Error(err);
+    console.log(session.Roots.length + " roots");
+    resolve(session);
   });
-
-
 };
 
 Wiregen.prototype.createWiregenImages = function(session) {
@@ -198,7 +226,7 @@ Wiregen.prototype.createWiregenImages = function(session) {
       console.log('[Wiregen-binding] child process exited with code ' + code);
       session.status = 'finished-Wiregen';
 
-      if (code === 0) {
+      if (code == 0) {
         // copy lowres ortho images
           var files = fs.readdirSync(path.join(session.orthoresult, 'lowres'));
           files.forEach(function(fname) {
@@ -208,6 +236,7 @@ Wiregen.prototype.createWiregenImages = function(session) {
             targetFile = path.join(session.workingDir, "wiregen", "output", "svg_hypothesis", fname);
             fs.writeFileSync(targetFile, fs.readFileSync(sourceFile));
           });
+        console.log('# ending wiregen');
         resolve(session);
       }
       else{