#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <string>
#include <ANN/ANNx.h>

Include dependency graph for ann2fig.cpp:

Macros
#define	TRANS_X(p) (offset_x + scale*(p[dim_x]))

#define	TRANS_Y(p) (offset_y - scale*(p[dim_y]))

Functions
void	Error (const char *msg, ANNerr level)

void	set_slice_val (double val)

void	getArgs (int argc, char **argv)

void	writeHeader ()

void	writePoint (ANNpoint p)

void	writeBox (const ANNorthRect &r)

void	writeLine (ANNpoint p0, ANNpoint p1)

void	writeCaption (const ANNorthRect &bnd_box, char *caption)

ANNbool	overlap (const ANNorthRect &box)

void	recReadTree (ANNorthRect &box)

void	readTree (ANNorthRect &bnd_box)

void	readANN ()

	main (int argc, char **argv)

Variables
const int	STRING_LEN = 500

const int	MAX_DIM = 1000

const double	DEF_SLICE_VAL = 0

const char	FIG_HEAD [] = {"#FIG 3.1"}

const char	DUMP_SUFFIX [] = {".dmp"}

const char	FIG_SUFFIX [] = {".fig"}

char	file_name [STRING_LEN]

char	infile_name [STRING_LEN]

char	outfile_name [STRING_LEN]

char	caption [STRING_LEN]

ofstream	ofile

ifstream	ifile

int	dim_x = 0

int	dim_y = 1

double	slice_val [MAX_DIM]

double	u_per_in = 1200

double	in_size = 5

double	in_low_x = 1

double	in_low_y = 1

double	u_size = 6000

double	u_low_x = 1200

double	u_low_y = 1200

int	pt_size = 10

int	dim

int	n_pts

ANNpointArray	pts = NULL

double	scale

double	offset_x

double	offset_y

Macro Definition Documentation

#define TRANS_X ( p ) (offset_x + scale*(p[dim_x]))

Definition at line 90 of file ann2fig.cpp.

Referenced by writeBox(), writeCaption(), writeLine(), and writePoint().

#define TRANS_Y ( p ) (offset_y - scale*(p[dim_y]))

Definition at line 91 of file ann2fig.cpp.

Referenced by writeBox(), writeCaption(), writeLine(), and writePoint().

Function Documentation

void Error	(	const char *	msg,
		ANNerr	level
	)

Definition at line 97 of file ann2fig.cpp.

References ANNabort.

Referenced by doValidation(), generatePts(), getArgs(), main(), readANN(), readPts(), and recReadTree().

 {
         if (level == ANNabort) {
                 cerr << "ann2fig: ERROR------->" << msg << "<-------------ERROR\n";
                 exit(1);
         }
         else {
                 cerr << "ann2fig: WARNING----->" << msg << "<-------------WARNING\n";
         }
 }

void getArgs	(	int	argc,
		char **	argv
	)

Definition at line 146 of file ann2fig.cpp.

References ANNabort, ANNfalse, ANNtrue, caption, DEF_SLICE_VAL, dim_x, dim_y, DUMP_SUFFIX, Error(), FIG_SUFFIX, file_name, ifile, in_low_x, in_low_y, in_size, infile_name, MAX_DIM, ofile, outfile_name, pt_size, set_slice_val(), slice_val, u_low_x, u_low_y, u_per_in, and u_size.

Referenced by main().

 {
         int i;
         int sl_dim;                                                                     // temp slice dimension
         double sl_val;                                                          // temp slice value
 
         set_slice_val(DEF_SLICE_VAL);                           // set initial slice-values
 
         if (argc <= 1) {
                 cerr << "Syntax:\n\
         ann2fig [-upi scale] [-x low_x] [-y low_y]\n\
                 [-sz size] [-dx dim_x] [-dy dim_y] [-sl dim value]*\n\
                 file\n\
         \n\
         where:\n\
             -upi scale          fig units per inch (default = 1200)\n\
             -x low_x            x and y offset of upper left corner (inches)\n\
             -y low_y            ...(default = 1)\n\
             -sz size            maximum side length of figure (in inches)\n\
                                 ...(default = 5)\n\
             -dx dim_x           horizontal dimension (default = 0)\n\
             -dy dim_y           vertical dimension (default = 1)\n\
             -sv value           default slice value (default = 0)\n\
             -sl dim value       each such pair defines the value along the\n\
                                 ...given dimension at which to slice.  This\n\
                                 ...may be supplied for each dimension except\n\
                                 ...dim_x and dim_y.\n\
             -ps pointsize       size of points in fig units (def = 10)\n\
             file                file (input=file.dmp, output=file.fig)\n";
                 exit(0);
         }
 
         ANNbool fileSeen = ANNfalse;                            // file argument seen?
 
         for (i = 1; i < argc; i++) {
                 if (!strcmp(argv[i], "-upi")) {                 // process -upi option
                         sscanf(argv[++i], "%lf", &u_per_in);
                 }
                 else if (!strcmp(argv[i], "-x")) {              // process -x option
                         sscanf(argv[++i], "%lf", &in_low_x);
                 }
                 else if (!strcmp(argv[i], "-y")) {              // process -y option
                         sscanf(argv[++i], "%lf", &in_low_y);
                 }
                 else if (!strcmp(argv[i], "-sz")) {             // process -sz option
                         sscanf(argv[++i], "%lf", &in_size);
                 }
                 else if (!strcmp(argv[i], "-dx")) {             // process -dx option
                         sscanf(argv[++i], "%d", &dim_x);
                 }
                 else if (!strcmp(argv[i], "-dy")) {             // process -dy option
                         sscanf(argv[++i], "%d", &dim_y);
                 }
                 else if (!strcmp(argv[i], "-sv")) {             // process -sv option
                         sscanf(argv[++i], "%lf", &sl_val);
                         set_slice_val(sl_val);                          // set slice values
                 }
                 else if (!strcmp(argv[i], "-sl")) {             // process -sl option
                         sscanf(argv[++i], "%d", &sl_dim);
                         if (sl_dim < 0 || sl_dim >= MAX_DIM) {
                                 Error("Slice dimension out of bounds", ANNabort);
                         }
                         sscanf(argv[++i], "%lf", &slice_val[sl_dim]);
                 }
                 if (!strcmp(argv[i], "-ps")) {                  // process -ps option
                         sscanf(argv[++i], "%i", &pt_size);
                 }
                 else {                                                                  // must be file name
                         fileSeen = ANNtrue;
                         sscanf(argv[i], "%s", file_name);
                         strcpy(infile_name, file_name);         // copy to input file name
                 strcat(infile_name, DUMP_SUFFIX);
                 strcpy(outfile_name, file_name);        // copy to output file name
                 strcat(outfile_name, FIG_SUFFIX);
                 }
         }
 
         if (!fileSeen) {                                                        // no file seen
                 Error("File argument is required", ANNabort);
         }
 
         ifile.open(infile_name, ios::in);                       // open for reading
         if (!ifile) {
                 Error("Cannot open input file", ANNabort);
         }
         ofile.open(outfile_name, ios::out);                     // open for writing
         if (!ofile) {
                 Error("Cannot open output file", ANNabort);
         }
 
         u_low_x = u_per_in * in_low_x;                          // convert inches to fig units
         u_low_y = u_per_in * in_low_y;
         u_size  = u_per_in * in_size;
 
         strcpy(caption, argv[0]);                                       // copy command line to caption
         for (i = 1; i < argc; i++) {
                 strcat(caption, " ");
                 strcat(caption, argv[i]);
         }
 }

main	(	int	argc,
		char **	argv
	)

Definition at line 583 of file ann2fig.cpp.

References getArgs(), and readANN().

 {
         getArgs(argc, argv);                                            // get input arguments
         readANN();                                                                      // read the dump file
 }

ANNbool overlap ( const ANNorthRect & box )

Definition at line 332 of file ann2fig.cpp.

References ANNfalse, ANNtrue, dim, dim_x, dim_y, ANNorthRect::hi, ANNorthRect::lo, and slice_val.

Referenced by recReadTree().

 {
         for (int i = 0; i < dim; i++) {
                 if (i != dim_x && i != dim_y &&
                    (box.lo[i] > slice_val[i] || box.hi[i] < slice_val[i]))
                         return ANNfalse;
         }
         return ANNtrue;
 }

void readANN ( )

Definition at line 514 of file ann2fig.cpp.

References ANNabort, annAllocPts(), dim, dim_x, dim_y, Error(), ANNorthRect::hi, ifile, ANNorthRect::lo, n_pts, offset_x, offset_y, pts, readTree(), scale, STRING_LEN, u_low_x, u_low_y, u_size, and version.

Referenced by main().

 {
         int j;
         char str[STRING_LEN];                                           // storage for string
     char version[STRING_LEN];                                   // storage for version
         int  bkt_size;                                                          // bucket size
 
         ifile >> str;                                                           // input header
         if (strcmp(str, "#ANN") != 0) {                         // incorrect header
                 Error("Incorrect header for dump file", ANNabort);
         }
     ifile.getline(version, STRING_LEN);                 // get version (ignore)
         ifile >> str;                                                           // get major heading
         if (strcmp(str, "points") == 0) {                       // points section
                 ifile >> dim;                                                   // read dimension
                 ifile >> n_pts;                                                 // number of points
                 pts = annAllocPts(n_pts, dim);                  // allocate points
                 for (int i = 0; i < n_pts; i++) {               // input point coordinates
                         int idx;                                                        // point index
                         ifile >> idx;                                           // input point index
                         if (idx < 0 || idx >= n_pts) {
                                 Error("Point index is out of range", ANNabort);
                         }
                         for (j = 0; j < dim; j++) {
                                 ifile >> pts[idx][j];                   // read point coordinates
                         }
                 }
                 ifile >> str;                                                   // get next major heading
         }
         if (strcmp(str, "tree") == 0) {                         // tree section
                 ifile >> dim;                                                   // read dimension
                 if (dim_x > dim || dim_y > dim) {
                         Error("Dimensions out of bounds", ANNabort);
                 }
                 ifile >> n_pts;                                                 // number of points
                 ifile >> bkt_size;                                              // bucket size (ignored)
                                                                                                 // read bounding box
                 ANNorthRect bnd_box(dim);                               // create bounding box
                 for (j = 0; j < dim; j++) {
                         ifile >> bnd_box.lo[j];                         // read box low coordinates
                 }
                 for (j = 0; j < dim; j++) {
                         ifile >> bnd_box.hi[j];                         // read box high coordinates
                 }
                                                                                                 // compute scaling factors
                 double box_len_x = bnd_box.hi[dim_x] - bnd_box.lo[dim_x];
                 double box_len_y = bnd_box.hi[dim_y] - bnd_box.lo[dim_y];
                                                                                                 // longer side determines scale
                 if (box_len_x > box_len_y) scale = u_size/box_len_x;
                 else                                       scale = u_size/box_len_y;
                                                                                                 // compute offsets
                 offset_x = u_low_x - scale*bnd_box.lo[dim_x];
                 offset_y = u_low_y + scale*bnd_box.hi[dim_y];
                 readTree(bnd_box);                                              // read the tree and process
         }
         else if (strcmp(str, "null") == 0) return;      // empty tree
         else {
                 cerr << "Input string: " << str << "\n";
                 Error("Illegal ann format.  Expecting section heading", ANNabort);
         }
 }

void readTree ( ANNorthRect & bnd_box )

Definition at line 464 of file ann2fig.cpp.

References caption, recReadTree(), writeBox(), writeCaption(), and writeHeader().

Referenced by readANN().

 {
         writeHeader();                                                          // output header
         writeBox(bnd_box);                                                      // draw bounding box
         writeCaption(bnd_box, caption);                         // write caption
         recReadTree(bnd_box);                                           // do it
 }

void recReadTree ( ANNorthRect & box )

Definition at line 377 of file ann2fig.cpp.

References ANNabort, ANNwarn, dim, dim_x, dim_y, Error(), ANNorthRect::hi, ifile, ANNorthRect::lo, n_pts, overlap(), ANNorthHalfSpace::project(), pts, STRING_LEN, writeBox(), writeLine(), and writePoint().

Referenced by readTree().

 {
         char tag[STRING_LEN];                                           // tag (leaf, split, shrink)
         int n_pts;                                                                      // number of points in leaf
         int idx;                                                                        // point index
         int cd;                                                                         // cut dimension
         ANNcoord cv;                                                            // cut value
         ANNcoord lb;                                                            // low bound
         ANNcoord hb;                                                            // high bound
         int n_bnds;                                                                     // number of bounding sides
         int sd;                                                                         // which side
 
         ifile >> tag;                                                           // input node tag
         if (strcmp(tag, "leaf") == 0) {                         // leaf node
 
                 ifile >> n_pts;                                                 // input number of points
                                                                                                 // check for overlap
                 if (dim == 2 || overlap(box)) {
                         for (int i = 0; i < n_pts; i++) {       // yes, write the points
                                 ifile >> idx;
                                 writePoint(pts[idx]);
                         }
                 }
                 else {                                                                  // input but ignore points
                         for (int i = 0; i < n_pts; i++) {
                                 ifile >> idx;
                         }
                 }
         }
         else if (strcmp(tag, "split") == 0) {           // splitting node
 
                 ifile >> cd >> cv >> lb >> hb;
                 if (lb != box.lo[cd] || hb != box.hi[cd]) {
                         Error("Bounding box coordinates are fishy", ANNwarn);
                 }
 
                 ANNcoord lv = box.lo[cd];                               // save bounds for cutting dim
                 ANNcoord hv = box.hi[cd];
 
                 //--------------------------------------------------------------
                 //      The following code is rather fragile so modify at your
                 //      own risk.  We first decrease the high-end of the bounding
                 //      box down to the cutting plane and then read the left subtree.
                 //      Then we increase the low-end of the bounding box up to the
                 //      cutting plane (thus collapsing the bounding box to a d-1
                 //      dimensional hyperrectangle).  Then we draw the projection of
                 //      its diagonal if it crosses the slicing plane.  This will have
                 //      the effect of drawing its intersection on the slicing plane.
                 //      Then we restore the high-end of the bounding box and read
                 //      the right subtree.  Finally we restore the low-end of the
                 //      bounding box, before returning.
                 //--------------------------------------------------------------
                 box.hi[cd] = cv;                                                // decrease high bounds
                 recReadTree(box);                                               // read left subtree
                                                                                                 // check for overlap
                 box.lo[cd] = cv;                                                // increase low bounds
                 if (dim == 2 || overlap(box)) {                 // check for overlap
                         if (cd == dim_x || cd == dim_y) {       // cut through slice plane
                                 writeLine(box.lo, box.hi);              // draw cutting line
                         }
                 }
                 box.hi[cd] = hv;                                                // restore high bounds
 
                 recReadTree(box);                                               // read right subtree
                 box.lo[cd] = lv;                                                // restore low bounds
         }
         else if (strcmp(tag, "shrink") == 0) {          // splitting node
 
                 ANNorthRect inner(dim, box);                    // copy bounding box
                 ifile >> n_bnds;                                                // number of bounding sides
                 for (int i = 0; i < n_bnds; i++) {
                         ifile >> cd >> cv >> sd;                        // input bounding halfspace
                         ANNorthHalfSpace hs(cd, cv, sd);        // create orthogonal halfspace
                         hs.project(inner.lo);                           // intersect by projecting
                         hs.project(inner.hi);
                 }
                 if (dim == 2 || overlap(inner)) {
                         writeBox(inner);                                        // draw inner rectangle
                 }
                 recReadTree(inner);                                             // read inner subtree
                 recReadTree(box);                                               // read outer subtree
         }
         else {
                 Error("Illegal node type in dump file", ANNabort);
         }
 }

void set_slice_val ( double val )

Definition at line 112 of file ann2fig.cpp.

References MAX_DIM, and slice_val.

Referenced by getArgs().

 {
         for (int i = 0; i < MAX_DIM; i++) {
                 slice_val[i] = val;
         }
 }

void writeBox ( const ANNorthRect & r )

Definition at line 277 of file ann2fig.cpp.

References ANNorthRect::hi, ANNorthRect::lo, ofile, TRANS_X, and TRANS_Y.

Referenced by readTree(), and recReadTree().

 {
                                                                                                 // unfilled box object
         ofile << "2 2 0 1 -1 7 0 0 -1 0.000 0 0 -1 0 0 5\n";
 
         int p0_x = (int) TRANS_X(r.lo);                         // transform endpoints
         int p0_y = (int) TRANS_Y(r.lo);
         int p1_x = (int) TRANS_X(r.hi);
         int p1_y = (int) TRANS_Y(r.hi);
         ofile << "\t"
                  << p0_x << " " << p0_y << " "                  // write vertices
                  << p1_x << " " << p0_y << " "
                  << p1_x << " " << p1_y << " "
                  << p0_x << " " << p1_y << " "
                  << p0_x << " " << p0_y << "\n";
 }

void writeCaption	(	const ANNorthRect &	bnd_box,
		char *	caption
	)

Definition at line 308 of file ann2fig.cpp.

References ANNorthRect::lo, ofile, TRANS_X, TRANS_Y, and u_per_in.

Referenced by readTree().

 {
         if (!strcmp(caption, "\0")) return;                     // null string?
         int px = (int) TRANS_X(bnd_box.lo);                     // put .5 in. lower left
         int py = (int) (TRANS_Y(bnd_box.lo) + 0.50 * u_per_in);
         ofile << "4 0 -1 0 0 0 20 0.0000 4 255 2000 ";
         ofile << px << " " << py << " " << caption << "\\001\n";
 }

void writeHeader ( )

Definition at line 256 of file ann2fig.cpp.

References FIG_HEAD, ofile, and u_per_in.

Referenced by readTree().

 {
         ofile << FIG_HEAD << "\n"                                       // fig file header
                  << "Portrait\n"
                  << "Center\n"
                  << "Inches\n"
                  << (int) u_per_in << " 2\n";
 }

void writeLine	(	ANNpoint	p0,
		ANNpoint	p1
	)

Definition at line 294 of file ann2fig.cpp.

References ofile, TRANS_X, and TRANS_Y.

Referenced by recReadTree().

 {
                                                                                                 // unfilled line object
         ofile << "2 1 0 1 -1 7 0 0 -1 0.000 0 0 -1 0 0 2\n";
 
         int p0_x = (int) TRANS_X(p0);                           // transform endpoints
         int p0_y = (int) TRANS_Y(p0);
         int p1_x = (int) TRANS_X(p1);
         int p1_y = (int) TRANS_Y(p1);
         ofile << "\t"
                  << p0_x << " " << p0_y << " "                  // write vertices
                  << p1_x << " " << p1_y << "\n";
 }

void writePoint ( ANNpoint p )

Definition at line 265 of file ann2fig.cpp.

References ofile, pt_size, TRANS_X, and TRANS_Y.

Referenced by recReadTree().

 {
                                                                                                 // filled black point object
         ofile << "1 3 0 1 -1 7 0 0 0 0.000 1 0.0000 ";
         int cent_x = (int) TRANS_X(p);                          // transform center coords
         int cent_y = (int) TRANS_Y(p);
         ofile << cent_x << " " << cent_y << " "         // write center, radius, bounds
                  << pt_size << " " << pt_size << " "
                  << cent_x << " " << cent_y << " "
                  << cent_x + pt_size << " " << cent_y + pt_size << "\n";
 }

Variable Documentation

char caption[STRING_LEN]

Definition at line 66 of file ann2fig.cpp.

Referenced by getArgs(), and readTree().

const double DEF_SLICE_VAL = 0

Definition at line 58 of file ann2fig.cpp.

Referenced by getArgs().

int dim

Definition at line 81 of file ann2fig.cpp.

Referenced by annAllocPt(), annAllocPts(), annAspectRatio(), annAssignRect(), annBox2Bnds(), annBoxDistance(), annClusEllipsoids(), annClusGaussPts(), annClusOrthFlats(), annCoGaussPts(), annCoLaplacePts(), annCopyPt(), annDist(), annEnclCube(), annEnclRect(), annGaussPts(), annLaplacePts(), annMaxSpread(), annPlanted(), annPrintPt(), annUniformPts(), QUESO::InterpolationSurrogateData< V, M >::check_dim_consistency(), QUESO::InterpolationSurrogateHelper::coordToGlobal(), ANNkd_tree::Dump(), fair_split(), generatePts(), genGauss(), genOrthFlat(), getTrueNN(), QUESO::InterpolationSurrogateHelper::globalToCoord(), QUESO::GslMatrix::GslMatrix(), initGlobals(), ANNorthRect::inside(), main(), midpt_split(), QUESO::GslOptimizer::minimize(), QUESO::GslOptimizer::minimize_no_gradient(), QUESO::GslOptimizer::minimize_with_gradient(), overlap(), printPoint(), printPt(), rbd_tree(), QUESO::InterpolationSurrogateIOASCII< V, M >::read(), readANN(), readPt(), readPts(), recReadTree(), rkd_tree(), QUESO::InterpolationSurrogateBuilder< V, M >::set_domain_vector(), sl_fair_split(), sl_midpt_split(), QUESO::InterpolationSurrogateData< V, M >::spacing(), ANNbruteForce::theDim(), ANNkd_tree::theDim(), tryCentroidShrink(), trySimpleShrink(), and QUESO::InterpolationSurrogateIOASCII< V, M >::write().

int dim_x = 0

Definition at line 69 of file ann2fig.cpp.

Referenced by getArgs(), overlap(), readANN(), and recReadTree().

int dim_y = 1

Definition at line 70 of file ann2fig.cpp.

Referenced by getArgs(), overlap(), readANN(), and recReadTree().

const char DUMP_SUFFIX[] = {".dmp"}

Definition at line 60 of file ann2fig.cpp.

Referenced by getArgs().

const char FIG_HEAD[] = {"#FIG 3.1"}

Definition at line 59 of file ann2fig.cpp.

Referenced by writeHeader().

const char FIG_SUFFIX[] = {".fig"}

Definition at line 61 of file ann2fig.cpp.

Referenced by getArgs().

char file_name[STRING_LEN]

Definition at line 63 of file ann2fig.cpp.

Referenced by getArgs().

ifstream ifile

Definition at line 68 of file ann2fig.cpp.

Referenced by getArgs(), readANN(), and recReadTree().

double in_low_x = 1

Definition at line 74 of file ann2fig.cpp.

Referenced by getArgs().

double in_low_y = 1

Definition at line 75 of file ann2fig.cpp.

Referenced by getArgs().

double in_size = 5

Definition at line 73 of file ann2fig.cpp.

Referenced by getArgs().

char infile_name[STRING_LEN]

Definition at line 64 of file ann2fig.cpp.

Referenced by getArgs().

const int MAX_DIM = 1000

Definition at line 57 of file ann2fig.cpp.

Referenced by getArgs(), and set_slice_val().

int n_pts

Definition at line 82 of file ann2fig.cpp.

Referenced by ANNkd_leaf::ANNkd_leaf(), annReadTree(), ANNkd_leaf::dump(), ANNkd_tree::Dump(), ANNbruteForce::nPoints(), ANNkd_tree::nPoints(), readANN(), and recReadTree().

double offset_x

Definition at line 86 of file ann2fig.cpp.

Referenced by readANN().

double offset_y

Definition at line 87 of file ann2fig.cpp.

Referenced by readANN().

ofstream ofile

Definition at line 67 of file ann2fig.cpp.

Referenced by getArgs(), writeBox(), writeCaption(), writeHeader(), writeLine(), and writePoint().

char outfile_name[STRING_LEN]

Definition at line 65 of file ann2fig.cpp.

Referenced by getArgs().

int pt_size = 10

Definition at line 79 of file ann2fig.cpp.

Referenced by getArgs(), and writePoint().

ANNpointArray pts = NULL

Definition at line 83 of file ann2fig.cpp.

Referenced by ANNkd_tree::Dump(), readANN(), recReadTree(), ANNbruteForce::thePoints(), and ANNkd_tree::thePoints().

double scale

Definition at line 85 of file ann2fig.cpp.

Referenced by QUESO::MLSamplingLevelOptions::checkOptions(), QUESO::MhOptionsValues::checkOptions(), QUESO::MetropolisHastingsSGOptions::getMyOptionValues(), and readANN().

double slice_val[MAX_DIM]

Definition at line 71 of file ann2fig.cpp.

Referenced by getArgs(), overlap(), and set_slice_val().

const int STRING_LEN = 500

Definition at line 56 of file ann2fig.cpp.

Referenced by annReadDump(), annReadTree(), main(), readANN(), and recReadTree().

double u_low_x = 1200

Definition at line 77 of file ann2fig.cpp.

Referenced by getArgs(), and readANN().

double u_low_y = 1200

Definition at line 78 of file ann2fig.cpp.

Referenced by getArgs(), and readANN().

double u_per_in = 1200

Definition at line 72 of file ann2fig.cpp.

Referenced by getArgs(), writeCaption(), and writeHeader().

double u_size = 6000

Definition at line 76 of file ann2fig.cpp.

Referenced by getArgs(), and readANN().

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation