Changeset 21 for trunk/grails-app/services/nl

Timestamp:

Mar 22, 2011, 3:04:40 PM (12 years ago)

Author:

robert@…

Message:

Solved issues with fuzzy matching (#23)

Location:

trunk/grails-app/services/nl/tno/metagenomics

Files:

• SampleExcelService.groovy (modified) (1 diff)
• imports/FuzzySearchService.groovy (modified) (1 diff)

trunk/grails-app/services/nl/tno/metagenomics/SampleExcelService.groovy

@@ -85 +85 @@
                 if( !includeRun )
                         fields = fields - runName
-                        
+                
+                        
+                // Do matching using fuzzy search. The 0.8 treshold makes sure that no match if chosen if
+                // there is actually no match at all.
+                def matches = fuzzySearchService.mostSimilarUnique( headers, possibleFields, 0.8 );
+                
                 headers.eachWithIndex { header, idx ->
-                        // Do matching using fuzzy search. The 0.8 treshold makes sure that no match if chosen if
-                        // there is actually no match at all.
-                        if( !header || header.toString().trim() == "" )
-                                bestMatches[idx] = null
-                        else
-                                bestMatches[idx] = fuzzySearchService.mostSimilar( header, possibleFields, 0.8 );
+                        bestMatches[idx] = matches[idx].candidate;
                 }
                 

trunk/grails-app/services/nl/tno/metagenomics/imports/FuzzySearchService.groovy

@@ -4 +4 @@
 
     static transactional = true
+        
+        /**
+         * Matches the patterns with the candidates, and returns the best candidates for all patterns, but returning
+         * the candidates only once
+         * 
+         * @param patterns              List with patterns to search for
+         * @param candidates    List with candidates to search in
+         * @param treshold              Treshold the matches have to be above
+         * @return                              
+         */
+        static def mostSimilarUnique( patterns, candidates, treshold ) {
+                def matches = []
+                
+                // Find the best matching candidate for each pattern
+                patterns.each { pattern ->
+                        def topScore = 0
+                        def bestFit = null
+                        
+                        candidates.each { candidate ->
+                                def score = stringSimilarity(pattern, candidate);
+                                if( score >= treshold )
+                                        matches << [ 'pattern': pattern, 'candidate': candidate, 'score': score ];
+                        }
+                }
+                
+                // Sort the list on descending score
+                matches = matches.sort( { a, b -> b.score <=> a.score } as Comparator )
+                
+                // Loop through the scores and select the best matching for every candidate
+                def results = patterns.collect { [ 'pattern': it, 'candidate': null ] }
+                def selectedCandidates = [];
+                def filledPatterns = [];
+                
+                matches.each { match ->
+                        if( !filledPatterns.contains( match.pattern ) && !selectedCandidates.contains( match.candidate ) ) {
+                                results.find { result -> result.pattern == match.pattern }?.candidate = match.candidate;
+                                
+                                selectedCandidates << match.candidate;
+                                filledPatterns << match.pattern;
+                        }
+                }
+                
+                return results
+        }
 
         // classes for fuzzy string matching