comparison query.cpp @ 431:8632cd387e24 api-inversion

Punishment gluttony.

Continue teasing out vague orthogonalities by beginning the task of
using an adb_query_parameters_t.  This does have the benefit of making
the distance calculation clearer, and we begin to see the shape of a
putative audiodb_query() emerging from the shrapnel of audioDB::query.
(Only the general shape; the detail is still a long, long way away).

   return true;
 }
 
 void audioDB::query(const char* dbName, const char* inFile, adb__queryResponse *adbQueryResponse) {
 
+  // init database tables and dbH first
+  if(query_from_key)
+    initTables(dbName);
+  else
+    initTables(dbName, inFile);
+
   adb_query_refine_t refine;
+  adb_query_parameters_t params;
   refine.flags = 0;
   /* FIXME: trackFile / ADB_REFINE_KEYLIST */
   if(radius) {
     refine.flags |= ADB_REFINE_RADIUS;
     refine.radius = radius;

   if(sequenceHop != 1) {
     refine.flags |= ADB_REFINE_HOP_SIZE;
     refine.hopsize = sequenceHop;
   }
 
-  // init database tables and dbH first
-  if(query_from_key)
-    initTables(dbName);
-  else
-    initTables(dbName, inFile);
-
-  // keyKeyPos requires dbH to be initialized
-  if(query_from_key && (!key || (query_from_key_index = audiodb_key_index(adb, key)) == (uint32_t) -1)) 
-    error("Query key not found", key);  
-  
-  switch (queryType) {
+  switch(queryType) {
   case O2_POINT_QUERY:
     sequenceLength = 1;
-    normalizedDistance = false;
+    params.accumulation = ADB_ACCUMULATION_DB;
+    params.distance = ADB_DISTANCE_DOT_PRODUCT;
+    params.npoints = pointNN;
+    params.ntracks = 0;
     reporter = new pointQueryReporter< std::greater < NNresult > >(pointNN);
-    accumulator = new DBAccumulator<adb_result_dist_gt>(pointNN);
     break;
   case O2_TRACK_QUERY:
     sequenceLength = 1;
-    normalizedDistance = false;
+    params.accumulation = ADB_ACCUMULATION_PER_TRACK;
+    params.distance = ADB_DISTANCE_DOT_PRODUCT;
+    params.npoints = pointNN;
+    params.ntracks = trackNN;
     reporter = new trackAveragingReporter< std::greater< NNresult > >(pointNN, trackNN, dbH->numFiles);
-    accumulator = new PerTrackAccumulator<adb_result_dist_gt>(pointNN, trackNN);
     break;
-  case O2_SEQUENCE_QUERY:    
-    if(no_unit_norming)
-      normalizedDistance = false;
-    accumulator = new PerTrackAccumulator<adb_result_dist_lt>(pointNN, trackNN);
-    if(!(refine.flags & ADB_REFINE_RADIUS)) {
-      reporter = new trackAveragingReporter< std::less< NNresult > >(pointNN, trackNN, dbH->numFiles);
-    } else {
-      if(index_exists(dbName, radius, sequenceLength)){
+  case O2_SEQUENCE_QUERY:
+  case O2_N_SEQUENCE_QUERY:
+    params.accumulation = ADB_ACCUMULATION_PER_TRACK;
+    params.distance = no_unit_norming ? ADB_DISTANCE_EUCLIDEAN : ADB_DISTANCE_EUCLIDEAN_NORMED;
+    params.npoints = pointNN;
+    params.ntracks = trackNN;
+    switch(queryType) {
+    case O2_SEQUENCE_QUERY:
+      if(!(refine.flags & ADB_REFINE_RADIUS)) {
+        reporter = new trackAveragingReporter< std::less< NNresult > >(pointNN, trackNN, dbH->numFiles);
+      } else if (index_exists(dbName, radius, sequenceLength)) {
 	char* indexName = index_get_name(dbName, radius, sequenceLength);
 	lsh = index_allocate(indexName, false);
 	reporter = new trackSequenceQueryRadReporter(trackNN, index_to_trackID(lsh->get_maxp(), lsh_n_point_bits)+1);
 	delete[] indexName;
-      }
-      else
+      } else {
 	reporter = new trackSequenceQueryRadReporter(trackNN, dbH->numFiles);
-    }
-    break;
-  case O2_N_SEQUENCE_QUERY:
-    if(no_unit_norming)
-      normalizedDistance = false;
-    accumulator = new PerTrackAccumulator<adb_result_dist_lt>(pointNN, trackNN);
-    if(!(refine.flags & ADB_REFINE_RADIUS)) {
-      reporter = new trackSequenceQueryNNReporter< std::less < NNresult > >(pointNN, trackNN, dbH->numFiles);
-    } else {
-      if(index_exists(dbName, radius, sequenceLength)){
+      }
+      break;
+    case O2_N_SEQUENCE_QUERY:
+      if(!(refine.flags & ADB_REFINE_RADIUS)) {
+        reporter = new trackSequenceQueryNNReporter< std::less < NNresult > >(pointNN, trackNN, dbH->numFiles);
+      } else if (index_exists(dbName, radius, sequenceLength)){
 	char* indexName = index_get_name(dbName, radius, sequenceLength);
 	lsh = index_allocate(indexName, false);
 	reporter = new trackSequenceQueryRadNNReporter(pointNN,trackNN, index_to_trackID(lsh->get_maxp(), lsh_n_point_bits)+1);
 	delete[] indexName;
-      }
-      else
+      } else {
 	reporter = new trackSequenceQueryRadNNReporter(pointNN,trackNN, dbH->numFiles);
+      }
+      break;
     }
     break;
-  case O2_ONE_TO_ONE_N_SEQUENCE_QUERY :
-    accumulator = new NearestAccumulator<adb_result_dist_lt>();
-    if(!(refine.flags & ADB_REFINE_RADIUS)) {
-      error("query-type not yet supported");
-    } else {
-      reporter = new trackSequenceQueryRadNNReporterOneToOne(pointNN,trackNN, dbH->numFiles);
-    }
+  case O2_ONE_TO_ONE_N_SEQUENCE_QUERY:
+    params.accumulation = ADB_ACCUMULATION_ONE_TO_ONE;
+    params.distance = ADB_DISTANCE_EUCLIDEAN_NORMED;
+    params.npoints = 0;
+    params.ntracks = 0;
     break;
   default:
-    error("unrecognized queryType in query()");
-  }  
-
+    error("unrecognized queryType");
+  }
+
+  // keyKeyPos requires dbH to be initialized
+  if(query_from_key && (!key || (query_from_key_index = audiodb_key_index(adb, key)) == (uint32_t) -1)) 
+    error("Query key not found", key);  
+
+  switch(params.distance) {
+  case ADB_DISTANCE_DOT_PRODUCT:
+    switch(params.accumulation) {
+    case ADB_ACCUMULATION_DB:
+      accumulator = new DBAccumulator<adb_result_dist_gt>(params.npoints);
+      break;
+    case ADB_ACCUMULATION_PER_TRACK:
+      accumulator = new PerTrackAccumulator<adb_result_dist_gt>(params.npoints, params.ntracks);
+      break;
+    case ADB_ACCUMULATION_ONE_TO_ONE:
+      accumulator = new NearestAccumulator<adb_result_dist_gt>();
+      break;
+    default:
+      error("unknown accumulation");
+    }
+    break;
+  case ADB_DISTANCE_EUCLIDEAN_NORMED:
+  case ADB_DISTANCE_EUCLIDEAN:
+    switch(params.accumulation) {
+    case ADB_ACCUMULATION_DB:
+      accumulator = new DBAccumulator<adb_result_dist_lt>(params.npoints);
+      break;
+    case ADB_ACCUMULATION_PER_TRACK:
+      accumulator = new PerTrackAccumulator<adb_result_dist_lt>(params.npoints, params.ntracks);
+      break;
+    case ADB_ACCUMULATION_ONE_TO_ONE:
+      accumulator = new NearestAccumulator<adb_result_dist_lt>();
+      break;
+    default:
+      error("unknown accumulation");
+    }
+    break;
+  default:
+    error("unknown distance function");
+  }
+  
   // Test for index (again) here
   if((refine.flags & ADB_REFINE_RADIUS) && index_exists(dbName, radius, sequenceLength)){ 
     VERB_LOG(1, "Calling indexed query on database %s, radius=%f, sequenceLength=%d\n", dbName, radius, sequenceLength);
-    index_query_loop(&refine, dbName, query_from_key_index);
+    index_query_loop(&params, &refine, dbName, query_from_key_index);
   }
   else{
     VERB_LOG(1, "Calling brute-force query on database %s\n", dbName);
-    query_loop(&refine, query_from_key_index);
+    query_loop(&params, &refine, query_from_key_index);
   }
 
   adb_query_results_t *rs = accumulator->get_points();
   for(unsigned int k = 0; k < rs->nresults; k++) {
     adb_result_t r = rs->results[k];

 // A reporter has been allocated
 //
 // Postconditions:
 // reporter contains the points and distances that meet the reporter constraints 
 
-void audioDB::query_loop_points(double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors, adb_query_refine_t *refine){ 
+void audioDB::query_loop_points(double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors, adb_query_parameters_t *params, adb_query_refine_t *refine){ 
   unsigned int dbVectors;
   double *sNorm = 0, *snPtr, *sPower = 0, *spPtr = 0;
   double *meanDBdur = 0;
 
   // check pre-conditions

   // so make a new method to build these values per-track or, even better, per-point
   if( !( dbH->flags & O2_FLAG_LARGE_ADB) )
     set_up_db(&sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors);
 
   VERB_LOG(1, "matching points...");
-
-  assert(pointNN>0 && pointNN<=O2_MAXNN);
-  assert(trackNN>0 && trackNN<=O2_MAXNN);
 
   // We are guaranteed that the order of points is sorted by:
   // trackID, spos, qpos
   // so we can be relatively efficient in initialization of track data.
   // Here we assume that points don't overlap, so we will use exhaustive dot

       }
       // Compute distance
       dist = audiodb_dot_product(query+qPos*dbH->dim, data_buffer+pp.spos*dbH->dim, dbH->dim*sequenceLength);
       double qn = qnPtr[qPos];
       double sn = sNorm[sPos];
-      if(normalizedDistance) 
+      switch(params->distance) {
+      case ADB_DISTANCE_EUCLIDEAN_NORMED:
 	dist = 2 - (2/(qn*sn))*dist;
-      else 
-	if(no_unit_norming)
-	  dist = qn*qn + sn*sn - 2*dist;
-      // else
-      // dist = dist;      
+        break;
+      case ADB_DISTANCE_EUCLIDEAN:
+        dist = qn*qn + sn*sn - 2*dist;
+        break;
+      }
       if((!radius) || dist <= (O2_LSH_EXACT_MULT*radius+O2_DISTANCE_TOLERANCE)) {
         adb_result_t r;
         r.key = fileTable + pp.trackID * O2_FILETABLE_ENTRY_SIZE;
         r.dist = dist;
         r.qpos = pp.qpos;

   SAFE_DELETE_ARRAY(sNorm);
   SAFE_DELETE_ARRAY(sPower);
   SAFE_DELETE_ARRAY(meanDBdur);
 }
 
-void audioDB::query_loop(adb_query_refine_t *refine, Uns32T queryIndex) {
+void audioDB::query_loop(adb_query_parameters_t *params, adb_query_refine_t *refine, Uns32T queryIndex) {
   
   unsigned int numVectors;
   double *query, *query_data;
   double *qNorm, *qnPtr, *qPower = 0, *qpPtr = 0;
   double meanQdur;

 
   set_up_db(&sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors);
 
   VERB_LOG(1, "matching tracks...");
   
-  assert(pointNN>0 && pointNN<=O2_MAXNN);
-  assert(trackNN>0 && trackNN<=O2_MAXNN);
-
   unsigned j,k,track,trackOffset=0, HOP_SIZE=sequenceHop, wL=sequenceLength;
   double **D = 0;    // Differences query and target 
   double **DD = 0;   // Matched filter distance
 
   D = new double*[numVectors]; // pre-allocate 

         }
 
 	// Search for minimum distance by shingles (concatenated vectors)
 	for(j = 0; j <= numVectors - wL; j += HOP_SIZE) {
 	  for(k = 0; k <= trackTable[track] - wL; k += HOP_SIZE) {
-            double thisDist;
-            if(normalizedDistance) 
+            double thisDist = 0;
+            switch(params->distance) {
+            case ADB_DISTANCE_EUCLIDEAN_NORMED:
               thisDist = 2-(2/(qnPtr[j]*sNorm[trackIndexOffset+k]))*DD[j][k];
-	    else 
-	      if(no_unit_norming)
-		thisDist = qnPtr[j]*qnPtr[j]+sNorm[trackIndexOffset+k]*sNorm[trackIndexOffset+k] - 2*DD[j][k];
-	      else
-		thisDist = DD[j][k];
-
+              break;
+            case ADB_DISTANCE_EUCLIDEAN:
+              thisDist = qnPtr[j]*qnPtr[j]+sNorm[trackIndexOffset+k]*sNorm[trackIndexOffset+k] - 2*DD[j][k];
+              break;
+            case ADB_DISTANCE_DOT_PRODUCT:
+              thisDist = DD[j][k];
+              break;
+            }
 	    // Power test
 	    if ((!usingPower) || audiodb_powers_acceptable(refine, qpPtr[j], sPower[trackIndexOffset + k])) {
               // radius test
               if((!(refine->flags & ADB_REFINE_RADIUS)) || 
                  thisDist <= (refine->radius+O2_DISTANCE_TOLERANCE)) {