Updates to UI and more documentation

Jordan Cheney
1 parent efe86ab6
Showing 34 changed files with 4457 additions and 914 deletions
docs/docs/docs/c_api.md
docs/docs/docs/cpp_api.md
docs/docs/docs/plugins/classification.md
docs/docs/docs/plugins/cluster.md
docs/docs/docs/plugins/core.md
docs/docs/docs/plugins/format.md
docs/docs/docs/plugins/gallery.md
docs/docs/docs/plugins/gui.md
docs/docs/docs/plugins/imgproc.md
docs/docs/index.md
docs/docs/install.md
docs/docs/technical.md
docs/docs/tutorials.md
docs/extensions/highlighter.py
docs/mkdocs.yml
docs/scripts/check_format_cpp.py
docs/scripts/check_links.py
docs/scripts/generate_api_class_doc.py
docs/scripts/generate_docs.py → docs/scripts/generate_plugin_docs.py
docs/themes/spacelab/css/base.css
+The C API is a high-level API for running algorithms and evaluating results.
+
+In order to provide a high-level interface that is usable from the command line and callable from other programming languages, the API is designed to operate at the "file system" level.
+In other words, arguments to many functions are file paths that specify either a source of input or a desired output.
+File extensions are relied upon to determine *how* files should be interpreted in the context of the function being called.
+The [C++ Plugin API](cpp_api.md) should be used if more fine-grained control is required.
+
+Import API considerations include-
+
+* Memory for <tt>const char*</tt> return values is managed internally and guaranteed until the next call to the function
+* Users should input a char * buffer and the size of that buffer. String data will be copied into the buffer, if the buffer is too small, only part of the string will be copied. Returns the buffer size required to contain the complete string.
+
+To use the API in your project use-
+
+    #include <openbr/openbr.h>
+
+[CMake](http://www.cmake.org/) developers may wish to the cmake configuration file found at
+
+    share/openbr/cmake/OpenBRConfig.cmake
+
+Please see the [tutorials](../tutorials.md) section for examples.
+
+---
+
+# Typedefs
+
+## void *br_template
+
+## void *br_template_list
+
+## void *br_gallery
+
+## void *br_matrix_output
+
+---
+
+# Functions
+
+## br_about
+
+Wraps [Context](cpp_api.md#context)
+
+* **return type:** const char *
+* **parameters:** None
+* **example call:** ```const char *br_about()```
+* **see:** [br_version](#br_version)
+
+---
+
+## br_cat
+
+Concatenates a list of galleries into 1 gallery.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+ num_input_galleries | int | Parameter description
+input_galleries[] | const char * | Parameter description
+output_gallery | const char * | Parameter description
+
+* **example call:** ```void br_cat(int num_input_galleries, const char *input_galleries[], const char *output_gallery)```
+
+---
+
+## br_deduplicate
+
+Removes duplicate [templates](cpp_api.md#template) in a [gallery](cpp_api.md#gallery). If a galley contains n duplicates, the first n-1 duplicates in the gallery will be removed and the nth will be kept. Users are encouraged to use binary gallery formats as the entire gallery is read into memory in one call to [Gallery](cpp_api.md#gallery)::read.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+input_gallery | const char * | Gallery to be deduplicated
+output_gallery | const char * | Deduplicated gallery
+threshold | const char * | Comparisons with a match score >= this value are designated to be duplicates.
+
+* **example call:** ```void br_deduplicate(const char *input_gallery, const char *output_gallery, const char *threshold)```
+
+---
+
+## br_cluster
+
+\brief Clusters one or more similarity matrices into a list of subjects. A [similarity matrix](../technical.md#the-evaluation-harness) is a type of [Output](cpp_api.md#output). The current clustering algorithm is a simplified implementation of \cite zhu11.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_simmats | int | Size of **simmats**
+simmats[] | const char * | Array of [simmat](../technical.md#the-evaluation-harness) composing one large self-similarity matrix arranged in row major order.
+aggressiveness | float | The higher the aggressiveness the larger the clusters. Suggested range is [0,10]
+csv | const char * | The cluster results file to generate. Results are stored one row per cluster and use gallery indices.
+
+* **example call:** ```void br_cluster(int num_simmats, const char *simmats[], float aggressiveness, const char *csv)```
+
+---
+
+## br_combine_masks
+
+Combines several equal-sized mask matrices. A comparison may not be simultaneously indentified as both a genuine and an imposter by different input masks.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_input_masks | int | Size of **input_masks**
+input_masks[] | const char * | Array of [mask matrices](../technical.md#the-evaluation-harness) to combine. All matrices must have the same dimensions.
+output_mask | const char * | The file to contain the resulting [mask matrix](../technical.md#the-evaluation-harness)
+method | const char * | Possible values are: <ul><li>And - Ignore comparison if *any* input masks ignore.</li> <li>Or - Ignore comparison if *all* input masks ignore.</li></ul>
+
+* **example call:** ```void br_combine_masks(int num_input_masks, const char *input_masks[], const char *output_mask, const char *method)```
+* **see:** [br_make_mask](#br_make_mask)
+
+---
+
+## br_compare
+
+Compares each template in the query gallery to each template in the target gallery.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+target_gallery | const char * | target_gallery The br::Gallery file whose templates make up the columns of the output.
+query_gallery | const char * | The br::Gallery file whose templates make up the rows of the output. A value of '.' reuses the target gallery as the query gallery.
+output | const char * | (Optional) [Output](cpp_api.md#output) file to contain the results of comparing the templates. The default behavior is to print scores to the terminal.
+
+* **example call:** ```void br_compare(const char *target_gallery, const char *query_gallery, const char *output = "")```
+* **see:** br_enroll
+
+---
+
+## br_compare_n
+
+Convenience function for comparing to multiple targets.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_targets | int | Size of **target_galleries**
+target_galleries[] | const char * | Target galleries to compare against
+query_gallery | const char * | query gallery for comparison.
+output | const char * | (Optional) [Output](cpp_api.md#output) file to contain the results of comparing the templates. The default behavior is to print scores to the terminal.
+
+* **example call:** ```void br_compare_n(int num_targets, const char *target_galleries[], const char *query_gallery, const char *output)```
+* **see:** br_compare
+
+---
+
+## br_pairwise_compare
+
+DOCUMENT ME!
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+target_gallery | const char * | DOCUMENT ME
+query_gallery | const char * | DOCUMENT ME
+output | const char * | DOCUMENT ME
+
+* **example call:** ```void br_pairwise_compare(const char *target_gallery, const char *query_gallery, const char *output = "")```
+
+---
+
+## br_convert
+
+Convert a file to a different type. Files can only be converted to types within the same group. For example [formats](cpp_api.md#format) can only be converted to other [formats](cpp_api.md#format).
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+file_type | const char * | Type of file to convert. Options are Format, Gallery or Output.
+input_file | const char * | File to convert.
+output_file | const char * | Output file. Type is determined by the file extension.
+
+* **example call:** ```void br_convert(const char *file_type, const char *input_file, const char *output_file)```
+
+---
+
+## br_enroll
+
+Constructs template(s) from an input.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+input | const char * | The [format](cpp_api.md#format) or [gallery](cpp_api.md#gallery) to enroll.
+gallery | const char * | (Optional) The [Gallery](cpp_api.md#gallery) file to contain the enrolled templates. By default the gallery will be held in memory and *input* can used as a gallery in [br_compare](#br_compare)
+
+* **example call:** ```void br_enroll(const char *input, const char *gallery = "")```
+* **see:** [br_enroll_n](#br_enroll_n)
+
+---
+
+## br_enroll_n
+
+Convenience function for enrolling multiple inputs.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_inputs | int | Size of **inputs**.
+inputs[] | const char * | Array of inputs to enroll.
+gallery | const char * | (Optional) The [Gallery](cpp_api.md#gallery) file to contain the enroll templates.
+
+* **example call:** ```void br_enroll_n(int num_inputs, const char *inputs[], const char *gallery = "")```
+* **see:** [br_enroll](#br_enroll)
+
+---
+
+## br_project
+
+A naive alternative to [br_enroll](#br_enroll).
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+input | const char * | DOCUMENT ME!
+output | const char * | DOCUMENT ME!
+
+* **example call:** ```void br_project(const char *input, const char *output)```
+* **see:** [br_enroll](#br_enroll)
+
+---
+
+## br_eval
+
+Creates a **.csv** file containing performance metrics from evaluating the similarity matrix using the mask matrix. The return value is the true accept rate at a false accept rate of one in one thousand.
+
+* **return type:** float
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+simmat | const char * | The [simmat](../technical.md#the-evaluation-harness) to use
+mask | const char * | The [mask](../technical.md#the-evaluation-harness) to use.
+csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+matches | int | (Optional) An integer number of matches to output around the EER. Default is 0.
+
+* **example call:** ```float br_eval(const char *simmat, const char *mask, const char *csv = "", int matches = 0)```
+* **see:** [br_plot](#br_plot)
+
+---
+
+## br_assert_eval
+
+Evaluates the similarity matrix using the mask matrix.  Function aborts ff TAR @ FAR = 0.001 does not meet an expected performance value.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+simmat | const char * | The [simmat](../technical.md#the-evaluation-harness) to use
+mask | const char * | The [mask](../technical.md#the-evaluation-harness)
+accuracy | const float | Desired true accept rate at false accept rate of one in one thousand.
+
+* **example call:** ```void br_assert_eval(const char *simmat, const char *mask, const float accuracy)```
+
+---
+
+## br_inplace_eval
+
+Creates a **.csv** file containing performance metrics from evaluating the similarity matrix using galleries containing ground truth labels.
+
+* **return type:** float
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+simmat | const char * | The [simmat](../technical.md#the-evaluation-harness)
+target | const char * | The name of a gallery containing metadata for the target set.
+query | const char * | The name of a gallery containing metadata for the query set.
+csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+
+* **example call:** ```float br_inplace_eval(const char * simmat, const char *target, const char *query, const char *csv = "")```
+* **see:** [br_plot](#br_plot)
+
+---
+
+## br_eval_classification
+
+Evaluates and prints classification accuracy to terminal.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+predicted_gallery | const char * | The predicted [Gallery](cpp_api.md#gallery).
+truth_gallery | const char * | The ground truth [Gallery](cpp_api.md#gallery).
+predicted_property | const char * | (Optional) Which metadata key to use from the **predicted_gallery**.
+truth_property | const char * | (Optional) Which metadata key to use from the **truth_gallery**.
+
+* **example call:** ```void br_eval_classification(const char *predicted_gallery, const char *truth_gallery, const char *predicted_property = "", const char *truth_property = "")```
+
+---
+
+## br_eval_clustering
+
+Evaluates and prints clustering accuracy to the terminal.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+csv | const char * | The cluster results file.
+gallery | const char * | The [Gallery](cpp_api.md#gallery) used to generate the [simmat](../technical.md#the-evaluation-harness) that was clustered.
+truth_property | const char * | (Optional) which metadata key to use from **gallery**, defaults to Label
+
+* **example call:** ```void br_eval_clustering(const char *csv, const char *gallery, const char * truth_property)```
+
+---
+
+## br_eval_detection
+
+Evaluates and prints detection accuracy to terminal.
+
+* **return type:** float
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+predicted_gallery | const char * | The predicted [Gallery](cpp_api.md#gallery).
+truth_gallery | const char * | The ground truth [Gallery](cpp_api.md#gallery).
+csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+normalize | bool | (Optional) Flag to normalize predicted bounding boxes for improved detection. Defaults to false.
+minSize | int | (Optional) Minimum size of faces to be considered in the evaluation. Size is applied to predicted and ground truth galleries. Defaults to -1 (no minimum size).
+maxSize | int | (Optional) Maximum size if faces to be considered in the evaluation. Size is applied to predicted and ground truth galleries. Defaults to -1 (no maximum size).
+
+* **example call:** ```float br_eval_detection(const char *predicted_gallery, const char *truth_gallery, const char *csv = "", bool normalize = false, int minSize = 0, int maxSize = 0)```
+
+---
+
+## br_eval_landmarking
+
+Evaluates and prints landmarking accuracy to terminal.
+
+* **return type:** float
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+predicted_gallery | const char * | The predicted [Gallery](cpp_api.md#gallery).
+truth_gallery | const char * | The ground truth [Gallery](cpp_api.md#gallery).
+csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+normalization_index_a | int | (Optional) The first index in the list of points to use for normalization. Default is 0.
+normalization_index_b | int | (Optional) The second index in the list of points to use for normalization. Default is 1.
+sample_index | int | (Optional) The index for sample landmark image in ground truth gallery. Default = 0.
+total_examples | int | (Optional) The number of accurate and inaccurate examples to display. Default is 5.
+
+* **example call:** ```float br_eval_landmarking(const char *predicted_gallery, const char *truth_gallery, const char *csv = "", int normalization_index_a = 0, int normalization_index_b = 1, int sample_index = 0, int total_examples = 5)```
+
+---
+
+## br_eval_regression
+
+Evaluates regression accuracy to disk.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+predicted_gallery | const char * | The predicted [Gallery](cpp_api.md#gallery)
+truth_gallery | const char * | The ground truth [Gallery](cpp_api.md#gallery)
+predicted_property | const char * | (Optional) Which metadata key to use from **predicted_gallery**.
+truth_property | const char * | (Optional) Which metadata key to use from **truth_gallery**.
+
+* **example call:** ```void br_eval_regression(const char *predicted_gallery, const char *truth_gallery, const char *predicted_property = "", const char *truth_property = "")```
+
+---
+
+## br_fuse
+
+Perform score level fusion on similarity matrices.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_input_simmats | int | Size of **input_simmats**.
+input_simmats[] | const char * | Array of [simmats](../technical.md#the-evaluation-harness). All simmats must have the same dimensions.
+normalization | const char * | Valid options are: <ul> <li>None - No score normalization.</li> <li>MinMax - Scores normalized to [0,1].</li> <li>ZScore - Scores normalized to a standard normal curve.</li> </ul>
+fusion | const char * | Valid options are: <ul> <li>Min - Uses the minimum score.</li> <li>Max - Uses the maximum score.</li> <li>Sum - Sums the scores. Sums can also be weighted: <tt>SumW1:W2:...:Wn</tt>.</li> <li>Replace - Replaces scores in the first matrix with scores in the second matrix when the mask is set.</li> </ul>
+output_simmat | const char * | [Simmat](../technical.md#the-evaluation-harness) to contain the fused scores.
+
+* **example call:** ```void br_fuse(int num_input_simmats, const char *input_simmats[],
+                       const char *normalization, const char *fusion, const char *output_simmat)```
+
+---
+
+## br_initialize
+
+Initializes the [Context](cpp_api.md#context). Required at the beginning of any OpenBR program.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+argc | int | Number of command line arguments.
+argv[] | char * | Array of command line arguments.
+sdk_path | const char * | (Optional) Path to the OpenBR sdk. If no path is provided OpenBR will try and find the sdk automatically.
+use_gui | bool | Enable OpenBR to use make GUI windows. Default is false.
+
+* **example call:** ```void br_initialize(int &argc, char *argv[], const char *sdk_path = "", bool use_gui = false)```
+* **see:** [br_finalize](#br_finalize)
+
+---
+
+## br_initialize_default
+
+Initializes the [Context](cpp_api.md#context) with default arguments.
+
+* **return type:** void
+* **parameters:** None
+* **example call:** ```void br_initialize_default()```
+* **see:** [br_finalize](#br_finalize)
+
+---
+
+## br_finalize
+
+Finalizes the context. Required at the end of any OpenBR program.
+
+* **return type:** void
+* **parameters:** None
+* **example call:** ```void br_finalize()```
+* **see:** [br_initialize](#br_initialize)
+
+---
+
+## br_is_classifier
+
+Checks if the provided algorithm is a classifier. Wrapper of [cpp_api.md#bool-isclassifierconst-qstring-algorithm].
+
+* **return type:** bool
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+algorithm | const char * | Algorithm to check.
+
+* **example call:** ```bool br_is_classifier(const char *algorithm)```
+
+---
+
+## br_make_mask
+
+Constructs a [mask](../technical.md#the-evaluation-harness) from target and query inputs.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+target_input | const char * | The target [Gallery](cpp_api.md#gallery)
+query_input | const char * | The query [Gallery](cpp_api.md#gallery)
+mask | const char * | The file to contain the resulting [mask](../technical.md#the-evaluation-harness).
+
+* **example call:** ```void br_make_mask(const char *target_input, const char *query_input, const char *mask)```
+* **see:** [br_combine_masks](#br_combine_masks)
+
+---
+
+## br_make_pairwise_mask
+
+Constructs a [mask](../technical.md#the-evaluation-harness) from target and query inputs considering the target and input sets to be definite pairwise comparisons.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+target_input | const char * | The target [Gallery](cpp_api.md#gallery)
+query_input | const char * | The query [Gallery](cpp_api.md#gallery)
+mask | const char * | The file to contain the resulting [mask](../technical.md#the-evaluation-harness).
+
+* **example call:** ```void br_make_pairwise_mask(const char *target_input, const char *query_input, const char *mask)```
+* **see:** [br_combine_masks](#br_combine_masks)
+
+---
+
+## br_most_recent_message
+
+Returns the most recent line sent to stderr. Please see the bullet about input string buffers at the top of this page.
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+buffer | char * | Buffer to store the last line in.
+buffer_length | int | Length of the buffer.
+
+* **example call:** ```int br_most_recent_message(char * buffer, int buffer_length)```
+* **see:** [br_progress](#br_progress), [br_time_remaining](#br_time_remaining)
+
+---
+
+## br_objects
+
+Returns names and parameters for the requested objects. Each object is newline seperated. Arguments are seperated from the object name with a tab. This function uses [QRegExp](http://doc.qt.io/qt-5/QRegExp.html) syntax.
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+ buffer | char * | Output buffer for results.
+ buffer_length | int | Length of output buffer.
+ abstractions | const char * | (Optional) Regular expression of the abstractions to search. Default is ".*".
+ implementations | const char * | (Optional) Regular expression of the implementations to search. Default is ".*".
+ parameters | bool | (Optional) Include parameters after object name. Default is true.
+
+* **example call:** ```int br_objects(char * buffer, int buffer_length, const char *abstractions = ".*", const char *implementations = ".*", bool parameters = true)```
+
+---
+
+## br_plot
+
+Renders recognition performance figures for a set of **.csv** files created by [br_eval](#br_eval).
+
+In order of their output, the figures are:
+1. Metadata table
+2. Receiver Operating Characteristic (ROC)
+3. Detection Error Tradeoff (DET)
+4. Score Distribution (SD) histogram
+5. True Accept Rate Bar Chart (BC)
+6. Cumulative Match Characteristic (CMC)
+7. Error Rate (ERR) curve
+
+Two files will be created:
+ * **destination.R** which is the auto-generated R script used to render the figures.
+ * **destination.pdf** which has all of the figures in one file multi-page file.
+
+OpenBR uses file and folder names to automatically determine the plot legend.
+For example, let's consider the case where three algorithms (<tt>A</tt>, <tt>B</tt>, & <tt>C</tt>) were each evaluated on two datasets (<tt>Y</tt> & <tt>Z</tt>).
+The suggested way to plot these experiments on the same graph is to create a folder named <tt>Algorithm_Dataset</tt> that contains the six <tt>.csv</tt> files produced by br_eval <tt>A_Y.csv</tt>, <tt>A_Z.csv</tt>, <tt>B_Y.csv</tt>, <tt>B_Z.csv</tt>, <tt>C_Y.csv</tt>, & <tt>C_Z.csv</tt>.
+The '<tt>_</tt>' character plays a special role in determining the legend title(s) and value(s).
+In this case, <tt>A</tt>, <tt>B</tt>, & <tt>C</tt> will be identified as different values of type <tt>Algorithm</tt>, and each will be assigned its own color; <tt>Y</tt> & <tt>Z</tt> will be identified as different values of type Dataset, and each will be assigned its own line style.
+Matches around the EER will be displayed if the matches parameter is set in [br_eval](#br_eval).
+
+Returns **true** on success. Returns **false** on a failure to compile the figures due to a missing, out of date, or incomplete <tt>R</tt> installation.
+
+This function requires a current [R](http://www.r-project.org/) installation with the following packages:
+
+    install.packages(c("ggplot2", "gplots", "reshape", "scales", "jpg", "png"))
+
+* **return type:** bool
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_files | int | Number of **.csv** files.
+files[] | const char * | **.csv** files created using [br_eval](#br_eval).
+destination | const char * | Basename for the resulting figures.
+show | bool | Open **destination.pdf** using the system's default PDF viewer. Default is false.
+
+* **example call:** ```bool br_plot(int num_files, const char *files[], const char *destination, bool show = false)```
+* **see:** [br_eval](#br_eval)
+
+---
+
+## br_plot_detection
+
+Renders detection performance figures for a set of **.csv** files created by [br_eval_detection](#br_eval_detection).
+
+In order of their output, the figures are:
+1. Discrete Receiver Operating Characteristic (DiscreteROC)
+2. Continuous Receiver Operating Characteristic (ContinuousROC)
+3. Discrete Precision Recall (DiscretePR)
+4. Continuous Precision Recall (ContinuousPR)
+5. Bounding Box Overlap Histogram (Overlap)
+6. Average Overlap Table (AverageOverlap)
+7. Average Overlap Heatmap (AverageOverlap)
+
+Detection accuracy is measured with *overlap fraction = bounding box intersection / union*.
+When computing *discrete* curves, an overlap >= 0.5 is considered a true positive, otherwise it is considered a false negative.
+When computing *continuous* curves, true positives and false negatives are measured fractionally as *overlap* and *1-overlap* respectively.
+
+Returns **true** on success. Returns **false** on a failure to compile the figures due to a missing, out of date, or incomplete <tt>R</tt> installation.
+
+This function requires a current [R](http://www.r-project.org/) installation with the following packages:
+
+    install.packages(c("ggplot2", "gplots", "reshape", "scales", "jpg", "png"))
+
+* **return type:** bool
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_files | int | Number of **.csv** files.
+files[] | const char * | **.csv** files created using [br_eval_detection](#br_eval_detection).
+destination | const char * | Basename for the resulting figures.
+show | bool | Open **destination.pdf** using the system's default PDF viewer. Default is false.
+
+* **example call:** ```bool br_plot_detection(int num_files, const char *files[], const char *destination, bool show = false)```
+* **see:** [br_eval_detection](#br_eval_detection), [br_plot](#br_plot)
+
+---
+
+## br_plot_landmarking
+
+Renders landmarking performance figures for a set of **.csv** files created by [br_eval_landmarking](#br_eval_landmarking).
+
+In order of their output, the figures are:
+1. Cumulative landmarks less than normalized error (CD)
+2. Normalized error box and whisker plots (Box)
+3. Normalized error violin plots (Violin)
+
+Landmarking error is normalized against the distance between two predifined points, usually inter-ocular distance (IOD).
+
+* **return type:** bool
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_files | int | Number of **.csv** files.
+files[] | const char * | **.csv** files created using [br_eval_landmarking](#br_eval_landmarking).
+destination | const char * | Basename for the resulting figures.
+show | bool | Open **destination.pdf** using the system's default PDF viewer. Default is false.
+
+* **example call:** ```bool br_plot_landmarking(int num_files, const char *files[], const char *destination, bool show = false)```
+* **see:** [br_eval_landmarking](#br_eval_landmarking), [br_plot](#br_plot)
+
+---
+
+## br_plot_metadata
+
+Renders metadata figures for a set of **.csv** files with specified columns.
+
+* **return type:** bool
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_files | int | Number of **.csv** files.
+files[] | const char * | **.csv** files created by enrolling templates to **.csv** metadata files.
+columns | const char * | ';' seperated list of columns to plot.
+show | bool | Open **PlotMetadata.pdf** using the system's default PDF viewer.
+
+* **example call:** ```bool br_plot_metadata(int num_files, const char *files[], const char *columns, bool show = false)```
+* **see:** [br_plot](#br_plot)
+
+---
+
+## br_progress
+
+Returns current progress from [Context](cpp_api.md#context)::progress().
+
+* **return type:** float
+* **parameters:** None
+* **example call:** ```float br_progress()```
+* **see:** [br_most_recent_message](#br_most_recent_message), [br_time_remaining](#br_time_remaining)
+
+---
+
+## br_read_pipe
+
+Read and parse arguments from a named pipe. Used by the [command line api](cl_api.md) to implement **-daemon**, generally not useful otherwise. Guaranteed to return at least one argument. See the bullets at the top of this page on managed return values.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+pipe | const char * | Pipe name
+argc | int * | Argument count
+argv | char *** | Argument list
+
+* **example call:** ```void br_read_pipe(const char *pipe, int *argc, char ***argv)```
+
+---
+
+## br_scratch_path
+
+Fills the buffer with the value of [Context](cpp_api.md#context)::scratchPath(). See the bullets at the top of this page on input string buffers.
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+buffer | char * | Buffer for scratch path
+buffer_length | int | Length of buffer.
+
+* **example call:** ```int br_scratch_path(char * buffer, int buffer_length)```
+* **see:** [br_version](#br_version)
+
+---
+
+## br_sdk_path
+
+Returns the full path to the root of the SDK.
+
+* **return type:** const char *
+* **parameters:** None
+* **example call:** ```const char *br_sdk_path()```
+* **see:** [br_initialize](#br_initialize)
+
+---
+
+## br_get_header
+
+Retrieve the target and query inputs in the [BEE matrix](../technical.md#the-evaluation-harness) header. See the bullets at the top of this page on managed return values.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+matrix | const char * | The [BEE matrix](../technical.md#the-evaluation-harness) file to modify
+target_gallery | const char ** | The matrix target
+query_gallery | const char ** | The matrix query
+
+* **example call:** ```void br_get_header(const char *matrix, const char **target_gallery, const char **query_gallery)```
+* **set:** [br_set_header](#br_set_header)
+
+---
+
+## br_set_header
+
+Update the target and query inputs in the [BEE matrix](../technical.md#the-evaluation-harness) header.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+matrix | const char * | The [BEE matrix](../technical.md#the-evaluation-harness) file to modify
+target_gallery | const char ** | The matrix target
+query_gallery | const char ** | The matrix query
+
+* **example call:** ```void br_set_header(const char *matrix, const char *target_gallery, const char *query_gallery)```
+* **see:** [br_get_header](#br_get_header)
+
+---
+
+## br_set_property
+
+Appends the given value to the global [metadata](cpp_api.md#context) using the given key.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+key | const char * | Key to append
+value | const char * | Value to append
+
+* **example call:** ```void br_set_property(const char *key, const char *value)```
+
+---
+
+## br_time_remaining
+
+Returns estimate of time remaining in the current process.
+
+* **return type:** int
+* **parameters:** None
+* **example call:** ```int br_time_remaining()```
+* **see:** [br_most_recent_message](#br_most_recent_message), [br_progress](#br_progress)
+
+---
+
+## br_train
+
+Trains the [Transform](cpp_api.md#transform) and [Distance](cpp_api.md#distance) on the input.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+input | const char * | The [Gallery](cpp_api.md#gallery) to train on.
+model | const char * | (Optional) String specifying the binary file to serialize training results to. The trained algorithm can be recovered by using this file as the algorithm. By default the trained algorithm will not be serialized to disk.
+
+* **example call:** ```void br_train(const char *input, const char *model = "")```
+* **see:** [br_train_n](#br_train_n)
+
+---
+
+## br_train_n
+
+Convenience function for training on multiple inputs
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+num_inputs | int | Size of **inputs**
+inputs[] | const char * | An array of [galleries](cpp_api.md#gallery) to train on.
+modell | const char *model = | (Optional) String specifying the binary file to serialize training results to. The trained algorithm can be recovered by using this file as the algorithm. By default the trained algorithm will not be serialized to disk.
+
+* **example call:** ```void br_train_n(int num_inputs, const char *inputs[], const char *model = "")```
+* **see:** [br_train](#br_train)
+
+---
+
+## br_version
+
+Returns the current OpenBR version.
+
+* **return type:** const char *
+* **parameters:** None
+* **example call:** ```const char *br_version()```
+* **see:** [br_about](#br_about), [br_scratch_path](#br_scratch_path)
+
+---
+
+## br_load_img
+
+Load an image from a string buffer. This is an easy way to pass an image in memory from another programming language to openbr.
+
+* **return type:** br_template
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+data | const char * | The image buffer.
+len | int | The length of the buffer.
+
+* **example call:** ```br_template br_load_img(const char *data, int len)```
+* **see:** [br_unload_img](#br_unload_img)
+
+---
+
+## br_unload_img
+
+Unload an image to a string buffer. This is an easy way to pass an image from openbr to another programming language.
+
+* **return type:** unsigned char*
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template)
+
+* **example call:** ```unsigned char* br_unload_img(br_template tmpl)```
+* **see:** [br_load_img](#br_load_img)
+
+---
+
+## br_template_list_from_buffer
+
+Deserialize a br::TemplateList from a buffer. Can be the buffer for a .gal file, since they are just a TemplateList serialized to disk.
+
+* **return type:** br_template_list
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+buf | const char * | The buffer.
+len | int | The length of the buffer.
+
+* **example call:** ```br_template_list br_template_list_from_buffer(const char *buf, int len)```
+
+---
+
+## br_free_template
+
+Free a [Template's](cpp_api.md#template) memory.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to the [Template](cpp_api.md#template) to free.
+
+* **example call:** ```void br_free_template(br_template tmpl)```
+
+---
+
+## br_free_template_list
+
+Free a [TemplateList's](cpp_api.md#templatelist) memory.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tl | br_template_list | Pointer to the [TemplateList](cpp_api.md#templatelist) to free.
+
+* **example call:** ```void br_free_template_list(br_template_list tl)```
+
+---
+
+## br_free_output
+
+Free a [Output's](cpp_api.md#output) memory.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+output | br_matrix_output | Pointer to the[Output](cpp_api.md#output) to free.
+
+* **example call:** ```void br_free_output(br_matrix_output output)```
+
+---
+
+## br_img_rows
+
+Returns the number of rows in an image.
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+
+* **example call:** ```int br_img_rows(br_template tmpl)```
+
+---
+
+## br_img_cols
+
+Returns the number of cols in an image.
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+
+* **example call:** ```int br_img_cols(br_template tmpl)```
+
+---
+
+## br_img_channels
+
+Returns the number of channels in an image.
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+
+* **example call:** ```int br_img_channels(br_template tmpl)```
+
+---
+
+## br_img_is_empty
+
+Checks if the image is empty.
+
+* **return type:** bool
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+
+* **example call:** ```bool br_img_is_empty(br_template tmpl)```
+
+---
+
+## br_get_filename
+
+Get the filename for a [Template](cpp_api.md#template). Please see the bullets at the top of the page on input string buffers.
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+buffer | char * | Buffer to hold the filename
+buffer_length | int | Length of the buffer
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+
+* **example call:** ```int br_get_filename(char * buffer, int buffer_length, br_template tmpl)```
+
+---
+
+## br_set_filename
+
+Set the filename for a [Template](cpp_api.md#template).
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+filename | const char * | New filename for the template.
+
+* **example call:** ```void br_set_filename(br_template tmpl, const char *filename)```
+
+---
+
+## br_get_metadata_string
+
+Get metadata as a string for the given key in the given [Template](cpp_api.md#template).
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+buffer | char * | Buffer to hold the metadata string.
+buffer_length | int | length of the buffer.
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+key | const char * | Key for the metadata lookup
+
+* **example call:** ```int br_get_metadata_string(char * buffer, int buffer_length, br_template tmpl, const char *key)```
+
+---
+
+## br_enroll_template
+
+Enroll a [Template](cpp_api.md#template) from the C API! Returns a pointer to a [TemplateList](cpp_api.md#templatelist)
+
+* **return type:** br_template_list
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template).
+
+* **example call:** ```br_template_list br_enroll_template(br_template tmpl)```
+
+---
+
+## br_enroll_template_list
+
+Enroll a [TemplateList](cpp_api.md#templatelist) from the C API!
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tl | br_template_list | Pointer to a [TemplateList](cpp_api.md#templatelist)
+
+* **example call:** ```void br_enroll_template_list(br_template_list tl)```
+
+---
+
+## br_compare_template_lists
+
+Compare [TemplateLists](cpp_api.md#templatelist) from the C API!
+
+* **return type:** br_matrix_output
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+target | br_template_list | Pointer to a [TemplateList](cpp_api.md#templatelist)
+query | br_template_list | Pointer to a [TemplateList](cpp_api.md#templatelist)
+
+* **example call:** ```br_matrix_output br_compare_template_lists(br_template_list target, br_template_list query)```
+
+---
+
+## br_get_matrix_output_at
+
+Get a value in the [MatrixOutput](cpp_api.md#matrixoutput).
+
+* **return type:** float
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+output | br_matrix_output | Pointer to [MatrixOutput](cpp_api.md#matrixoutput)
+row | int | Row for lookup
+col | int | Col for lookup
+
+* **example call:** ```float br_get_matrix_output_at(br_matrix_output output, int row, int col)```
+
+---
+
+## br_get_template
+
+Get a pointer to a [Template](cpp_api.md#template) at a specified index.
+
+* **return type:** br_template
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tl | br_template_list | Pointer to a [TemplateList](cpp_api.md#templatelist)
+index | int | Index into the template list. Should be in the range [0,len(tl) - 1].
+
+* **example call:** ```br_template br_get_template(br_template_list tl, int index)```
+
+---
+
+## br_num_templates
+
+Get the number of [Templates](cpp_api.md#template) in a [TemplateList](cpp_api.md#templatelist).
+
+* **return type:** int
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+tl | br_template_list | Pointer to a [TemplateList](cpp_api.md#templatelist)
+
+* **example call:** ```int br_num_templates(br_template_list tl)```
+
+---
+
+## br_make_gallery
+
+Initialize a [Gallery](cpp_api.md#gallery).
+
+* **return type:** br_gallery
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+gallery | const char * | String location of gallery on disk.
+
+* **example call:** ```br_gallery br_make_gallery(const char *gallery)```
+
+---
+
+## br_load_from_gallery
+
+Read [TemplateList](cpp_api.md#templatelist) from [Gallery](cpp_api.md#gallery).
+
+* **return type:** br_template_list
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+gallery | br_gallery | Pointer to a [Gallery](cpp_api.md#gallery)
+
+* **example call:** ```br_template_list br_load_from_gallery(br_gallery gallery)```
+
+---
+
+## br_add_template_to_gallery
+
+Write a [Template](cpp_api.md#template) to the [Gallery](cpp_api.md#gallery) on disk
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+gallery | br_gallery | Pointer to a [Gallery](cpp_api.md#gallery)
+tmpl | br_template | Pointer to a [Template](cpp_api.md#template)
+
+* **example call:** ```void br_add_template_to_gallery(br_gallery gallery, br_template tmpl)```
+
+---
+
+## br_add_template_list_to_gallery
+
+Write a [TemplateList](cpp_api.md#templatelist) to the [Gallery](cpp_api.md#gallery) on disk.
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+gallery | br_gallery | Pointer to a [Gallery](cpp_api.md#gallery)
+tl | br_template_list | Pointer to a [TemplateList](cpp_api.md#templatelist)
+
+* **example call:** ```void br_add_template_list_to_gallery(br_gallery gallery, br_template_list tl)```
+
+---
+
+## br_close_gallery
+
+Close the [Gallery](cpp_api.md#gallery).
+
+* **return type:** void
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+gallery | br_gallery | Pointer to a [Gallery](cpp_api.md#gallery)
+
+* **example call:** ```void br_close_gallery(br_gallery gallery)```
+
+---
+# API Functions
+
+## IsClassifier {: #function-isclassiifer }
+
+Determines if the given algorithm is a classifier. A classifier is defined as a [Transform](#transform) with no associated [Distance](#distance). Instead metadata fields with the predicted output classes are populated in [Template](#template) [files](#template-members-file).
+
+* **function definition:**
+
+        bool IsClassifier(const QString &algorithm)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    algorithm | const [QString][QString] & | Algorithm to evaluate
+
+* **output:** (bool) True if the algorithm is a classifier and false otherwise
+* **see:** [br_is_classifier](c_api.md#br_is_classifier)
+* **example:**
+
+        IsClassifier("Identity"); // returns true
+        IsClassifier("Identity:Dist"); // returns false
+
+## Train {: #function-train }
+
+High level function for creating models.
+
+* **function definition:**
+
+        void Train(const File &input, const File &model)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const [File](#file) & | Training data
+    model | const [File](#file) & | Model file
+
+* **output:** (void)
+* **see:** The [training tutorial](../tutorials.md#training-algorithms) for an example of training.
+* **example:**
+
+        File file("/path/to/images/or/gallery.gal");
+        File model("/path/to/model/file");
+        Train(file, model);
+
+## Enroll {: #function-enroll }
+
+High level function for creating [galleries](#gallery).
+
+* **function definition:**
+
+        void Enroll(const File &input, const File &gallery = File())
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const [File](#file) & | Path to enrollment file
+    gallery | const [File](#file) & | (Optional) Path to gallery file.
+
+* **output:** (void)
+* **see:** [br_enroll](c_api.md#br_enroll)
+* **example:**
+
+        File file("/path/to/images/or/gallery.gal");
+        Enroll(file); // Don't need to specify a gallery file
+        File gallery("/path/to/gallery/file");
+        Enroll(file, gallery); // Will write to the specified gallery file
+
+## Enroll {: #function-enroll }
+
+High level function for enrolling templates. Templates are modified in place as they are projected through the algorithm.
+
+* **function definition:**
+
+        void Enroll(TemplateList &tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [TemplateList](#templatelist) & | Data to enroll
+
+* **output:** (void)
+* **example:**
+
+        TemplateList tList = TemplateList() << Template("picture1.jpg")
+                                            << Template("picture2.jpg")
+                                            << Template("picture3.jpg");
+        Enroll(tList);
+
+## Project {: #function-project}
+
+A naive alternative to [Enroll](#function-enroll-1).
+
+* **function definition:**
+
+        void Project(const File &input, const File &output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const [File](#file) & | Path to enrollment file
+    gallery | const [File](#file) & | Path to gallery file.
+
+* **output:** (void)
+* **see:** [Enroll](#function-enroll-1)
+* **example:**
+
+        File file("/path/to/images/or/gallery.gal");
+        File output("/path/to/gallery/file");
+        Project(file, gallery); // Will write to the specified gallery file
+
+## Compare {: #function-compare }
+
+High level function for comparing galleries. Each template in the **queryGallery** is compared against every template in the **targetGallery**.
+
+* **function definition:**
+
+        void Compare(const File &targetGallery, const File &queryGallery, const File &output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targetGallery | const [File](#file) & | Gallery of target templates
+    queryGallery | const [File](#file) & | Gallery of query templates
+    output | const [File](#file) & | Output file for results
+
+* **returns:** (output)
+* **see:** [br_compare](c_api.md#br_compare)
+* **example:**
+
+        File target("/path/to/target/images/");
+        File query("/path/to/query/images/");
+        File output("/path/to/output/file");
+        Compare(target, query, output);
+
+## CompareTemplateList {: #function-comparetemplatelists}
+
+High level function for comparing templates.
+
+* **function definition:**
+
+        void CompareTemplateLists(const TemplateList &target, const TemplateList &query, Output *output);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    target | const [TemplateList](#templatelist) & | Target templates
+    query | const [TemplateList](#templatelist) & | Query templates
+    output | [Output](#output) \* | Output file for results
+
+* **output:** (void)
+* **example:**
+
+        TemplateList targets = TemplateList() << Template("target_img1.jpg")
+                                              << Template("target_img2.jpg")
+                                              << Template("target_img3.jpg");
+
+        TemplateList query = TemplateList() << Template("query_img.jpg");
+        Output *output = Factory::make<Output>("/path/to/output/file");
+
+        CompareTemplateLists(targets, query, output);
+
+
+## PairwiseCompare {: #function-pairwisecompare }
+
+High level function for doing a series of pairwise comparisons.
+
+* **function definition:**
+
+        void PairwiseCompare(const File &targetGallery, const File &queryGallery, const File &output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targetGallery | const [File](#file) & | Gallery of target templates
+    queryGallery | const [File](#file) & | Gallery of query templates
+    output | const [File](#file) & | Output file for results  
+
+* **output:** (void)
+* **see:** [br_pairwise_comparison](c_api.md#br_pairwise_compare)
+* **example:**
+
+        File target("/path/to/target/images/");
+        File query("/path/to/query/images/");
+        File output("/path/to/output/file");
+        PairwiseCompare(target, query, output);
+
+## Convert {: #function-convert }
+
+Change the format of the **inputFile** to the format of the **outputFile**. Both the **inputFile** format and the **outputFile** format must be of the same format group, which is specified by the **fileType**.
+
+* **function definition:**
+
+        void Convert(const File &fileType, const File &inputFile, const File &outputFile)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    fileType | const [File](#file) & | Can be either: <ul> <li>[Format](#format)</li> <li>[Gallery](#gallery)</li> <li>[Output](#output)</li> </ul>
+    inputFile | const [File](#file) & | File to be converted. Format is inferred from the extension.
+    outputFile | const [File](#file) & | File to store converted input. Format is inferred from the extension.
+
+* **output:** (void)
+* **example:**
+
+        File input("input.csv");
+        File output("output.xml");
+        Convert("Format", input, output);
+
+## Cat {: #function-cat }
+
+Concatenate several galleries into one.
+
+* **function definition:**
+
+        void Cat(const QStringList &inputGalleries, const QString &outputGallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    inputGalleries | const [QStringList][QStringList] & | List of galleries to concatenate
+    outputGallery | const [QString][QString] & | Gallery to store the concatenated result. This gallery cannot be in the inputGalleries
+
+* **output:** (void)
+* **see:** [br_cat](c_api.md#br_cat)
+* **example:**
+
+        QStringList inputGalleries = QStringList() << "/path/to/gallery1"
+                                                   << "/path/to/gallery2"
+                                                   << "/path/to/gallery3";
+
+        QString outputGallery = "/path/to/outputGallery";
+        Cat(inputGalleries, outputGallery);
+
+## Deduplicate {: #function-deduplicate }
+
+Deduplicate a gallery. A duplicate is defined as an image with a match score above a given threshold to another image in the gallery.
+
+* **function definition:**
+
+        void Deduplicate(const File &inputGallery, const File &outputGallery, const QString &threshold)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    inputGallery | const [File](#file) & | Gallery to deduplicate
+    outputGallery | const [File](#file) & | Gallery to store the deduplicated result
+    threshold | const [QString][QString] & | Match score threshold to determine duplicates
+
+* **output:** (void)
+* **see:** [br_deduplicate](c_api.md#br_deduplicate)
+* **example:**
+
+        File input("/path/to/input/galley/with/dups");
+        File output("/path/to/output/gallery");
+        Deduplicate(input, output, "0.7"); // Remove duplicates with match scores above 0.7
+
+---
+
 # File
  
 A file path with associated metadata.
@@ -14,7 +283,7 @@ Files have a simple grammar that allow them to be converted to and from strings.
 If a string ends with a **]** or **)** then the text within the final **[]** or **()** are parsed as comma separated metadata fields.
 By convention, fields within **[]** are expected to have the format <tt>[key1=value1, key2=value2, ..., keyN=valueN]</tt> where order is irrelevant.
 Fields within **()** are expected to have the format <tt>(value1, value2, ..., valueN)</tt> where order matters and the key context dependent.
-The left hand side of the string not parsed in a manner described above is assigned to [name](#qstring-name).
+The left hand side of the string not parsed in a manner described above is assigned to [name](#file-members-name).
  
 Values are not necessarily stored as strings in the metadata table.
 The system will attempt to infer and convert them to their "native" type.
@@ -34,8 +303,8 @@ Below are some of the most commonly occurring standardized keys:
  
 Key             | Value          | Description
 ---             | ----           | -----------
-name            | QString        | Contents of [name](#name)
-separator       | QString        | Separate [name](#name) into multiple files
+name            | QString        | Contents of [name](#file-members-name)
+separator       | QString        | Separate [name](#file-members-name) into multiple files
 Index           | int            | Index of a template in a template list
 Confidence      | float          | Classification/Regression quality
 FTE             | bool           | Failure to enroll
@@ -59,93 +328,134 @@ _*              | *              | Reserved for internal use
  
 ---
  
-## Members
+## Members {: #file-members }
+
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id="file-members-name"></a>name | [QString][QString] | Path to a file on disk
+<a class="table-anchor" id=file-members-fte></a>fte | bool | Failed to enroll. If true this file failed to be processed somewhere in the template enrollment algorithm
+<a class="table-anchor" id=file-members-m_metadata></a>m_metadata | [QVariantMap][QVariantMap] | Map for storing metadata. It is a [QString][QString], [QVariant][QVariant] key value pairing.
+
+---
+
+## Constructors {: #file-constructors }
  
-### [QString][QString] name
+Constructor | Description
+--- | ---
+File() | Default constructor. Sets [name](#file-members-fte) to false.
+File(const [QString][QString] &file) | Initializes the file by calling the private function init.
+File(const [QString][QString] &file, const [QVariant][QVariant] &label) | Initializes the file by calling the private function init. Append label to the [metadata](#file-members-m_metadata) using the key "Label".
+File(const char \*file) | Initializes the file with a c-style string.
+File(const [QVariantMap][QVariantMap] &metadata) | Sets [name](#file-members-fte) to false and sets the [file metadata](#file-members) to metadata.
  
-Path to a file on disk
+---
  
-### bool fte
+## Static Functions {: #file-static-functions }
  
-Failed to enroll. If true this file failed to be processed somewhere in the template enrollment algorithm
  
-### [QVariantMap][QVariantMap] m_metadata
+### [QVariant][QVariant] parse(const [QString][QString] &value) {: #function-static-parse }
  
-Map for storing metadata. It is a [QString][QString], [QVariant][QVariant] key value pairing.
+Try to convert a given value to a [QPointF][QPointF], [QRectF][QRectF], int or float.
  
----
+* **function definition:**
  
-## Constructors
+        static QVariant parse(const QString &value);
  
-### File()
+* **parameters:**
  
-Default constructor. Sets [FTE](#bool-fte) to false.
+    Parameter | Type | Description
+    --- | --- | ---
+    value | const [QString][QString] & | String value to be converted.
  
-### File(const [QString][QString] &file)
+* **output:** ([QVariant][QVariant]) The converted file if a conversion was possible. Otherwise the unconverted string is returned.
+* **example:**
  
-Initializes the file by calling the private function init.
+        QString point = "(1, 1)";
+        QString rect = "(1, 1, 5, 5)";
+        QString integer = "1";
+        QString fp = "1.0";
+        QString string = "Hello World";
  
-### File(const [QString][QString] &file, const [QVariant][QVariant] &label)
+        File::parse(point);   // returns QVariant(QPointF, QPointF(1, 1))
+        File::parse(rect);    // returns QVariant(QRectF, QRectF(1, 1, 5x5))
+        File::parse(integer); // returns QVariant(int, 1)
+        File::parse(fp);      // returns QVariant(float, 1.0f)
+        File::parse(string);  // returns QVariant(QString, "Hello World")
  
-Initializes the file by calling the private function init. Append label to the [metadata](#qvariantmap-m_metadata) using the key "Label".
  
-### File(const char \*file)
+### [QList][QList]&lt;[QVariant][QVariant]&gt; values(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key) {: #file-static-values }
  
-Initializes the file with a c-style string.
+Gather a list of [QVariant][QVariant] values associated with a metadata key from a provided list of files.
  
-### File(const [QVariantMap][QVariantMap] &metadata)
+* **function definition:**
  
-Sets [FTE](#bool-fte) to false and sets the [file metadata](#qvariantmap-m_metadata) to metadata.
+        template<class U> static [QList<QVariant> values(const QList<U> &fileList, const QString &key)
  
----
+* **parameters:**
  
-## Static Functions
+    Parameter | Type | Description
+    --- | --- | ---
+    fileList | const [QList][QList]&lt;U&gt; & | A list of files to parse for values. A type is required for <tt>U</tt>. Valid options are: <ul> <li>[File](#file)</li> <li>[QString][QString]</li> </ul>
+    key | const [QString][QString] & | A metadata key used to lookup the values.
  
+* **output:** ([QList][QList]&lt;[QVariant][QVariant]&gt;) A list of [QVariant][QVariant] values associated with the given key in each of the provided files.
+* **example:**
  
-### static [QVariant][QVariant] parse([QString][QString] &value) const
+        File f1, f2;
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f1.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key1", QVariant::fromValue<float>(3));
  
-Try to convert value to a [QPointF][QPointF], [QRectF][QRectF], int or float. If a conversion is possible it returns the converted value, otherwise it returns the unconverted string.
+        File::values<File>(QList<File>() << f1 << f2, "Key1"); // returns [QVariant(float, 1),
+                                                               //          QVariant(float, 3)]
  
-    QString point = "(1, 1)";
-    QString rect = "(1, 1, 5, 5)";
-    QString integer = "1";
-    QString fp = "1.0";
-    QString string = "Hello World";
  
-    File::parse(point);   // returns QVariant(QPointF, QPointF(1, 1))
-    File::parse(rect);    // returns QVariant(QRectF, QRectF(1, 1, 5x5))
-    File::parse(integer); // returns QVariant(int, 1)
-    File::parse(fp);      // returns QVariant(float, 1.0f)
-    File::parse(string);  // returns QVariant(QString, "Hello World")
+### [QList][QList]&lt;T&gt; get(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key) {: #file-static-get-1 }
  
-### static [QList][QList]&lt;[QVariant][QVariant]&gt; values(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key)
+Gather a list of <tt>T</tt> values associated with a metadata key from a provided list of files. <tt>T</tt> is a user provided type. If the key does not exist in the metadata of *any* file an error is thrown.
  
-This function requires a type specification in place of U. Valid types are [File](#file) and [QString][QString]. Returns a list of the values of the key in each of the given files.
+* **function definition:**
  
-    File f1, f2;
-    f1.set("Key1", QVariant::fromValue<float>(1));
-    f1.set("Key2", QVariant::fromValue<float>(2));
-    f2.set("Key1", QVariant::fromValue<float>(3));
+        template<class T, class U> static QList<T> get(const QList<U> &fileList, const QString &key)
  
-    File::values<File>(QList<File>() << f1 << f2, "Key1"); // returns [QVariant(float, 1),
-                                                           //          QVariant(float, 3)]
+* **parameters:**
  
-### static [QList][QList]&lt;T&gt; get(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key)
+    Parameter | Type | Description
+    --- | --- | ---
+    fileList | const [QList][QList]&lt;U&gt; & | A list of files to parse for values. A type is required for U. Valid options are: <ul> <li>[File](#file)</li> <li>[QString][QString]</li> </ul>
+    key | const [QString][QString] & | A metadata key used to lookup the values.
  
-This function requires a type specification in place of T and U. Valid types for U are [File](#file) and [QString][QString]. T can be any type. Returns a list of the values of the key in each of the given files. If the key doesn't exist in any of the files or the value cannot be converted to type T an error is thrown.
+* **output:** ([QList][QList]&lt;T&gt;) A list of the values of type <tt>T</tt> associated with the given key. A type is required for <tt>T</tt>.
+* **example:**
+
+        File f1, f2;
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f1.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key1", QVariant::fromValue<float>(3));
+
+        File::get<float, File>(QList<File>() << f1 << f2, "Key1");  // returns [1., 3.]
+        File::get<float, File>(QList<File>() << f1 << f2, "Key2");  // Error: Key doesn't exist in f2
+        File::get<QRectF, File>(QList<File>() << f1 << f2, "Key1"); // Error: float is not convertable to QRectF
  
-    File f1, f2;
-    f1.set("Key1", QVariant::fromValue<float>(1));
-    f1.set("Key2", QVariant::fromValue<float>(2));
-    f2.set("Key1", QVariant::fromValue<float>(3));
  
-    File::get<float, File>(QList<File>() << f1 << f2, "Key1");  // returns [1., 3.]
-    File::get<float, File>(QList<File>() << f1 << f2, "Key2");  // Error: Key doesn't exist in f2
-    File::get<QRectF, File>(QList<File>() << f1 << f2, "Key1"); // Error: float is not convertable to QRectF
+### [QList][QList]&lt;T&gt; get(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key, const T &defaultValue) {: #file-static-get-2 }
  
-### static [QList][QList]&lt;T&gt; get(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key, const T &defaultValue)
+Gather a list of <tt>T</tt> values associated with a metadata key from a provided list of files. <tt>T</tt> is a user provided type. If the key does not exist in the metadata of *any* file the provided **defaultValue** is used.
  
-This function requires a type specification in place of T and U. Valid types for U are [File](#file) and [QString][QString]. T can be any type. Returns a list of the values of the key in each of the given files. If the key doesn't exist in any of the files or the value cannot be converted to type T the given defaultValue is returned.
+* **function definition:**
+
+        template<class T, class U> static QList<T> get(const QList<U> &fileList, const QString &key, const T &defaultValue)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    fileList | const [QList][QList]&lt;U&gt; & | A list of files to parse for values. A type is required for U. Valid options are: <ul> <li>[File](#file)</li> <li>[QString][QString]</li> </ul>
+    key | const [QString][QString] & | A metadata key used to lookup the values.
+    defaultValue | const T & | The default value if the key is not in a file's metadata. A type is required for T. All types are valid.
+
+* **output:** ([QList][QList]&lt;T&gt;) A list of the values of type <tt>T</tt> associated with the given key. A type is required for <tt>T</tt>.
+* **example:**
  
     File f1, f2;
     f1.set("Key1", QVariant::fromValue<float>(1));
@@ -156,76 +466,155 @@ This function requires a type specification in place of T and U. Valid types for
     File::get<float, File>(QList<File>() << f1 << f2, "Key2", QList<float>() << 1);  // returns [1.]
     File::get<QRectF, File>(QList<File>() << f1 << f2, "Key1, QList<QRectF>()");     // returns []
  
-### [QDebug][QDebug] operator <<([QDebug][QDebug] dbg, const [File](#file) &file)
  
-Calls [flat](#qstring-flat-const) on the given file and that streams that file to stderr.
+### [QDebug][QDebug] operator <<([QDebug][QDebug] dbg, const [File](#file) &file) {: #file-static-dbg-operator-ltlt }
  
-    File file("../path/to/pictures/picture.jpg");
-    file.set("Key", QString("Value"));
+Calls [flat](#file-function-flat) on the given file and then streams that file to stderr.
  
-    qDebug() << file; // "../path/to/pictures/picture.jpg[Key=Value]" streams to stderr
+* **function definition:**
  
-### [QDataStream][QDataStream] &operator <<([QDataStream][QDataStream] &stream, const [File](#file) &file)
+        QDebug operator <<(QDebug dbg, const File &file)
  
-Serialize a file to a data stream.
+* **parameter:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    dbg | [QDebug][QDebug] | The debug stream
+    file | const [File](#file) & | File to stream
+
+* **output:** ([QDebug][QDebug] &) returns a reference to the updated debug stream
+* **example:**
  
-    void store(QDataStream &stream)
-    {
         File file("../path/to/pictures/picture.jpg");
         file.set("Key", QString("Value"));
  
-        stream << file; // "../path/to/pictures/picture.jpg[Key=Value]" serialized to the stream
-    }
+        qDebug() << file; // "../path/to/pictures/picture.jpg[Key=Value]" streams to stderr
+
+
+### [QDataStream][QDataStream] &operator <<([QDataStream][QDatastream] &stream, const [File](#file) &file) {: #file-static-stream-operator-ltlt }
+
+Serialize a file to a data stream.
+
+* **function definition:**
+
+        QDataStream &operator <<(QDataStream &stream, const File &file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] | The data stream
+    file | const [File](#file) & | File to stream
  
-### [QDataStream][QDataStream] &operator >>([QDataStream][QDataStream] &stream, [File](#file) &file)
+* **output:** ([QDataStream][QDataStream] &) returns a reference to the updated data stream
+* **example:**
+
+        void store(QDataStream &stream)
+        {
+            File file("../path/to/pictures/picture.jpg");
+            file.set("Key", QString("Value"));
+
+            stream << file; // "../path/to/pictures/picture.jpg[Key=Value]" serialized to the stream
+        }
+
+
+### [QDataStream][QDataStream] &operator >>([QDataStream][QDataStream] &stream, const [File](#file) &file) {: #file-static-stream-operator-gtgt }
  
 Deserialize a file from a data stream.
  
-    void load(QDataStream &stream)
-    {
-        File in("../path/to/pictures/picture.jpg");
-        in.set("Key", QString("Value"));
+* **function definition:**
+
+        QDataStream &operator >>(QDataStream &stream, const File &file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] | The data stream
+    file | const [File](#file) & | File to stream
+
+* **output:** ([QDataStream][QDataStream] &) returns a reference to the updated data stream
+* **example:**
  
-        stream << in; // "../path/to/pictures/picture.jpg[Key=Value]" serialized to the stream
+        void load(QDataStream &stream)
+        {
+            File in("../path/to/pictures/picture.jpg");
+            in.set("Key", QString("Value"));
  
-        File out;
-        stream >> out;
+            stream << in; // "../path/to/pictures/picture.jpg[Key=Value]" serialized to the stream
  
-        out.name; // returns "../path/to/pictures/picture.jpg"
-        out.flat(); // returns "../path/to/pictures/picture.jpg[Key=Value]"
-    }
+            File out;
+            stream >> out;
+
+            out.name; // returns "../path/to/pictures/picture.jpg"
+            out.flat(); // returns "../path/to/pictures/picture.jpg[Key=Value]"
+        }
  
 ---
  
-## Functions
+## Functions {: #file-functions }
  
-### Operator [QString][QString]() const
  
-returns [name](#qstring-name). Allows Files to be used as [QString][QString].
+### operator [QString][QString]() const {: #file-function-operator-qstring }
  
-### [QString][QString] flat() const
+Convenience function that allows [Files](#file) to be used as [QStrings][QString]
  
-Returns the [name](#qstring-name) and [metadata](#qvariantmap-m_metadata) as string.
+* **function definition:**
  
-    File file("../path/to/pictures/picture.jpg");
-    file.set("Key1", QVariant::fromValue<float>(1));
-    file.set("Key2", QVariant::fromValue<float>(2));
+        inline operator QString() const
  
-    file.flat(); // returns "../path/to/pictures/picture.jpg[Key1=1,Key2=2]"
+* **parameters:** NONE
+* **output:** ([QString][QString]) returns [name](#file-members-name).
  
-### [QString][QString] hash() const
+### [QString][QString] flat() const {: #file-function-flat }
  
-Returns a hash of the file.
+Function to output files in string formats.
  
-    File file("../path/to/pictures/picture.jpg");
-    file.set("Key1", QVariant::fromValue<float>(1));
-    file.set("Key2", QVariant::fromValue<float>(2));
+* **function definition:**
+
+        QString flat() const
  
-    file.hash(); // returns "kElVwY"
+* **parameters:** NONE
+* **output:** ([QString][QString]) returns the [file name](#file-members) and [metadata](#file-members-m_metadata) as a formated string. The format is *filename*[*key1=value1,key2=value2,...keyN=valueN*].
+* **example:**
  
-### [QStringList][QStringList] localKeys() const
+        File file("picture.jpg");
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
  
-Returns an immutable version of the local metadata keys gotten by calling [metadata](#metadata).keys().
+        file.flat(); // returns "picture.jpg[Key1=1,Key2=2]"
+
+
+### [QString][QString] hash() const {: #file-function-hash }
+
+Function to output a hash of the file.
+
+* **function definition:**
+
+        QString hash() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a hash of the file.
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
+
+        file.hash(); // returns "kElVwY"
+
+
+### [QStringList][QStringList] localKeys() const {: #file-function-localkeys }
+
+Function to get the private [metadata](#file-members-m_metadata) keys.
+
+* **function definition:**
+
+        inline QStringList localKeys() const
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns a list of the local [metadata](#file-members-m_metadata) keys. They are called local because they do not include the keys in the [global metadata](#context).
+* **example:**
  
     File file("../path/to/pictures/picture.jpg");
     file.set("Key1", QVariant::fromValue<float>(1));
@@ -233,1099 +622,2674 @@ Returns an immutable version of the local metadata keys gotten by calling [metad
  
     file.localKeys(); // returns [Key1, Key2]
  
-### [QVariantMap][QVariantMap] localMetadata() const
  
-returns an immutable version of the local [metadata](#qvariantmap-m_metadata).
+### [QVariantMap][QVariantMap] localMetadata() const {: #file-function-localmetadata }
  
-    File file("../path/to/pictures/picture.jpg");
-    file.set("Key1", QVariant::fromValue<float>(1));
-    file.set("Key2", QVariant::fromValue<float>(2));
+Function to get the private [metadata](#file-members-m_metadata).
  
-    file.localMetadata(); // return QMap(("Key1", QVariant(float, 1)) ("Key2", QVariant(float, 2)))
+* **function definition:**
  
-### void append([QVariantMap][QVariantMap] &localMetadata)
+        inline QVariantMap localMetadata() const
  
-Add new metadata fields to [metadata](#qvariantmap-m_metadata).
+* **parameters:** NONE
+* **output:** ([QVariantMap][QVariantMap]) Returns the local [metadata](#file-members-m_metadata).
+* **example:**
  
-    File f();
-    f.set("Key1", QVariant::fromValue<float>(1));
+        File file("../path/to/pictures/picture.jpg");
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
  
-    QVariantMap map;
-    map.insert("Key2", QVariant::fromValue<float>(2));
-    map.insert("Key3", QVariant::fromValue<float>(3));
+        file.localMetadata(); // return QMap(("Key1", QVariant(float, 1)) ("Key2", QVariant(float, 2)))
  
-    f.append(map);
-    f.flat(); // returns "[Key1=1, Key2=2, Key3=3]"
  
-### void append(const [File](#file) &other)
+### void append(const [QVariantMap][QVariantMap] &localMetadata) {: #file-function-append-1 }
  
-Append another file using the **;** separator. The file names are combined with the separator in between them. The metadata fields are combined. An additional field describing the separator is appended to the metadata.
+Add new metadata fields to [metadata](#file-members-m_metadata).
  
-    File f1("../path/to/pictures/picture1.jpg");
-    f1.set("Key1", QVariant::fromValue<float>(1));
+* **function definition:**
  
-    File f2("../path/to/pictures/picture2.jpg");
-    f2.set("Key2", QVariant::fromValue<float>(2));
-    f2.set("Key3", QVariant::fromValue<float>(3));
+        void append(const QVariantMap &localMetadata)
  
-    f1.append(f2);
-    f1.name; // return "../path/to/pictures/picture1.jpg;../path/to/pictures/picture2.jpg"
-    f1.localKeys(); // returns "[Key1, Key2, Key3, separator]"
+* **parameters:**
  
+    Parameter | Type | Description
+    --- | --- | ---
+    localMetadata | const [QVariantMap][QVariantMap] & | metadata to append to the local [metadata](#file-members-m_metadata)
  
-### [File](#file) &operator +=(const [QMap][QMap]&lt;[QString][QString], [QVariant][QVariant]&gt; &other)
+* **output:** (void)
+* **example:**
  
-Shortcut operator to call [append](#void-appendqvariantmap-localmetadata).
+        File f();
+        f.set("Key1", QVariant::fromValue<float>(1));
  
-### [File](#file) &operator +=(const [File](#file) &other)
+        QVariantMap map;
+        map.insert("Key2", QVariant::fromValue<float>(2));
+        map.insert("Key3", QVariant::fromValue<float>(3));
  
-Shortcut operator to call [append](#void-appendconst-file-other).
+        f.append(map);
+        f.flat(); // returns "[Key1=1, Key2=2, Key3=3]"
  
-### [QList][QList]&lt;[File](#file)&gt; split() const
  
-Parse [name](#qstring-name) and split on the **;** separator. Each split file has the same [metadata](#qvariantmap-m_metadata) as the joined file.
+### void append(const [File](#file) &other) {: #file-function-append-2 }
  
-    File f1("../path/to/pictures/picture1.jpg");
-    f1.set("Key1", QVariant::fromValue<float>(1));
+Append another file using the **;** separator. The [File](#file) [names](#file-members-name) are combined with the separator in between them. The [metadata](#file-members-m_metadata) fields are combined. An additional field describing the separator is appended to the [metadata](#file-members-m_metadata).
  
-    f1.split(); // returns [../path/to/pictures/picture1.jpg[Key1=1]]
+* **function definition:**
  
-    File f2("../path/to/pictures/picture2.jpg");
-    f2.set("Key2", QVariant::fromValue<float>(2));
-    f2.set("Key3", QVariant::fromValue<float>(3));
+        void append(const File &other)
  
-    f1.append(f2);
-    f1.split(); // returns [../path/to/pictures/picture1.jpg[Key1=1, Key2=2, Key3=3, separator=;],
-                    //          ../path/to/pictures/picture2.jpg[Key1=1, Key2=2, Key3=3, separator=;]]
+* **parameters:**
  
-### [QList][QList]&lt;[File](#file)&gt; split(const [QString][QString] &separator) const
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](#file) & | File to append
  
-Split the file on the given separator. Each split file has the same [metadata](#qvariantmap-m_metadata) as the joined file.
+* **output:** (void)
+* **example:**
  
-    File f("../path/to/pictures/picture1.jpg,../path/to/pictures/picture2.jpg");
-    f.set("Key1", QVariant::fromValue<float>(1));
-    f.set("Key2", QVariant::fromValue<float>(2));
+        File f1("../path/to/pictures/picture1.jpg");
+        f1.set("Key1", QVariant::fromValue<float>(1));
  
-    f.split(","); // returns [../path/to/pictures/picture1.jpg[Key1=1, Key2=2],
-                              ../path/to/pictures/picture2.jpg[Key1=1, Key2=2]]
+        File f2("../path/to/pictures/picture2.jpg");
+        f2.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key3", QVariant::fromValue<float>(3));
  
-### void setParameter(int index, const [QVariant][QVariant]&value)
+        f1.append(f2);
+        f1.name; // return "../path/to/pictures/picture1.jpg;../path/to/pictures/picture2.jpg"
+        f1.localKeys(); // returns "[Key1, Key2, Key3, separator]"
  
-Insert a keyless value into the [metadata](#qvariantmap-m_metadata).
  
-    File f;
-    f.set("Key1", QVariant::fromValue<float>(1));
-    f.set("Key2", QVariant::fromValue<float>(2));
+### [File](#file) &operator+=(const [QMap][QMap]&lt;[QString][QString], [QVariant][QVariant]&gt; &other) {: #file-function-operator-pe-1 }
  
-    f.setParameter(1, QVariant::fromValue<float>(3));
-    f.setParameter(5, QVariant::fromValue<float>(4));
+Shortcut operator to call [append](#file-function-append-1).
  
-    f.flat(); // returns "[Key1=1, Key2=2, Arg1=3, Arg5=4]"
+* **function definition:**
  
-### bool operator ==(const char \*other) const
+        inline File &operator+=(const QMap<QString, QVariant> &other)
  
-Compare [name](#qstring-name) to c-style string other.
+* **parameters:**
  
-    File f("picture.jpg");
+    Parameter | Type | Description
+    other | const [QMap][QMap]&lt;[QString][QString], [QVariant][QVariant]&gt; & | Metadata map to append to the local [metadata](#file-members-m_metadata)
  
-    f == "picture.jpg";       // returns true
-    f == "other_picture.jpg"; // returns false
+* **output:** ([File](#file) &) Returns a reference to this file after the append occurs.
+* **example:**
  
-### bool operator ==(const [File](#file) &other) const
+        File f();
+        f.set("Key1", QVariant::fromValue<float>(1));
  
-Compare [name](#qstring-name) and [metadata](#qvariantmap-m_metadata) to another file name and metadata for equality.
+        QMap<QString, QVariant> map;
+        map.insert("Key2", QVariant::fromValue<float>(2));
+        map.insert("Key3", QVariant::fromValue<float>(3));
  
-    File f1("picture1.jpg");
-    File f2("picture1.jpg");
+        f += map;
+        f.flat(); // returns "[Key1=1, Key2=2, Key3=3]"
  
-    f1 == f2; // returns true
  
-    f1.set("Key1", QVariant::fromValue<float>(1));
-    f2.set("Key2", QVariant::fromValue<float>(2));
+### [File](#file) &operator+=(const [File](#file) &other) {: #file-function-operator-pe-2 }
  
-    f1 == f2; // returns false (metadata doesn't match)
+Shortcut operator to call [append](#file-function-append-2).
  
-### bool operator !=(const [File](#file) &other) const
+* **function definition:**
  
-Compare [name](#qstring-name) and [metadata](#qvariantmap-m_metadata) to another file name and metadata for inequality.
+        inline File &operator+=(const File &other)
  
-    File f1("picture1.jpg");
-    File f2("picture1.jpg");
+* **parameters:**
  
-    f1 != f2; // returns false
+    Parameter | Type | Description
+    other | const [File](#file) & | File to append
  
-    f1.set("Key1", QVariant::fromValue<float>(1));
-    f2.set("Key2", QVariant::fromValue<float>(2));
+* **output:** ([File](#file) &) Returns a reference to this file after the append occurs.
+* **example:**
  
-    f1 != f2; // returns true (metadata doesn't match)
+        File f1("../path/to/pictures/picture1.jpg");
+        f1.set("Key1", QVariant::fromValue<float>(1));
  
-### bool operator <(const [File](#file) &other) const
+        File f2("../path/to/pictures/picture2.jpg");
+        f2.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key3", QVariant::fromValue<float>(3));
  
-Compare [name](#qstring-name) to a different file name.
+        f1 += f2;
+        f1.name; // return "../path/to/pictures/picture1.jpg;../path/to/pictures/picture2.jpg"
+        f1.localKeys(); // returns "[Key1, Key2, Key3, separator]"
  
-### bool operator <=(const [File](#file) &other) const
  
-Compare [name](#qstring-name) to a different file name.
+### [QList][QList]&lt;[File](#file)&gt; split() const {: #file-function-split-1 }
  
-### bool operator >(const [File](#file) &other) const
+This function splits the [File](#file) into multiple files and returns them as a list. This is done by parsing the file [name](#file-members-name) and splitting on the separator located at [metadata](#file-members-m_metadata)["separator"]. If "separator" is not a [metadata](#file-members-m_metadata) key, the returned list has the original file as the only entry. Each new file has the same [metadata](#file-members-m_metadata) as the original, pre-split, file.
  
-Compare [name](#qstring-name) to a different file name.
+* **function definition:**
  
-### bool operator >=(const [File](#file) &other) const
+        QList<File> split() const
  
-Compare [name](#qstring-name) to a different file name.
+* **parameters:** None
+* **output:** ([QList][QList]&lt;[File](#file)&gt;) List of split files
+* **example:**
  
-### bool isNull() const
+        File f1("../path/to/pictures/picture1.jpg");
+        f1.set("Key1", QVariant::fromValue<float>(1));
  
-Returns true if [name](#qstring-name) and [metadata](#qvariantmap-m_metadata) are empty and false otherwise.
+        f1.split(); // returns [../path/to/pictures/picture1.jpg[Key1=1]]
  
-    File f;
-    f.isNull(); // returns true
+        File f2("../path/to/pictures/picture2.jpg");
+        f2.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key3", QVariant::fromValue<float>(3));
  
-    f.set("Key1", QVariant::fromValue<float>(1));
-    f.isNull(); // returns false
+        f1.append(f2);
+        f1.split(); // returns [../path/to/pictures/picture1.jpg[Key1=1, Key2=2, Key3=3, separator=;],
+                    //          ../path/to/pictures/picture2.jpg[Key1=1, Key2=2, Key3=3, separator=;]]
  
-### bool isTerminal() const
  
-Returns true if [name](#qstring-name) equals "Terminal".
+### [QList][QList]&lt;[File](#file)&gt; split(const [QString][QString] &separator) const {: #file-function-split-2 }
  
-### bool exists() const
+This function splits the file into multiple files and returns them as a list. This is done by parsing the file [name](#file-members-name) and splitting on the given separator. Each new file has the same [metadata](#file-members-m_metadata) as the original, pre-split, file.
  
-Returns true if the file at [name](#qstring-name) exists on disk.
+* **function definition:**
  
-### [QString][QString] fileName() const
+        QList<File> split(const QString &separator) const
  
-Returns the file's base name and extension.
+* **parameters:**
  
-    File file("../path/to/pictures/picture.jpg");
-    file.fileName(); // returns "picture.jpg"
+    Parameter | Type | Description
+    --- | --- | ---
+    separator | const [QString][QString] & | Separator to split the file name on
  
-### [QString][QString] baseName() const
+* **output:** ([QList][QList]&lt;[File](#file)&gt;) List of split files
+* **example:**
  
-Returns the file's base name.
+        File f("../path/to/pictures/picture1.jpg,../path/to/pictures/picture2.jpg");
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.set("Key2", QVariant::fromValue<float>(2));
  
-    File file("../path/to/pictures/picture.jpg");
-    file.baseName(); // returns "picture"
+        f.split(","); // returns [../path/to/pictures/picture1.jpg[Key1=1, Key2=2],
+                                  ../path/to/pictures/picture2.jpg[Key1=1, Key2=2]]
  
-### [QString][QString] suffix() const
  
-Returns the file's extension.
+### void setParameter(int index, const [QVariant][QVariant] &value) {: #file-function-setparameter }
  
-    File file("../path/to/pictures/picture.jpg");
-    file.suffix(); // returns "jpg"
+Insert a keyless value into the [metadata](#file-members-m_metadata). Generic key of "ArgN" is used, where N is given as a parameter.
  
-### [QString][QString] path() const
+* **function definition:**
  
-Return's the path of the file, excluding the name.
+        inline void setParameter(int index, const QVariant &value)
  
-    File file("../path/to/pictures/picture.jpg");
-    file.suffix(); // returns "../path/to/pictures"
+* **parameters:**
  
-### [QString][QString] resolved() const
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | Number to append to generic key
+    value | const [QVariant][QVariant] & | Value to add to the metadata
  
-Returns [name](#qstring-name). If name does not exist it prepends name with the path in Globals->path.
+* **output:** (void)
+* **see:** [containsParameter](#file-function-containsparameter), [getParameter](#file-function-getparameter)
+* **example:**
  
-### bool contains(const [QString][QString] &key) const
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.set("Key2", QVariant::fromValue<float>(2));
  
-Returns True if the key is in the [metadata](#qvariantmap-m_metadata) and False otherwise.
+        f.setParameter(1, QVariant::fromValue<float>(3));
+        f.setParameter(5, QVariant::fromValue<float>(4));
  
-    File file;
-    file.set("Key1", QVariant::fromValue<float>(1));
+        f.flat(); // returns "[Key1=1, Key2=2, Arg1=3, Arg5=4]"
  
-    file.contains("Key1"); // returns true
-    file.contains("Key2"); // returns false
  
-### bool contains(const [QStringList][QStringList] &keys) const
+### bool containsParameter(int index) const {: #file-function-containsparameter }
  
-Returns True if all of the keys are in the [metadata](#qvariantmap-m_metadata) and False otherwise.
+Check if the local [metadata](#file-members-m_metadata) contains a keyless value.
  
-    File file;
-    file.set("Key1", QVariant::fromValue<float>(1));
-    file.set("Key2", QVariant::fromValue<float>(2));
+* **function definition:**
  
-    file.contains(QStringList("Key1")); // returns true
-    file.contains(QStringList() << "Key1" << "Key2") // returns true
-    file.contains(QStringList() << "Key1" << "Key3"); // returns false
+        inline bool containsParameter(int index) const
  
-### [QVariant][QVariant] value(const [QString][QString] &key) const
+* **parameters:**
  
-Returns the value associated with key in the [metadata](#qvariantmap-m_metadata).
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | Index of the keyless value to check for
  
-    File file;
-    file.set("Key1", QVariant::fromValue<float>(1));
-    file.value("Key1"); // returns QVariant(float, 1)
+* **output:** (bool) Returns true if the local [metadata](#file-members-m_metadata) contains the keyless value, otherwise reutrns false.
+* **see:** [setParameter](#file-function-setparameter), [getParameter](#file-function-getparameter)
+* **example:**
  
-### void set(const [QString][QString] &key, const [QVariant][QVariant] &value)
+        File f;
+        f.setParameter(1, QVariant::fromValue<float>(1));
+        f.setParameter(2, QVariant::fromValue<float>(2));
  
-Insert or overwrite the [metadata](#qvariantmap-m_metadata) key with the given value.
+        f.containsParameter(1); // returns true
+        f.containsParameter(2); // returns true
+        f.containsParameter(3); // returns false
  
-    File f;
-    f.flat(); // returns ""
  
-    f.set("Key1", QVariant::fromValue<float>(1));
-    f.flat(); // returns "[Key1=1]"
+### [QVariant][QVariant] getParameter(int index) const {: #file-function-getparameter }
  
-### void set(const [QString][QString] &key, const [QString][QString] &value)
+Get a keyless value from the local [metadata](#file-members-m_metadata). If the value does not exist an error is thrown.
  
-Insert or overwrite the [metadata](#qvariantmap-m_metadata) key with the given value.
+* **function definition:**
  
-    File f;
-    f.flat(); // returns ""
+        inline QVariant getParameter(int index) const
  
-    f.set("Key1", QString("1"));
-    f.flat(); // returns "[Key1=1]"
+* **parameter:**
  
-### void setList(const [QString][QString] &key, const [QList][QList]&lt;T&gt; &value)
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | Index of the keyless value to look up. If the index does not exist an error is thrown.
  
-This function requires a type specification in place of T. Insert or overwrite the [metadata](#qvariantmap-m_metadata) key with the value. The value will remain a list and should be queried with the function [getList](#qlistt-getlistconst-qstring-key-const).
+* **output:** ([QVariant][QVariant]) Returns the keyless value associated with the given index
+* **see:** [setParameter](#file-function-setparameter), [containsParameter](#file-function-containsparameter)
+* **example:**
  
-    File file;
+        File f;
+        f.setParameter(1, QVariant::fromValue<float>(1));
+        f.setParameter(2, QVariant::fromValue<float>(2));
  
-    QList<float> list = QList<float>() << 1 << 2 << 3;
-    file.setList<float>("List", list);
-    file.getList<float>("List"); // return [1., 2. 3.]
+        f.getParameter(1); // returns 1
+        f.getParameter(2); // returns 2
+        f.getParameter(3); // error: index does not exist
  
-### void remove(const [QString][QString] &key)
  
-Remove the key value pair associated with the given key from the [metadata](#metadata)
+### bool operator==(const char \*other) const {: #file-function-operator-ee-1 }
  
-    File f;
-    f.set("Key1", QVariant::fromValue<float>(1));
-    f.set("Key2", QVariant::fromValue<float>(2));
+Compare [name](#file-members-name) against a c-style string.
  
-    f.flat(); // returns "[Key1=1, Key2=2]"
+* **function definition:**
  
-    f.remove("Key1");
-    f.flat(); // returns "[Key2=2]"
+        inline bool operator==(const char *other) const
  
-### T get(const [QString][QString] &key)
+* **parameters:**
  
-This function requires a type specification in place of T. Try and get the value associated with the given key in the [metadata](#qvariantmap-m_metadata). If the key does not exist or cannot be converted to the given type an error is thrown.
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const char \* | C-style string to compare against
  
-    File f;
-    f.set("Key1", QVariant::fromValue<float>(1));
+* **output:** (bool) Returns true if the strings are equal, false otherwise.
+* **example:**
  
-    f.get<float>("Key1");  // returns 1
-    f.get<float>("Key2");  // Error: Key2 is not in the metadata
-    f.get<QRectF>("Key1"); // Error: A float can't be converted to a QRectF
+        File f("picture.jpg");
  
-### T get(const [QString][QString] &key, const T &defaultValue)
+        f == "picture.jpg";       // returns true
+        f == "other_picture.jpg"; // returns false
  
-This function requires a type specification in place of T. Try and get the value associated with the given key in the [metadata](#qvariantmap-m_metadata). If the key does not exist or cannot be converted to the given type the defaultValue is returned.
  
-    File f;
-    f.set("Key1", QVariant::fromValue<float>(1));
+### bool operator==(const [File](#file) &other) const {: #file-function-operator-ee-2 }
  
-    f.get<float>("Key1", 5);  // returns 1
-    f.get<float>("Key2", 5);  // returns 5
-    f.get<QRectF>("Key1", QRectF(0, 0, 10, 10)); // returns QRectF(0, 0, 10x10)
+Compare [name](#file-members-name) and [metadata](#file-members-m_metadata) against another file name and metadata.
  
-### bool getBool(const [QString][QString] &key, bool defaultValue = false)
+* **function definition:**
  
-This is a specialization of [get](#t-getconst-qstring-key) for the boolean type. If the key is not in the [metadata](#qvariantmap-m_metadata) the defaultValue is returned. If the key is in the metadata but the value cannot be converted to a bool **true** is returned. If the key is found and the value can be converted to a bool the value is returned.
+        inline bool operator==(const File &other) const
  
-    File f;
-    f.set("Key1", QVariant::fromValue<bool>(true));
-    f.set("Key2", QVariant::fromValue<float>(10));
+* **parameters:**
  
-    f.getBool("Key1");       // returns true
-    f.getBool("Key2")        // returns true (key found)
-    f.getBool("Key3");       // returns false (default value)
-    f.getBool("Key3", true); // returns true (default value)
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](#file) & | File to compare against
  
-### [QList][QList]&lt;T&gt; getList(const [QString][QString] &key) const
+* **output:** (bool) Returns true if the names and metadata are equal, false otherwise.
+* **example:**
  
-This function requires a type specification in place of T. Similar to [get](#t-getconst-qstring-key) only this returns a list. If the key is not found or the value cannot be converted into a [QList][QList]&lt;T&gt; an error is thrown.
+        File f1("picture1.jpg");
+        File f2("picture1.jpg");
  
-    File file;
+        f1 == f2; // returns true
  
-    QList<float> list = QList<float>() << 1 << 2 << 3;
-    file.setList<float>("List", list);
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f2.set("Key2", QVariant::fromValue<float>(2));
  
-    file.getList<float>("List");  // return [1., 2. 3.]
-    file.getList<QRectF>("List"); // Error: float cannot be converted to QRectF
-    file.getList<float>("Key");   // Error: key doesn't exist
+        f1 == f2; // returns false (metadata doesn't match)
  
-### [QList][QList]&lt;T&gt; getList(const [QString][QString] &key, const [QList][QList]&lt;T&gt; &defaultValue) const
  
-This function requires a type specification in place of T. Similar to [get](#t-getconst-qstring-key-const-t-defaultvalue) only this returns a list. If the key is not found or the value cannot be converted into a [QList][QList]&lt;T&gt; the supplied defaultValue is returned.
+### bool operator!=(const [File](#file) &other) const {: #file-function-operator-ne }
  
-    File file;
+Compare [name](#file-members-name) and [metadata](#file-members-m_metadata) against another file name and metadata.
  
-    QList<float> list = QList<float>() << 1 << 2 << 3;
-    file.setList<float>("List", list);
+* **function definition:**
  
-    file.getList<float>("List", QList<float>());                  // return [1., 2. 3.]
-    file.getList<QRectF>("List", QList<QRectF>());                // return []
-    file.getList<float>("Key", QList<float>() << 1 << 2 << 3);    // return [1., 2., 3.]
+        inline bool operator!=(const File &other) const
  
-### [QList][QList]&lt;[QPointF][QPointF]&gt; namedPoints() const
+* **parameters:**
  
-Find all of the points that can be parsed from [metadata](#qvariantmap-m_metadata) keys and return them. Only values that are convertable to [QPointF][QPointF] are found. Values that can be converted to [QList][QList]>&lt;[QPointF][QPointF]&gt; are not included.
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](#file) & | File to compare against
  
-    File file;
-    file.set("Key1", QVariant::fromValue<QPointF>(QPointF(1, 1)));
-    file.set("Key2", QVariant::fromValue<QPointF>(QPointF(2, 2)));
-    file.set("Points", QVariant::fromValue<QPointF>(QPointF(3, 3)))
+* **output:** (bool) Returns true if the names and metadata are not equal, false otherwise.
+* **example:**
  
-    f.namedPoints(); // returns [QPointF(1, 1), QPointF(2, 2), QPointF(3, 3)]
+        File f1("picture1.jpg");
+        File f2("picture1.jpg");
  
-    file.setPoints(QList<QPointF>() << QPointF(3, 3)); // changes metadata["Points"] to QList<QPointF>
-    f.namedPoints(); // returns [QPointF(1, 1), QPointF(2, 2)]
+        f1 != f2; // returns false
  
-### [QList][QList]&lt;[QPointf][QPointF]>&gt; points() const
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f2.set("Key2", QVariant::fromValue<float>(2));
  
-Returns the list of points stored in [metadata](#qvariantmap-m_metadata)["Points"]. A list is expected and a single point not in a list will not be returned. Convenience functions [appendPoint](#void-appendpointconst-qpointf-point), [appendPoints](#void-appendpointsconst-qlistqpointf-points), [clearPoints](#void-clearpoints) and [setPoints](#void-setpointsconst-qlistqpointf-points) have been provided to manipulate the internal points list.
+        f1 != f2; // returns true (metadata doesn't match)
  
-    File file;
-    file.set("Points", QVariant::fromValue<QPointF>(QPointF(1, 1)));
-    file.points(); // returns [] (point is not in a list)
  
-    file.setPoints(QList<QPointF>() << QPointF(2, 2));
-    file.points(); // returns [QPointF(2, 2)]
+### bool operator<(const [File](#file) &other) const {: #file-function-operator-lt }
  
-### void appendPoint(const [QPointF][QPointF] &point)
+Compare [name](#file-members-name) against another file name.
  
-Add a point to the file's points list stored in [metadata](#qvariantmap-m_metadata)["Points"]
+* **function definition:**
  
-    File file;
-    file.points(); // returns []
+        inline bool operator<(const File &other) const
  
-    file.appendPoint(QPointF(1, 1));
-    file.points(); // returns [QPointF(1, 1)]
+* **parameters:**
  
-### void appendPoints(const [QList][QList]&lt;[QPointF][QPointF]&gt; &points)
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](#file) & | File to compare against
  
-Add a list of points to the file's points list stored in [metadata](#qvariantmap-m_metadata)["Points"]
+* **output:** (bool) Returns true if [name](#file-members-name) < others.name
  
-    File file;
-    file.points(); // returns []
  
-    file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
-    file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
+### bool operator<=(const [File](#file) &other) const {: #file-function-operator-lte }
  
-### void clearPoints()
+Compare [name](#file-members-name) against another file name.
  
-Clear the list of points stored in [metadata](#qvariantmap-m_metadata)["Points"].
+* **function definition:**
  
-    File file;
-    file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
-    file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
+        inline bool operator<=(const File &other) const
  
-    file.clearPoints();
-    file.points(); // returns []
+* **parameters:**
  
-### void setPoints(const [QList][QList]&lt;[QPointF][QPointF]&gt; &points)
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](#file) & | File to compare against
  
-Clears the points stored in [metadata](#qvariantmap-m_metadata) and replaces them with points.
+* **output:** (bool) Returns true if [name](#file-members-name) <= others.name
  
-    File file;
-    file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
-    file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
  
-    file.setPoints(QList<QPointF>() << QPointF(3, 3) << QPointF(4, 4));
-    file.points(); // returns [QPointF(3, 3), QPointF(4, 4)]
+### bool operator>(const [File](#file) &other) const {: #file-function-operator-gt }
  
-### [QList][QList]&lt;[QRectF][QRectF]&gt; namedRects() const
+Compare [name](#file-members-name) against another file name.
  
-Find all of the rects that can be parsed from [metadata](#qvariantmap-m_metadata) keys and return them. Only values that are convertable to [QRectF][QRectF] are found. Values that can be converted to [QList][QList]&lt;[QRectF][QRectF]&gt; are not included.
+* **function definition:**
  
-    File file;
-    file.set("Key1", QVariant::fromValue<QRectF>(QRectF(1, 1, 5, 5)));
-    file.set("Key2", QVariant::fromValue<QRectF>(QRectF(2, 2, 5, 5)));
-    file.set("Rects", QVariant::fromValue<QRectF>(QRectF(3, 3, 5, 5)));
+        inline bool operator>(const File &other) const
  
-    f.namedRects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5), QRectF(3, 3, 5x5)]
+* **parameters:**
  
-    file.setRects(QList<QRectF>() << QRectF(3, 3, 5x5)); // changes metadata["Rects"] to QList<QRectF>
-    f.namedRects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](#file) & | File to compare against
  
-### [QList][QList]&lt;[QRectF][QRectF]&gt; rects() const
+* **output:** (bool) Returns true if [name](#file-members-name) > others.name
  
-Returns the list of points stored in [metadata](#qvariantmap-m_metadata)["Rects"]. A list is expected and a single rect not in a list will not be returned. Convenience functions [appendRect](#void-appendrectconst-qrectf-rect), [appendRects](#void-appendrectsconst-qlistqrectf-rects), [clearRects](#void-clearrects) and [setRects](#void-setrectsconst-qlistqrectf-rects) have been provided to manipulate the internal points list.
  
-    File file;
-    file.set("Rects", QVariant::fromValue<QRectF>(QRectF(1, 1, 5, 5)));
-    file.rects(); // returns [] (rect is not in a list)
+### bool operator>=(const [File](#file) &other) const {: #file-function-operator-gte }
  
-    file.setRects(QList<QRectF>() << QRectF(2, 2, 5, 5));
-    file.rects(); // returns [QRectF(2, 2, 5x5)]
+Compare [name](#file-members-name) against another file name.
  
-### void appendRect(const [QRectF][QRectF] &rect)
+* **function definition:**
  
-Add a rect to the file's rects list stored in [metadata](#qvariantmap-m_metadata)["Rects"].
+        inline bool operator>=(const File &other) const
  
-    File file;
-    file.rects(); // returns []
+* **parameters:**
  
-    file.appendRect(QRectF(1, 1, 5, 5));
-    file.rects(); // returns [QRectF(1, 1, 5x5)]
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](#file) & | File to compare against
  
-### void appendRect(const [Rect][Rect] &rect)
+* **output:** (bool) Returns true if [name](#file-members-name) >= others.name
  
-Add a OpenCV style rect to the file's rects list stored in [metadata](#qvariantmap-m_metadata)["Rects"]. The rect is automatically converted to a QRectF.
  
-    File file;
-    file.rects(); // returns []
+### bool isNull() const {: #file-function-isnull }
  
-    file.appendRect(cv::Rect(1, 1, 5, 5)); // automatically converted to QRectF
-    file.rects(); // returns [QRectF(1, 1, 5x5)]
+Check if the file is null.
  
-### void appendRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects)
+* **function definition:**
  
-Add a list of rects to the file's rects list stored in [metadata](#qvariantmap-m_metadata)["Rects"]
+        inline bool isNull() const
  
-    File file;
-    file.rects(); // returns []
+* **parameters:** NONE
+* **output:** (bool) Returns true if [name](#file-members-name) and [metadata](#file-members-m_metadata) are empty, false otherwise.
+* **example:**
  
-    file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
-    file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+        File f;
+        f.isNull(); // returns true
  
-### void appendRects(const [QList][QList]&lt;[Rect][Rect]&gt; &rects)
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.isNull(); // returns false
  
-Add a list of OpenCV style rects to the file's rects list stored in [metadata](#qvariantmap-m_metadata)["Rects"]. Each rect is automatically converted to a QRectF.
  
-    File file;
-    file.rects(); // returns []
+### bool isTerminal() const {: #file-function-isterminal }
  
-    file.appendRects(QList<cv::Rect>() << cv::Rect(1, 1, 5, 5) << cv::Rect(2, 2, 5, 5));
-    file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+Checks if the value of [name](#file-members-name) == "terminal".
  
+* **function definition:**
  
-### void clearRects()
+        inline bool isTerminal() const
  
-Clear the list of rects stored in [metadata](#qvariantmap-m_metadata)["Rects"].
+* **parameters:** NONE
+* **output:** (bool) Returns true if [name](#file-members-name) == "terminal", false otherwise.
+* **example:**
  
-    File file;
-    file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
-    file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+        File f1("terminal"), f2("not_terminal");
  
-    file.clearRects();
-    file.rects(); // returns []
+        f1.isTerminal(); // returns true
+        f2.isTerminal(); // returns false
  
-### void setRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects)
  
-Clears the rects stored in [metadata](#qvariantmap-m_metadata)["Rects"] and replaces them with the given rects.
+### bool exists() const {: #file-function-exists }
  
-    File file;
-    file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
-    file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+Check if the file exists on disk.
  
-    file.setRects(QList<QRectF>() << QRectF(3, 3, 5, 5) << QRectF(4, 4, 5, 5));
-    file.rects(); // returns [QRectF(3, 3, 5x5), QRectF(4, 4, 5x5)]
+* **function definition:**
  
-### void setRects(const [QList][QList]&lt;[Rect][Rect]&gt; &rects)
+        inline bool exists() const
  
-Clears the rects stored in [metadata](#qvariantmap-m_metadata)["Rects"] and replaces them with the given OpenCV style rects.
+* **parameters:** NONE
+* **output:** Returns true if [name](#file-members-name) exists on disk, false otherwise.
+* **example:**
  
-    File file;
-    file.appendRects(QList<cv::Rect>() << cv::Rect(1, 1, 5, 5) << cv::Rect(2, 2, 5, 5));
-    file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+    File f1("/path/to/file/that/exists"), f2("/path/to/non/existant/file");
  
-    file.setRects(QList<cv::Rect>() << cv::Rect(3, 3, 5, 5) << cv::Rect(4, 4, 5, 5));
-    file.rects(); // returns [QRectF(3, 3, 5x5), QRectF(4, 4, 5x5)]
+    f1.exists(); // returns true
+    f2.exists(); // returns false
  
----
  
-# FileList
+### [QString][QString] fileName() const {: #file-function-filename }
  
-Inherits [QList][QList]&lt;[File](#file)&gt;.
+Get the file's base name and extension.
  
-A convenience class for dealing with lists of files.
+* **function definition:**
  
-## Members
+        inline QString fileName() const
  
----
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the base name + extension of [name](#file-members-name)
+* **example:**
  
-## Constructors
+        File file("../path/to/pictures/picture.jpg");
+        file.fileName(); // returns "picture.jpg"
  
-### FileList()
  
-Default constructor. Doesn't do anything
+### [QString][QString] baseName() const {: #file-function-basename }
  
-### FileList(int n)
+Get the file's base name.
  
-Initialize the [FileList](#filelist) with n empty files
+* **function definition:**
  
-### FileList(const [QStringList][QStringList] &files)
+        inline QString baseName() const
  
-Initialize the [FileList](#filelist) from a list of strings. Each string should have the format "filename[key1=value1, key2=value2, ... keyN=valueN]"
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the base name of [name](#file-members-name)
+* **example:**
  
-### FileList(const [QList][QList]&lt;[File](#file)&gt; &files)
+        File file("../path/to/pictures/picture.jpg");
+        file.baseName(); // returns "picture"
  
-Initialize the [FileList](#filelist) from a list of [files](#file).
  
----
+### [QString][QString] suffix() const {: #file-function-suffix }
  
-## Static Functions
+Get the file's extension.
  
-### static FileList fromGallery(const [File](#file) &gallery, bool cache = false)
+* **function definition:**
  
-Creates a [FileList](#filelist) from a [Gallery](#gallery). Galleries store one or more [Templates](#template) on disk. Common formats include csv, xml, and gal, which is a unique OpenBR format. Read more about this in the [Gallery](#gallery) section. This function creates a [FileList](#filelist) by parsing the stored gallery based on its format. Cache determines whether the gallery should be stored for faster reading later.
+        inline QString suffix() const
  
-    File gallery("gallery.csv");
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the extension of [name](#file-members-name)
+* **example:**
  
-    FileList fList = FileList::fromGallery(gallery);
-    fList.flat(); // returns all the files that have been loaded from disk. It could
-                  // be 1 or 100 depending on what was stored.
+        File file("../path/to/pictures/picture.jpg");
+        file.suffix(); // returns "jpg"
  
----
  
-## Functions
+### [QString][QString] path() const {: #file-function-path }
  
-### [QStringList][QStringList] flat() const
+Get the path of the file without the name.
  
-Calls [flat](#qstring-flat-const) on every [File](#file) in the list and returns the resulting strings as a [QStringList][QStringList].
+* **function definition:**
  
-    File f1("picture1.jpg"), f2("picture2.jpg");
-    f1.set("Key", QString("Value"));
+        inline QString path() const
  
-    FileList fList(QList<File>() << f1 << f2);
-    fList.flat(); // returns ["picture1.jpg[Key=Value]", "picture2.jpg"]
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the path of [name](#file-members-name).
+* **example:**
  
-### [QStringList][QStringList] names() const
+        File file("../path/to/pictures/picture.jpg");
+        file.suffix(); // returns "../path/to/pictures"
  
-Stores the name of every [file](#file) in the list and returns the resulting strings as a [QStringList][QStringList].
  
-    File f1("picture1.jpg"), f2("picture2.jpg");
-    f1.set("Key", QString("Value"));
+### [QString][QString] resolved() const {: #file-function-resolved }
  
-    FileList fList(QList<File>() << f1 << f2);
-    fList.names(); // returns ["picture1.jpg", "picture2.jpg"]
+Get the full path for the file. This is done in three steps:
  
-### void sort(const [QString][QString] &key)
+1. If [name](#file-members-name) exists, return [name](#file-members-name).
+2. Prepend each path stored in [Globals->path](#context-members-path) to [name](#file-members-name). If the combined name exists then it is returned.
+3. Prepend each path stored in [Globals->path](#context-members-path) to [fileName](#file-function-filename). If the combined name exists then it is returned.
  
-Sorts the [FileList](#filelist) based on the value associated with the given key in each file.
+If none of the attempted names exist, [name](#file-members-name) is returned unmodified.
  
-    File f1("1"), f2("2"), f3("3");
-    f1.set("Key", QVariant::fromValue<float>(3));
-    f2.set("Key", QVariant::fromValue<float>(1));
-    f3.set("Key", QVariant::fromValue<float>(2));
+* **function definition:**
  
-    FileList fList(QList<File>() << f1 << f2 << f3);
-    fList.names(); // returns ["1", "2", "3"]
+        QString resolved() const
  
-    fList.sort("Key");
-    fList.names(); // returns ["2", "3", "1"]
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the resolved string if it can be created. Otherwise it returns [name](#file-members-name)
  
-### [QList][QList]&lt;int&gt; crossValidationPartitions() const
  
-Returns the cross-validation partition (default=0) for each file in the list. The partition is stored with the [metadata](#qvariantmap-m_metadata) key "Partition".
+### bool contains(const [QString][QString] &key) const {: #file-function-contains-1 }
  
-    File f1, f2, f3;
-    f1.set("Partition", QVariant::fromValue<int>(1));
-    f3.set("Partition", QVariant::fromValue<int>(3));
+Check if a given key is in the local [metadata](#file-members-m_metadata).
  
-    FileList fList(QList<File>() << f1 << f2 << f3);
-    fList.crossValidationPartitions(); // returns [1, 0, 3]
+* **function definition:**
  
-### int failures() const
+        bool contains(const QString &key) const
  
-Returns the number of files that have [FTE](#bool-fte) = **True**.
+* **parameters:**
  
-    File f1, f2, f3;
-    f1.fte = false;
-    f2.fte = true;
-    f3.fte = true;
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to check the [metadata](#file-members-m_metadata) for
  
-    FileList fList(QList<File>() << f1 << f2 << f3);
-    fList.failures(); // returns 2
+* **output:** (bool) Returns true if the given key is in the [metadata](#file-members-m_metadata), false otherwise.
+* **example:**
  
----
+        File file;
+        file.set("Key1", QVariant::fromValue<float>(1));
  
-# Template
+        file.contains("Key1"); // returns true
+        file.contains("Key2"); // returns false
  
-Inherits [QList][QList]&lt;[Mat][Mat]&gt;.
  
-A list of matrices associated with a file.
+### bool contains(const [QStringList][QStringList] &keys) const {: #file-function-contains-2 }
  
-The Template is one of two important data structures in OpenBR (the [File](#file) is the other).
-A template represents a biometric at various stages of enrollment and can be modified by [Transforms](#transform) and compared to other [templates](#template) with [Distance](#distance).
+Check if a list of keys is in the local [metadata](#file-members-m_metadata).
  
-While there exist many cases (ex. video enrollment, multiple face detects, per-patch subspace learning, ...) where the template will contain more than one matrix,
-in most cases templates have exactly one matrix in their list representing a single image at various stages of enrollment.
-In the cases where exactly one image is expected, the template provides the function m() as an idiom for treating it as a single matrix.
-Casting operators are also provided to pass the template into image processing functions expecting matrices.
+* **function definition:**
  
-Metadata related to the template that is computed during enrollment (ex. bounding boxes, eye locations, quality metrics, ...) should be assigned to the template's [File](#file-file) member.
+        bool contains(const QStringList &keys) const
  
-## Members
+* **parameters:**
  
-### File file
+    Parameter | Type | Description
+    --- | --- | ---
+    keys | const [QStringList][QStringList] & | Keys to check the [metadata](#file-members-m_metadata) for
  
-The [File](#file) that constructs the [template](#template)
+* **output:** (bool) Returns true if *all* of the given keys are in the [metadata](#file-members-m_metadata), false otherwise.
+* **example:**
  
----
+        File file;
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
  
-## Constructors
+        file.contains(QStringList("Key1")); // returns true
+        file.contains(QStringList() << "Key1" << "Key2") // returns true
+        file.contains(QStringList() << "Key1" << "Key3"); // returns false
  
-### Template()
  
-The default template constructor. It doesn't do anything.
+### [QVariant][QVariant] value(const [QString][QString] &key) const {: #file-function-value }
  
-### Template(const [File](#file) &file)
+Get the value associated with a given key from the [metadata](#file-members-m_metadata). If the key is not found in the [local metadata](#file-members-m_metadata), the [global metadata](#context) is searched. In a special case, the key can be "name". This returns the file's [name](#file-members-name).
  
-Sets [file](#file-file) to the given file.
+* **function description:**
  
-### Template(const [File](#file) &file, const [Mat][Mat] &mat)
+        QVariant value(const QString &key) const
  
-Sets [file](#file-file) to the given file and appends the given mat to itself.
+* **parameters:**
  
-### Template(const [File](#file) &file, const [QList][QList]&lt;[Mat][Mat]&gt &mats)
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to look up the value in the [local metadata](#file-members-m_metadata) or [global metadata](#context). The key can also be "name".
  
-Sets [file](#file-file) to the given file and appends the given mats to itself.
+* **output:** ([QVariant][QVariant]) Returns the key associated with the value from either the [local](#file-members-m_metadata) or [global](#context) metadata. If the key is "name", [name](#file-members-name) is returned.
+* **example:**
  
-### Template(const [Mat][Mat] &mat)
+        File file;
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.value("Key1"); // returns QVariant(float, 1)
  
-Appends the given mat to itself.
  
+### void set(const [QString][QString] &key, const [QVariant][QVariant] &value) {: #file-function-set-1 }
  
----
+Insert a value into the [metadata](#file-members-m_metadata) using a provided key. If the key already exists the new value will override the old one.
  
-## Static Functions
+* **function description:**
  
-[QDataStream][QDataStream] &operator <<([QDataStream][QDataStream] &stream, const [Template](#template) &t)
+        inline void set(const QString &key, const QVariant &value)
  
-Serialize a template.
+* **parameters:**
  
-    void store(QDataStream &stream)
-    {
-        Template t("picture.jpg");
-        t.append(Mat::ones(1, 1, CV_8U));
+    Parameters | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to store the given value in the [metadata](#file-members-m_metadata)
+    value | const [QVariant][QVariant] & | Value to be stored
  
-        stream << t; // "["1"]picture.jpg" serialized to the stream
-    }
+* **output:** (void)
+* **example:**
  
-[QDataStream][QDataStream] &operator >>([QDataStream][QDataStream] &stream, const [Template](#template) &t)
+        File f;
+        f.flat(); // returns ""
  
-Deserialize a template.
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.flat(); // returns "[Key1=1]"
  
-    void load(QDataStream &stream)
-    {
-        Template in("picture.jpg");
-        in.append(Mat::ones(1, 1, CV_8U));
  
-        stream << in; // "["1"]picture.jpg" serialized to the stream
+### void set(const [QString][QString] &key, const [QString][QString] &value) {: #file-function-set-2 }
  
-        Template out;
-        stream >> out;
+Insert a value into the [metadata](#file-members-m_metadata) using a provided key. If the key already exists the new value will override the old one.
  
-        out.file; // returns "picture.jpg"
-        out; // returns ["1"]
-    }
+* **function description:**
  
----
+        void set(const QString &key, const QString &value)
  
-## Functions
+* **parameters:**
  
-### operator const [File](#file) &()
+    Parameters | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to store the given value in the [metadata](#file-members-m_metadata)
+    value | const [QString][QString] & | Value to be stored
  
-Idiom to treat the template like a [File](#file). Returns [file](#file-file).
+* **output:** (void)
+* **example:**
  
-### const [Mat][Mat] &m()
+        File f;
+        f.flat(); // returns ""
  
-Idiom to treat the template like a [Mat][Mat]. If the template is empty then an empty [Mat][Mat] is returned. If the list has multiple [Mats][Mat] the last is returned.
+        f.set("Key1", QString("1"));
+        f.flat(); // returns "[Key1=1]"
  
-    Template t;
-    t.m(); // returns empty mat
  
-    Mat m1;
-    t.append(m1);
-    t.m(); // returns m1;
+### void setList(const [QString][QString] &key, const [QList][QList]&lt;T&gt; &value) {: #file-function-setlist }
  
-    Mat m2;
-    t.append(m2);
-    t.m(); // returns m2;
+Insert a list into the [metadata](#file-members-m_metadata) using a provided key. If the key already exists the new value will override the old one. The value should be queried with [getList](#file-function-getlist-1) instead of [get](#file-function-get-1).
  
-### [Mat][Mat] &m()
+* **function description:**
  
-Idiom to treat the template like a [Mat][Mat]. If the template is empty then an empty [Mat][Mat] is returned. If the list has multiple [Mats][Mat] the last is returned.
+        template <typename T> void setList(const QString &key, const QList<T> &value)
  
-    Template t;
-    t.m(); // returns empty mat
+* **parameters:**
  
-    Mat m1;
-    t.append(m1);
-    t.m(); // returns m1;
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to store the given value in the [metadata](#file-members-m_metadata)
+    value | const [QList][QList]&lt;T&gt; | List to be stored
  
-    Mat m2;
-    t.append(m2);
-    t.m(); // returns m2;
+* **output:** (void)
+* **see:** [getList](#file-function-getlist-1), [get](#file-function-get-1)
+* **example:**
  
-### operator const [Mat][Mat] &()
+        File file;
  
-Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#mat-m).
+        QList<float> list = QList<float>() << 1 << 2 << 3;
+        file.setList<float>("List", list);
+        file.getList<float>("List"); // return [1., 2. 3.]
  
-### operator [Mat][Mat] &()
  
-Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#mat-m).
+### void remove(const [QString][QString] &key) {: #file-function-remove }
  
-### operator [_InputArray][InputArray] &()
+Remove a key-value pair from the [metadata](#file-members-m_metadata)
  
-Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#mat-m).
+* **function description:**
  
-### operator [_OutputArray][OutputArray] &()
+        inline void remove(const QString &key)
  
-Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#mat-m).
+* **parameters:**
  
-### [Mat][Mat] &operator =(const [Mat][Mat] &other)
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to be removed from [metadata](#file-members-m_metadata) along with its associated value.
  
-Idiom to treat the template like a [Mat][Mat]. Sets other equal to [m()](#mat-m).
+* **output:** (void)
+* **example:**
  
-### bool isNull() const
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.set("Key2", QVariant::fromValue<float>(2));
  
-Returns true if the template is empty or if [m()](#mat-m) has no data.
+        f.flat(); // returns "[Key1=1, Key2=2]"
  
-    Template t;
-    t.isNull(); // returns true
+        f.remove("Key1");
+        f.flat(); // returns "[Key2=2]"
  
-    t.append(Mat());
-    t.isNull(); // returns true
  
-    t.append(Mat::ones(1, 1, CV_8U));
-    t.isNull(); // returns false
+### T get(const [QString][QString] &key) const {: #file-function-get-1 }
  
-### void merge(const [Template](#template) &other)
+Get a value from the [metadata](#file-members-m_metadata) using a provided key. If the key does not exist or the value cannot be converted to a user specified type an error is thrown.
  
-Append the contents of another template. The [files](#file-file) are appended using [append()](#void-append-const-file-other).
+* **function definition:**
  
-    Template t1("picture1.jpg"), t2("picture2.jpg");
-    Mat m1, m2;
+        template <typename T> T get(const QString &key) const
  
-    t1.append(m1);
-    t2.append(m2);
+* **parameters:**
  
-    t1.merge(t2);
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from [metadata](#file-members-m_metadata)
  
-    t1.file; // returns picture1.jpg;picture2.jpg[seperator=;]
-    t1; // returns [m1, m2]
+* **output:** (<tt>T</tt>) Returns a value of type <tt>T</tt>. <tt>T</tt> is a user specified type. The value associated with the given key must be convertable to <tt>T</tt>.
+* **see:** [get](#file-function-get-2), [getList](#file-function-getlist-1)
+* **example:**
  
-### size_t bytes() const
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
  
-Returns the total number of bytes in all of the matrices in the template.
+        f.get<float>("Key1");  // returns 1
+        f.get<float>("Key2");  // Error: Key2 is not in the metadata
+        f.get<QRectF>("Key1"); // Error: A float can't be converted to a QRectF
  
-    Template t;
+### T get(const [QString][QString] &key, const T &defaultValue) {: #file-function-get-2 }
  
-    Mat m1 = Mat::ones(1, 1, CV_8U); // 1 byte
-    Mat m2 = Mat::ones(2, 2, CV_8U); // 4 bytes
-    Mat m3 = Mat::ones(3, 3, CV_8U); // 9 bytes
+Get a value from the [metadata](#file-members-m_metadata) using a provided key. If the key does not exist or the value cannot be converted to user specified type a provided default value is returned instead.
  
-    t << m1 << m2 << m3;
+* **function definition:**
  
-    t.bytes(); // returns 14
+        template <typename T> T get(const QString &key, const T &defaultValue)
  
-### Template clone() const
+* **parameters:**
  
-Returns a new template with copies of the [file](#file-file) and all of the matrices that were in the original.
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](#file-members-m_metadata)
+    defaultValue | const T & | Default value to be returned if the key does not exist or found value cannot be converted to <tt>T</tt>. <tt>T</tt> is a user specified type.
  
-    Template t1("picture.jpg");
-    t1.append(Mat::ones(1, 1, CV_8U));
+* **output:** (<tt>T</tt>) Returns a value of type <tt>T</tt>. <tt>T</tt> is a user specified type. If the value associated with the key is invalid, the provided default value is returned instead.
+* **see:** [get](#file-function-get-1), [getList](#file-function-getlist-1)
+* **example:**
  
-    Template t2 = t1.clone();
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
  
-    t2.file; // returns "picture.jpg"
-    t2; // returns ["1"]
+        f.get<float>("Key1", 5);  // returns 1
+        f.get<float>("Key2", 5);  // returns 5
+        f.get<QRectF>("Key1", QRectF(0, 0, 10, 10)); // returns QRectF(0, 0, 10x10)
  
----
  
-# TemplateList
+### bool getBool(const [QString][QString] &key, bool defaultValue = false) const {: #file-function-getbool }
  
-Inherits [QList][QList]&lt;[Template][#template]&gt;.
+Get a boolean value from the [metadata](#file-members-m_metadata) using a provided key. If the key is not in the [metadata](#file-members-m_metadata) a provided default value is returned. If the key is in the metadata but the value cannot be converted to a bool true is returned. If the key is found and the value can be converted to a bool the value is returned.
  
-Convenience class for working with a list of templates.
+* **function definition:**
  
-## Members
+        bool getBool(const QString &key, bool defaultValue = false) const
  
----
+* **parameters:**
  
-## Constructors
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](#file-members-m_metadata)
+    defaultValue | bool | (Optional) Default value to be returned if the key is not in the [metadata](#file-members-m_metadata).
  
-### TemplateList()
+* **output:** (bool) If the key *is not* in the [metadata](#file-members-m_metadata) the provided default value is returned. If the key *is* in the [metadata](#file-members-m_metadata) but the associated value *cannot* be converted to a bool true is returned. If the key *is* in the [metadata](#file-members-m_metadata) and the associated value *can* be converted to a bool, that value is returned.
+* **see:** [get](#file-function-get-2)
+* **example:**
  
-Default constructor.
+        File f;
+        f.set("Key1", QVariant::fromValue<bool>(true));
+        f.set("Key2", QVariant::fromValue<float>(10));
  
-### TemplateList(const [QList][QList]&lt;[Template](#template)&gt; &templates)
+        f.getBool("Key1");       // returns true
+        f.getBool("Key2")        // returns true (key found)
+        f.getBool("Key3");       // returns false (default value)
+        f.getBool("Key3", true); // returns true (default value)
  
-Initialize the [TemplateList](#templatelist) with a list of templates. The given list is appended.
  
-### TemplateList(const [QList][QList]&lt;[File](#file)&gt; &files)
+### [QList][QList]&lt;T&gt; getList(const [QString][QString] &key) const {: #file-function-getlist-1 }
  
-Initialize the [TemplateList](#templatelist) with a list of files. The files are each treated like a template and appended.
+Get a list from the [metadata](#file-members-m_metadata) using a provided key. If the key does not exist or the elements of the list cannot be converted to a user specified type an error is thrown.
  
----
+* **function definition:**
  
-## Static Functions
+        template <typename T> QList<T> getList(const QString &key) const
  
-### static [TemplateList](#templatelist) fromGallery(const [File](#file) &gallery)
+* **parameters:**
  
-Create a [TemplateList](#templatelist) from a [Gallery](#gallery).
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](#file-members-m_metadata)
  
-### static [TemplateList](#templatelist) fromBuffer(const [QByteArray][QByteArray] &buffer)
+* **output:** ([QList][QList]&lt;<tt>T</tt>&gt;) Returns a list of values of a user specified type.
+* **see:** [setList](#file-function-setlist), [get](#file-function-get-1)
+* **example:**
  
-Create a template from a memory buffer of individual templates. This is compatible with **.gal** galleries.
+        File file;
  
-### static [TemplateList](#templatelist) relabel(const [TemplateList](#templatelist) &tl, const [QString][QString] &propName, bool preserveIntegers)
+        QList<float> list = QList<float>() << 1 << 2 << 3;
+        file.setList<float>("List", list);
  
-Relabels the metadata value associated with propName in each [Template](#template) to be between [0, numClasses-1]. **numClasses** is equal to the maximum value of the given metadata if the value can be converted to an **int** and **preserveIntegers** is true, or the total number of unique values. The relabeled values are stored in the "Label" field of each template.
+        file.getList<float>("List");  // return [1., 2. 3.]
+        file.getList<QRectF>("List"); // Error: float cannot be converted to QRectF
+        file.getList<float>("Key");   // Error: key doesn't exist
  
-    Template t1, t2, t3;
  
-    t1.file.set("Class", QString("1"));
-    t2.file.set("Class", QString("10"));
-    t3.file.set("Class", QString("100"));
-    TemplateList tList(QList<Template>() << t1 << t2 << t3);
+### [QList][QList]&lt;T&gt; getList(const [QString][QString] &key, const [QList][QList]&lt;T&gt; defaultValue) const {: #file-function-getlist-2 }
  
-    TemplateList relabeled = TemplateList::relabel(tList, "Class", true);
-    relabeled.files(); // returns [[Class=1, Label=1], [Class=10, Label=10], [Class=100, Label=100]]
+Get a list from the [metadata](#file-members-m_metadata) using a provided key. If the key does not exist or the elements of the list cannot be converted to a user specified type a provided default value is returned.
  
-    relabeled = TemplateList::relabel(tList, "Class", false);
-    relabeled.files(); // returns [[Class=1, Label=0], [Class=10, Label=1], [Class=100, Label=2]]
+* **function definition:**
  
----
+template <typename T> QList<T> getList(const QString &key, const QList<T> defaultValue) const
  
-## Functions
+* **parameters:**
  
-### [QList][QList]&lt;int&gt; indexProperty(const [QString][QString] &propName, [QHash][QHash]&lt;[QString][QString], int&gt; &valueMap, [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; &reverseLookup) const
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](#file-members-m_metadata)
+    defaultValue | [QList][QList]&lt;<tt>T</tt> | (Optional) Default value to be returned if the key is not in the [metadata](#file-members-m_metadata).
  
-Convert metadata values associated with **propName** to integers. Each unique value gets its own integer. Returns a list of the integer replacement for each template. This is useful in many classification problems where nominal data (e.g "Male", "Female") needs to represented with integers ("Male" = 0, "Female" = 1). **valueMap** and **reverseLookup** are created to allow easy conversion to the integer replacements and back.
+* **output:** ([QList][QList]&lt;<tt>T</tt>&gt;) Returns a list of values of user specified type. If key is not in the [metadata](#file-members-m_metadata) or if the value cannot be converted to a [QList][QList]&lt;<tt>T</tt>&gt; the default value is returned.
+* **see:** [getList](#file-function-getlist-1)
+* **example:**
  
-    Template t1, t2, t3, t4;
+        File file;
  
-    t1.file.set("Key", QString("Class 1"));
-    t2.file.set("Key", QString("Class 2"));
-    t3.file.set("Key", QString("Class 3"));
-    t4.file.set("Key", QString("Class 1"));
+        QList<float> list = QList<float>() << 1 << 2 << 3;
+        file.setList<float>("List", list);
  
-    TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+        file.getList<float>("List", QList<float>());                  // return [1., 2. 3.]
+        file.getList<QRectF>("List", QList<QRectF>());                // return []
+        file.getList<float>("Key", QList<float>() << 1 << 2 << 3);    // return [1., 2., 3.]
  
-    QHash<QString, int> valueMap;
-    QHash<int, QVariant> reverseLookup;
-    tList.indexProperty("Key", valueMap, reverseLookup); // returns [0, 1, 2, 0]
-    valueMap; // returns QHash(("Class 1", 0)("Class 2", 1)("Class 3", 2))
-    reverseLookup; // QHash((0, QVariant(QString, "Class 1")) (2, QVariant(QString, "Class 3")) (1, QVariant(QString, "Class 2")))  
  
+### [QList][QList]&lt;[QPointF][QPointF]&gt; namedPoints() const {: #file-function-namedpoints }
  
-### [QList][QList]&lt;int&gt; indexProperty(const [QString][QString] &propName, [QHash][QHash]&lt;[QString][QString], int&gt; \*valueMap=NULL, [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; \*reverseLookup=NULL) const
+Find values in the [metadata](#file-members-m_metadata) that can be converted into [QPointF][QPointF]'s. Values stored as [QList][QList]&lt;[QPointF][QPointF]&gt; *will not** be returned.
  
-Shortcut to call [indexProperty](#qlistint-indexpropertyconst-qstring-propname-qhashqstring-int-valuemap-qhashint-qvariant-reverselookup-const) without **valueMap** or **reverseLookup** arguments.
+* **function definition:**
  
-### [QList][QList]&lt;int&gt; applyIndex(const [QString][QString] &propName, const [QHash][QHash]&lt;[QString][QString], int&gt; &valueMap) const
+        QList<QPointF> namedPoints() const
  
-Apply a mapping to convert non-integer values to integers. Metadata values associated with **propName** are mapped through the given **valueMap**. If the value is found its integer mapping is appened to the list to be returned. If not, -1 is appened to the list.
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QPointF][QPointF]&gt;) Returns a list of points that can be converted from [metadata](#file-members-m_metadata) values.
+* **example:**
  
-    Template t1, t2, t3, t4;
+        File file;
+        file.set("Key1", QVariant::fromValue<QPointF>(QPointF(1, 1)));
+        file.set("Key2", QVariant::fromValue<QPointF>(QPointF(2, 2)));
+        file.set("Points", QVariant::fromValue<QPointF>(QPointF(3, 3)))
  
-    t1.file.set("Key", QString("Class 1"));
-    t2.file.set("Key", QString("Class 2"));
-    t3.file.set("Key", QString("Class 3"));
-    t4.file.set("Key", QString("Class 1"));
+        f.namedPoints(); // returns [QPointF(1, 1), QPointF(2, 2), QPointF(3, 3)]
  
-    TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+        file.setPoints(QList<QPointF>() << QPointF(3, 3)); // changes metadata["Points"] to QList<QPointF>
+        f.namedPoints(); // returns [QPointF(1, 1), QPointF(2, 2)]
  
-    QHash<QString, int> valueMap;
-    valueMap.insert("Class 1", 0);
-    valueMap.insert("Class 2", 1);
  
-    tList.applyIndex("Key", valueMap); // returns [0, 1, -1, 0]
+### [QList][QList]&lt;[QPointF][QPointF]&gt; points() const {: #file-function-points }
  
-### T bytes() const
+Get values stored in the [metadata](#file-members-m_metadata) with key "Points". It is expected that this field holds a [QList][QList]&lt;[QPointf][QPointF]>&gt;.
  
-This function requires a type specification in place of T. Returns the total number of bytes in the [TemplateList](#templatelist). Calls [bytes()](#size_t-bytes-const) on each [Template](#template) in the list.
+* **function definition:**
  
-    Template t1, t2;
+        QList<QPointF> points() const
  
-    t1.append(Mat::ones(1, 1, CV_8U)); // 1 byte
-    t1.append(Mat::ones(2, 2, CV_8U)); // 4 bytes
-    t2.append(Mat::ones(3, 3, CV_8U)); // 9 bytes
-    t2.append(Mat::ones(4, 4, CV_8U)); // 16 bytes
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QPointf][QPointF]>&gt;) Returns a list of points stored at [metadata](#file-members-m_metadata)["Points"]
+* **see:** [appendPoint](#file-function-appendpoint), [appendPoints](#file-function-appendpoints), [clearPoints](#file-function-clearpoints), [setPoints](#file-function-setpoints)
+* **example:**
  
-    TemplateList tList(QList<Template>() << t1 << t2);
-    tList.bytes(); // returns 30
+        File file;
+        file.set("Points", QVariant::fromValue<QPointF>(QPointF(1, 1)));
+        file.points(); // returns [] (point is not in a list)
  
-### [QList][QList]&lt;[Mat][Mat]&gt; data(int index = 0) const
+        file.setPoints(QList<QPointF>() << QPointF(2, 2));
+        file.points(); // returns [QPointF(2, 2)]
  
-Returns a list of matrices. The list is compiled with one [Mat][Mat] from each [Template][#template] taken at the given index.
  
-    Template t1, t2;
+### void appendPoint(const [QPointF][QPointF] &point) {: #file-function-appendpoint }
  
-    t1.append(Mat::ones(1, 1, CV_8U));
-    t1.append(Mat::zeros(1, 1, CV_8U));
-    t2.append(Mat::ones(1, 1, CV_8U));
-    t2.append(Mat::zeros(1, 1, CV_8U));
+Append a point to the [QList][QList]&lt;[QPointF][QPointF]&gt; stored at [metadata](#file-members-m_metadata)["Points"].
  
-    TemplateList tList(QList<Template>() << t1 << t2);
-    tList.data(); // returns ["1", "1"];
-    tList.data(1); // returns ["0", "0"];
+* **function definition:**
  
-### [QList][QList]&lt;[TemplateList](#templatelist)&gt; partition(const [QList][QList]&lt;int&gt; &partitionSizes) const
+        void appendPoint(const QPointF &point)
  
-Returns a [QList][QList] of [TemplateLists](#templatelist). The number of [TemplateLists](#templatelist) returned is equal to the length of partitionSizes. The number of [Templates](#template) in each returned  [TemplateList](#templatelist) is equal to the number of templates in the orginal [TemplateList](#templatelist). Each [Template](#template) in the original [TemplateList](#templatelist) must have length equal to the sum of the given partition sizes. Each [Template](#template) is divided into partitions and stored in the corresponding [TemplateList](#templatelist).
+* **parameters:**
  
-    Template t1, t2, t3;
+    Parameter | Type | Description
+    --- | --- | ---
+    point | const [QPoint][QPoint] & | Point to be appended
  
-    t1.append(Mat::ones(1, 1, CV_8U));
-    t1.append(2*Mat::ones(1, 1, CV_8U));
-    t1.append(3*Mat::ones(1, 1, CV_8U));
+* **output:** (void)
+* **example:**
  
-    t2.append(4*Mat::ones(1, 1, CV_8U));
-    t2.append(5*Mat::ones(1, 1, CV_8U));
-    t2.append(6*Mat::ones(1, 1, CV_8U));
+        File file;
+        file.points(); // returns []
  
-    t3.append(7*Mat::ones(1, 1, CV_8U));
-    t3.append(8*Mat::ones(1, 1, CV_8U));
-    t3.append(9*Mat::ones(1, 1, CV_8U));
+        file.appendPoint(QPointF(1, 1));
+        file.points(); // returns [QPointF(1, 1)]
  
-    TemplateList tList(QList<Template>() << t1 << t2 << t3);
  
-    QList<TemplateList> partitions = tList.partition(QList<int>() << 1 << 2); // split into 2 partitions. 1 with 1 Mat and 1 with 2 Mats.
+### void appendPoints(const [QList][QList]&lt;[QPointF][QPointF]&gt; &points) {: #file-function-appendpoints }
  
-    partitions[0]; // returns [("1"), ("4"), ("7")]
-    partitions[1]; // returns [("2", "3"), ("5", "6"), ("8", "9")]
+Append a list of points to the [QList][QList]&lt;[QPointF][QPointF]&gt; stored at [metadata](#file-members-m_metadata)["Points"].
  
-### [FileList](#filelist) files() const
+* **function definition:**
  
-Returns a [FileList](#filelist) with the [file](#file-file) of each [Template](#template) in the [TemplateList](#templatelist).
+        void appendPoints(const QList<QPointF> &points)
  
-    Template t1("picture1.jpg"), t2("picture2.jpg");
+* **parameters:**
  
-    t1.file.set("Key", QVariant::fromValue<float>(1));
-    t2.file.set("Key", QVariant::fromValue<float>(2));
+    Parameter | Type | Description
+    --- | --- | ---
+    points | const [QList][QList]&lt;[QPointF][QPointF]&gt; & | List of points to be appended
  
-    TemplateList tList(QList<Template>() << t1 << t2);
+* **output:** (void)
+* **example:**
  
-    tList.files(); // returns ["picture1.jpg[Key=1]", "picture2.jpg[Key=2]"]
+        File file;
+        file.points(); // returns []
  
-### [FileList](#filelist) operator()()
+        file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
+        file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
  
-Returns [files()](#filelist-files-const).
  
-### [QMap][QMap]&lt;T, int&gt; countValues(const [QString][QString] &propName, bool excludeFailures = false) const
+### void clearPoints() {: #file-function-clearpoints }
  
-This function requires a type specification in place of T. Returns the number of occurences for each label in the list. If excludedFailures is true [Files](#file) with [fte](#bool-fte) = true are excluded from the count.
+Remove all points stored at [metadata](#file-members-m_metadata)["Points"].
  
-    Template t1, t2, t3, t4;
+* **function definition:**
  
-    t1.file.set("Key", QString("Class 1"));
-    t2.file.set("Key", QString("Class 2"));
-    t3.file.set("Key", QString("Class 3"));
-    t4.file.set("Key", QString("Class 1"));
+        inline void clearPoints()
  
-    TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+* **parameters:** NONE
+* **output:** (void)
+* **example:**
  
-    tList.countValues<QString>("Key"); // returns QMap(("Class 1", 2), ("Class 2", 1), ("Class 3", 1))
+        File file;
+        file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
+        file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
  
-### [TemplateList](#templatelist) reduced() const
+        file.clearPoints();
+        file.points(); // returns []
  
-Merge all of them templates together and store the resulting template in the list. The merges are done by calling [merge()](#void-merge-const-template-other).
  
-    Template t1("picture1.jpg"), t2("picture2.jpg");
+### void setPoints(const [QList][QList]&lt;[QPointF][QPointF]&gt; &points) {: #file-function-setpoints }
  
-    t1.file.set("Key1", QString("Value1"));
-    t2.file.set("Key2", QString("Value2"));
+Replace the points stored at [metadata](#file-members-m_metadata)["Points"]
  
-    TemplateList tList(QList<Template>() << t1 << t2);
+* **function definition:**
  
-    TemplateList reduced = tList.reduced();
-    reduced.size(); // returns 1
-    reduced.files(); // returns ["picture1.jpg;picture2.jpg[Key1=Value1, Key2=Value2, separator=;]"]
+        inline void setPoints(const QList<QPointF> &points)
  
-### [QList][QList]&lt;int&gt; find(const [QString][QString] &key, const T &value)
+* **parameters:**
  
-This function requires a type specification in place of T. Returns the indices of templates that have the given key-value pairing.
+    Parameter | Type | Description
+    --- | --- | ---
+    points | const [QList][QList]&lt;[QPointF][QPointF]&gt; & | Points to overwrite [metadata](#file-members-m_metadata) with
  
-    Template t1, t2, t3;
+* **output:** (void)
+* **example:**
  
-    t1.file.set("Key", QString("Value1"));
-    t2.file.set("Key", QString("Value2"));
-    t3.file.set("Key", QString("Value2"));
+        File file;
+        file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
+        file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
  
-    TemplateList tList(QList<Template>() << t1 << t2 << t3);
-    tList.find<QString>("Key", "Value2"); // returns [1, 2]
+        file.setPoints(QList<QPointF>() << QPointF(3, 3) << QPointF(4, 4));
+        file.points(); // returns [QPointF(3, 3), QPointF(4, 4)]
  
----
  
-# Context
+### [QList][QList]&lt;[QRectF][QRectF]&gt; namedRects() const {: #file-function-namedrects }
  
----
+Find values in the [metadata](#file-members-m_metadata) that can be converted into [QRectF][QRectF]'s. Values stored as [QList][QList]&lt;[QRectF][QRectF]&gt; *will not** be returned.
  
-# Object
+* **function definition:**
  
----
+        QList<QRectF> namedRects() const
  
-# Factory
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QRectF][QRectF]&gt;) Returns a list of rects that can be converted from [metadata](#file-members-m_metadata) values.
+* **example:**
  
----
+        File file;
+        file.set("Key1", QVariant::fromValue<QRectF>(QRectF(1, 1, 5, 5)));
+        file.set("Key2", QVariant::fromValue<QRectF>(QRectF(2, 2, 5, 5)));
+        file.set("Rects", QVariant::fromValue<QRectF>(QRectF(3, 3, 5, 5)));
  
-# Transform
+        f.namedRects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5), QRectF(3, 3, 5x5)]
  
----
+        file.setRects(QList<QRectF>() << QRectF(3, 3, 5x5)); // changes metadata["Rects"] to QList<QRectF>
+        f.namedRects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
  
-# UntrainableTransform
  
----
+### [QList][QList]&lt;[QRectF][QRectF]&gt; rects() const {: #file-function-rects }
  
-# MetaTransform
+Get values stored at [metadata](#file-members-m_metadata)["Rects"]. It is expected that this field holds a [QList][QList]&lt;[QRectf][QRectF]>&gt;.
  
----
+* **function definition:**
  
-# UntrainableMetaTransform
+        QList<QRectF> points() const
  
----
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QRectf][QRectF]>&gt;) Returns a list of rects stored at [metadata](#file-members-m_metadata)["Rects"]
+* **see:** [appendRect](#file-function-appendrect-1), [appendRects](#file-function-appendrects-1), [clearRects](#file-function-clearrects), [setRects](#file-function-setrects-1)
+* **example:**
  
-# MetadataTransform
+        File file;
+        file.set("Rects", QVariant::fromValue<QRectF>(QRectF(1, 1, 5, 5)));
+        file.rects(); // returns [] (rect is not in a list)
  
----
+        file.setRects(QList<QRectF>() << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(2, 2, 5x5)]
  
-# UntrainableMetadataTransform
  
----
+### void appendRect(const [QRectF][QRectF] &rect) {: #file-function-appendrect-1 }
  
-# TimeVaryingTransform
+Append a rect to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](#file-members-m_metadata)["Rects"].
  
----
+* **function definition:**
  
-# Distance
+        void appendRect(const QRectF &rect)
  
----
+* **parameters:**
  
-# UntrainableDistance
+    Parameter | Type | Description
+    --- | --- | ---
+    rect | const [QRect][QRect] & | Rect to be appended
  
----
+* **output:** (void)
+* **example:**
  
-# Output
+        File file;
+        file.rects(); // returns []
  
----
+        file.appendRect(QRectF(1, 1, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5)]
  
-# MatrixOutput
  
----
+### void appendRect(const [Rect][Rect] &rect) {: #file-function-appendrect-2 }
  
-# Format
+Append an OpenCV-style [Rect][Rect] to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](#file-members-m_metadata)["Rects"]. Supplied OpenCV-style rects are converted to [QRectF][QRectF] before being appended.
  
----
+* **function definition:**
  
-# Representation
+        void appendRect(const Rect &rect)
  
----
+* **parameters:**
  
-# Classifier
+    Parameter | Type | Description
+    --- | --- | ---
+    rect | const [Rect][Rect] & | OpenCV-style rect to be appended
  
+* **output:** (void)
+* **example:**
  
+        File file;
+        file.rects(); // returns []
  
-[QString]: http://doc.qt.io/qt-5/QString.html "QString"
-[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+        file.appendRect(cv::Rect(1, 1, 5, 5)); // automatically converted to QRectF
+        file.rects(); // returns [QRectF(1, 1, 5x5)]
  
-[QList]: http://doc.qt.io/qt-5/QList.html "QList"
-[QMap]: http://doc.qt.io/qt-5/qmap.html "QMap"
-[QHash]: http://doc.qt.io/qt-5/qhash.html "QHash"
  
-[QRectF]: http://doc.qt.io/qt-5/qrectf.html "QRectF"
-[QPointF]: http://doc.qt.io/qt-5/qpointf.html "QPointF"
+### void appendRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects) {: #file-function-appendrects-1 }
  
-[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
-[QVariantList]: http://doc.qt.io/qt-5/qvariant.html#QVariantList-typedef "QVariantList"
-[QVariantMap]: http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef "QVariantMap"
+Append a list of rects to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](#file-members-m_metadata)["Rects"].
+
+* **function definition:**
+
+        void appendRects(const QList<QRectF> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[QRectF][QRectF]&gt; & | List of rects to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.rects(); // returns []
+
+        file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+
+### void appendRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects) {: #file-function-appendrects-2 }
+
+Append a list of OpenCV-style [Rects][Rect] to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](#file-members-m_metadata)["Rects"]. Supplied OpenCV-style rects are converted to [QRectF][QRectF] before being appended.
+
+* **function definition:**
+
+        void appendRects(const QList<QRectF> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[Rect][Rect]&gt; & | List of OpenCV-style rects to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.rects(); // returns []
+
+        file.appendRects(QList<Rect>() << Rect(1, 1, 5, 5) << Rect(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+### void clearRects() {: #file-function-clearrects }
+
+Remove all points stored at [metadata](#file-members-m_metadata)["Rects"].
+
+* **function definition:**
+
+        inline void clearRects()
+
+* **parameters:** NONE
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+        file.clearRects();
+        file.rects(); // returns []
+
+
+### void setRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects) {: #file-function-setrects-1 }
+
+Replace the rects stored at [metadata](#file-members-m_metadata) with a provided list of rects.
+
+* **function definition:**
+
+        inline void setRects(const QList<QRectF> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[QRectF][QRectF]&gt; & | Rects to overwrite [metadata](#file-members-m_metadata)["Rects"] with
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+        file.setRects(QList<QRectF>() << QRectF(3, 3, 5, 5) << QRectF(4, 4, 5, 5));
+        file.rects(); // returns [QRectF(3, 3, 5x5), QRectF(4, 4, 5x5)]
+
+
+### void setRects(const [QList][QList]&lt;[Rect][Rect]&gt; &rects) {: #file-function-setrects-2 }
+
+Replace the rects stored at [metadata](#file-members-m_metadata) with a provided list of OpenCV-style [Rects][Rect].
+
+* **function definition:**
+
+        inline void setRects(const QList<Rect> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[Rect][Rect]&gt; & | OpenCV-style rects to overwrite [metadata](#file-members-m_metadata)["Rects"] with
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendRects(QList<cv::Rect>() << cv::Rect(1, 1, 5, 5) << cv::Rect(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+        file.setRects(QList<cv::Rect>() << cv::Rect(3, 3, 5, 5) << cv::Rect(4, 4, 5, 5));
+        file.rects(); // returns [QRectF(3, 3, 5x5), QRectF(4, 4, 5x5)]
+
+---
+
+# FileList
+
+Inherits [QList][QList]&lt;[File](#file)&gt;.
+
+A convenience class for dealing with lists of files.
+
+## Members {: #filelist-members }
+
+NONE
+
+---
+
+## Constructors {: #filelist-constructors }
+
+Constructor | Description
+--- | ---
+FileList() | Default constructor. Doesn't do anything.
+FileList(int n) | Intialize the [FileList](#filelist) with n empty [Files](#file)
+FileList(const [QStringList][QStringList] &files) | Initialize the [FileList](#filelist) with a list of strings. Each string should have the format "filename[key1=value1, key2=value2, ... keyN=valueN]"
+FileList(const [QList][QList]&lt;[File](#file)&gt; &files) | Initialize the [FileList](#filelist) from a list of [files](#file).
+
+---
+
+## Static Functions {: #filelist-static-functions }
+
+
+### [FileList](#filelist) fromGallery(const [File](#file) &gallery, bool cache = false) {: #filelist-static-fromgallery }
+
+Create a [FileList](#filelist) from a [Gallery](#gallery). Galleries store one or more [Templates](#template) on disk. Common formats include **csv**, **xml**, and **gal**, which is a unique OpenBR format. Read more about this in the [Gallery](#gallery) section. This function creates a [FileList](#filelist) by parsing the stored gallery based on its format. Cache determines whether the gallery should be stored for faster reading later.
+
+* **function definition:**
+
+        static FileList fromGallery(const File &gallery, bool cache = false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | const [File](#file) & | Gallery file to be enrolled
+    cache | bool | (Optional) Retain the gallery in memory. Default is false.
+
+* **output:** ([FileList](#filelist)) Returns the filelist that the gallery was enrolled into
+* **example:**
+
+        File gallery("gallery.csv");
+
+        FileList fList = FileList::fromGallery(gallery);
+        fList.flat(); // returns all the files that have been loaded from disk. It could
+                      // be 1 or 100 depending on what was stored.
+
+---
+
+## Functions {: #filelist-functions }
+
+
+### [QStringList][QStringList] flat() const {: #filelist-function-flat }
+
+Calls [flat](#file-function-flat) on every [File](#file) in the list and returns the resulting strings as a [QStringList][QStringList].
+
+* **function definition:**
+
+        QStringList flat() const
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns a list of the output of calling [flat](#file-function-flat) on each [File](#file)
+* **example:**
+
+        File f1("picture1.jpg"), f2("picture2.jpg");
+        f1.set("Key", QString("Value"));
+
+        FileList fList(QList<File>() << f1 << f2);
+        fList.flat(); // returns ["picture1.jpg[Key=Value]", "picture2.jpg"]
+
+
+### [QStringList][QStringList] names() const {: #filelist-function-names }
+
+Get the [names](#file-members-name) of every [File](#file) in the list.
+
+* **function definition:**
+
+        QStringList names() const
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns the [name](#file-members-name) of every [File](#file) in the list
+* **example:**
+
+        File f1("picture1.jpg"), f2("picture2.jpg");
+        f1.set("Key", QString("Value"));
+
+        FileList fList(QList<File>() << f1 << f2);
+        fList.names(); // returns ["picture1.jpg", "picture2.jpg"]
+
+
+### void sort(const [QString][QString] &key) {: #filelist-function-sort }
+
+Sort the [FileList](#filelist) based on the values associated with a provided key in each [File](#file).
+
+* **function definition:**
+
+        void sort(const QString &key)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to look up desired values in each [Files](#file) [metadata](#file-members-m_metadata)
+
+* **output:** (void)
+* **example:**
+
+        File f1("1"), f2("2"), f3("3");
+        f1.set("Key", QVariant::fromValue<float>(3));
+        f2.set("Key", QVariant::fromValue<float>(1));
+        f3.set("Key", QVariant::fromValue<float>(2));
+
+        FileList fList(QList<File>() << f1 << f2 << f3);
+        fList.names(); // returns ["1", "2", "3"]
+
+        fList.sort("Key");
+        fList.names(); // returns ["2", "3", "1"]
+
+
+### [QList][QList]&lt;int&gt; crossValidationPartitions() const {: #filelist-function-crossvalidationpartitions }
+
+Get the cross-validation partion of each [File](#file) in the list. The partition is stored in each [File](#file) at [metadata](#file-members-m_metadata)["Partition"].
+
+* **function definition:**
+
+        QList<int> crossValidationPartitions() const
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;int&gt;) Returns the cross-validation partion of each [File](#file) as a list. If a [File](#file) does not have the "Partition" field in it's [metadata](#file-members-m_metadata) 0 is used.
+* **example:**
+
+        File f1, f2, f3;
+        f1.set("Partition", QVariant::fromValue<int>(1));
+        f3.set("Partition", QVariant::fromValue<int>(3));
+
+        FileList fList(QList<File>() << f1 << f2 << f3);
+        fList.crossValidationPartitions(); // returns [1, 0, 3]
+
+
+### int failures() const {: #filelist-function-failures }
+
+Get the number of [Files](#file) in the list that have [failed to enroll](#file-members-fte).
+
+* **function definition:**
+
+        int failures() const
+
+* **parameters:** NONE
+* **output:** (int) Returns the number of [Files](#file) that have [fte](#file-members-fte) equal true.
+* **example:**
+
+        File f1, f2, f3;
+        f1.fte = false;
+        f2.fte = true;
+        f3.fte = true;
+
+        FileList fList(QList<File>() << f1 << f2 << f3);
+        fList.failures(); // returns 2
+
+---
+
+# Template
+
+Inherits [QList][QList]&lt;[Mat][Mat]&gt;.
+
+A list of matrices associated with a file.
+
+The Template is one of two important data structures in OpenBR (the [File](#file) is the other).
+A template represents a biometric at various stages of enrollment and can be modified by [Transforms](#transform) and compared to other [templates](#template) with [Distance](#distance).
+
+While there exist many cases (ex. video enrollment, multiple face detects, per-patch subspace learning, ...) where the template will contain more than one matrix,
+in most cases templates have exactly one matrix in their list representing a single image at various stages of enrollment.
+In the cases where exactly one image is expected, the template provides the function m() as an idiom for treating it as a single matrix.
+Casting operators are also provided to pass the template into image processing functions expecting matrices.
+
+Metadata related to the template that is computed during enrollment (ex. bounding boxes, eye locations, quality metrics, ...) should be assigned to the template's [File](#template-members-file) member.
+
+## Members {: #template-members }
+
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=template-members-file></a>file | [File](#file) | The file that constructs the template and stores its associated metadata
+
+---
+
+## Constructors {: #template-constructors }
+
+Constructor | Description
+--- | ---
+Template() | The default template constructor. It doesn't do anything.
+Template(const [File](#file) &file) | Sets [file](#template-members-file) to the given [File](#file).
+Template(const [File](#file) &file, const [Mat][Mat] &mat) | Sets [file](#template-members-file) to the given [File](#file) and appends the given [Mat][Mat] to itself.
+Template(const [Mat][Mat] &mat) | Appends the given [Mat][Mat] to itself
+
+---
+
+## Static Functions {: #template-static-functions }
+
+
+### [QDataStream][QDataStream] &operator<<([QDataStream][QDataStream] &stream, const [Template](#template) &t) {: #template-static-operator-ltlt }
+
+Serialize a template
+
+* **function definition:**
+
+        QDataStream &operator<<(QDataStream &stream, const Template &t)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | The stream to serialize to
+    t | const [Template](#template) & | The template to serialize
+
+* **output:** ([QDataStream][QDataStream] &) Returns the updated stream
+* **example:**
+
+        void store(QDataStream &stream)
+        {
+            Template t("picture.jpg");
+            t.append(Mat::ones(1, 1, CV_8U));
+
+            stream << t; // "["1"]picture.jpg" serialized to the stream
+        }
+
+### [QDataStream][QDataStream] &operator>>([QDataStream][QDataStream] &stream, [Template](#template) &t) {: #template-static-operator-gtgt }
+
+Deserialize a template
+
+* **function definition:**
+
+        QDataStream &operator>>(QDataStream &stream, Template &t)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | The stream to deserialize to
+    t | const [Template](#template) & | The template to deserialize
+
+* **output:** ([QDataStream][QDataStream] &) Returns the updated stream
+* **example:**
+
+        void load(QDataStream &stream)
+        {
+            Template in("picture.jpg");
+            in.append(Mat::ones(1, 1, CV_8U));
+
+            stream << in; // "["1"]picture.jpg" serialized to the stream
+
+            Template out;
+            stream >> out;
+
+            out.file; // returns "picture.jpg"
+            out; // returns ["1"]
+        }
+
+---
+
+## Functions {: #template-functions }
+
+
+### operator const [File](#file) &() const {: #template-function-operator-file }
+
+Idiom to treat the template like a [File](#file).
+
+* **function definition:**
+
+        inline operator const File &() const
+
+* **parameters:** NONE
+* **output:** ([File](#file) Returns [file](#template-members-file).
+
+
+### const [Mat][Mat] &m() const {: #template-function-m-1 }
+
+Idiom to treat the template like a [Mat][Mat].
+
+* **function definition:**
+
+        inline const Mat &m() const
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **example:**
+
+        Template t;
+        t.m(); // returns empty mat
+
+        Mat m1;
+        t.append(m1);
+        t.m(); // returns m1;
+
+        Mat m2;
+        t.append(m2);
+        t.m(); // returns m2;
+
+
+### [Mat][Mat] &m() {: #template-function-m-2 }
+
+Idiom to treat the template like a [Mat][Mat].
+
+* **function definition:**
+
+        inline Mat &m()
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **example:**
+
+        Template t;
+        t.m(); // returns empty mat
+
+        Mat m1;
+        t.append(m1);
+        t.m(); // returns m1;
+
+        Mat m2;
+        t.append(m2);
+        t.m(); // returns m2;
+
+
+### operator const [Mat][Mat] &() {: #template-function-operator-mat-1 }
+
+Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#template-function-m-1).
+
+* **function definition:**
+
+        inline operator const Mat&() const
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#template-function-m-1)
+
+
+### operator [Mat][Mat] &() {: #template-function-operator-mat-2 }
+
+Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#template-function-m-1).
+
+* **function definition:**
+
+        inline operator Mat&()
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#template-function-m-1)
+
+
+### operator [_InputArray][InputArray] &() {: #template-function-operator-inputarray }
+
+Idiom to treat the template like an [_InputArray][InputArray]. Makes a call to [m()](#template-function-m-1).
+
+* **function definition:**
+
+        inline operator _InputArray() const
+
+<!-- _no italics_-->
+* **parameters:** NONE
+* **output:** ([_InputArray][InputArray]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#template-function-m-1)
+
+
+### operator [_OutputArray][OutputArray] &() {: #template-function-operator-outputarray }
+
+Idiom to treat the template like an [_OutputArray][InputArray]. Makes a call to [m()](#template-function-m-1).
+
+* **function definition:**
+
+        inline operator _OutputArray()
+
+<!-- _no italics_-->
+* **parameters:** NONE
+* **output:** ([_OutputArray][OutputArray]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#template-function-m-1)
+
+
+### [Mat][Mat] &operator =(const [Mat][Mat] &other) {: #template-function-operator-e }
+
+Idiom to treat the template like a [Mat][Mat]. Set the result of [m()](#template-function-m-1) equal to other.
+
+* **function definition:**
+
+        inline Mat &operator=(const Mat &other)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const Mat & | Mat to overwrite value of [m](#template-function-m-1)
+
+* **output**: ([Mat][Mat] &) Returns a reference to the updated [Mat][Mat]
+
+
+### bool isNull() const {: #template-function-isnull }
+
+Check if the template is NULL.
+
+* **function definition:**
+
+        inline bool isNull() const
+
+* **parameters:** NONE
+* **output:** (bool) Returns true if the template is empty *or* if [m](#template-function-m-1) has no data.
+* **example:**
+
+        Template t;
+        t.isNull(); // returns true
+
+        t.append(Mat());
+        t.isNull(); // returns true
+
+        t.append(Mat::ones(1, 1, CV_8U));
+        t.isNull(); // returns false
+
+
+### void merge(const [Template](#template) &other) {: #template-function-merge }
+
+Append the contents of another template. The [files](#template-members-file) are appended using [append](#file-function-append-1).
+
+* **function definition:**
+
+        inline void merge(const Template &other)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [Template][#template] & | Template to be merged
+
+* **output:** (void)
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+        Mat m1, m2;
+
+        t1.append(m1);
+        t2.append(m2);
+
+        t1.merge(t2);
+
+        t1.file; // returns picture1.jpg;picture2.jpg[seperator=;]
+        t1; // returns [m1, m2]
+
+
+### size_t bytes() const {: #template-function-bytes }
+
+Get the total number of bytes in the template
+
+* **function definition:**
+
+        size_t bytes() const
+
+* **parameters:** None
+* **output:** (int) Returns the sum of the bytes in each [Mat][Mat] in the [Template](#template)
+* **example:**
+
+        Template t;
+
+        Mat m1 = Mat::ones(1, 1, CV_8U); // 1 byte
+        Mat m2 = Mat::ones(2, 2, CV_8U); // 4 bytes
+        Mat m3 = Mat::ones(3, 3, CV_8U); // 9 bytes
+
+        t << m1 << m2 << m3;
+
+        t.bytes(); // returns 14
+
+
+### Template clone() const {: #template-function-clone }
+
+Clone the template
+
+* **function definition:**
+
+        Template clone() const
+
+* **parameters:** NONE
+* **output:** ([Template](#template)) Returns a new [Template](#template) with copies of the [file](#template-members-file) and each [Mat][Mat] that was in the original.
+* **example:**
+
+        Template t1("picture.jpg");
+        t1.append(Mat::ones(1, 1, CV_8U));
+
+        Template t2 = t1.clone();
+
+        t2.file; // returns "picture.jpg"
+        t2; // returns ["1"]
+
+---
+
+# TemplateList
+
+Inherits [QList][QList]&lt;[Template][#template]&gt;.
+
+Convenience class for working with a list of templates.
+
+## Members {: #templatelist-members }
+
+NONE
+
+---
+
+## Constructors {: #templatelist-constructors }
+
+Constructor | Description
+--- | ---
+TemplateList() | The default [TemplateList](#templatelist) constructor. Doesn't do anything.
+TemplateList(const [QList][QList]&lt;[Template](#template)&gt; &templates) | Initialize the [TemplateList](#templatelist) with a list of templates. The given list is appended
+TemplateList(const [QList][QList]&lt;[File](#file)&gt; &files) | Initialize the [TemplateList](#templatelist) with a list of [Files](#file). Each [File](#file) is treated like a template and appended.
+
+---
+
+## Static Functions {: #templatelist-static-functions }
+
+### [TemplateList](#templatelist) fromGallery(const [File](#file) &gallery) {: #templatelist-static-fromgallery }
+
+Create a [TemplateList](#templatelist) from a gallery [File](#file).
+
+* **function definition:**
+
+        static TemplateList fromGallery(const File &gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | const [File](#file) & | Gallery [file](#file) to be enrolled.
+
+* **output:** ([TemplateList](#templatelist)) Returns a [TemplateList](#templatelist) created by enrolling the gallery.
+
+
+### [TemplateList](#templatelist) fromBuffer(const [QByteArray][QByteArray] &buffer) {: #templatelist-static-frombuffer }
+
+Create a template from a memory buffer of individual templates. This is compatible with **.gal** galleries.
+
+* **function definition:**
+
+        static TemplateList fromBuffer(const QByteArray &buffer)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    buffer | const [QByteArray][QByteArray] & | Raw data buffer to be enrolled
+
+* **output:** ([TemplateList][TemplateList]) Returns a [TemplateList](#templatelist) created by enrolling the buffer
+
+
+### [TemplateList](#templatelist) relabel(const [TemplateList](#templatelist) &tl, const [QString][QString] &propName, bool preserveIntegers) {: #templatelist-static-relabel }
+
+Relabel the values associated with a given key in the [metadata](#file-members-m_metadata) of a provided [TemplateList](#templatelist). The values are relabeled to be between [0, numClasses-1]. If preserveIntegers is true and the [metadata](#file-members-m_metadata) can be converted to integers then numClasses equals the maximum value in the values. Otherwise, numClasses equals the number of unique values. The relabeled values are stored in the "Label" field of the returned [TemplateList](#templatelist).
+
+* **function definition:**
+
+        static TemplateList relabel(const TemplateList &tl, const QString &propName, bool preserveIntegers)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tl | const [TemplateList](#templatelist) & | [TemplateList](#templatelist) to be relabeled
+    propName | const [QString][QString] & | [Metadata](#file-members-m_metadata) key
+    preserveIntegers | bool | If true attempt to use the [metadata](#file-members-m_metadata) values as the relabeled values. Otherwise use the number of unique values.
+
+* **output:** ([TemplateList](#templatelist)) Returns a [TemplateList](#templatelist) identical to the input [TemplateList](#templatelist) but with the new labels appended to the [metadata](#file-members-m_metadata) using the "Label" key.
+* **example:**
+
+        Template t1, t2, t3;
+
+        t1.file.set("Class", QString("1"));
+        t2.file.set("Class", QString("10"));
+        t3.file.set("Class", QString("100"));
+        TemplateList tList(QList<Template>() << t1 << t2 << t3);
+
+        TemplateList relabeled = TemplateList::relabel(tList, "Class", true);
+        relabeled.files(); // returns [[Class=1, Label=1], [Class=10, Label=10], [Class=100, Label=100]]
+
+        relabeled = TemplateList::relabel(tList, "Class", false);
+        relabeled.files(); // returns [[Class=1, Label=0], [Class=10, Label=1], [Class=100, Label=2]]
+
+---
+
+## Functions {: #templatelist-functions }
+
+### [QList][QList]&lt;int&gt; indexProperty(const [QString][QString] &propName, [QHash][QHash]&lt;[QString][QString], int&gt; &valueMap, [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; &reverseLookup) const {: #templatelist-function-indexproperty-1 }
+
+Convert [metadata](#file-members-m_metadata) values associated with **propName** to integers. Each unique value gets its own integer. This is useful in many classification problems where nominal data (e.g "Male", "Female") needs to represented with integers ("Male" = 0, "Female" = 1). **valueMap** and **reverseLookup** are created to allow easy conversion to the integer replacements and back.
+
+* **function definition:**
+
+        QList<int> indexProperty(const QString &propName, QHash<QString, int> &valueMap, QHash<int, QVariant> &reverseLookup) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](#file-members-m_metadata) key
+    valueMap | [QHash][QHash]&lt;[QString][QString], int&gt; & | A mapping from [metadata](#file-members-m_metadata) values to the equivalent unique index. [QStrings][QString] are used instead of [QVariant][QVariant] so comparison operators can be used. This is filled in by the function and can be provided empty.
+    reverseLookup | [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; & | A mapping from the unique index to the original value. This is the *reverse* mapping of the **valueMap**. This is filled in by the function and can be provided empty.
+
+* **output:** ([QList][QList]&lt;int&gt;) Returns a list of unique integers that can be mapped to the [metadata](#file-members-m_metadata) values associated with **propName**. The integers can be mapped to their respective values using **valueMap** and the values can be mapped to the integers using **reverseLookup**.
+* **example:**
+
+        Template t1, t2, t3, t4;
+
+        t1.file.set("Key", QString("Class 1"));
+        t2.file.set("Key", QString("Class 2"));
+        t3.file.set("Key", QString("Class 3"));
+        t4.file.set("Key", QString("Class 1"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+
+        QHash<QString, int> valueMap;
+        QHash<int, QVariant> reverseLookup;
+        tList.indexProperty("Key", valueMap, reverseLookup); // returns [0, 1, 2, 0]
+        valueMap; // returns QHash(("Class 1", 0)("Class 2", 1)("Class 3", 2))
+        reverseLookup; // QHash((0, QVariant(QString, "Class 1")) (2, QVariant(QString, "Class 3")) (1, QVariant(QString, "Class 2")))  
+
+
+### [QList][QList]&lt;int&gt; indexProperty(const [QString][QString] &propName, [QHash][QHash]&lt;[QString][QString], int&gt; \*valueMap=NULL, [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; \*reverseLookup=NULL) const {: #templatelist-function-indexproperty-2 }
+
+Shortcut to call [indexProperty](#templatelist-function-indexproperty-1) without **valueMap** or **reverseLookup** arguments.
+
+* **function definition:**
+
+        QList<int> indexProperty(const QString &propName, QHash<QString, int> * valueMap=NULL,QHash<int, QVariant> * reverseLookup = NULL) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](#file-members-m_metadata) key
+    valueMap | [QHash][QHash]&lt;[QString][QString], int&gt; \* | (Optional) A mapping from [metadata](#file-members-m_metadata) values to the equivalent unique index. [QStrings][QString] are used instead of [QVariant][QVariant] so comparison operators can be used. This is filled in by the function and can be provided empty.
+    reverseLookup | [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; \* | (Optional) A mapping from the unique index to the original value. This is the *reverse* mapping of the **valueMap**. This is filled in by the function and can be provided empty.
+
+* **output:** ([QList][QList]&lt;int&gt;) Returns a list of unique integers that can be mapped to the [metadata](#file-members-m_metadata) values associated with **propName**. The integers can be mapped to their respective values using **valueMap** (if provided) and the values can be mapped to the integers using **reverseLookup** (if provided).
+
+
+### [QList][QList]&lt;int&gt; applyIndex(const [QString][QString] &propName, const [QHash][QHash]&lt;[QString][QString], int&gt; &valueMap) const {: #templatelist-function-applyindex }
+
+Apply a mapping to convert non-integer values to integers. [Metadata](#file-members-m_metadata) values associated with **propName** are mapped through the given **valueMap**.
+
+* **function definition:**
+
+        QList<int> applyIndex(const QString &propName, const QHash<QString, int> &valueMap) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](#file-members-m_metadata) key
+    valueMap | const [QHash][QHash]&lt;[QString][QString], int&gt; & | (Optional) A mapping from [metadata](#file-members-m_metadata) values to the equivalent unique index. [QStrings][QString] are used instead of [QVariant][QVariant] so comparison operators can be used.
+
+* **output:** ([Qlist][QList]&lt;int&gt;) Returns a list of integer values. The values are ordered in the same order as the [Templates](#template) in the list. The values are calculated like so:
+
+    1. If the value *is* found in the **valueMap**, its integer mapping is appened to the list.
+    2. If the value *is not* found in the **valueMap**, -1 is appened to the list.
+
+* **example:**
+
+        Template t1, t2, t3, t4;
+
+        t1.file.set("Key", QString("Class 1"));
+        t2.file.set("Key", QString("Class 2"));
+        t3.file.set("Key", QString("Class 3"));
+        t4.file.set("Key", QString("Class 1"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+
+        QHash<QString, int> valueMap;
+        valueMap.insert("Class 1", 0);
+        valueMap.insert("Class 2", 1);
+
+        tList.applyIndex("Key", valueMap); // returns [0, 1, -1, 0]
+
+
+### <tt>T</tt> bytes() const {: #templatelist-function-bytes }
+
+Get the total number of bytes in the [TemplateList](#templatelist).
+
+* **function definition:**
+
+        template <typename T> T bytes() const
+
+* **parameters:** NONE
+* **output:** (<tt>T</tt>) Returns the sum of the bytes in each of the [Templates](#template) in the list. <tt>T</tt> is a user specified type. It is expected to be numeric (int, float etc.)
+* **see:** [bytes](#template-function-bytes)
+* **example:**
+
+        Template t1, t2;
+
+        t1.append(Mat::ones(1, 1, CV_8U)); // 1 byte
+        t1.append(Mat::ones(2, 2, CV_8U)); // 4 bytes
+        t2.append(Mat::ones(3, 3, CV_8U)); // 9 bytes
+        t2.append(Mat::ones(4, 4, CV_8U)); // 16 bytes
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+        tList.bytes(); // returns 30
+
+
+### [QList][QList]&lt;[Mat][Mat]&gt; data(int index = 0) const {: #templatelist-function-data }
+
+Get a list of matrices compiled from each [Template](#template) in the list.
+
+* **function definition:**
+
+        QList<cv::Mat> data(int index = 0) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | (Optional) Index into each [Template](#template) to select a [Mat][Mat]. Default is 0.
+
+* **output:** ([QList][QList]&lt;[Mat][Mat]&gt;) Returns a list of [Mats][Mat]. One [Mat][Mat] is supplied by each [Template](#template) in the image at the specified index.
+* **example:**
+
+        Template t1, t2;
+
+        t1.append(Mat::ones(1, 1, CV_8U));
+        t1.append(Mat::zeros(1, 1, CV_8U));
+        t2.append(Mat::ones(1, 1, CV_8U));
+        t2.append(Mat::zeros(1, 1, CV_8U));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+        tList.data(); // returns ["1", "1"];
+        tList.data(1); // returns ["0", "0"];
+
+
+### [QList][QList]&lt;[TemplateList](#templatelist)&gt; partition(const [QList][QList]&lt;int&gt; &partitionSizes) const {: #templatelist-function-partition }
+
+Divide the [TemplateList](#templatelist) into a list of [TemplateLists](#templatelist) partitions.
+
+ * **function defintion:**
+
+        QList<TemplateList> partition(const QList<int> &partitionSizes) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    partitionSizes | [QList][QList]&lt;int&gt; | A list of sizes for the partitions. The total number of partitions is equal to the length of this list. Each value in this list specifies the number of [Mats][Mat] that should be in each template of the associated partition. The sum of values in this list *must* equal the number of [Mats][Mat] in each [Template](#template) in the original [TemplateList](#templatelist).
+
+* **output:** ([QList][QList]&lt;[TemplateList](#templatelist)&gt;) Returns a [QList][QList] of [TemplateLists](#templatelist) of partitions. Each partition has length equal to the number of templates in the original [TemplateList](#templatelist). Each [Template](#template) has length equal to the size specified in the associated value in **partitionSizes**.
+* **example:**
+
+        Template t1, t2, t3;
+
+        t1.append(Mat::ones(1, 1, CV_8U));
+        t1.append(2*Mat::ones(1, 1, CV_8U));
+        t1.append(3*Mat::ones(1, 1, CV_8U));
+
+        t2.append(4*Mat::ones(1, 1, CV_8U));
+        t2.append(5*Mat::ones(1, 1, CV_8U));
+        t2.append(6*Mat::ones(1, 1, CV_8U));
+
+        t3.append(7*Mat::ones(1, 1, CV_8U));
+        t3.append(8*Mat::ones(1, 1, CV_8U));
+        t3.append(9*Mat::ones(1, 1, CV_8U));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3);
+
+        QList<TemplateList> partitions = tList.partition(QList<int>() << 1 << 2); // split into 2 partitions. 1 with 1 Mat and 1 with 2 Mats.
+
+        partitions[0]; // returns [("1"), ("4"), ("7")]
+        partitions[1]; // returns [("2", "3"), ("5", "6"), ("8", "9")]
+
+### [FileList](#filelist) files() const {: #templatelist-function-files }
+
+Get a list of all the [Files](#file) in the [TemplateList](#templatelist)
+
+* **function definition:**
+
+        FileList files() const
+
+* **parameters:** NONE
+* **output:** ([FileList](#filelist)) Returns a [FileList](#filelist) with the [file](#template-members-file) of each [Template](#template) in the [TemplateList](#templatelist).
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+
+        t1.file.set("Key", QVariant::fromValue<float>(1));
+        t2.file.set("Key", QVariant::fromValue<float>(2));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+
+        tList.files(); // returns ["picture1.jpg[Key=1]", "picture2.jpg[Key=2]"]
+
+
+### [FileList](#filelist) operator()() {: #templatelist-function-operator-pp }
+
+Shortcut call to [files](#templatelist-function-files)
+
+* **function definition:**
+
+        FileList operator()() const
+
+* **parameters:** NONE
+* **output:** ([FileList](#filelist)) Returns a [FileList](#filelist) with the [file](#template-members-file) of each [Template](#template) in the [TemplateList](#templatelist).
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+
+        t1.file.set("Key", QVariant::fromValue<float>(1));
+        t2.file.set("Key", QVariant::fromValue<float>(2));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+
+        tList.files(); // returns ["picture1.jpg[Key=1]", "picture2.jpg[Key=2]"]
+
+
+### [QMap][QMap]&lt;T, int&gt; countValues(const [QString][QString] &propName, bool excludeFailures = false) const {: #templatelist-function-countvalues }
+
+Get the frequency of each unique value associated with a provided [metadata](#file-members-m_metadata) key.
+
+* **function definition:**
+
+template<typename T> QMap<T,int> countValues(const QString &propName, bool excludeFailures = false) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](#file-members-m_metadata) key
+    excludeFailures | bool | (Optional) Exclude [File](#file) [metadata](#file-members-m_metadata) if the [File](#file) has [fte](#file-members-fte) equal to true. Default is false
+
+* **output:** ([QMap][QMap]&lt;<T, int&gt;) Returns a mapping between unique [metadata](#file-members-m_metadata) and their frequency.
+* **example:**
+
+        Template t1, t2, t3, t4;
+
+        t1.file.set("Key", QString("Class 1"));
+        t2.file.set("Key", QString("Class 2"));
+        t3.file.set("Key", QString("Class 3"));
+        t4.file.set("Key", QString("Class 1"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+
+        tList.countValues<QString>("Key"); // returns QMap(("Class 1", 2), ("Class 2", 1), ("Class 3", 1))
+
+### [TemplateList](#templatelist) reduced() const {: #templatelist-function-reduced }
+
+Reduce the [Templates](#template) in the [TemplateList](#templatelist) by merging them together.
+
+* **function definition:**
+
+        TemplateList reduced() const
+
+* **parameters:** NONE
+* **output:** ([TemplateList](#templatelist)) Returns a [TemplateList](#templatelist) with a single [Template](#template). The [Template](#template) is the result of calling [merge](#template-function-merge) on every [Template](#template).
+* **see:** [merge](#template-function-merge)
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+
+        t1.file.set("Key1", QString("Value1"));
+        t2.file.set("Key2", QString("Value2"));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+
+        TemplateList reduced = tList.reduced();
+        reduced.size(); // returns 1
+        reduced.files(); // returns ["picture1.jpg;picture2.jpg[Key1=Value1, Key2=Value2, separator=;]"]
+
+### [QList][QList]&lt;int&gt; find(const [QString][QString] &key, const T &value) {: #templatelist-function-find }
+
+Get the indices of every [Template](#template) that has a provided key value pairing in its [metadata](#file-members-m_metadata)
+
+* **function definition:**
+
+        template<typename T> QList<int> find(const QString &key, const <tt>T</tt> &value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | [Metadata](#file-members-m_metadata) key to search for
+    value | const <tt>T</tt> & | Value to search for. Both the **key** and value must match. <tt>T</tt> is a user specified type.
+
+* **output:** ([QList][QList]&lt;int&gt;) Returns a list of indices for [Templates](#template) that contained the key-value pairing in their [metadata](#file-members-m_metadata)
+* **example:**
+
+        Template t1, t2, t3;
+
+        t1.file.set("Key", QString("Value1"));
+        t2.file.set("Key", QString("Value2"));
+        t3.file.set("Key", QString("Value2"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3);
+        tList.find<QString>("Key", "Value2"); // returns [1, 2]
+
+---
+
+# Factory
+
+For run time construction of objects from strings.
+
+Uses the Industrial Strength Pluggable Factory model described [here](http://adtmag.com/articles/2000/09/25/industrial-strength-pluggable-factories.aspx).
+
+The factory might be the most important construct in OpenBR. It is what enables the entire plugin architecture to function. All plugins in OpenBR are children of the [Object](#object) type. At compile time, each plugin is registered in the factory using the plugin name and abstraction type ([Transform](#transform), [Distance](#distance), etc.). At runtime, OpenBR utilizes
+
+## Members {: #factory-members }
+
+Member | Type | Description
+--- | --- | ---
+registry | static [QMap][QMap]&lt;[QString][QString],[Factory](#factory)&lt;<tt>T</tt>&gt;\*&gt; | Registered
+
+---
+
+# Object
+
+---
+
+# Context
+
+The singleton class of global settings. Before including and using OpenBR in a project the user must call [initialize](#context-static-initialize). Before the program terminates the user must call [finalize](#context-static-finalize). The settings are accessible as Context \*Globals.
+
+## Members {: #context-members }
+
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=context-members-sdkpath></a>sdkPath | [QString][QString] | Path to the sdk. Path + **share/openbr/openbr.bib** must exist.
+<a class="table-anchor" id=context-members-algorithm></a>algorithm | [QString][QString] | The default algorithm to use when enrolling and comparing templates.
+<a class="table-anchor" id=context-members-log></a>log | [QString][QString] | Optional log file to copy **stderr** to.
+<a class="table-anchor" id=context-members-path></a>path | [QString][QString] | Path to use when resolving images specified with relative paths. Multiple paths can be specified using a semicolon separator.
+<a class="table-anchor" id=context-members-parallelism></a>parallelism | int | The number of threads to use. The default is the maximum of 1 and the value returned by ([QThread][QThread]::idealThreadCount() + 1).
+<a class="table-anchor" id=context-members-usegui></a>useGui | bool | Whether or not to use GUI functions. The default is true.
+<a class="table-anchor" id=context-members-blocksize></a>blockSize | int | The maximum number of templates to process in parallel. The default is: ```parallelism * ((sizeof(void*) == 4) ? 128 : 1024)```
+<a class="table-anchor" id=context-members-quiet></a>quiet | bool | If true, no messages will be sent to the terminal. The default is false.
+<a class="table-anchor" id=context-members-verbose></a>verbose | bool | If true, extra messages will be sent to the terminal. The default is false.
+<a class="table-anchor" id=context-members-mostrecentmessage></a>mostRecentMessage | [QString][QString] | The most recent message sent to the terminal.
+<a class="table-anchor" id=context-members-currentstep></a>currentStep | double | Used internally to compute [progress](#context-function-progress) and [timeRemaining](#context-function-timeremaining).
+<a class="table-anchor" id=context-members-totalsteps></a>totalSteps | double | Used internally to compute [progress](#context-function-progress) and [timeRemaining](#context-function-timeremaining).
+<a class="table-anchor" id=context-members-enrollall></a>enrollAll | bool | If true, enroll 0 or more templates per image. Otherwise, enroll exactly one. The default is false.
+<a class="table-anchor" id=context-members-filters></a>filters | Filters | Filters is a ```typedef QHash<QString,QStringList> Filters```. Filters that automatically determine imposter matches based on target ([gallery](#gallery)) template metadata. See [FilterDistance](plugins/distance.md#filterdistance).
+<a class="table-anchor" id=context-members-buffer></a>buffer | [QByteArray][QByteArray] | File output is redirected here if the file's basename is "buffer". This clears previous contents.
+<a class="table-anchor" id=context-members-scorenormalization></a>scoreNormalization | bool | If true, enable score normalization. Otherwise disable it. The default is true.
+<a class="table-anchor" id=context-members-crossValidate></a>crossValidate | int | Perform k-fold cross validation where k is the value of **crossValidate**. The default value is 0.
+<a class="table-anchor" id=context-members-modelsearch></a>modelSearch | [QList][QList]&lt;[QString][QString]&gt; | List of paths to search for sub-models on.
+<a class="table-anchor" id=context-members-abbreviations></a>abbreviations | [QHash][QHash]&lt;[QString][QString], [QString][QString]&gt; | Used by [Transform](#transform)::[make](#transform-function-make) to expand abbreviated algorithms into their complete definitions.
+<a class="table-anchor" id=context-members-starttime></a>startTime | [QTime][QTime] | Used to estimate [timeRemaining](#context-function-timeremaining).
+<a class="table-anchor" id=context-members-logfile></a>logFile | [QFile][QFile] | Log file to write to.
+
+---
+
+## Constructors {: #context-constructors }
+
+NONE
+
+---
+
+## Static Functions {: #context-static-functions }
+
+### void initialize(int &argc, char \*argv[], [QString][QString] sdkPath = "", bool useGui = true) {: #context-static-initialize }
+
+Call *once* at the start of the application to allocate global variables. If the project is a [Qt][Qt] project this call should occur after initializing <tt>QApplication</tt>.
+
+* **function definition:**
+
+        static void initialize(int &argc, char *argv[], QString sdkPath = "", bool useGui = true);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    argc | int & | Number of command line arguments as provided by <tt>main()</tt>
+    argv | char * [] | Command line arguments as provided by <tt>main()</tt>
+    sdkPath | [QString][QString] | (Optional) The path to the folder containing **share/openbr/openbr.bib**. If no path is provided (default) OpenBR automatically searches: <ul> <li>The working directory</li> <li>The executable's location</li> </ul>
+    useGui | bool | (Optional) Make OpenBR as a [QApplication][QApplication] instead of a [QCoreApplication][QCoreApplication]. Default is true.
+
+* **output:** (void)
+* **see:** [finalize](#context-static-finalize)
+* **example:**
+
+        int main(int argc, char \*argv[])
+        {
+            QApplication(argc, argv); // ONLY FOR QT PROJECTS
+            br::Context::initialize(argc, argv);
+
+            // ...
+
+            br::Context::finalize();
+            return 0;
+        }
+
+### void finalize() {: #context-static-finalize }
+
+Call *once* at the end of the application to deallocate global variables.
+
+* **function definition:**
+
+        static void finalize();
+
+* **parameters:** NONE
+* **output:** (void)
+* **see:** [initialize](#context-static-initialize)
+
+
+### bool checkSDKPath(const [QString][QString] &sdkPath) {: #context-static-checksdkpath }
+
+Check if a given SDK path is valid. A valid SDK satisfies
+
+    exists(sdkPath + "share/openbr/openbr.bib")
+
+* **function definition:**
+
+        static bool checkSDKPath(const QString &sdkPath);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    sdkPath | const [QString][QString] & | Possible sdk path to examine
+
+* **output:** (bool) Returns true if the sdkPath + "share/openbr/openbr.bib" exists, otherwise returns false.
+* **example:**
+
+        // OpenBR is at /libs/openbr
+
+        checkSDKPath("/libs/openbr/"); // returns true
+        checkSDKPath("/libs/"); // returns false
+
+### [QString][QString] about() {: #context-static-about }
+
+Get a string with the name, version, and copyright of the project. This string is suitable for printing or terminal.
+
+* **function definition:**
+
+        static QString about();
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a string containing the name, version and copyright of the project
+* **example:**
+
+        // Using OpenBR version 0.6.0
+        Context::about(); // returns "OpenBR 0.6.0 Copyright (c) 2013 OpenBiometrics. All rights reserved."
+
+### [QString][QString] version() {: #context-static-version }
+
+Get the version of the SDK.
+
+* **function definition:**
+
+        static QString version();
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a string containing the version of the OpenBR SDK. The string has the format *<MajorVersion\>*\.*<MinorVersion\>*\.*<PatchVersion\>*
+* **example:**
+
+        // Using OpenBR version 0.6.0
+        Context::version(); // returns "0.6.0"
+
+### [QString][QString] scratchPath() {: #context-static-scratchpath }
+
+Get the scratch directory used by OpenBR. This directory should be used as the root directory for managing temporary files and providing process persistence.
+
+* **function definition:**
+
+        static QString scratchPath();
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a string pointing to the OpenBR scratch directory. The string has the format *<path/to/user/home\><OpenBR-\><MajorVersion\>*\.*<MinorVersion\>*.
+* **see:** [version](#context-static-version)
+* **example:**
+
+        // Using OpenBR version 0.6.0
+        Context::scratchPath(); // returns "/path/to/user/home/OpenBR-0.6"
+
+### [QStringList][QStringList] objects(const char \*abstractions = ".\*", const char \*implementations = ".\*", bool parameters = true) {: #context-static-objects }
+
+Get a collection of objects in OpenBR that match provided regular expressions. This function uses [QRegExp][QRegExp] syntax.
+
+* **function definition:**
+
+        static QStringList objects(const char *abstractions = ".*", const char *implementations = ".*", bool parameters = true)
+
+* **parameters:**
+
+        Parameter | Type | Description
+        --- | --- | ---
+        abstractions | const char \* | (Optional) Regular expression of the abstractions to search. Default is ".\*"
+        implementations | const char \* | (Optional) Regular expression of the implementations to search. Default is ".\*".
+        parameters | bool | (Optional) If true include parameters after object name. Default is true.
+
+* **output:** ([QStringList][QStringList]) Return names and parameters for the requested objects. Each object is newline separated. Arguments are separated from the object name with tabs.
+* **example:**
+
+        // Find all 'Rnd' Transforms
+        Context::objects("Transform", "Rnd.*", false); // returns ["RndPoint", "RndRegion", "RndRotate", "RndSample", "RndSubspace"]
+
+<!-- no italics* -->
+
+---
+
+## Functions {: #context-functions }
+
+
+### bool contains(const [QString][QString] &name) {: #context-function-contains }
+
+Check if a property exists in the [global metadata](#context).
+
+* **function definition:**
+
+        bool contains(const QString &name);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    name | const [QString][QString] & | [Metadata](#context) key. It must be queryable using [QObject::property][QObject::property].
+
+* **output:** (bool) Returns true if the provided key is a global property.
+* **see:** [setProperty](#context-function-setproperty)
+* **example:**
+
+        Globals->contains("path"); // returns true
+        Globals->contains("key"); // returns false
+
+
+### void setProperty(const [QString][QString] &key, const [QString][QString] &value) {: #context-function-setproperty }
+
+Set a global property.
+
+* **function definition:**
+
+        void setProperty(const QString &key, const QString &value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | [Metadata](#context) key
+    value | const [QString][QString] & | Value to be added to the [Metadata](#context)
+
+* **output:** (void)
+* **see:** [contains](#context-function-contains)
+* **example:**
+
+        Globals->contains("key"); // returns false
+        Globals->setProperty("key", "value");
+        Globals->contains("key"); // returns true
+
+
+### void printStatus() {: #context-function-printstatus }
+
+Prints the current progress statistics to **stdout**.
+
+* **function definition:**
+
+void printStatus();
+
+* **parameters:** NONE
+* **output:** (void)
+* **see:** [progress](#context-function-progress)
+* **example:**
+
+        Globals->printStatus(); // returns 00.00%  ELAPSED=00:00:00  REMAINING=99:99:99  COUNT=0
+
+
+### int timeRemaining() const {: #context-function-timeremaining }
+
+Get the time remaining in seconds of a call to [Train](#function-train), [Enroll](#function-enroll-1) or [Compare](#function-compare).
+
+* **function defintion:**
+
+        int timeRemaining() const;
+
+* **parameters:** NONE
+* **output:** (int) Returns the estimated time remaining in the currently running process. If not process is running returns -1.
+
+### float progress() {: #context-function-progress }
+
+Get the completion percentage of a call to [Train](#function-train), [Enroll](#function-enroll-1), or [Compare](#function-compare).
+
+* **function definition:**
+
+        float progress() const;
+
+* **parameters:** NONE
+* **output:** (float) Returns the fraction of the currently running job that has been completed.
+
+---
+
+# Initializer
+
+Inherits [Object](#object)
+
+Plugin base class for initializing resources. On startup (the call to [Context](#context)::(initialize)(#context-static-initialize)), OpenBR will call [initialize](#initializer-function-initialize) on every Initializer that has been registered with the [Factory](#factory). On shutdown (the call to [Context](#context)::(finalize)(#context-static-finalize)), OpenBR will call [finalize](#initializer-function-finalize) on every registered initializer.
+
+The general use case for initializers is to launch shared contexts for third party integrations into OpenBR. These cannot be launched during [Transform](#transform)::(init)(#transform-function-init) for example, because multiple instances of the [Transform](#transform) object could exist across multiple threads.
+
+## Members {: #initializer-members }
+
+NONE
+
+## Constructors {: #initializer-constructors }
+
+Destructor | Description
+--- | ---
+virtual ~Initializer() | Virtual function. Default destructor.
+
+## Static Functions {: #initializer-static-functions }
+
+NONE
+
+## Functions {: #initializer-functions }
+
+### virtual void initialize() const {: #initializer-function-initialize }
+
+Initialize
+
+* **function definition:**
+
+        virtual void initialize() const = 0
+
+---
+
+# Transform
+
+Inherits [Object](#object)
+
+---
+
+# UntrainableTransform
+
+Inherits [Object](#object)
+
+---
+
+# MetaTransform
+
+Inherits [Object](#object)
+
+---
+
+# UntrainableMetaTransform
+
+Inherits [Object](#object)
+
+---
+
+# MetadataTransform
+
+Inherits [Object](#object)
+
+---
+
+# UntrainableMetadataTransform
+
+Inherits [Object](#object)
+
+---
+
+# TimeVaryingTransform
+
+Inherits [Object](#object)
+
+---
+
+# Distance
+
+Inherits [Object](#object)
+
+---
+
+# UntrainableDistance
+
+Inherits [Object](#object)
+
+---
+
+# Output
+
+Inherits from [Object](#object)
+
+## Properties {: #output-properties }
+
+Property | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=output-properties-blockrows></a>blockRows | int | DOCUMENT ME
+<a class="table-anchor" id=output-properties-blockcols></a>blockCols | int | DOCUMENT ME
+
+## Members {: #output-members }
+
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=output-members-targetfiles></a>targetFiles | [FileList][#filelist] | DOCUMENT ME
+<a class="table-anchor" id=output-members-queryfiles></a>queryFiles | [FileList](#filelist) | DOCUMENT ME
+<a class="table-anchor" id=output-members-selfsimilar></a>selfSimilar | bool | DOCUMENT ME
+<a class="table-anchor" id=output-members-next></a>next | [QSharedPointer][QSharedPointer]<[Output](#output)> | DOCUMENT ME
+<a class="table-anchor" id=output-members-offset></a>offset | [QPoint][QPoint] | DOCUMENT ME
+
+## Constructors {: #output-constructors }
+
+Constructor \| Destructor | Description
+--- | ---
+virtual ~Output() | DOCUMENT ME
+
+## Static Functions {: #output-static-functions }
+
+### Output \*make(const [File][#file] &file, const [FileList](#filelist) &targetFiles, const [FileList](#filelist) &queryFiles) {: #output-function-make}
+
+DOCUMENT ME
+
+* **function definition:**
+
+		static Output *make(const File &file, const FileList &targetFiles, const FileList &queryFiles)
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	file | const [File](#file) & | DOCUMENT ME
+	targetFiles | const [FileList](#filelist) & | DOCUMENT ME
+	queryFiles | const [FileList](#filelist) & | DOCUMENT ME
+
+* **output:** ([Output](#output)) DOCUMENT ME
+
+
+## Functions {: #output-functions }
+
+### virtual void initialize(const [FileList](#filelist) &targetFiles, const [FileList](#filelist) &queryFiles) {: #output-function-initialize }
+
+DOCUMENT ME
+
+* **function definition:**
+
+		virtual void initialize(const [FileList](#filelist) &targetFiles, const [FileList](#filelist) &queryFiles)
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	targetFiles | const [FileList](#filelist) & | DOCUMENT ME
+	queryFiles | const [FileList](#filelist) & | DOCUMENT ME
+
+* **output:** (void) DOCUMENT ME
+
+
+### virtual void setBlock(int rowBlock, int columnBlock) {: #output-function-setblock }
+
+DOCUMENT ME
+
+* **function definition:**
+
+		virtual void setBlock(int rowBlock, int columnBlock)
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	rowBlock | int | DOCUMENT ME
+	columnBlock | int | DOCUMENT ME
+
+* **output:** (void) DOCUMENT ME
+
+
+### virtual void setRelative(float value, int i, int j) {: #output-function-setrelative }
+
+DOCUMENT ME
+
+* **function definition:**
+
+		virtual void setRelative(float value, int i, int j)
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	value | float | DOCUMENT ME
+	i | int | DOCUMENT ME
+	j | int | DOCUMENT ME
+
+* **output:** (void) DOCUMENT ME
+
+
+### virtual void set(float value, int i, int j) = 0 {: #output-function-set }
+
+DOCUMENT ME
+
+* **function definition:**
+
+		virtual void set(float value, int i, int j) = 0
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	value | float | DOCUMENT ME
+	i | int | DOCUMENT ME
+	j | int | DOCUMENT ME
+
+* **output:** (void) DOCUMENT ME
+
+---
+
+# MatrixOutput
+
+Inherits [Object](#object)
+
+---
+
+# Format
+
+Inherits [Object](#object)
+
+---
+
+# Gallery
+
+Inherits [Object](#object)
+
+---
+
+# FileGallery
+
+Inherits [Object](#object)
+
+---
+
+# Representation
+
+Inherits [Object](#object).
+
+---
+
+# Classifier
+
+Inherits [Object](#object)
+
+[Qt]: http://qt-project.org/ "Qt"
+[QApplication]: http://doc.qt.io/qt-5/qapplication.html "QApplication"
+[QCoreApplication]: http://doc.qt.io/qt-5/qcoreapplication.html "QCoreApplication"
+
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QMap]: http://doc.qt.io/qt-5/qmap.html "QMap"
+[QHash]: http://doc.qt.io/qt-5/qhash.html "QHash"
+
+[QRectF]: http://doc.qt.io/qt-5/qrectf.html "QRectF"
+[QPoint]: http://doc.qt.io/qt-5/qpoint.html "QPoint"
+[QPointF]: http://doc.qt.io/qt-5/qpointf.html "QPointF"
+
+[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
+[QVariantList]: http://doc.qt.io/qt-5/qvariant.html#QVariantList-typedef "QVariantList"
+[QVariantMap]: http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef "QVariantMap"
+
+[QRegExp]: http://doc.qt.io/qt-5/QRegExp.html "QRegExp"
+[QThread]: http://doc.qt.io/qt-5/qthread.html "QThread"
+[QFile]: http://doc.qt.io/qt-5/qfile.html "QFile"
+
+[QSharedPointer]: http://doc.qt.io/qt-5/qsharedpointer.html "QSharedPointer"
  
+[QTime]: http://doc.qt.io/qt-5/QTime.html "QTime"
 [QDebug]: http://doc.qt.io/qt-5/qdebug.html "QDebug"
 [QDataStream]: http://doc.qt.io/qt-5/qdatastream.html "QDataStream"
 [QByteArray]: http://doc.qt.io/qt-5/qbytearray.html "QByteArray"
@@ -8,10 +8,10 @@ Wraps OpenCV&#39;s Ada Boost framework
 * **author:** Scott Klum
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
-type | enum | Type of Adaboost to perform. Options are Discrete, Real, Logit, and Gentle. Default is Real.
-splitCriteria | enum | Splitting criteria used to choose optimal splits during a weak tree construction. Options are Default, Gini, Misclass, Sqerr. Default is Default.
+type | enum | Type of Adaboost to perform. Options are:<ul><li>Discrete</li><li>Real</li><li>Logit</li><li>Gentle</li></ul>Default is Real.
+splitCriteria | enum | Splitting criteria used to choose optimal splits during a weak tree construction. Options are:<ul><li>Default</li><li>Gini</li><li>Misclass</li><li>Sqerr</li></ul>Default is Default.
 weakCount | int | Maximum number of weak classifiers per stage. Default is 100.
 trimRate | float | A threshold between 0 and 1 used to save computational time. Samples with summary weight
 folds | int | OpenCV parameter variable. Default value is 0.
@@ -32,7 +32,7 @@ Computes Distance From Feature Space (DFFS)
 * **author:** Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 keep | float | Sets PCA keep property. Default is 0.95.
  
@@ -44,11 +44,11 @@ Face Recognition Using Early Biologically Inspired Features
  
 * **file:** classification/ebif.cpp
 * **inherits:** [UntrainableTransform](../cpp_api.md#untrainabletransform)
-* **see:** [Min Li (IBM China Research Lab, China), Nalini Ratha (IBM Watson Research Center, USA), Weihong Qian (IBM China Research Lab, China), Shenghua Bao (IBM China Research Lab, China), Zhong Su (IBM China Research Lab, China)](Min Li (IBM China Research Lab, China), Nalini Ratha (IBM Watson Research Center, USA), Weihong Qian (IBM China Research Lab, China), Shenghua Bao (IBM China Research Lab, China), Zhong Su (IBM China Research Lab, China))
+* **see:** [Min Li (IBM China Research Lab, China), Nalini Ratha (IBM Watson Research Center, USA), Weihong Qian (IBM China Research Lab, China), Shenghua Bao (IBM China Research Lab, China), Zhong Su (IBM China Research Lab, China)](#min li (ibm china research lab, china), nalini ratha (ibm watson research center, usa), weihong qian (ibm china research lab, china), shenghua bao (ibm china research lab, china), zhong su (ibm china research lab, china))
 * **author:** Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 N | int | The number of scales. Default is 6.
 M | int | The number of orientations between 0 and pi. Default is 9.
@@ -60,12 +60,12 @@ M | int | The number of orientations between 0 and pi. Default is 9.
 Wraps OpenCV's random trees framework to induce features
  
 * **file:** classification/forest.cpp
-* **inherits:** [ForestTransform](../cpp_api.md#foresttransform)
+* **inherits:** [ForestTransform](#foresttransform)
 * **see:** [https://lirias.kuleuven.be/bitstream/123456789/316661/1/icdm11-camready.pdf](https://lirias.kuleuven.be/bitstream/123456789/316661/1/icdm11-camready.pdf)
 * **author:** Scott Klum
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 useRegressionValue | bool | SCOTT FILL ME IN.
  
@@ -81,7 +81,7 @@ Wraps OpenCV&#39;s random trees framework
 * **author:** Scott Klum
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 classification | bool | If true the labels are expected to be categorical. Otherwise they are expected to be numerical. Default is true.
 splitPercentage | float | Used to calculate the minimum number of samples per split in a random tree. The minimum number of samples is calculated as the number of samples x splitPercentage. Default is 0.01.
@@ -118,7 +118,7 @@ Projects input into learned Linear Discriminant Analysis subspace.
 * **authors:** Brendan Klare, Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 pcaKeep | float | BRENDAN OR JOSH FILL ME IN. Default is 0.98.
 pcaWhiten | bool | BRENDAN OR JOSH FILL ME IN. Default is false.
@@ -140,7 +140,7 @@ Wraps OpenCV&#39;s multi-layer perceptron framework
 * **author:** Scott Klum
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 kernel | enum | Type of MLP kernel to use. Options are Identity, Sigmoid, Gaussian. Default is Sigmoid.
 alpha | float | Determines activation function for neural network. See OpenCV documentation for more details. Default is 1.
@@ -208,9 +208,9 @@ Projects input into learned Principal Component Analysis subspace.
 * **authors:** Brendan Klare, Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
-keep | float | Default is 0.95. If (keep <  0) then all eigenvalues are retained. If (keep =  0) then no PCA is performed and the eigenvectors form an identity matrix. If (0 < keep <  1) then keep is the fraction of the variance to retain. If (keep >= 1) then keep is the number of leading eigenvectors to retain.
+keep | float | Options are:<ul><li>keep < 0 - All eigenvalues are retained</li><li>keep == 0 - No PCA is performed and the eigenvectors form an identity matrix</li><li>0 < keep < 1 - Keep is the fraction of the variance to retain</li><li>keep >= 1 - keep is the number of leading eigenvectors to retain</li></ul>Default is 0.95.
 drop | int | BRENDAN OR JOSH FILL ME IN. Default is 0.
 whiten | bool | BRENDAN OR JOSH FILL ME IN. Default is false.
  
@@ -221,7 +221,7 @@ whiten | bool | BRENDAN OR JOSH FILL ME IN. Default is false.
 Compare faces using PittPatt 4.
  
 * **file:** classification/pp4.cpp
-* **inherits:** [Distance,](../cpp_api.md#distance,)
+* **inherits:** [Distance](../cpp_api.md#distance)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -237,7 +237,7 @@ Enroll faces in PittPatt 4
 * **author:** Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 detectOnly | bool | If true, return all detected faces. Otherwise, return only faces that are suitable for recognition. Default is false.
  
@@ -264,7 +264,7 @@ Enroll faces in PP5
 * **authors:** Josh Klontz, E. Taborsky
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 detectOnly | bool | If true, enroll all detected faces. Otherwise, only enroll faces suitable for recognition. Default is false.
 requireLandmarks | bool | If true, require the right eye, left eye, and nose base to be detectable by PP5. If this does not happen FTE is set to true for that template. Default is false.
@@ -280,7 +280,7 @@ searchPruningAggressiveness | int | The amount of aggressiveness involved in sea
 PCA on each row.
  
 * **file:** classification/lda.cpp
-* **inherits:** [PCATransform](../cpp_api.md#pcatransform)
+* **inherits:** [PCATransform](#pcatransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -301,7 +301,7 @@ Wraps OpenCV&#39;s SVM framework.
 * **author:** Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 Kernel | enum | The type of SVM kernel to use. Options are Linear, Poly, RBF, Sigmoid. Default is Linear.
 Type | enum | The type of SVM to do. Options are C_SVC, NU_SVC, ONE_CLASS, EPS_SVR, NU_SVR. Default is C_SVC.
@@ -325,7 +325,7 @@ Projects input into learned Linear Discriminant Analysis subspace learned on a s
 * **author:** Brendan Klare
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 varThreshold | float | BRENDAN FILL ME IN. Default is 1.5.
 pcaKeep | float | BRENDAN FILL ME IN. Default is 0.98.
@@ -342,10 +342,10 @@ Convenience class for training turk attribute regressors
 * **author:** Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 key | QString | Metadata key to pass input values to SVM. Actual lookup key is "key_value" where value is each value in the parameter values. Default is "".
-values | QStringList | Metadata keys to pass input values to SVM. Actual lookup key is "key_value" where key is the parameter key and value is each value in this list. Each passed value trains a new SVM with the input values found in metadata["key_value"]. Default is "".
+values | QStringList | Metadata keys to pass input values to SVM. Actual lookup key is "key_value" where key is the parameter key and value is each value in this list. Each passed value trains a new SVM with the input values found in metadata<ul><li>"key_value"</li></ul>. Default is "".
 isMeta | bool | If true, "Average+SaveMat(predicted_key_value)" is appended to each classifier. If false, nothing is appended. Default is false.
  
 ---
@@ -5,8 +5,11 @@ Collect nearest neighbors and append them to metadata.
 * **file:** cluster/collectnn.cpp
 * **inherits:** [UntrainableMetaTransform](../cpp_api.md#untrainablemetatransform)
 * **author:** Charles Otto
-* **properties:** None
+* **properties:**
  
+Property | Type | Description
+--- | --- | ---
+keep | int | The maximum number of nearest neighbors to keep. Default is 20.
  
 ---
  
@@ -16,9 +19,14 @@ Wraps OpenCV kmeans and flann.
  
 * **file:** cluster/kmeans.cpp
 * **inherits:** [Transform](../cpp_api.md#transform)
+* **see:** [http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html](http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html)
 * **author:** Josh Klontz
-* **properties:** None
+* **properties:**
  
+Property | Type | Description
+--- | --- | ---
+kTrain | int | The number of random centroids to make at train time. Default is 256.
+kSearch | int | The number of nearest neighbors to search for at runtime. Default is 1.
  
 ---
  
@@ -41,8 +49,11 @@ Log nearest neighbors to specified file.
 * **file:** cluster/lognn.cpp
 * **inherits:** [TimeVaryingTransform](../cpp_api.md#timevaryingtransform)
 * **author:** Charles Otto
-* **properties:** None
+* **properties:**
  
+Property | Type | Description
+--- | --- | ---
+fileName | QString | The name of the log file. An empty fileName won't be written to. Default is "".
  
 ---
  
@@ -52,10 +63,14 @@ Chooses k random points to be centroids.
  
 * **file:** cluster/randomcentroids.cpp
 * **inherits:** [Transform](../cpp_api.md#transform)
-* **see:** [KMeansTransform](KMeansTransform)
+* **see:** [http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html](http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html)
 * **author:** Austin Blanton
-* **properties:** None
+* **properties:**
  
+Property | Type | Description
+--- | --- | ---
+kTrain | int | The number of random centroids to make at train time. Default is 256.
+kSearch | int | The number of nearest neighbors to search for at runtime. Default is 1.
  
 ---
  
@@ -40,7 +40,7 @@ Removes all template&#39;s matrices.
  
 * **file:** core/discard.cpp
 * **inherits:** [UntrainableMetaTransform](../cpp_api.md#untrainablemetatransform)
-* **see:** [IdentityTransform FirstTransform RestTransform RemoveTransform](IdentityTransform FirstTransform RestTransform RemoveTransform)
+* **see:** [IdentityTransform FirstTransform RestTransform RemoveTransform](#identitytransform firsttransform resttransform removetransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -53,7 +53,7 @@ Performs an expansion step on input templatelists
  
 * **file:** core/expand.cpp
 * **inherits:** [UntrainableMetaTransform](../cpp_api.md#untrainablemetatransform)
-* **see:** [PipeTransform](PipeTransform)
+* **see:** [PipeTransform](#pipetransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -78,7 +78,7 @@ Removes all but the first matrix from the template.
  
 * **file:** core/first.cpp
 * **inherits:** [UntrainableMetaTransform](../cpp_api.md#untrainablemetatransform)
-* **see:** [IdentityTransform DiscardTransform RestTransform RemoveTransform](IdentityTransform DiscardTransform RestTransform RemoveTransform)
+* **see:** [IdentityTransform DiscardTransform RestTransform RemoveTransform](#identitytransform discardtransform resttransform removetransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -90,8 +90,8 @@ Removes all but the first matrix from the template.
 Transforms in parallel.
  
 * **file:** core/fork.cpp
-* **inherits:** [CompositeTransform](../cpp_api.md#compositetransform)
-* **see:** [PipeTransform](PipeTransform)
+* **inherits:** [CompositeTransform](#compositetransform)
+* **see:** [PipeTransform](#pipetransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -116,7 +116,7 @@ A no-op transform.
  
 * **file:** core/identity.cpp
 * **inherits:** [UntrainableMetaTransform](../cpp_api.md#untrainablemetatransform)
-* **see:** [DiscardTransform FirstTransform RestTransform RemoveTransform](DiscardTransform FirstTransform RestTransform RemoveTransform)
+* **see:** [DiscardTransform FirstTransform RestTransform RemoveTransform](#discardtransform firsttransform resttransform removetransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -164,7 +164,7 @@ Caches transform training.
 Transforms in series.
  
 * **file:** core/pipe.cpp
-* **inherits:** [CompositeTransform](../cpp_api.md#compositetransform)
+* **inherits:** [CompositeTransform](#compositetransform)
 * **see:**
  
 	* [ExpandTransform](ExpandTransform)
@@ -181,7 +181,7 @@ Transforms in series.
 Interface to a separate process
  
 * **file:** core/processwrapper.cpp
-* **inherits:** [WrapperTransform](../cpp_api.md#wrappertransform)
+* **inherits:** [WrapperTransform](#wrappertransform)
 * **author:** Charles Otto
 * **properties:** None
  
@@ -206,7 +206,7 @@ Removes the first matrix from the template.
  
 * **file:** core/rest.cpp
 * **inherits:** [UntrainableMetaTransform](../cpp_api.md#untrainablemetatransform)
-* **see:** [IdentityTransform DiscardTransform FirstTransform RemoveTransform](IdentityTransform DiscardTransform FirstTransform RemoveTransform)
+* **see:** [IdentityTransform DiscardTransform FirstTransform RemoveTransform](#identitytransform discardtransform firsttransform removetransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -75,7 +75,7 @@ Likely matrix format
 Reads a NIST BEE mask matrix.
  
 * **file:** format/mtx.cpp
-* **inherits:** [mtxFormat](../cpp_api.md#mtxformat)
+* **inherits:** [mtxFormat](#mtxformat)
 * **author:** Josh Klontz
 * **properties:** None
  
+# BinaryGallery
+
+An abstract gallery for handling binary data
+
+* **file:** gallery/binary.cpp
+* **inherits:** [Gallery](../cpp_api.md#gallery)
+* **author:** Unknown
+* **properties:** None
+
+
+---
+
 # DefaultGallery
  
 Treats the gallery as a br::Format.
@@ -64,7 +76,7 @@ Treats each line as a file.
  
 * **file:** gallery/csv.cpp
 * **inherits:** [FileGallery](../cpp_api.md#filegallery)
-* **see:** [txtGallery](txtGallery)
+* **see:** [txtGallery](#txtgallery)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -100,7 +112,7 @@ Treats each line as a call to File::flat()
 A binary gallery.
  
 * **file:** gallery/binary.cpp
-* **inherits:** [BinaryGallery](../cpp_api.md#binarygallery)
+* **inherits:** [BinaryGallery](#binarygallery)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -124,7 +136,7 @@ Input from a google image search.
 Newline-separated JSON objects.
  
 * **file:** gallery/binary.cpp
-* **inherits:** [BinaryGallery](../cpp_api.md#binarygallery)
+* **inherits:** [BinaryGallery](#binarygallery)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -196,7 +208,7 @@ A gallery held in memory.
 Read key frames of a .mp4 video file with LibAV
  
 * **file:** gallery/keyframes.cpp
-* **inherits:** [keyframesGallery](../cpp_api.md#keyframesgallery)
+* **inherits:** [keyframesGallery](#keyframesgallery)
 * **author:** Ben Klein
 * **properties:** None
  
@@ -257,7 +269,7 @@ Treats each line as a file.
  
 * **file:** gallery/txt.cpp
 * **inherits:** [FileGallery](../cpp_api.md#filegallery)
-* **see:** [csvGallery](csvGallery)
+* **see:** [csvGallery](#csvgallery)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -269,7 +281,7 @@ Treats each line as a file.
 Newline-separated URLs.
  
 * **file:** gallery/binary.cpp
-* **inherits:** [BinaryGallery](../cpp_api.md#binarygallery)
+* **inherits:** [BinaryGallery](#binarygallery)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -281,7 +293,7 @@ Newline-separated URLs.
 A contiguous array of br_universal_template.
  
 * **file:** gallery/binary.cpp
-* **inherits:** [BinaryGallery](../cpp_api.md#binarygallery)
+* **inherits:** [BinaryGallery](#binarygallery)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -99,7 +99,7 @@ Renders metadata onto the image.
 Elicits metadata for templates in a pretty GUI
  
 * **file:** gui/show.cpp
-* **inherits:** [ShowTransform](../cpp_api.md#showtransform)
+* **inherits:** [ShowTransform](#showtransform)
 * **author:** Scott Klum
 * **properties:** None
  
@@ -135,7 +135,7 @@ Limits the frequency of projects going through this transform to the input targe
 Manual select rectangular regions on an image.
  
 * **file:** gui/show.cpp
-* **inherits:** [ShowTransform](../cpp_api.md#showtransform)
+* **inherits:** [ShowTransform](#showtransform)
 * **author:** Charles Otto
 * **properties:** None
  
@@ -147,7 +147,7 @@ Manual select rectangular regions on an image.
 Manual selection of landmark locations
  
 * **file:** gui/show.cpp
-* **inherits:** [ShowTransform](../cpp_api.md#showtransform)
+* **inherits:** [ShowTransform](#showtransform)
 * **author:** Scott Klum
 * **properties:** None
  
@@ -183,7 +183,7 @@ Displays templates in a GUI pop-up window using QT.
 Display an image, and asks a yes/no question about it
  
 * **file:** gui/show.cpp
-* **inherits:** [ShowTransform](../cpp_api.md#showtransform)
+* **inherits:** [ShowTransform](#showtransform)
 * **author:** Charles Otto
 * **properties:** None
  
@@ -579,7 +579,7 @@ Sliding window feature extraction from a multi-channel integral image.
 Overloads SlidingWindowTransform for integral images that should be
  
 * **file:** imgproc/slidingwindow.cpp
-* **inherits:** [SlidingWindowTransform](../cpp_api.md#slidingwindowtransform)
+* **inherits:** [SlidingWindowTransform](#slidingwindowtransform)
 * **author:** Josh Klontz
 * **properties:** None
  
@@ -775,7 +775,7 @@ Normalize matrix to unit length
 * **author:** Josh Klontz
 * **properties:**
  
-Name | Type | Description
+Property | Type | Description
 --- | --- | ---
 NormType | enum | Values are NORM_INF, NORM_L1, NORM_L2, NORM_MINMAX
 ByRow | bool | If true normalize each row independently otherwise normalize the entire matrix.
 # OpenBR ![Overview](img/openbr_48x48.png)
  
-Open source, industry quality biometrics.
+<p id=tagline>Open source, industry quality biometrics.</p>
  
 ---
  
@@ -35,7 +35,7 @@ OpenBR is supported on multiple operating systems. Please select yours from the 
 We have created a few tutorials to help teach you the basic principles of the OpenBR system. If this is your first time using OpenBR you should look at these before moving on to the more technical descriptions below.
  
 * [Quick Start](tutorials.md#quick-start)
-* [Training in OpenBR](tutorials.md#training-in-openbr)
+* [Training in OpenBR](tutorials.md#training-algorithms)
 * [Face Recognition](tutorials.md#face-recognition)
 * [Age Estimation](tutorials.md#age-estimation)
 * [Gender Estimation](tutorials.md#gender-estimation)
@@ -13,7 +13,7 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
  
         $ sudo apt-get install cmake cmake-curses-gui
  
-3. <a href="http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.5/opencv-2.4.5.tar.gz">Download OpenCV 2.4.5</a>, **note** <a href="https://github.com/biometrics/openbr/wiki/Build-OpenCV-with-Video-Support-on-Ubuntu">this</a>
+3. [Download OpenCV 2.4.5](http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.5/opencv-2.4.5.tar.gz), **note** [Build OpenCV with video support](https://github.com/biometrics/openbr/wiki/Build-OpenCV-with-Video-Support-on-Ubuntu)
  
         $ cd ~/Downloads
         $ tar -xf opencv-2.4.5.tar.gz
@@ -31,7 +31,7 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
  
         $ sudo apt-get install qt5-default libqt5svg5-dev qtcreator
  
-5. Create a <a href="github.com">GitHub</a> account, follow their instructions for <a href="https://help.github.com/articles/set-up-git">setting up Git</a>.
+5. Create a [GitHub](https://github.com/) account, follow their instructions for [setting up Git](https://help.github.com/articles/set-up-git).
  
         $ git clone https://github.com/biometrics/openbr.git
         $ cd openbr
@@ -56,7 +56,7 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
     3. Select "openbr/CMakeLists.txt" then "Open".
     4. Browse to your pre-existing build directory "openbr/build" then select "Next".
     5. Select "Run CMake" then "Finish".
-    6. You're all set! You can find more information on Qt Creator <a href="http://qt-project.org/doc/qtcreator">here</a> if you need.
+    6. You're all set! You can find more information on Qt Creator [here](http://qt-project.org/doc/qtcreator) if you need it.
  
 8. (Optional) Test OpenBR!
  
@@ -72,19 +72,15 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
  
 10. (Optional) Build OpenBR documentation!
  
-        $ sudo apt-get install doxygen
-        $ cd openbr/build
-        $ cmake -DBR_BUILD_DOCUMENTATION=ON ..
-        $ make -j4
-        $ sudo apt-get install libgnome2-bin
-        $ gnome-open html/index.html
+Need to rewrite this step for the new docs!
  
 ---
  
 # OSX
  
-1. Download and install the latest "Xcode" and "Command Line Tools" from the <a href="https://developer.apple.com/downloads/index.action#">Apple Developer Downloads</a> page.
-    1. <a href="http://www.cmake.org/files/v2.8/cmake-2.8.11.2.tar.gz">Download CMake 2.8.11.2</a>
+1. Download and install the latest "Xcode" and "Command Line Tools" from the [Apple Developer Downloads](https://developer.apple.com/downloads/index.action#) page.
+
+2. [Download CMake 2.8.11.2](http://www.cmake.org/files/v2.8/cmake-2.8.11.2.tar.gz)
  
             $ cd ~/Downloads
             $ tar -xf cmake-2.8.11.2.tar.gz
@@ -95,7 +91,7 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
             $ cd ..
             $ rm -rf cmake-2.8.11.2*
  
-2. <a href="http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.6.1/opencv-2.4.6.1.tar.gz">Download OpenCV 2.4.6.1</a>
+3. [Download OpenCV 2.4.6.1](http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.6.1/opencv-2.4.6.1.tar.gz)
  
         $ cd ~/Downloads
         $ tar -xf opencv-2.4.6.1.tar.gz
@@ -108,9 +104,9 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
         $ cd ../..
         $ rm -rf opencv-2.4.6.1*
  
-3. <a href="http://download.qt-project.org/official_releases/qt/5.1/5.1.1/qt-mac-opensource-5.1.1-clang-offline.dmg">Download and install Qt 5.1.1</a>
+4. [Download and install Qt 5.1.1](http://download.qt-project.org/official_releases/qt/5.1/5.1.1/qt-mac-opensource-5.1.1-clang-offline.dmg)
  
-4. Create a <a href="github.com">GitHub</a> account, follow their instructions for <a href="https://help.github.com/articles/set-up-git">setting up Git</a>.
+5. Create a [GitHub](https://github.com/) account, follow their instructions for [setting up Git](https://help.github.com/articles/set-up-git).
  
         $ git clone https://github.com/biometrics/openbr.git
         $ cd openbr
@@ -118,7 +114,7 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
         $ git submodule init
         $ git submodule update
  
-5. Build OpenBR!
+6. Build OpenBR!
  
         $ mkdir build # from the OpenBR root directory
         $ cd build
@@ -126,7 +122,7 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
         $ make -j4
         $ sudo make install
  
-6. Hack OpenBR!
+7. Hack OpenBR!
     1. Open Qt Creator IDE
  
             $ open ~/Qt5.1.1/Qt\ Creator.app
@@ -135,9 +131,9 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
     3. Select "openbr/CMakeLists.txt" then "Open".
     4. Browse to your pre-existing build directory "openbr/build" then select "Continue".
     5. Select "Run CMake" then "Done".
-    6. You're all set! You can find more information on Qt Creator <a href="http://qt-project.org/doc/qtcreator">here</a> if you need.
+    6. You're all set! You can find more information on Qt Creator [here](http://qt-project.org/doc/qtcreator) if you need it.
  
-7. (Optional) Test OpenBR!
+8. (Optional) Test OpenBR!
  
         $ cd openbr/scripts
         $ ./downloadDatasets.sh
@@ -145,47 +141,31 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
         $ make test
  
  
-8. (Optional) Package OpenBR!
+9. (Optional) Package OpenBR!
  
         $ cd openbr/build
         $ sudo cpack -G TGZ
  
  
-9. (Optional) Build OpenBR documentation!
-    1. <a href="ftp://ftp.stack.nl/pub/users/dimitri/doxygen-1.8.5.src.tar.gz">Download Doxygen 1.8.5</a>
-
-            $ cd ~/Downloads
-            $ tar -xf doxygen-1.8.5.src.tar.gz
-            $ cd doxygen-1.8.5
-            $ ./configure
-            $ make -j4
-            $ sudo make install
-            $ cd ..
-            $ rm -rf doxygen-1.8.5*
-
-
-    2. Modify build settings and recompile.
+10. (Optional) Build OpenBR documentation!
  
-            $ cd openbr/build
-            $ cmake -DBR_BUILD_DOCUMENTATION=ON ..
-            $ make -j4
-            $ open html/index.html
+Need to remake this step with the new docs!
  
 ---
  
 # Windows
  
-1. <a href="http://www.microsoft.com/en-us/download/details.aspx?id=34673">Download Visual Studio 2012 Express Edition for Windows Desktop</a> and install.
-    1. Consider the free open source program <a href="http://wincdemu.sysprogs.org">WinCDEmu</a> if you need a program to mount ISO images.
+1. [Download Visual Studio 2012 Express Edition for Windows Desktop](http://www.microsoft.com/en-us/download/details.aspx?id=34673) and install.
+    1. Consider the free open source program [WinCDEmu](http://wincdemu.sysprogs.org) if you need a program to mount ISO images.
     2. You will have to register with Microsoft after installation, but it's free.
-    3. Grab any available <a href="http://www.microsoft.com/visualstudio/eng/downloads#d-visual-studio-2012-update">Visual Studio Updates</a>.
-    4. Download and install <a href="http://msdn.microsoft.com/en-us/windows/hardware/hh852363.aspx">Windows 8 SDK</a>.
+    3. Grab any available [Visual Studio Updates](http://www.microsoft.com/visualstudio/eng/downloads#d-visual-studio-2012-update).
+    4. Download and install [Windows 8 SDK](http://msdn.microsoft.com/en-us/windows/hardware/hh852363.aspx).
  
-2. <a href="http://www.cmake.org/files/v2.8/cmake-2.8.11.2-win32-x86.exe">Download and Install CMake 2.8.11.2</a>
+2. [Download and Install CMake 2.8.11.2](http://www.cmake.org/files/v2.8/cmake-2.8.11.2-win32-x86.exe)
     1. During installation setup select "add CMake to PATH".
  
-3. <a href="http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.6.1/opencv-2.4.6.1.tar.gz">Download OpenCV 2.4.6.1</a>
-    1. Consider the free open source program <a href="http://www.7-zip.org/">7-Zip</a> if you need a program to unarchive tarballs.
+3. [Download OpenCV 2.4.6.1](http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.6.1/opencv-2.4.6.1.tar.gz)
+    1. Consider the free open source program [7-Zip](http://www.7-zip.org/) if you need a program to unarchive tarballs.
     2. Move the "opencv-2.4.6.1" folder to "C:\".
     3. Open "VS2012 x64 Cross Tools Command Prompt" (from the Start Menu, select "All Programs" -> "Microsoft Visual Studio 2012" -> "Visual Studio Tools" -> "VS2012 x64 Cross Tools Command Prompt") and enter:
  
@@ -200,9 +180,9 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
             $ nmake install
             $ nmake clean
  
-4. <a href="http://download.qt-project.org/official_releases/qt/5.1/5.1.1/qt-windows-opensource-5.1.1-msvc2012-x86_64-offline.exe">Download and Install Qt 5.1.1</a>
+4. [Download and Install Qt 5.1.1](http://download.qt-project.org/official_releases/qt/5.1/5.1.1/qt-windows-opensource-5.1.1-msvc2012-x86_64-offline.exe)
  
-5. Create a <a href="github.com">GitHub</a> account and follow their instructions for <a href="https://help.github.com/articles/set-up-git">setting up Git</a>.
+5. Create a [GitHub](https://github.com/) account and follow their instructions for [setting up Git](https://help.github.com/articles/set-up-git).
     1. Launch "Git Bash" from the Desktop and clone OpenBR:
  
             $ cd /c
@@ -285,7 +265,7 @@ A hacker&#39;s guide to building, editing, and running OpenBR.
  
         $ sudo apt-get install qt5-default libqt5svg5-dev
  
-6. Create a <a href="github.com">GitHub</a> account, follow their instructions for <a href="https://help.github.com/articles/set-up-git">setting up Git</a>.
+6. Create a [GitHub](https://github.com/) account, follow their instructions for [setting up Git](https://help.github.com/articles/set-up-git).
  
         $ git clone https://github.com/biometrics/openbr.git
         $ cd openbr
@@ -16,7 +16,7 @@ Ok, you probably knew all of this already, let&#39;s move on.
 The only way of creating an algorithm in OpenBR is from a text string that describes it.
 We call this string the *algorithm description*.
 The algorithm description is separated into two parts by a ':', with the left hand side indicating how to generate templates and the right hand side indicating how to compare them.
-Some algorithms, like [age_estimation](tutorials.md#age estimation) and [gender estimation](tutorials.md#gender estimation) are *classifiers* that don't create templates.
+Some algorithms, like [age_estimation](tutorials.md#age-estimation) and [gender estimation](tutorials.md#gender-estimation) are *classifiers* that don't create templates.
 In these cases, the colon and the template comparison technique can be omitted from the algorithm description.
  
 There are several motivations for mandating that algorithms are defined from these strings, here are the most important:
@@ -29,12 +29,12 @@ Let&#39;s look at some of the important parts of the code base that make this possib
  
 In `AlgorithmCore::init()` in `openbr/core/core.cpp` you can see the code for splitting the algorithm description at the colon.
 Shortly thereafter in this function we *make* the template generation and comparison methods.
-These make calls are defined in the public [C++ plugin API](#the c++ plugin api) and can also be called from end user code.
+These make calls are defined in the public [C++ plugin API](docs/cpp_api.md) and can also be called from end user code.
  
 Below we discuss some of the source code for `Transform::make` in `openbr/openbr_plugin.cpp`.
 Note, the make functions for other plugin types are similar in spirit and will not be covered.
  
-One of the first steps when converting the template enrollment description into a [Transform](docs/cpp_api.md#Transform) is to replace the operators, like '+', with their full form:
+One of the first steps when converting the template enrollment description into a [Transform](docs/cpp_api.md#transform) is to replace the operators, like '+', with their full form:
  
     { // Check for use of '+' as shorthand for Pipe(...)
          QStringList words = parse(str, '+');
@@ -83,10 +83,10 @@ The *Biometric Evaluation Environment* (BEE) is a [NIST](http://www.nist.gov/ind
  
 OpenBR implements the following portions of the BEE specification:
  
-* Signature Set- A signature set (or *sigset*) is a [Gallery](docs/cpp_api.md#gallery) compliant **XML** file-list specified on page 9 of [MBGC File Overview](MBGC_file_overview.pdf#page=9) and implemented in [xmlGallery](docs/plugins/gallery.md#xmlGallery). Sigsets are identified with a **.xml** extension.
+* Signature Set- A signature set (or *sigset*) is a [Gallery](docs/cpp_api.md#gallery) compliant **XML** file-list specified on page 9 of [MBGC File Overview](DOCUMENT ME) and implemented in [xmlGallery](docs/plugins/gallery.md#xmlgallery). Sigsets are identified with a **.xml** extension.
  
-* Similarity Matrix- A similarity matrix (or *simmat*) is an [Output](docs/cpp_api.md#output) compliant binary score matrix specified on page 12 of [MBGC File Overview](MBGC_file_overview.pdf#page=12) and implemented in [mtxOutput](docs/plugins/output.md#mtxOutput). Simmats are identified with a **.mtx** extension. See [br_eval](docs/c_api.md#br_eval) for more information.
+* Similarity Matrix- A similarity matrix (or *simmat*) is an [Output](docs/cpp_api.md#output) compliant binary score matrix specified on page 12 of [MBGC File Overview](DOCUMENT ME) and implemented in [mtxOutput](docs/plugins/output.md#mtxoutput). Simmats are identified with a **.mtx** extension. See [br_eval](docs/c_api.md#br_eval) for more information.
  
-* Mask Matrix- A mask matrix (or *mask*) is a binary matrix specified on page 14 of [MBGC File Overview](MBGC_file_overview.pdf#page=14) identifying the ground truth genuines and impostors of a corresponding *simmat*. Masks are identified with a **.mask** extension. See [br_make_mask](docs/c_api.md#br_make_mask) and [br_combine_masks](docs/c_api.md#br_combine_masks) for more information.
+* Mask Matrix- A mask matrix (or *mask*) is a binary matrix specified on page 14 of [MBGC File Overview](DOCUMENT ME) identifying the ground truth genuines and impostors of a corresponding *simmat*. Masks are identified with a **.mask** extension. See [br_make_mask](docs/c_api.md#br_make_mask) and [br_combine_masks](docs/c_api.md#br_combine_masks) for more information.
  
 ---
@@ -32,7 +32,7 @@ You&#39;re webcam should be open again but this time a box should have appeared arou
 3. [Draw(lineThickness=3)](docs/plugins/gui.md#drawtransform): Take the rects detected by [Cascade](docs/plugins/metadata.md#cascadetransform) and draw them onto the frame from the webcam. **lineThickness** determines the thickness of the drawn rect.
 4. [Show(false)](docs/plugins/gui.md#showtransform): Show the image in a GUI window. **false** indicates the images should be shown in succession without waiting for a key press.
  
-Pretty straightforward right? Each plugin completes one task and the passes the output on to the next plugin. You can pipe together as many plugins as you like as long as the output data from one can be the input data to the next. But wait! Output data? Input data? we haven't talked about data at all yet! How does OpenBR handle data? There are two objects that handle data is OpenBR; [Files](docs/cpp_api.md#file), which handle metadata, and [Templates](docs/cpp_api.md#template) which are containers for images and [Files](docs/cpp_api.md#file). Let's talk about [Files](docs/cpp_api.md#file) first. A file consists of file name, which is a path to a file on disk, and metadata which is a map of key-value pairs. The metadata can contain any textual information about the file. In the example above we use it to store the rectangles detected by [Cascade](docs/plugins/metadata.md#cascadetransform) and pass them along to [Draw](docs/plugins/metadata.md#drawtransform) for drawing. [Templates](docs/cpp_api.md#template) are containers for images, given as OpenCV [Mats](http://docs.opencv.org/modules/core/doc/basic_structures.html#mat), and [Files](docs/cpp_api.md#file). They can contain one image or a list of images. Plugins are either [Template](docs/cpp_api.md#template) in, [Template](docs/cpp_api.md#template) out or [TemplateList](docs/cpp_api.md#templatelist) in, [TemplateList](docs/cpp_api.md#templatelist) out. [TemplateLists](docs/cpp_api.md#templatelist) are, of course, just a list of [Templates](docs/cpp_api.md#template) which a few functions added for your convenience.
+Pretty straightforward right? Each plugin completes one task and the passes the output on to the next plugin. You can pipe together as many plugins as you like as long as the output data from one can be the input data to the next. But wait! Output data? Input data? we haven't talked about data at all yet! How does OpenBR handle data? There are two objects that handle data is OpenBR; [Files](docs/cpp_api.md#file), which handle metadata, and [Templates](docs/cpp_api.md#template) which are containers for images and [Files](docs/cpp_api.md#file). Let's talk about [Files](docs/cpp_api.md#file) first. A file consists of file name, which is a path to a file on disk, and metadata which is a map of key-value pairs. The metadata can contain any textual information about the file. In the example above we use it to store the rectangles detected by [Cascade](docs/plugins/metadata.md#cascadetransform) and pass them along to [Draw](docs/plugins/gui.md#drawtransform) for drawing. [Templates](docs/cpp_api.md#template) are containers for images, given as OpenCV [Mats](http://docs.opencv.org/modules/core/doc/basic_structures.html#mat), and [Files](docs/cpp_api.md#file). They can contain one image or a list of images. Plugins are either [Template](docs/cpp_api.md#template) in, [Template](docs/cpp_api.md#template) out or [TemplateList](docs/cpp_api.md#templatelist) in, [TemplateList](docs/cpp_api.md#templatelist) out. [TemplateLists](docs/cpp_api.md#templatelist) are, of course, just a list of [Templates](docs/cpp_api.md#template) which a few functions added for your convenience.
  
 And there you go! You have gotten your quick start in OpenBR. We covered the [command line](docs/cl_api.md), plugins, and the key [data structures](docs/cpp_api.md) in OpenBR. If you want to learn more the next few tutorials will cover these fields with more depth. For even more information check out the [technical overviews](technical.md) and class documentation!
  
+import re
+
+from markdown.postprocessors import Postprocessor
+from markdown.extensions import Extension
+
+class HighlighterPostprocessor(Postprocessor):
+    def run(self, text):
+        print text
+        return text
+
+class HighlighterExtension(Extension):
+    def extendMarkdown(self, md, md_globals):
+        md.postprocessors.add('highlight', HighlighterPostprocessor(md))
@@ -3,7 +3,7 @@ repo_url: https://github.com/biometrics/openbr
 site_favicon: docs/img/openbr.ico
 copyright: 2012 The MITRE Corporation
  
-theme: readly
+theme: spacelab
 theme_dir: themes/spacelab/
  
 pages:
+import os
+import markdown
+from HTMLParser import HTMLParser
+
+def subfiles(path, ext):
+    return [os.path.join(path, name) for name in os.listdir(path) if os.path.isfile(os.path.join(path, name)) and name[-len(ext):] == ext]
+
+def subdirs(path):
+    return [name for name in os.listdir(path) if os.path.isdir(os.path.join(path, name))]
+
+def walk(path, ext):
+    files = []
+    for d in subdirs(path):
+        files.extend(walk(os.path.join(path, d), ext))
+
+    files.extend(subfiles(path, ext))
+    return files
+
+def basename_no_ext(name):
+    basename = os.path.basename(name)
+    return basename.split('.')[0]
+
+class Link():
+    def __init__(self, raw_link):
+        if 'http' in raw_link:
+            self.http = raw_link
+            self.file = None
+            self.anchor = None
+        elif raw_link[0] == '#':
+            self.http = None
+            self.file = None
+            self.anchor = raw_link[1:]
+        elif '#' in raw_link:
+            self.http = None
+
+            split_link = raw_link.split('#')
+            self.file = basename_no_ext(split_link[0])
+            self.anchor = split_link[1]
+        else:
+            self.http = None
+            self.file = basename_no_ext(raw_link)
+            self.anchor = None
+
+class LinkParser(HTMLParser):
+    def __init__(self):
+        HTMLParser.__init__(self)
+
+        self.headers = []
+        self.links = []
+
+    def handle_starttag(self, tag, attrs):
+        for attr in attrs:
+            if u'href' == attr[0]:
+                self.links.append(Link(attr[1].encode('ascii', 'ignore')))
+
+            elif u'class' == attr[0]:
+                self.headers.append(attr[1].encode('ascii', 'ignore'))
+
+            elif u'name' == attr[0]:
+                self.headers.append(attr[1].encode('ascii', 'ignore'))
+
+            elif u'id' == attr[0]:
+                self.headers.append(attr[1].encode('ascii', 'ignore'))
+
+
+def parse(html):
+    parser = LinkParser()
+    parser.feed(html)
+
+    return parser.headers, parser.links
+
+def check(headers, links):
+    for f, file_links in links.items():
+        for link in file_links:
+            if link.http:
+                continue
+
+            link_file = f
+            if link.file:
+                link_file = link.file
+
+            if link_file not in headers:
+                print 'BAD FILE IN ' + f + '.md:', link_file
+                continue
+
+            if link.anchor and link.anchor not in headers[link_file]:
+                print 'BAD LINK IN ' + f + '.md:', link_file + ', ' + link.anchor
+
+
+def main():
+    docs_dir = '../docs/'
+    ext = 'md'
+
+    md_files = walk(docs_dir, ext)
+    md = markdown.Markdown( ['meta', 'toc', 'tables', 'fenced_code'] )
+
+    html_files = [md.convert(open(f, 'r').read()) for f in md_files]
+
+    headers = {}
+    links = {}
+    for i in range(len(md_files)):
+        local_headers, local_links = parse(html_files[i])
+
+        headers[basename_no_ext(md_files[i])] = local_headers
+        links[basename_no_ext(md_files[i])] = local_links
+
+    check(headers, links)
+
+main()
+# This script is intended to take an API-style class from OpenBR and output
+# structured Markdown text in the OpenBR documentation format. The class details
+# should then be filled in.
+
+import sys
+import re
+
+def find_name_parent(content):
+    name_re = re.compile('class(.*?):')
+    name = name_re.search(content).group()[:-1].strip().split(' ')[-1]
+
+    parent_re = re.compile('public.*')
+    parent = parent_re.search(content).group().strip().split(' ')[-1]
+
+    return name, parent
+
+def find_properties(content):
+    properties = []
+
+    property_re = re.compile('Q_PROPERTY\((.*?)\)')
+    it = property_re.finditer(content)
+    for prop in it:
+        prop_type = prop.group()[11:-1].split(' ')[0]
+        prop_name = prop.group()[11:-1].split(' ')[1]
+        properties.append((prop_name, prop_type))
+
+    return properties
+
+def find_members(content):
+    members = []
+
+    member_re = re.compile('(\w+(<\w+>)*)\s(\w+);')
+    it = member_re.finditer(content)
+    for member in it:
+        member_type = member.group()[:-1].strip().split(' ')[0]
+        member_name = member.group()[:-1].strip().split(' ')[1]
+        members.append((member_name, member_type))
+
+    return members
+
+def find_constructors(name, content):
+    constructors = []
+
+    constructor_re = re.compile('(.*)' + name + '\(\)')
+    it = constructor_re.finditer(content)
+    for constructor in it:
+        constructors.append(constructor.group().strip())
+
+    return constructors
+
+def find_functions(content):
+    functions = []
+
+    function_re = re.compile('(.*)[^PROPERTY]\(.*\).*;')
+    it = function_re.finditer(content)
+    for func in it:
+        function = {}
+
+        function['Full'] = func.group()[:-1].strip() #don't include semi colon
+
+        func_split = func.group().strip().split(' ')
+        if func_split[0] == "static":
+            function['Type'] = 'static'
+            function['Return'] = func_split[1]
+            function['Name'] = func_split[2].split('(')[0]
+        elif func_split[0] == "virtual":
+            function['Type'] = 'virtual'
+            function['Return'] = func_split[1]
+            function['Name'] = func_split[2].split('(')[0]
+        else:
+            function['Type'] = 'normal'
+            function['Return'] = func_split[0]
+            function['Name'] = func_split[1].split('(')[0]
+
+        args = []
+
+        args_list = func.group()[func.group().find('(')+1:func.group().find(')')].split(',')
+        for arg in args_list:
+            arg = arg.strip()
+            split_idx = arg.rfind(' ')
+            if arg[split_idx:].strip()[0] == '*' or arg[split_idx:].strip()[0] == '&':
+                split_idx += 2
+
+            args.append((arg[split_idx:].strip(), arg[:split_idx].strip()))
+
+        function['Args'] = args
+
+        functions.append(function)
+
+    return functions
+
+def parse(content):
+    name, parent = find_name_parent(content)
+    properties = find_properties(content)
+    members = find_members(content)
+    constructors = find_constructors(name, content)
+    functions = find_functions(content)
+
+    return name, parent, properties, members, constructors, functions
+
+def function_builder(name, function):
+    markdown = ""
+
+    markdown += "### <h3 id=" + name.lower() + "-function-" + function['Name'].lower() + ">" + function['Full'] + "</h3>\n\n"
+    markdown += "DOCUMENT ME\n\n"
+
+    markdown += "* **function definition:**\n\n"
+    markdown += "\t\t" + function['Full'] + "\n\n"
+
+    markdown += "* **parameters:**"
+    if len(function['Args']) == 0:
+        markdown += " NONE\n"
+    else:
+        markdown += "\n\n"
+        markdown += "\tParameter | Type | Description\n"
+        markdown += "\t--- | --- | ---\n"
+        for arg in function['Args']:
+            markdown += "\t" + arg[0] + " | " + arg[1] + " | DOCUMENT ME\n"
+        markdown += "\n"
+
+    markdown += "* **output:** (" + function['Return'] + ") DOCUMENT ME\n\n\n"
+
+    return markdown
+
+def format_md(name, parent, properties, members, constructors, functions):
+    markdown = ""
+
+    markdown += "# " + name + "\n\n"
+    markdown += "Inherits from [" + parent + "](#" + parent.lower() + ")\n\n"
+
+    markdown += "## <h2 id=" + name.lower() + "-properties>Properties</h2>\n\n"
+    if len(properties) == 0:
+        markdown += "NONE\n\n"
+    else:
+        markdown += "Property | Type | Description\n"
+        markdown += "--- | --- | ---\n"
+        for prop in properties:
+            markdown += '<a class="table-anchor" id=' + name.lower() + '-properties-' + prop[0].lower() + '></a>'
+            markdown += prop[0] + " | " + prop[1] + " | DOCUMENT ME\n"
+        markdown += "\n"
+
+    markdown += "## <h2 id=" + name.lower() + "-members>Members</h2>\n\n"
+    if len(members) == 0:
+        markdown += "NONE\n\n"
+    else:
+        markdown += "Member | Type | Description\n"
+        markdown += "--- | --- | ---\n"
+        for member in members:
+            markdown += '<a class="table-anchor" id=' + name.lower() + '-members-' + member[0].lower() + '></a>'
+            markdown += member[0] + " | " + member[1] + " | DOCUMENT ME\n"
+        markdown += "\n"
+
+    markdown += "## <h2 id=" + name.lower() + "-constructors>Constructors</h2>\n\n"
+    if len(constructors) == 0:
+        markdown += "NONE\n\n"
+    else:
+        markdown += "Constructor \| Destructor | Description\n"
+        markdown += "--- | ---\n"
+        for constructor in constructors:
+            markdown += constructor + " | DOCUMENT ME\n"
+        markdown += "\n"
+
+    markdown += "## <h2 id=" + name.lower() + "-static-functions>Static Functions</h2>\n\n"
+    for function in functions:
+        if function['Type'] == 'static':
+            markdown += function_builder(name, function)
+
+    markdown += "## <h2 id=" + name.lower() + "-functions>Functions</h2>\n\n"
+    for function in functions:
+        if not function['Type'] == 'static':
+            markdown += function_builder(name, function)
+
+    return markdown
+
+def main():
+    if len(sys.argv) != 3:
+        print 'Inputs => class documentation'
+        sys.exit(1)
+
+    class_file = open(sys.argv[1], 'r')
+    doc_file = open(sys.argv[2], 'w+')
+
+    name, parent, properties, members, constructors, functions = parse(class_file.read())
+
+    doc_file.write(format_md(name, parent, properties, members, constructors, functions))
+
+main()
@@ -35,9 +35,27 @@ def parse(group):
             attributes[key] = [value]
  
     attributes['Name'] = clss[5:clss.find(':')].strip()
-    attributes['Parent'] = clss[clss.find('public')+6:].strip()
+    attributes['Parent'] = clss[clss.find('public')+6:].strip().strip(',') # Handles the edge case of multiple inheritence
     return attributes
  
+def parseInheritance(inheritance):
+    abstractions = ['Transform', 'UntrainableTransform',
+                    'MetaTransform', 'UntrainableMetaTransform',
+                    'MetadataTransform', 'UntrainableMetadataTransform',
+                    'TimeVaryingTransform',
+                    'Distance', 'UntrainableDistance',
+                    'Output', 'MatrixOutput',
+                    'Format',
+                    'Gallery', 'FileGallery',
+                    'Representation',
+                    'Classifier'
+                   ]
+
+    if inheritance in abstractions:
+        return '../cpp_api.md#' + inheritance.lower()
+    else: # Not an abstraction must inherit in the local file!
+        return '#' + inheritance.lower()
+
 def parseSees(sees):
     if not sees:
         return ""
@@ -49,7 +67,10 @@ def parseSees(sees):
             output += "\t* [" + see + "](" + see + ")\n"
         output += "\n"
     else:
-        output += " [" + sees[0] + "](" + sees[0] + ")\n"
+        link = sees[0]
+        if not 'http' in link:
+            link = '#' + link.lower()
+        output += " [" + sees[0] + "](" + link + ")\n"
  
     return output
  
@@ -70,7 +91,7 @@ def parseProperties(properties):
         return "* **properties:** None\n\n"
  
     output = "* **properties:**\n\n"
-    output += "Name | Type | Description\n"
+    output += "Property | Type | Description\n"
     output += "--- | --- | ---\n"
     for prop in properties:
         split = prop.split(' ')
@@ -78,6 +99,22 @@ def parseProperties(properties):
         name = split[1]
         desc = ' '.join(split[2:])
  
+        table_regex = re.compile('\[(.*?)\]')
+        table_match = table_regex.search(desc)
+        while table_match:
+            before = desc[:table_match.start()]
+            after = desc[table_match.end():]
+
+            table_content = desc[table_match.start()+1:table_match.end()-1].split(',')
+
+            table = "<ul>"
+            for field in table_content:
+                table += "<li>" + field.strip() + "</li>"
+            table += "</ul>"
+
+            desc = before.strip() + table + after.strip()
+            table_match = table_regex.search(desc)
+
         output += name + " | " + ty + " | " + desc + "\n"
  
     return output
@@ -109,7 +146,7 @@ def main():
                 plugin_string = "# " + attributes["Name"] + "\n\n"
                 plugin_string += ' '.join([brief for brief in attributes["brief"]]) + "\n\n"
                 plugin_string += "* **file:** " + os.path.join(module, plugin) + "\n"
-                plugin_string += "* **inherits:** [" + attributes["Parent"] + "](../cpp_api.md#" + attributes["Parent"].lower() + ")\n"
+                plugin_string += "* **inherits:** [" + attributes["Parent"] + "](" + parseInheritance(attributes["Parent"]) + ")\n"
  
                 plugin_string += parseSees(attributes.get("see", None))
                 plugin_string += parseAuthors(attributes.get("author", None))
@@ -3,6 +3,21 @@ body {
     padding-top: 5%;
 }
  
+/* Center the header and tagline */
+#openbr, #tagline {
+    text-align: center;
+}
+
+/* The anchor tags in the tables
+ * are blocked by the navbar when
+ * they are used. This fixes that */
+a.table-anchor {
+    display: block;
+    position: relative;
+    top: -70px;
+    visibility: hidden;
+}
+
 h1[id]:before, h2[id]:before {
     content: "";
     display: block;
@@ -10,8 +25,19 @@ h1[id]:before, h2[id]:before {
     height: 75px;
 }
  
+h3 {
+    margin-top: 50px;
+    margin-bottom: 20px;
+    padding: 10px;
+    border-radius: 5px;
+    font-size: 120%;
+    background-color: #e7e7e7;/* text-color => #3399f3;*/
+    display: block;
+}
+
 ul.nav li.main {
     font-weight: bold;
+    font-size: 90%;
 }
  
 div.col-md-3 {
@@ -7,9 +7,18 @@ $( document ).ready(function() {
  
  
 $('body').scrollspy({
-    target: '.bs-sidebar',
+    target: '#bs-sidebar',
 });
  
+$('[data-spy="scroll"]').each(function()
+{
+    $(this).scrollspy('refresh');
+});
+
+$('#myScrollspy').on('activate.bs.scrollspy', function () {
+    $(this).parent().children('ul.scroll_toggle').toggle(50)
+})
+
 /* Prevent disabled links from causing a page reload */
 $("li.disabled a").click(function() {
     event.preventDefault();
-<div class="bs-sidebar hidden-print affix" role="complementary">
+<div id="bs-sidebar" class="bs-sidebar hidden-print affix" role="complementary">
     <ul class="nav bs-sidenav">
-    {% for toc_item in toc %}
-        <li class="main {% if toc_item.active %}active{% endif %}"><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
-        {% for toc_item in toc_item.children %}
-            <li><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
+        {% for toc_item in toc %}
+            <li class="main {% if toc_item.active %}active{% endif %}"><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
+            {% if toc_item.children %}
+                <ul class="nav scroll_toggle">
+                {% for toc_item in toc_item.children %}
+                    <li><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
+                {% endfor %}
+                </ul>
+                <hr />
+            {% endif %}
         {% endfor %}
-    {% endfor %}
+
+        <!-- Isn't working yet :( -->
+        {% if current_page == "Home" %}
+            <li class="github-button">
+                <div align="center">
+                    <iframe src="http://ghbtns.com/github-btn.html?user=biometrics&amp;repo=openbr&amp;type=watch&amp;count=true&amp;size=large"
+                        allowtransparency="true" frameborder="0" scrolling="0" width="150" height="30">
+                    </iframe>
+                </div>
+            </li>
+        {% endif %}
     </ul>
 </div>
@@ -23,41 +23,6 @@
 extern "C" {
 #endif
  
- /*!
- * \defgroup c_sdk C SDK
- * \brief High-level API for running algorithms and evaluating results.
- *
- * In order to provide a high-level interface that is usable from the command line and callable from other programming languages,
- * the API is designed to operate at the "file system" level.
- * In other words, arguments to many functions are file paths that specify either a source of input or a desired output.
- * File extensions are relied upon to determine \em how files should be interpreted in the context of the function being called.
- * The \ref cpp_plugin_sdk should be used if more fine-grained control is required.
- *
- * \code
- * #include <openbr/openbr.h>
- * \endcode
- * <a href="http://www.cmake.org/">CMake</a> developers may wish to use <tt>share/openbr/cmake/OpenBRConfig.cmake</tt>.
- *
- * \section managed_return_value Managed Return Value
- * Memory for <tt>const char*</tt> return values is managed internally and guaranteed until the next call to the function.
- *
- * \section input_string_buffer Input String Buffer
- * Users should input a char * buffer and the size of that buffer. String data will be copied into the buffer, if the buffer is too
- * small, only part of the string will be copied. Returns the buffer size required to contain the complete string.
- *
- * \section examples Examples
- * - \ref c_face_recognition_evaluation
- *
- * \subsection c_face_recognition_evaluation Face Recognition Evaluation
- * \ref cli_face_recognition_evaluation "Command Line Interface Equivalent"
- * \snippet app/examples/face_recognition_evaluation.cpp face_recognition_evaluation
- */
-
-/*!
- * \addtogroup c_sdk
- *  @{
- */
-
 /*!
  * \brief Wraps br::Context::about()
  * \see br_version
@@ -77,7 +42,6 @@ BR_EXPORT void br_cat(int num_input_galleries, const char *input_galleries[], co
  * \note If a gallery contains n duplicates, the first n-1 duplicates in the gallery will be removed and the nth will be kept.
  * \note Users are encouraged to use binary gallery formats as the entire gallery is read into memory in one call to Gallery::read.
  */
-
 BR_EXPORT void br_deduplicate(const char *input_gallery, const char *output_gallery, const char *threshold);
  
 /*!
@@ -122,6 +86,9 @@ BR_EXPORT void br_compare(const char *target_gallery, const char *query_gallery,
  */
 BR_EXPORT void br_compare_n(int num_targets, const char *target_galleries[], const char *query_gallery, const char *output);
  
+/*!
+ * \brief DOCUMENT ME!
+ */
 BR_EXPORT void br_pairwise_compare(const char *target_gallery, const char *query_gallery, const char *output = "");
  
 /*!
@@ -1040,11 +1040,6 @@ void Object::init(const File &amp;file_)
 }
  
 /* Context - public methods */
-int br::Context::blocks(int size) const
-{
-    return std::ceil(1.f*size/blockSize);
-}
-
 bool br::Context::contains(const QString &name)
 {
     return property(qPrintable(name)).isValid();
@@ -764,12 +764,6 @@ public:
     QTime startTime; /*!< \brief Used to estimate timeRemaining(). */
  
     /*!
-     * \brief Returns the suggested number of partitions \em size should be divided into for processing.
-     * \param size The length of the list to be partitioned.
-     */
-    int blocks(int size) const;
-
-    /*!
      * \brief Returns true if \em name is queryable using <a href="http://doc.qt.digia.com/qt/qobject.html#property">QObject::property</a>
      * \param name The property key to check for existance.
      * \return \c true if \em name is a property, \c false otherwise.
@@ -27,8 +27,8 @@ namespace br
  * \brief Wraps OpenCV's Ada Boost framework
  * \author Scott Klum \cite sklum
  * \see http://docs.opencv.org/modules/ml/doc/boosting.html
- * \property enum type Type of Adaboost to perform. Options are Discrete, Real, Logit, and Gentle. Default is Real.
- * \property enum splitCriteria Splitting criteria used to choose optimal splits during a weak tree construction. Options are Default, Gini, Misclass, Sqerr. Default is Default.
+ * \property enum type Type of Adaboost to perform. Options are: [Discrete, Real, Logit, Gentle] Default is Real.
+ * \property enum splitCriteria Splitting criteria used to choose optimal splits during a weak tree construction. Options are: [Default, Gini, Misclass, Sqerr] Default is Default.
  * \property int weakCount Maximum number of weak classifiers per stage. Default is 100.
  * \property float trimRate A threshold between 0 and 1 used to save computational time. Samples with summary weight \leq 1 - weight\_trim\_rate do not participate in the next iteration of training. Set this parameter to 0 to turn off this functionality. Default is 0.95.
  * \property int folds OpenCV parameter variable. Default value is 0.
@@ -49,7 +49,7 @@ BR_REGISTER(Initializer, EigenInitializer)
  * \author Brendan Klare \cite bklare
  * \author Josh Klontz \cite jklontz
  *
- * \property float keep Default is 0.95. If (keep <  0) then all eigenvalues are retained. If (keep =  0) then no PCA is performed and the eigenvectors form an identity matrix. If (0 < keep <  1) then keep is the fraction of the variance to retain. If (keep >= 1) then keep is the number of leading eigenvectors to retain.
+ * \property float keep Options are: [keep < 0 - All eigenvalues are retained, keep == 0 - No PCA is performed and the eigenvectors form an identity matrix, 0 < keep < 1 - Keep is the fraction of the variance to retain, keep >= 1 - keep is the number of leading eigenvectors to retain] Default is 0.95.
  * \property int drop BRENDAN OR JOSH FILL ME IN. Default is 0.
  * \property bool whiten BRENDAN OR JOSH FILL ME IN. Default is false.
  */
@@ -23,6 +23,7 @@ namespace br
  * \ingroup transforms
  * \brief Collect nearest neighbors and append them to metadata.
  * \author Charles Otto \cite caotto
+ * \property int keep The maximum number of nearest neighbors to keep. Default is 20.
  */
 class CollectNNTransform : public UntrainableMetaTransform
 {
@@ -28,6 +28,9 @@ namespace br
  * \ingroup transforms
  * \brief Wraps OpenCV kmeans and flann.
  * \author Josh Klontz \cite jklontz
+ * \property int kTrain The number of random centroids to make at train time. Default is 256.
+ * \property int kSearch The number of nearest neighbors to search for at runtime. Default is 1.
+ * \see http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html
  */
 class KMeansTransform : public Transform
 {
@@ -25,6 +25,7 @@ namespace br
  * \ingroup transforms
  * \brief Log nearest neighbors to specified file.
  * \author Charles Otto \cite caotto
+ * \property QString fileName The name of the log file. An empty fileName won't be written to. Default is "".
  */
 class LogNNTransform : public TimeVaryingTransform
 {
@@ -29,7 +29,9 @@ namespace br
  * \ingroup transforms
  * \brief Chooses k random points to be centroids.
  * \author Austin Blanton \cite imaus10
- * \see KMeansTransform
+ * \property int kTrain The number of random centroids to make at train time. Default is 256.
+ * \property int kSearch The number of nearest neighbors to search for at runtime. Default is 1.
+ * \see http://docs.opencv.org/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.html
  */
 class RandomCentroidsTransform : public Transform
 {
@@ -29,6 +29,11 @@
 namespace br
 {
  
+/*!
+ * \ingroup galleries
+ * \brief An abstract gallery for handling binary data
+ * \author Unknown
+ */
 class BinaryGallery : public Gallery
 {
     Q_OBJECT
@@ -58,7 +58,7 @@ PROJECT_LOGO           = ${CPACK_PACKAGE_ICON}
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
  
-OUTPUT_DIRECTORY       =
+OUTPUT_DIRECTORY       = ${CMAKE_SOURCE_DIR}/docs/doxygen/
  
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
@@ -1026,7 +1026,7 @@ IGNORE_PREFIX          =
 # If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
 # The default value is: YES.
  
-GENERATE_HTML          = YES
+GENERATE_HTML          = NO
  
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
@@ -1813,7 +1813,7 @@ MAN_LINKS              = NO
 # captures the structure of the code including all documentation.
 # The default value is: NO.
  
-GENERATE_XML           = NO
+GENERATE_XML           = YES
  
 # The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
 # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of