comparison query.cpp @ 425:d65410f4bb85 api-inversion

Begin pushing information through.

Create and initialize an adb_query_refine_t struct in audioDB::query,
and pass it through to various callees, which can then use it instead of
the automagic class member variables.

This allows conversion of some routines into ordinary static C
functions.  Begin doing so.

 #include "reporter.h"
 
 #include "audioDB-internals.h"
 #include "accumulators.h"
 
-bool audioDB::powers_acceptable(double p1, double p2) {
-  if (use_absolute_threshold) {
-    if ((p1 < absolute_threshold) || (p2 < absolute_threshold)) {
+static bool audiodb_powers_acceptable(adb_query_refine_t *r, double p1, double p2) {
+  if (r->flags & ADB_REFINE_ABSOLUTE_THRESHOLD) {
+    if ((p1 < r->absolute_threshold) || (p2 < r->absolute_threshold)) {
       return false;
     }
   }
-  if (use_relative_threshold) {
-    if (fabs(p1-p2) > fabs(relative_threshold)) {
+  if (r->flags & ADB_REFINE_RELATIVE_THRESHOLD) {
+    if (fabs(p1-p2) > fabs(r->relative_threshold)) {
       return false;
     }
   }
   return true;
 }
 
 void audioDB::query(const char* dbName, const char* inFile, adb__queryResponse *adbQueryResponse) {
+
+  adb_query_refine_t refine;
+  refine.flags = 0;
+  /* FIXME: trackFile / ADB_REFINE_KEYLIST */
+  if(radius) {
+    refine.flags |= ADB_REFINE_RADIUS;
+    refine.radius = radius;
+  }
+  if(use_absolute_threshold) {
+    refine.flags |= ADB_REFINE_ABSOLUTE_THRESHOLD;
+    refine.absolute_threshold = absolute_threshold;
+  }
+  if(use_relative_threshold) {
+    refine.flags |= ADB_REFINE_RELATIVE_THRESHOLD;
+    refine.relative_threshold = relative_threshold;
+  }
+  if(usingTimes) {
+    refine.flags |= ADB_REFINE_DURATION_RATIO;
+    refine.duration_ratio = timesTol;
+  }
+  /* FIXME: not sure about this any more; maybe it belongs in query_id */
+  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);

     break;
   case O2_SEQUENCE_QUERY:    
     if(no_unit_norming)
       normalizedDistance = false;
     accumulator = new PerTrackAccumulator<adb_result_dist_lt>(pointNN, trackNN);
-    if(radius == 0) {
+    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);

     break;
   case O2_N_SEQUENCE_QUERY:
     if(no_unit_norming)
       normalizedDistance = false;
     accumulator = new PerTrackAccumulator<adb_result_dist_lt>(pointNN, trackNN);
-    if(radius == 0) {
+    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, dbH->numFiles);
     }
     break;
   case O2_ONE_TO_ONE_N_SEQUENCE_QUERY :
     accumulator = new NearestAccumulator<adb_result_dist_lt>();
-    if(radius == 0) {
+    if(!(refine.flags & ADB_REFINE_RADIUS)) {
       error("query-type not yet supported");
     } else {
       reporter = new trackSequenceQueryRadNNReporterOneToOne(pointNN,trackNN, dbH->numFiles);
     }
     break;
   default:
     error("unrecognized queryType in query()");
   }  
 
   // Test for index (again) here
-  if(radius && index_exists(dbName, radius, sequenceLength)){ 
+  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(dbName, query_from_key_index);
+    index_query_loop(&refine, dbName, query_from_key_index);
   }
   else{
     VERB_LOG(1, "Calling brute-force query on database %s\n", dbName);
-    query_loop(dbName, query_from_key_index);
+    query_loop(&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){ 
+void audioDB::query_loop_points(double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors, adb_query_refine_t *refine){ 
   unsigned int dbVectors;
   double *sNorm = 0, *snPtr, *sPower = 0, *spPtr = 0;
   double *meanDBdur = 0;
 
   // check pre-conditions

       trackIndexOffset=trackOffset/dbH->dim;    // num vectors offset
     }    
     Uns32T qPos = usingQueryPoint?0:pp.qpos;// index for query point
     Uns32T sPos = trackIndexOffset+pp.spos; // index into l2norm table
     // Test power thresholds before computing distance
-    if( ( !usingPower || powers_acceptable(qpPtr[qPos], sPower[sPos])) &&
+    if( ( !usingPower || audiodb_powers_acceptable(refine, qpPtr[qPos], sPower[sPos])) &&
 	( qPos<numVectors-sequenceLength+1 && pp.spos<trackTable[pp.trackID]-sequenceLength+1 ) ){
       // Non-large ADB track data is loaded inside power test for efficiency
       if( !(dbH->flags & O2_FLAG_LARGE_ADB) && (currentTrack!=pp.trackID) ){
 	// On currentTrack change, allocate and load track data
 	currentTrack=pp.trackID;
 	lseek(dbfid, dbH->dataOffset + trackOffset * sizeof(double), SEEK_SET);
 	read_data(dbfid, currentTrack, &data_buffer, &data_buffer_size);
       }
       // Compute distance
-      dist = dot_product_points(query+qPos*dbH->dim, data_buffer+pp.spos*dbH->dim, dbH->dim*sequenceLength);
+      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) 
 	dist = 2 - (2/(qn*sn))*dist;
       else 

   SAFE_DELETE_ARRAY(sNorm);
   SAFE_DELETE_ARRAY(sPower);
   SAFE_DELETE_ARRAY(meanDBdur);
 }
 
-// A completely unprotected dot-product method
-// Caller is responsible for ensuring that memory is within bounds
-inline double audioDB::dot_product_points(double* q, double* p, Uns32T  L){
-  double dist = 0.0;
-  while(L--)
-    dist += *q++ * *p++;
-  return dist;
-}
-
-void audioDB::query_loop(const char* dbName, Uns32T queryIndex) {
+void audioDB::query_loop(adb_query_refine_t *refine, Uns32T queryIndex) {
   
   unsigned int numVectors;
   double *query, *query_data;
   double *qNorm, *qnPtr, *qPower = 0, *qpPtr = 0;
   double meanQdur;

       
       VERB_LOG(7,"%u.%jd.%u | ", track, (intmax_t) trackIndexOffset, trackTable[track]);
       
       initialize_arrays(track, numVectors, query, data_buffer, D, DD);
 
-      if(usingTimes) {
+      if(refine->flags & ADB_REFINE_DURATION_RATIO) {
         VERB_LOG(3,"meanQdur=%f meanDBdur=%f\n", meanQdur, meanDBdur[track]);
       }
 
-      if((!usingTimes) || fabs(meanDBdur[track]-meanQdur) < meanQdur*timesTol) {
-        if(usingTimes) {
+      if((!(refine->flags & ADB_REFINE_DURATION_RATIO)) || fabs(meanDBdur[track]-meanQdur) < meanQdur*refine->duration_ratio) {
+        if(refine->flags & ADB_REFINE_DURATION_RATIO) {
           VERB_LOG(3,"within duration tolerance.\n");
         }
 
 	// Search for minimum distance by shingles (concatenated vectors)
 	for(j = 0; j <= numVectors - wL; j += HOP_SIZE) {

 		thisDist = qnPtr[j]*qnPtr[j]+sNorm[trackIndexOffset+k]*sNorm[trackIndexOffset+k] - 2*DD[j][k];
 	      else
 		thisDist = DD[j][k];
 
 	    // Power test
-	    if ((!usingPower) || powers_acceptable(qpPtr[j], sPower[trackIndexOffset + k])) {
+	    if ((!usingPower) || audiodb_powers_acceptable(refine, qpPtr[j], sPower[trackIndexOffset + k])) {
               // radius test
-              if((!radius) || thisDist <= (radius+O2_DISTANCE_TOLERANCE)) {
+              if((!(refine->flags & ADB_REFINE_RADIUS)) || 
+                 thisDist <= (refine->radius+O2_DISTANCE_TOLERANCE)) {
                 adb_result_t r;
                 r.key = fileTable + track * O2_FILETABLE_ENTRY_SIZE;
                 r.dist = thisDist;
                 r.qpos = usingQueryPoint ? queryPoint : j;
                 r.ipos = k;

     }
     X += dim;
   }
   VERB_LOG(2, "done.\n");
 }
-
-