adftester.cpp

Go to the documentation of this file.

/************************************************************************
  Simple test program for ADF's, using a spherical distance function.
 ************************************************************************/

#include "spheredistance.h"
#include "adf.h"
#include <string>
#include <stdlib.h>
static double tolerance = 0.001;
static double iso = 0;

static char *options = "hi:t:";
static char *usage_string =
"-t <tolerance> Use a different tolerance. [0.001]\n"
"-i <iso>       Achieve tolerance from 0 to iso iso-surfaces. [0]\n"
"\n";

double random1() { return (double)rand() / (double)RAND_MAX;}

static void test_usage(int code, const char *  msg=NULL, std::ostream& out= std::cerr)
{
    if ( msg )
        out << msg << std::endl << std::endl;

    out << "Adaptively-Sampled Distance Field test program." << std::endl;
    out << "Copyright (C) 2001 Steve Zelinka.  All rights reserved." << std::endl;
    out << "This software is NOT for public distribution." << std::endl;

    out << std::endl << "Usage: adftest <options>";
    out << std::endl;
    out << "-h             This message." << std::endl;
    out << "-t <tolerance> Use a difference tolerance. [0.001]" << std::endl;
    out << "-i <iso>       Achieve tolerance from 0 to <iso> away. [0]\n";

    exit(code);
}


static int test_cmdline_option(int argc, char **argv, int& index)
{
    std::string opt = argv[index];
    if ( opt == "-h" )
        test_usage(0);
    else if ( opt == "-t" )
        tolerance = atof(argv[++index]);
    else if ( opt == "-i" )
        iso = atof(argv[++index]);
    else
        return 0;

    ++index;
    return 1;
}


int main(int argc, char *argv[])
{
    int i = 1;

    while( i < argc )
        if ( !test_cmdline_option(i, argv, i) )
            test_usage(0, "Invalid option");
    
    SphereDistance sd(gmVector3(0, 0, 0), 0.4);
    ADF adf(&sd, iso);
    ADFRefiner refiner;
    refiner.refine(&adf, tolerance);

    ADFPruner pruner;
    pruner.prune(&adf);

    ADFAnalyzer analyzer;
    analyzer.collect_statistics(&adf);
    analyzer.report_statistics();

    double worst = 0;
    double avgbad = 0;
    double avg = 0;
    int bad = 0;
    for( i=0; i<10000; i++ )
    {
        gmVector3 p(random1()-0.5, random1()-0.5, random1()-0.5);
        double d = fabs(adf.get_distance(p) - sd.get_distance(p));
        if ( d > tolerance )
        {
            avgbad += d;
            bad++;
        }
        avg += d;
        if ( d > worst )
            worst = d;
    }

        std::cout << bad << " bad tests.\n";
    std::cout << worst << " worst deviation.\n";
    std::cout << avg/10000 << " average deviation.\n";
    std::cout << avgbad/bad << " average deviation in bad samples.\n";

    // Gather statistics about the ADF.

    return 1;
}

---