find_neighbours.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// CVS: $Revision: 2866 $, $Date: 2006-09-15 12:04:57 +0100 (Fri, 15 Sep 2006) $, $Author: rsc $
//-----------------------------------------------------------------------------
/*                                                         Based on nn_file.cpp
 * Command line options are:
 *
 * <a_dir> [optional - default is ./]
 *   The common directory prefix for all file I/O
 * <a_file>
 *   The common file name prefix, or full filename (including path).
 * <binary|ascii>
 *   indicates if the file is binary or ascii.
 * <large|small>
 *   both input and output files are larger than 2 Gb
 * <maxDistInArcSecs>
 *   as it says.
 * <index|list>
 *   Indexed or list for the active list.
 * <filter|nested|sweep>
 *   Use CM filter, or generic nested loop, or generic plane sweep.
 * <outfile_name>
 *   Name of the output file for the final matches.
 * <binary|ascii>
 *   indicates if the file is binary or ascii.
 */
//-----------------------------------------------------------------------------
#include <iostream>
#include "String.h"

#include "ActiveList.h"
#include "DecPlaneSweepFilter.h"
#include "FileReader.h"
#include "FileWriter.h"
#include "Filter.h"
#include "IndexedActiveList.h"
#include "Matcher.h"
#include "Neighbours.h"
#include "NeighboursTextFileWriter.h"
#include "NeighboursBinaryFileWriter.h"
#include "NestedLoopFilter.h"
#include "Object.h"
#include "ObjectConsumer.h"
#include "ObjectPairConsumer.h"
#include "ObjectPairRefineConsumer.h"
#include "ObjectProducer.h"
#include "Refine.h"
#include "SimpleActiveList.h"
#include "Timer.h"
#include "WithinDistanceRefine.h"
#include "WSATextFileReader.h"
#include "WSAReader.h"
//-----------------------------------------------------------------------------
static void usage(char const * const prog_name)
{
  std::cerr << prog_name
          << " [dir] <file> <binary|ascii> <large|small>"
          << " <maxDistInArcSecs> <index|list> <filter|nested|sweep>"
          << " <outfile_name> <binary|ascii>"
          << std::endl;
}
//-----------------------------------------------------------------------------
int main(int argc, char * argv[])
{
#ifdef PLOT_TIMES
  Timer::globalTimer()->cont();        // need to start the timer
#endif

  int status = 0;
  const int cAllParamTotal = 10;

  if (argc != cAllParamTotal && argc != cAllParamTotal-1)
  {
    usage(argv[0]);
    status = 1;
  }
  else
  {
// ******** Read in Arguments ***********
    int param = 1;
    char *dirStr = (argc == cAllParamTotal) ? argv[param++]
                                            : 0;
    String directory;
    if (dirStr)
    {
      directory = String(dirStr);
      if (directory[directory.size()-1] != '/')
      {
        directory += '/';
      }
    } else {
      directory = "";
    }
    char *nameStr = argv[param++];
    String inputFilePath = directory + String(nameStr);
    String inputFileDtd = inputFilePath;
    inputFileDtd.replace(inputFileDtd.find("."), 4, ".dtd");
    bool isBinary = (strcmp(argv[param++], "binary") == 0);
    bool isLarge = (strcmp(argv[param++], "large") == 0);
    double maxDist = atof(argv[param++])/3600.0;
    bool useIndex = (strcmp(argv[param++], "index") == 0);
    bool useFilter =     (strcmp(argv[param], "filter") == 0);
    bool useNestedLoop = (!useFilter && strcmp(argv[param], "nested") == 0);
    char *outNameStr = argv[++param];
    String outputFilePath = directory + String(outNameStr);
    bool isOutBinary = (strcmp(argv[++param], "binary") == 0);

#ifndef SILENT
    if (useFilter)
      std::cout << "Using NN filter           : true" << std::endl; 
    else if (useNestedLoop)
      std::cout << "Using generic nested loop : true" << std::endl;
    else
      std::cout << "Using generic plane sweep : true" << std::endl;
    std::cout << "Using index active list   : "
              << ((useIndex) ? "true" : "false")
              << std::endl;
    std::cout << "Max distance (Dec Degs)   : " << maxDist << std::endl;
#endif

// ******** Create Matcher ***********

    // Read in objects with an object producer
    ObjectProducer* prod = new
      ObjectProducer(new
        FileReader(isBinary ? (FileObjectReader *) new WSAReader(inputFileDtd)
                            : (FileObjectReader *) new WSATextFileReader(),
                   inputFilePath.c_str(),
                   isLarge));

    // Create the active list
    ActiveList* aList = (useIndex) ? (ActiveList*) new IndexedActiveList()
                                   : (ActiveList*) new SimpleActiveList();

    // Write out matched pairs to a file, output always large file just in case
    bool isOutLarge = true;
    ObjectPairConsumer accWithinDistPairCons
    (
      WithinDistanceRefine::name() + " accept",
      (isOutBinary) ? (ObjectPairWriter*) 
                       new NeighboursBinaryFileWriter(outputFilePath.c_str(),
                                                      isOutLarge)
                    : (ObjectPairWriter*)
                       new NeighboursTextFileWriter(outputFilePath.c_str(),
                                                    isOutLarge)
    );
    // Ignore rejected pairs
    ObjectPairConsumer rejWithinDistPairCons(WithinDistanceRefine::name()
                                             + " reject");

    // Refine matched pairs using WithinDistance
    WithinDistanceRefine withinDistRefine(maxDist,
                                          &accWithinDistPairCons,
                                          &rejWithinDistPairCons);
    ObjectPairRefineConsumer pairCons
    (
      (useNestedLoop) ? NestedLoopFilter::name()
                      : DecPlaneSweepFilter::name(),
      &withinDistRefine
    );

    ObjectConsumer cons("points reject");

    Matcher *matcher = new Neighbours(prod, aList, &pairCons, &cons, maxDist);

// ******** Filter ***********

    Filter *filter = 0;

    if (useFilter)
      filter = new Filter(matcher);
    else if (useNestedLoop)
      filter = new NestedLoopFilter(matcher);
    else
      filter = new DecPlaneSweepFilter(matcher);

    filter->filter();

    delete filter;
  }

  return status;
}
//-----------------------------------------------------------------------------