Core Classes and Interfaces

Application:

Application is the most basic class responsible for instantiating the program’s features. Upon creation, it populates a “Toolbox”, constructs global data references, and displays the UI.

IAction/IActionReceiver:

In the default implementation, user interaction is accomplished via the command pattern using Actions and, optionally, ActionReceivers. The doAction() method executes the action. It is useful to assign IActions to UI components to diminish coupling and reduce the need for passing in external references. Example IActions

ToolBox:

ToolBox constructs all Tools used by the application, and is responsible for passing in the appropriate data references. Example: DefaultToolBox

Tools:

A Tool constructs a Glimpse View. Any displayable panel in the application should extend the ITool interface. Non-default functionality can be accomplished by overriding the default toolbox and adding customized tools. Example Tools

Observers and Observables:

Applications use the observer pattern to automatically update the displayed graph when the underlying data updates. Specifically, tools observe data references, which in turn may observe each other. An observer begins observing an Observable with the addObserver() function. Whenever an update occurs, the notifyObservers() function is called on the Observable, which calls update() on the observer. Example Observers: GraphableDataPanel, GraphPanel, EvaluationSetPanel. Example Obervables: InputDataReferenceImpl, OutputDataReferenceImpl.

Data Reference (InputDataReference, OutputDataReference, and GraphReference):

A data reference is a class that holds data for the application. It is an Observable so that any parts of the application that use the data can be updated whenever its data changes.

TagHeader:

TagHeader is a single set of identifiers (tags) for the data points in the application. For example, a tag header could be the fold used for the classifier and the tags in the header could be fold1, fold2, and fold3. Each data point should have single tag from each tag header.

ClassifierDataSet:

ClassifierDataSet is a set of DataPoints that have been classified. It contains the name of the set of point as well as the tags associated with the points in its set.

DataPoint:

DataPoint is a single point of data that is input into the application. It should at minimum have a truth value and a set of one or more classifier scores associated with that value. They should be stored in ClassifierDataSets according to their associated tags. Example DataPoint

GraphPoint:

GraphPoint is a single point of graphable data. It should at minimum have an X and Y value, as well as a map containing further analytics associated with that point. Example GraphPoint

Axis:

An Axis is responsible for determining the range over which data is displayed on a graph, the label to display on the axis, and the unit, if applicable. Example Axis

GraphableData:

GraphableData is a set of GraphPoints that can be plotted on a graph. It outputs the X and Y values of the points in its set, the bounds of these values, as well as other necessary information for plotting the points. Example GraphableData

GraphableFunction:

Any implementation of GraphableFunction, given some input, must produce GraphableData. For example, given a ClassifierDataSet as input, the ROCCurveFunction plots the False Positive Rate against the True Positive Rate. A CompositeFunction is a GraphableFunction takes GraphableData as input. Example GraphableFunctions: Composite Function, ROCCurveFunction.

ClassifierSetPoint:

This is used specifically by the ROCCurveFunction. A ClassifierSetPoint stores the number of true positives, true negatives, false positives, and false negatives at a given threshold.

ParametricFunction:

A ParametricFunction, given some input, outputs a double. For example, given a ClassifierSetPoint as input, the FalsePositiveRate function outputs a double representing the false positive rate at that point’s threshold. Example ParametricFunction