WekaSegmentation (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- trainableSegmentation.WekaSegmentation

```
public class WekaSegmentation
extends Object
```
This class contains all the library methods to perform image segmentation based on the Weka classifiers.

Field Summary

Fields
Modifier and Type Field and Description

static int MAX_NUM_CLASSES
maximum number of classes (labels) allowed

Fields
Modifier and Type	Field and Description
`static int`	`MAX_NUM_CLASSES` maximum number of classes (labels) allowed

Constructor Summary

Constructors
Constructor and Description
`WekaSegmentation()` No-image constructor.
`WekaSegmentation(boolean isProcessing3D)` Constructor for both 2D and 3D images.
`WekaSegmentation(ij.ImagePlus trainingImage)` Default constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`boolean`	`addBinaryData(ij.ImagePlus labelImage, FeatureStack featureStack, String className)` Add instances to a specific class from a label (binary) image.
`boolean`	`addBinaryData(ij.ImagePlus labelImage, FeatureStack featureStack, String className1, String className2)` Add instances to two classes from a label (binary) image.
`boolean`	`addBinaryData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, ij.ImagePlus filters, String whiteClassName, String blackClassName)` Add binary training data from input and label images.
`boolean`	`addBinaryData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, String whiteClassName, String blackClassName)` Add binary training data from input and label images.
`boolean`	`addBinaryData(ij.ImagePlus labelImage, int n, String whiteClassName, String blackClassName)` Add label image as binary data
`boolean`	`addBinaryData(List<Point3f>[] classPoints, FeatureStackArray fsa, String whiteClassName, String blackClassName)` Add instances to two classes from lists of coordinates.
`boolean`	`addCenterLinesBinaryData(ij.ImagePlus labelImage, int n, String whiteClassName, String blackClassName)` Add center lines of label image as binary data
`void`	`addClass()` Add new segmentation class.
`boolean`	`addErodedBinaryData(ij.ImagePlus labelImage, int n, String whiteClassName, String blackClassName)` Add eroded version of label image as binary data
`void`	`addExample(int classNum, Roi roi, int n)` Adds a ROI to the list of examples for a certain class and slice.
`boolean`	`addLabeledData(ij.ImagePlus labelImage, FeatureStack featureStack)` Add instances from a labeled image.
`boolean`	`addLabeledData(ij.ImagePlus inputImage, ij.ImagePlus labelImage)` Add labeled training data from input and label images.
`boolean`	`addLabeledData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, int[] classIndexToLabel, int numSamples)` Add training data from input and labeled images.
`boolean`	`addLabeledData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, String[] classNames, int numSamples)` Add training data from input and labeled images.
`boolean`	`addLabeledData(ij.process.ImageProcessor labelImage, FeatureStack featureStack, int[] classIndexToLabel, int numSamples)` Add instances reading the pixel classes from a label image.
`boolean`	`addLabeledData(ij.process.ImageProcessor labelImage, FeatureStack featureStack, String[] classNames, int numSamples)` Add instances reading the pixel classes from a label image.
`boolean`	`addRandomBalancedBinaryData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, ij.ImagePlus filters, String whiteClassName, String blackClassName, int numSamples)` Add binary training data from input and label images in a random and balanced way (same number of samples per class).
`boolean`	`addRandomBalancedBinaryData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, String whiteClassName, String blackClassName, int numSamples)` Add binary training data from input and label images in a random and balanced way (same number of samples per class).
`boolean`	`addRandomBalancedBinaryData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, String whiteClassName, String blackClassName, int numSamples, ij.ImagePlus mask)` Add binary training data from input and label images in a random and balanced way (same number of samples per class).
`boolean`	`addRandomBalancedBinaryData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, String whiteClassName, String blackClassName, int numSamples, ij.ImagePlus mask, ij.ImagePlus weights)` Add binary training data from input and label images in a random and balanced way (same number of samples per class).
`boolean`	`addRandomBalancedBinaryData(ij.process.ImageProcessor labelImage, FeatureStack featureStack, String whiteClassName, String blackClassName, int numSamples)` Add instances to two classes from a label (binary) image in a random and balanced way.
`boolean`	`addRandomBalancedBinaryData(ij.process.ImageProcessor labelImage, ij.process.ImageProcessor mask, FeatureStack featureStack, String whiteClassName, String blackClassName, int numSamples)` Add instances to two classes from a label (binary) image in a random and balanced way (with repetition).
`boolean`	`addRandomBalancedBinaryData(ij.process.ImageProcessor labelImage, ij.process.ImageProcessor mask, ij.process.ImageProcessor weights, FeatureStack featureStack, String whiteClassName, String blackClassName, int numSamples)` Add instances to two classes from a label (binary) image in a random and balanced way (with repetition).
`boolean`	`addRandomBalancedBinaryData(List<Point3f>[] classPoints, FeatureStackArray fsa, ij.ImagePlus weights, String whiteClassName, String blackClassName, int numSamples)` Add instances to two classes from lists of coordinates in a random and balanced way.
`boolean`	`addRandomBalancedBinaryData(List<Point3f>[] classPoints, FeatureStackArray fsa, String whiteClassName, String blackClassName, int numSamples)` Add instances to two classes from lists of coordinates in a random and balanced way.
`boolean`	`addRandomBalancedLabeledData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, int numSamples)` Add training data from input and labeled images in a random and balanced way (same number of samples per class).
`boolean`	`addRandomBalancedLabeledData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, int[] classIndexToLabel, int numSamples)` Add training data from input and labeled images in a random and balanced way (same number of samples per class).
`boolean`	`addRandomBalancedLabeledData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, String[] classNames, int numSamples)` Add training data from input and labeled images in a random and balanced way (same number of samples per class).
`boolean`	`addRandomBalancedLabeledData(ij.process.ImageProcessor labelImage, FeatureStack featureStack, int numSamples)` Add instances from a labeled image in a random and balanced way.
`boolean`	`addRandomBalancedLabeledData(ij.process.ImageProcessor labelImage, FeatureStack featureStack, String[] classNames, int numSamples)` Add instances reading the pixel classes from a label image in a random and balanced way.
`boolean`	`addRandomBalancedLabeledData(ij.process.ImageProcessor labelImage, int[] classIndexToLabel, FeatureStack featureStack, int numSamples)` Add instances from a labeled image in a random and balanced way.
`boolean`	`addRandomData(ij.ImagePlus labelImage, FeatureStack featureStack, String whiteClassName, int numSamples)` Add instances defined by a label (binary) image in a random way.
`boolean`	`addRandomData(ij.ImagePlus inputImage, ij.ImagePlus labelImage, String whiteClassName, int numSamples)` Add training data from input and a binary label image in a random way.
`boolean`	`adjustSegmentationStateToData(Instances data)` Adjust current segmentation state (attributes and classes) to loaded data
`void`	`applyClassifier(boolean classify)` Apply current classifier to current image.
`ij.ImagePlus`	`applyClassifier(FeatureStackArray fsa, int numThreads, boolean probabilityMaps)` Apply current classifier to a set of feature vectors (given in a feature stack array).
`ij.ImagePlus`	`applyClassifier(ij.ImagePlus imp)` Apply current classifier to a given image.
`ij.ImagePlus`	`applyClassifier(ij.ImagePlus imp, FeatureStackArray fsa, int numThreads, boolean probabilityMaps)` Apply current classifier to a given image with precomputed features.
`ij.ImagePlus`	`applyClassifier(ij.ImagePlus imp, ij.ImagePlus filters, int numThreads, boolean probabilityMaps)` Apply current classifier to a given image with precomputed features.
`ij.ImagePlus`	`applyClassifier(ij.ImagePlus imp, int[] origin, int[] cropDims, int numThreads, boolean probabilityMaps)` Apply current classifier to a user-defined ROI of a given image.
`ij.ImagePlus`	`applyClassifier(ij.ImagePlus imp, int[] tilesPerDim, int numThreads, boolean probabilityMaps)` Apply the current classifier to an image subdividing the image in tiles for memory saving.
`ij.ImagePlus`	`applyClassifier(ij.ImagePlus imp, int numThreads, boolean probabilityMaps)` Apply current classifier to a given image.
`ij.ImagePlus`	`applyClassifier(Instances data, int w, int h, int numThreads, boolean probabilityMaps)` Apply current classifier to set of instances
`void`	`applyClassifier(int numThreads, boolean classify)` Apply current classifier to current image.
`ij.ImagePlus`	`applyClassifierMT(ij.ImagePlus imp, int numThreads, boolean probabilityMaps)` Apply current classifier to a given image in a complete concurrent way.
`void`	`balanceTrainingData()` Balance number of instances per class (in the loaded training data)
`static Instances`	`balanceTrainingData(Instances data)` Balance number of instances per class
`Callable<ArrayList<ij.ImagePlus>>`	`classifyListOfImages(ArrayList<ij.ImagePlus> images, Instances dataInfo, AbstractClassifier classifier, AtomicInteger counter, boolean probabilityMaps)` Classify a list of images in a concurrent way
`Callable<ij.ImagePlus>`	`classifySlice(ij.ImagePlus slice, Instances dataInfo, AbstractClassifier classifier, AtomicInteger counter, boolean probabilityMaps)` Classify a slice in a concurrent way
`static Callable<int[][]>`	`confusionMatrixBinarySlice(ij.process.ImageProcessor proposal, ij.process.ImageProcessor expectedLabels, double threshold)` Calculate the confusion matrix of a slice (2 classes)
`boolean`	`containsColorFeatures(Instances data)` Check if a set of Weka instances has color attributes (given by the presence of the attribute names "Hue", "Saturation" or "Brightness").
`boolean`	`containsExclusive2DFeatures(Instances data)` Check if a set of Weka instances has 2D image attributes (given by the presence of the attribute names from FeatureStack which are not present in FeatureStack3D).
`boolean`	`containsExclusive3DFeatures(Instances data)` Check if a set of Weka instances has 3D image attributes (given by the presence of the attribute names from FeatureStack3D which are not present in FeatureStack).
`String`	`createHeaderName(boolean bool3d, boolean boolRGB)` Create the name of the training header.
`Callable<Instances>`	`createInstances(ArrayList<String> classNames, FeatureStack featureStack)` Create instances of a feature stack (to be submitted to an Executor Service)
`Instances`	`createTrainingInstances()` Create training instances out of the user markings
`void`	`deleteExample(int classNum, int nSlice, int index)` Remove an example list from a class and specific slice
`boolean`	`doClassBalance()` Get the boolean flag to enable/disable the class balance
`boolean`	`doHomogenizeClasses()` Deprecated. use doClassBalance
`void`	`filterFeatureStackByList()` Filter feature stack based on the list of feature names to use
`static void`	`filterFeatureStackByList(ArrayList<String> featureNames, FeatureStack featureStack)` Filter feature stack based on the list of feature names to use
`ij.ImagePlus`	`getClassifiedImage()` Get current classification result
`AbstractClassifier`	`getClassifier()` Returns the current classifier.
`String`	`getClassLabel(int classNum)` Get the label name of a class.
`String[]`	`getClassLabels()` Get the current class labels
`static int[][]`	`getConfusionMatrix(ij.ImagePlus proposal, ij.ImagePlus expectedLabels, double threshold)` Get confusion matrix (2 classes)
`int[][]`	`getConfusionMatrix(ij.ImagePlus proposedLabels, ij.ImagePlus expectedLabels, int whiteClassIndex, int blackClassIndex)` Get confusion matrix (binary images)
`boolean[]`	`getEnabledFeatures()` Get the current enabled features
`List<Roi>`	`getExamples(int classNum, int n)` Return the list of examples for a certain class.
`FeatureStack`	`getFeatureStack(int i)` Get current feature stack
`FeatureStackArray`	`getFeatureStackArray()` Get the current feature stack array
`Instances`	`getLoadedTrainingData()` Returns a the loaded training data or null, if no training data was loaded.
`int`	`getMaxDepth()` Get maximum depth of the random forest
`float`	`getMaximumSigma()` Get the maximum sigma/radius to use in the features
`int`	`getMembranePatchSize()` Get the membrane patch size
`int`	`getMembraneThickness()` Get current expected membrane thickness
`float`	`getMinimumSigma()` Get the minimum sigma (radius) to use in the features
`String`	`getModelVersion()` Get the version of the plugin used for creating the model.
`int`	`getNumOfClasses()` Get the current number of classes.
`int`	`getNumOfTrees()` Get current number of trees (for random forest training)
`int`	`getNumRandomFeatures()` Get number of random features (random forest training)
`int[][]`	`getTestConfusionMatrix(ij.ImagePlus image, ij.ImagePlus filters, ij.ImagePlus expectedLabels, int whiteClassIndex, int blackClassIndex)` Get the confusion matrix for an input image and its expected labels
`int[][]`	`getTestConfusionMatrix(ij.ImagePlus image, ij.ImagePlus expectedLabels, int whiteClassIndex, int blackClassIndex)` Get the confusion matrix for an input image and its expected labels
`double`	`getTestError(ij.ImagePlus image, ij.ImagePlus labels, ij.ImagePlus filters, int whiteClassIndex, int blackClassIndex, boolean verbose)` Get test error of current classifier on a specific image and its binary labels
`double`	`getTestError(ij.ImagePlus image, ij.ImagePlus labels, int whiteClassIndex, int blackClassIndex, boolean verbose)` Get test error of current classifier on a specific image and its binary labels
`Instances`	`getTraceTrainingData()` Returns a the trace training data or null, if no examples have been given.
`Instances`	`getTrainHeader()` Get the current training header
`double`	`getTrainingError(boolean verbose)` Get training error (from loaded data).
`Instances`	`getTrainingInstances()` Get loaded (or accumulated) training instances
`void`	`homogenizeTrainingData()` Deprecated. use balanceTrainingData
`static Instances`	`homogenizeTrainingData(Instances data)` Deprecated. use balanceTrainingData
`boolean`	`isProcessing3D()` Check the use of 3D or 2D features
`boolean`	`loadClassifier(InputStream classifierInputStream)` load a binary classifier from a stream
`boolean`	`loadClassifier(String filename)` Read header classifier from a .model file
`boolean`	`loadNewImage(ij.ImagePlus newImage)` Load a new image to segment (no GUI)
`boolean`	`loadTrainingData(String pathname)` Load training data
`void`	`mergeDataInPlace(Instances first, Instances second)` Merge two datasets of Weka instances in place
`Instances`	`readDataFromARFF(String filename)` Read ARFF file
`boolean`	`saveClassifier(String filename)` Write current classifier into a file
`boolean`	`saveData(String pathname)` Save training data into a file (.arff)
`void`	`saveFeatureStack(int slice, String dir, String fileWithExt)` Save specific slice feature stack
`boolean`	`selectAttributes()` Select attributes of current data by BestFirst search.
`static Instances`	`selectAttributes(Instances data)` Select attributes using BestFirst search to reduce the number of parameters per instance of a dataset
`void`	`setClassBalance(boolean balanceClasses)` Set flag to balance classes before training
`void`	`setClassifier(AbstractClassifier cls)` Set current classifier
`void`	`setClassLabel(int classNum, String label)` Set the name of a class.
`void`	`setClassLabels(String[] classLabels)` Set the labels for each class
`void`	`setDoClassBalance(boolean balanceClasses)` Set the flag to balance the class distributions
`void`	`setDoHomogenizeClasses(boolean homogenizeClasses)` Deprecated. use setDoClassBalance
`void`	`setEnabledFeatures(boolean[] newFeatures)` Set the new enabled features
`boolean`	`setFeatures(ArrayList<String> featureNames)` Set features to use during training
`void`	`setFeaturesDirty()` Forces the feature stack to be updated whenever it is needed next.
`void`	`setFeatureStackArray(FeatureStackArray fsa)` Assign an arbitrary filter stack array
`void`	`setHomogenizeClasses(boolean homogenizeClasses)` Deprecated. use setClassBalance
`void`	`setLoadedClassNames(ArrayList<String> classNames)` Set the list of loaded class names
`void`	`setLoadedTrainingData(Instances data)` Set pre-loaded training data (not from the user traces)
`void`	`setMaximumSigma(float sigma)` Set the maximum sigma/radius to use in the features
`void`	`setMembranePatchSize(int patchSize)` Set the membrane patch size (it must be an odd number)
`void`	`setMembraneThickness(int thickness)` Set expected membrane thickness (this will be the width of the center column of the membrane filter)
`void`	`setMinimumSigma(float sigma)` Set the minimum sigma (radius) to use in the features
`void`	`setNumOfClasses(int numOfClasses)` Set the current number of classes.
`void`	`setProjectFolder(String projectFolder)` Set the project folder
`boolean`	`setTrainHeader(Instances newHeader)` Set current training header, and attempt to adjust segmentation state to it.
`void`	`setTrainingImage(ij.ImagePlus imp)` Set the training image (single image or stack)
`void`	`setUpdateFeatures(boolean updateFeatures)` Set feature update flag
`void`	`setUseNeighbors(boolean useNeighbors)` Set the use of the neighbor features
`void`	`shutDownNow()` Shut down the executor service for training and feature creation
`boolean`	`trainClassifier()` Train classifier with the current instances
`void`	`udpateDataClassification(ij.ImagePlus labels, String className1, String className2)` Update the class attribute of "loadedTrainingData" from the input binary labels.
`boolean`	`updateClassifier(int newNumTrees, int newRandomFeatures, int newMaxDepth)` Update fast random forest classifier with new values
`static void`	`updateDataClassification(Instances data, ij.ImagePlus labels, int classIndex1, int classIndex2)` Update the class attribute of "data" from the input binary labels.
`static void`	`updateDataClassification(Instances data, ij.ImagePlus labels, int classIndex1, int classIndex2, ArrayList<Point3f>[] mismatches)` Update the class attribute of "data" from the input binary labels.
`Instances`	`updateWholeImageData()` Create the whole image data (instances) from the current image and feature stack.
`void`	`useAllFeatures()` Force segmentator to use all available features
`boolean`	`writeDataToARFF(Instances data, String filename)` Write current instances into an ARFF file

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MAX_NUM_CLASSES
```
public static final int MAX_NUM_CLASSES
```
    maximum number of classes (labels) allowed
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - WekaSegmentation
```
public WekaSegmentation(ij.ImagePlus trainingImage)
```
    Default constructor.
    
    Parameters:
    
    trainingImage - The image to be segmented/trained
  - WekaSegmentation
```
public WekaSegmentation()
```
    No-image constructor. If you use this constructor, the image has to be set using setTrainingImage(). Another option is to use the object to load a classifier and apply it to other images without additional training.
  - WekaSegmentation
```
public WekaSegmentation(boolean isProcessing3D)
```
    Constructor for both 2D and 3D images. No training image is set yet, so it can be used by loading a classifier (using loadClassifier() or by setting later a training image (using setTrainingImage()).
    
    Parameters:
    
    isProcessing3D - true to process images in 3D and false to do it in 2D
- Method Detail
  - setTrainingImage
```
public void setTrainingImage(ij.ImagePlus imp)
```
    Set the training image (single image or stack)
    
    Parameters:
    
    imp - training image
  - addExample
```
public void addExample(int classNum,
                       Roi roi,
                       int n)
```
    Adds a ROI to the list of examples for a certain class and slice.
    
    Parameters:
    
    classNum - the number of the class
    
    roi - the ROI containing the new example
    
    n - number of the current slice
  - deleteExample
```
public void deleteExample(int classNum,
                          int nSlice,
                          int index)
```
    Remove an example list from a class and specific slice
    
    Parameters:
    
    classNum - the number of the examples' class
    
    nSlice - the slice number
    
    index - the index of the example list to remove
  - getExamples
```
public List<Roi> getExamples(int classNum,
                             int n)
```
    Return the list of examples for a certain class.
    
    Parameters:
    
    classNum - the number of the examples' class
    
    n - the slice number
    
    Returns:
    
    list of examples (ROIs) of a specific class on a given slice
  - setHomogenizeClasses
```
public void setHomogenizeClasses(boolean homogenizeClasses)
```
    Deprecated. use setClassBalance
    
    Set flag to homogenize classes before training
    
    Parameters:
    
    homogenizeClasses - true to resample the classes before training
  - setClassBalance
```
public void setClassBalance(boolean balanceClasses)
```
    Set flag to balance classes before training
    
    Parameters:
    
    balanceClasses - true to resample the classes before training
  - setNumOfClasses
```
public void setNumOfClasses(int numOfClasses)
```
    Set the current number of classes. Should not be used to create new classes. Use addClass() instead.
    
    Parameters:
    
    numOfClasses - the new number of classes
  - getNumOfClasses
```
public int getNumOfClasses()
```
    Get the current number of classes.
    
    Returns:
    
    the current number of classes
  - addClass
```
public void addClass()
```
    Add new segmentation class.
  - setClassLabel
```
public void setClassLabel(int classNum,
                          String label)
```
    Set the name of a class.
    
    Parameters:
    
    classNum - class index
    
    label - new name for the class
  - getClassLabel
```
public String getClassLabel(int classNum)
```
    Get the label name of a class.
    
    Parameters:
    
    classNum - class index
    
    Returns:
    
    label name of a class
  - loadTrainingData
```
public boolean loadTrainingData(String pathname)
```
    Load training data
    
    Parameters:
    
    pathname - complete path name of the training data file (.arff)
    
    Returns:
    
    false if error
  - getLoadedTrainingData
```
public Instances getLoadedTrainingData()
```
    Returns a the loaded training data or null, if no training data was loaded.
    
    Returns:
    
    set of training instances loaded from file or null if nothing has been loaded
  - getTraceTrainingData
```
public Instances getTraceTrainingData()
```
    Returns a the trace training data or null, if no examples have been given.
    
    Returns:
    
    current set of training samples calculated from the user traces
  - getClassifiedImage
```
public ij.ImagePlus getClassifiedImage()
```
    Get current classification result
    
    Returns:
    
    classified image
  - getTrainHeader
```
public Instances getTrainHeader()
```
    Get the current training header
    
    Returns:
    
    training header (empty set of instances with the current attributes and classes)
  - loadClassifier
```
public boolean loadClassifier(InputStream classifierInputStream)
```
    load a binary classifier from a stream
    
    Parameters:
    
    classifierInputStream - the input stream
    
    Returns:
    
    true if properly read, false otherwise
  - loadClassifier
```
public boolean loadClassifier(String filename)
```
    Read header classifier from a .model file
    
    Parameters:
    
    filename - complete path and file name
    
    Returns:
    
    false if error
  - containsColorFeatures
```
public boolean containsColorFeatures(Instances data)
```
    Check if a set of Weka instances has color attributes (given by the presence of the attribute names "Hue", "Saturation" or "Brightness").
    
    Parameters:
    
    data - set of Weka instances
    
    Returns:
    
    true if the set contains color attributes, false otherwise
  - containsExclusive2DFeatures
```
public boolean containsExclusive2DFeatures(Instances data)
```
    Check if a set of Weka instances has 2D image attributes (given by the presence of the attribute names from FeatureStack which are not present in FeatureStack3D).
    
    Parameters:
    
    data - set of Weka instances
    
    Returns:
    
    true if the set contains exclusive 2D attributes, false otherwise
  - containsExclusive3DFeatures
```
public boolean containsExclusive3DFeatures(Instances data)
```
    Check if a set of Weka instances has 3D image attributes (given by the presence of the attribute names from FeatureStack3D which are not present in FeatureStack).
    
    Parameters:
    
    data - set of Weka instances
    
    Returns:
    
    true if the set contains exclusive 3D attributes, false otherwise
  - getClassifier
```
public AbstractClassifier getClassifier()
```
    Returns the current classifier.
    
    Returns:
    
    current classifier
  - saveClassifier
```
public boolean saveClassifier(String filename)
```
    Write current classifier into a file
    
    Parameters:
    
    filename - name (with complete path) of the destination file
    
    Returns:
    
    false if error
  - saveData
```
public boolean saveData(String pathname)
```
    Save training data into a file (.arff)
    
    Parameters:
    
    pathname - complete path name
    
    Returns:
    
    false if error
  - setUseNeighbors
```
public void setUseNeighbors(boolean useNeighbors)
```
    Set the use of the neighbor features
    
    Parameters:
    
    useNeighbors - flag to set the use of the neighbor features
  - addBinaryData
```
public boolean addBinaryData(ij.ImagePlus labelImage,
                             FeatureStack featureStack,
                             String className)
```
    Add instances to a specific class from a label (binary) image. Only white (non black) pixels will be added to the corresponding class.
    
    Parameters:
    
    labelImage - binary image
    
    featureStack - corresponding feature stack
    
    className - name of the class which receives the instances
    
    Returns:
    
    false if error
  - addBinaryData
```
public boolean addBinaryData(ij.ImagePlus labelImage,
                             FeatureStack featureStack,
                             String className1,
                             String className2)
```
    Add instances to two classes from a label (binary) image. White pixels will be added to the corresponding class 1 and black pixels will be added to class 2.
    
    Parameters:
    
    labelImage - binary image
    
    featureStack - corresponding feature stack
    
    className1 - name of the class which receives the white pixels
    
    className2 - name of the class which receives the black pixels
    
    Returns:
    
    false if error
  - addLabeledData
```
public boolean addLabeledData(ij.ImagePlus labelImage,
                              FeatureStack featureStack)
```
    Add instances from a labeled image. Each sample will be added to the class with the index value equal to the sample label. Labels that do not correspond to any class will be skipped.
    
    Parameters:
    
    labelImage - labeled image
    
    featureStack - corresponding feature stack
    
    Returns:
    
    false if error
  - addRandomBalancedLabeledData
```
public boolean addRandomBalancedLabeledData(ij.process.ImageProcessor labelImage,
                                            FeatureStack featureStack,
                                            int numSamples)
```
    Add instances from a labeled image in a random and balanced way. For convention, the label zero is used to define pixels with no class assigned. The rest of integer values correspond to the order of the classes (1 for the first class, 2 for the second class, etc.).
    
    Parameters:
    
    labelImage - labeled image (labels are positive integer or 0)
    
    featureStack - corresponding feature stack
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addRandomBalancedLabeledData
```
public boolean addRandomBalancedLabeledData(ij.process.ImageProcessor labelImage,
                                            int[] classIndexToLabel,
                                            FeatureStack featureStack,
                                            int numSamples)
```
    Add instances from a labeled image in a random and balanced way.
    
    Parameters:
    
    labelImage - labeled image
    
    classIndexToLabel - correspondences between class indices and label values
    
    featureStack - corresponding feature stack
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(ij.process.ImageProcessor labelImage,
                                           FeatureStack featureStack,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples)
```
    Add instances to two classes from a label (binary) image in a random and balanced way. White pixels will be added to the corresponding class 1 and black pixels will be added to class 2.
    
    Parameters:
    
    labelImage - binary image
    
    featureStack - corresponding feature stack
    
    whiteClassName - name of the class which receives the white pixels
    
    blackClassName - name of the class which receives the black pixels
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addRandomBalancedLabeledData
```
public boolean addRandomBalancedLabeledData(ij.process.ImageProcessor labelImage,
                                            FeatureStack featureStack,
                                            String[] classNames,
                                            int numSamples)
```
    Add instances reading the pixel classes from a label image in a random and balanced way. The label image might contain more than 2 classes and its values need to be consecutive integers starting at 0 (0, 1, 2...) that correspond to the indexes of the class names provided by the user. Label values that do not correspond with any class index are skipped.
    
    Parameters:
    
    labelImage - label image with a different labeling per class
    
    featureStack - corresponding feature stack
    
    classNames - array with the corresponding names of the classes
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addLabeledData
```
public boolean addLabeledData(ij.process.ImageProcessor labelImage,
                              FeatureStack featureStack,
                              String[] classNames,
                              int numSamples)
```
    Add instances reading the pixel classes from a label image. The label image might contain more than 2 classes and its values need to be consecutive integers starting at 0 (0, 1, 2...) that correspond to the indexes of the class names provided by the user. Label values that do not correspond with any class index are skipped. Repetition will be used in the selection of samples.
    
    Parameters:
    
    labelImage - label image with a different labeling per class
    
    featureStack - corresponding feature stack
    
    classNames - array with the corresponding names of the classes
    
    numSamples - total number of random samples to select
    
    Returns:
    
    false if error
  - addLabeledData
```
public boolean addLabeledData(ij.process.ImageProcessor labelImage,
                              FeatureStack featureStack,
                              int[] classIndexToLabel,
                              int numSamples)
```
    Add instances reading the pixel classes from a label image. The label image might contain more than 2 classes. Label values that do not correspond with any class index are skipped. Repetition will be used in the selection of samples.
    
    Parameters:
    
    labelImage - label image with a different labeling per class
    
    featureStack - corresponding feature stack
    
    classIndexToLabel - array with the corresponding label values per class
    
    numSamples - total number of random samples to select
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(ij.process.ImageProcessor labelImage,
                                           ij.process.ImageProcessor mask,
                                           FeatureStack featureStack,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples)
```
    Add instances to two classes from a label (binary) image in a random and balanced way (with repetition). White pixels will be added to the corresponding class 1 and black pixels will be added to class 2.
    
    Parameters:
    
    labelImage - binary image
    
    mask - binary mask image to prevent some pixel to be selected (null if all pixels are eligible)
    
    featureStack - corresponding feature stack
    
    whiteClassName - name of the class which receives the white pixels
    
    blackClassName - name of the class which receives the black pixels
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(List<Point3f>[] classPoints,
                                           FeatureStackArray fsa,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples)
```
    Add instances to two classes from lists of coordinates in a random and balanced way. White pixels will be added to the corresponding class 1 and black pixels will be added to class 2.
    
    Parameters:
    
    classPoints - list of 3D coordinates to be used (x, y, slice)
    
    fsa - feature stack array
    
    whiteClassName - name of the class which receives the white pixels
    
    blackClassName - name of the class which receives the black pixels
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addBinaryData
```
public boolean addBinaryData(List<Point3f>[] classPoints,
                             FeatureStackArray fsa,
                             String whiteClassName,
                             String blackClassName)
```
    Add instances to two classes from lists of coordinates. White pixels will be added to the corresponding class 1 and black pixels will be added to class 2.
    
    Parameters:
    
    classPoints - list of 3D coordinates to be used (x, y, slice)
    
    fsa - feature stack array
    
    whiteClassName - name of the class which receives the white pixels
    
    blackClassName - name of the class which receives the black pixels
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(List<Point3f>[] classPoints,
                                           FeatureStackArray fsa,
                                           ij.ImagePlus weights,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples)
```
    Add instances to two classes from lists of coordinates in a random and balanced way. White pixels will be added to the corresponding class 1 and black pixels will be added to class 2.
    
    Parameters:
    
    classPoints - list of 3D coordinates to be used (x, y, slice)
    
    fsa - feature stack array
    
    weights - weight image
    
    whiteClassName - name of the class which receives the white pixels
    
    blackClassName - name of the class which receives the black pixels
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(ij.process.ImageProcessor labelImage,
                                           ij.process.ImageProcessor mask,
                                           ij.process.ImageProcessor weights,
                                           FeatureStack featureStack,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples)
```
    Add instances to two classes from a label (binary) image in a random and balanced way (with repetition). White pixels will be added to the corresponding class 1 and black pixels will be added to class 2.
    
    Parameters:
    
    labelImage - binary image
    
    mask - binary mask image to prevent some pixel to be selected (null if all pixels are eligible)
    
    weights - weight image
    
    featureStack - corresponding feature stack
    
    whiteClassName - name of the class which receives the white pixels
    
    blackClassName - name of the class which receives the black pixels
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - addRandomData
```
public boolean addRandomData(ij.ImagePlus labelImage,
                             FeatureStack featureStack,
                             String whiteClassName,
                             int numSamples)
```
    Add instances defined by a label (binary) image in a random way. White pixels (with intensity values larger than 0) will be added to the corresponding class 1 (defined by whiteClassName)
    
    Parameters:
    
    labelImage - binary image
    
    featureStack - corresponding feature stack
    
    whiteClassName - name of the class which receives the white pixels
    
    numSamples - number of samples to add of each class
    
    Returns:
    
    false if error
  - getFeatureStack
```
public FeatureStack getFeatureStack(int i)
```
    Get current feature stack
    
    Parameters:
    
    i - number of feature stack slice (>=1)
    
    Returns:
    
    feature stack of the corresponding slice
  - getFeatureStackArray
```
public FeatureStackArray getFeatureStackArray()
```
    Get the current feature stack array
    
    Returns:
    
    current feature stack array
  - getTrainingInstances
```
public Instances getTrainingInstances()
```
    Get loaded (or accumulated) training instances
    
    Returns:
    
    loaded/accumulated training instances
  - setClassifier
```
public void setClassifier(AbstractClassifier cls)
```
    Set current classifier
    
    Parameters:
    
    cls - new classifier
  - setTrainHeader
```
public boolean setTrainHeader(Instances newHeader)
```
    Set current training header, and attempt to adjust segmentation state to it.
    
    Parameters:
    
    newHeader - the header to set
    
    Returns:
    
    true if adjustment was successful
  - loadNewImage
```
public boolean loadNewImage(ij.ImagePlus newImage)
```
    Load a new image to segment (no GUI)
    
    Parameters:
    
    newImage - new image to segment
    
    Returns:
    
    false if error
  - addCenterLinesBinaryData
```
public boolean addCenterLinesBinaryData(ij.ImagePlus labelImage,
                                        int n,
                                        String whiteClassName,
                                        String blackClassName)
```
    Add center lines of label image as binary data
    
    Parameters:
    
    labelImage - binary label image
    
    n - feature stack array index
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    Returns:
    
    false if error
  - filterFeatureStackByList
```
public void filterFeatureStackByList()
```
    Filter feature stack based on the list of feature names to use
  - filterFeatureStackByList
```
public static void filterFeatureStackByList(ArrayList<String> featureNames,
                                            FeatureStack featureStack)
```
    Filter feature stack based on the list of feature names to use
    
    Parameters:
    
    featureNames - list of feature names to use
    
    featureStack - feature stack to filter
  - addBinaryData
```
public boolean addBinaryData(ij.ImagePlus labelImage,
                             int n,
                             String whiteClassName,
                             String blackClassName)
```
    Add label image as binary data
    
    Parameters:
    
    labelImage - binary label image
    
    n - slice number (0 <= n < number of slices)
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    Returns:
    
    false if error
  - addBinaryData
```
public boolean addBinaryData(ij.ImagePlus inputImage,
                             ij.ImagePlus labelImage,
                             String whiteClassName,
                             String blackClassName)
```
    Add binary training data from input and label images. Input and label images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - binary label image
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    Returns:
    
    false if error
  - addLabeledData
```
public boolean addLabeledData(ij.ImagePlus inputImage,
                              ij.ImagePlus labelImage)
```
    Add labeled training data from input and label images. Input and label images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - label image with pixel values corresponding to class indexes
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(ij.ImagePlus inputImage,
                                           ij.ImagePlus labelImage,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples)
```
    Add binary training data from input and label images in a random and balanced way (same number of samples per class). Input and label images can be 2D or stacks and their sizes must match. It works as well for 3D features.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - binary label image
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    numSamples - number of samples to pick for each class
    
    Returns:
    
    false if error
  - addRandomBalancedLabeledData
```
public boolean addRandomBalancedLabeledData(ij.ImagePlus inputImage,
                                            ij.ImagePlus labelImage,
                                            int numSamples)
```
    Add training data from input and labeled images in a random and balanced way (same number of samples per class). Input and labeled images can be 2D or stacks and their sizes must match. For convention, the label zero is used to define pixels with no class assigned. The rest of integer values correspond to the order of the classes (1 for the first class, 2 for the second class, etc.).
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - labeled image (labeled values are positive integer or 0)
    
    numSamples - number of samples to pick for each class
    
    Returns:
    
    false if error
  - addRandomBalancedLabeledData
```
public boolean addRandomBalancedLabeledData(ij.ImagePlus inputImage,
                                            ij.ImagePlus labelImage,
                                            int[] classIndexToLabel,
                                            int numSamples)
```
    Add training data from input and labeled images in a random and balanced way (same number of samples per class). Input and labeled images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale or RGB image
    
    labelImage - labeled image
    
    classIndexToLabel - correspondences between class indices and label values
    
    numSamples - number of samples to pick for each class
    
    Returns:
    
    false if error
  - addLabeledData
```
public boolean addLabeledData(ij.ImagePlus inputImage,
                              ij.ImagePlus labelImage,
                              String[] classNames,
                              int numSamples)
```
    Add training data from input and labeled images. Input and labeled images can be 2D or stacks and their sizes must match. The label values must correspond with the indexes of the class names provided by the user.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - labeled image (labeled values are positive integer or 0)
    
    classNames - array with the corresponding class names
    
    numSamples - total number of random samples to pick
    
    Returns:
    
    false if error
  - addLabeledData
```
public boolean addLabeledData(ij.ImagePlus inputImage,
                              ij.ImagePlus labelImage,
                              int[] classIndexToLabel,
                              int numSamples)
```
    Add training data from input and labeled images. Input and labeled images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale or RGB image
    
    labelImage - labeled image (labeled values are positive integer or 0)
    
    classIndexToLabel - correspondences between class indices and label values
    
    numSamples - total number of random samples to pick
    
    Returns:
    
    false if error
  - addRandomBalancedLabeledData
```
public boolean addRandomBalancedLabeledData(ij.ImagePlus inputImage,
                                            ij.ImagePlus labelImage,
                                            String[] classNames,
                                            int numSamples)
```
    Add training data from input and labeled images in a random and balanced way (same number of samples per class). Input and labeled images can be 2D or stacks and their sizes must match. The label values must correspond with the indexes of the class names provided by the user.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - labeled image (labeled values are positive integer or 0)
    
    classNames - array with the corresponding class names
    
    numSamples - number of samples to pick for each class
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(ij.ImagePlus inputImage,
                                           ij.ImagePlus labelImage,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples,
                                           ij.ImagePlus mask)
```
    Add binary training data from input and label images in a random and balanced way (same number of samples per class). Input and label images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - binary label image
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    numSamples - number of samples to pick for each class
    
    mask - mask to prevent some pixel to be selected (null if all pixels are eligible)
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(ij.ImagePlus inputImage,
                                           ij.ImagePlus labelImage,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples,
                                           ij.ImagePlus mask,
                                           ij.ImagePlus weights)
```
    Add binary training data from input and label images in a random and balanced way (same number of samples per class). Input and label images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - binary label image
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    numSamples - number of samples to pick for each class
    
    mask - mask to prevent some pixel to be selected (null if all pixels are eligible)
    
    weights - image containing the weight of each sample
    
    Returns:
    
    false if error
  - addRandomData
```
public boolean addRandomData(ij.ImagePlus inputImage,
                             ij.ImagePlus labelImage,
                             String whiteClassName,
                             int numSamples)
```
    Add training data from input and a binary label image in a random way. Input and label images can be 2D or stacks and their sizes must match. The data will be added to the defined white class.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - binary label image (labels in white)
    
    whiteClassName - class name for the white pixels
    
    numSamples - number of samples to pick for each class
    
    Returns:
    
    false if error
  - addRandomBalancedBinaryData
```
public boolean addRandomBalancedBinaryData(ij.ImagePlus inputImage,
                                           ij.ImagePlus labelImage,
                                           ij.ImagePlus filters,
                                           String whiteClassName,
                                           String blackClassName,
                                           int numSamples)
```
    Add binary training data from input and label images in a random and balanced way (same number of samples per class). The features will be created out of a list of filters. Input and label images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - binary label image
    
    filters - stack of filters to create features
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    numSamples - number of samples to pick for each class
    
    Returns:
    
    false if error
  - addBinaryData
```
public boolean addBinaryData(ij.ImagePlus inputImage,
                             ij.ImagePlus labelImage,
                             ij.ImagePlus filters,
                             String whiteClassName,
                             String blackClassName)
```
    Add binary training data from input and label images. The features will be created out of a list of filters. Input and label images can be 2D or stacks and their sizes must match.
    
    Parameters:
    
    inputImage - input grayscale image
    
    labelImage - binary label image
    
    filters - stack of filters to create features
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    Returns:
    
    false if error
  - addErodedBinaryData
```
public boolean addErodedBinaryData(ij.ImagePlus labelImage,
                                   int n,
                                   String whiteClassName,
                                   String blackClassName)
```
    Add eroded version of label image as binary data
    
    Parameters:
    
    labelImage - binary label image
    
    n - feature stack array index
    
    whiteClassName - class name for the white pixels
    
    blackClassName - class name for the black pixels
    
    Returns:
    
    false if error
  - setLoadedTrainingData
```
public void setLoadedTrainingData(Instances data)
```
    Set pre-loaded training data (not from the user traces)
    
    Parameters:
    
    data - new data
  - useAllFeatures
```
public void useAllFeatures()
```
    Force segmentator to use all available features
  - setProjectFolder
```
public void setProjectFolder(String projectFolder)
```
    Set the project folder
    
    Parameters:
    
    projectFolder - complete path name for project folder
  - homogenizeTrainingData
```
public static Instances homogenizeTrainingData(Instances data)
```
    Deprecated. use balanceTrainingData
    
    Homogenize number of instances per class
    
    Parameters:
    
    data - input set of instances
    
    Returns:
    
    resampled set of instances
  - balanceTrainingData
```
public static Instances balanceTrainingData(Instances data)
```
    Balance number of instances per class
    
    Parameters:
    
    data - input set of instances
    
    Returns:
    
    resampled set of instances
  - homogenizeTrainingData
```
public void homogenizeTrainingData()
```
    Deprecated. use balanceTrainingData
    
    Homogenize number of instances per class (in the loaded training data)
  - balanceTrainingData
```
public void balanceTrainingData()
```
    Balance number of instances per class (in the loaded training data)
  - selectAttributes
```
public boolean selectAttributes()
```
    Select attributes of current data by BestFirst search. The data is reduced to the selected attributes (features).
    
    Returns:
    
    false if the current dataset is empty
  - selectAttributes
```
public static Instances selectAttributes(Instances data)
```
    Select attributes using BestFirst search to reduce the number of parameters per instance of a dataset
    
    Parameters:
    
    data - input set of instances
    
    Returns:
    
    resampled set of instances
  - getTrainingError
```
public double getTrainingError(boolean verbose)
```
    Get training error (from loaded data).
    
    Parameters:
    
    verbose - option to display evaluation information in the log window
    
    Returns:
    
    classifier error on the training data set.
  - getTestError
```
public double getTestError(ij.ImagePlus image,
                           ij.ImagePlus labels,
                           int whiteClassIndex,
                           int blackClassIndex,
                           boolean verbose)
```
    Get test error of current classifier on a specific image and its binary labels
    
    Parameters:
    
    image - input image
    
    labels - binary labels
    
    whiteClassIndex - index of the white class
    
    blackClassIndex - index of the black class
    
    verbose - option to display evaluation information in the log window
    
    Returns:
    
    pixel classification error
  - getTestConfusionMatrix
```
public int[][] getTestConfusionMatrix(ij.ImagePlus image,
                                      ij.ImagePlus expectedLabels,
                                      int whiteClassIndex,
                                      int blackClassIndex)
```
    Get the confusion matrix for an input image and its expected labels
    
    Parameters:
    
    image - input image
    
    expectedLabels - binary labels
    
    whiteClassIndex - index of the white class
    
    blackClassIndex - index of the black class
    
    Returns:
    
    confusion matrix
  - getConfusionMatrix
```
public int[][] getConfusionMatrix(ij.ImagePlus proposedLabels,
                                  ij.ImagePlus expectedLabels,
                                  int whiteClassIndex,
                                  int blackClassIndex)
```
    Get confusion matrix (binary images)
    
    Parameters:
    
    proposedLabels - proposed binary labels
    
    expectedLabels - original binary labels
    
    whiteClassIndex - index of white class
    
    blackClassIndex - index of black class
    
    Returns:
    
    confusion matrix
  - getConfusionMatrix
```
public static int[][] getConfusionMatrix(ij.ImagePlus proposal,
                                         ij.ImagePlus expectedLabels,
                                         double threshold)
```
    Get confusion matrix (2 classes)
    
    Parameters:
    
    proposal - probability image
    
    expectedLabels - original labels
    
    threshold - binary threshold to be applied to proposal
    
    Returns:
    
    confusion matrix
  - confusionMatrixBinarySlice
```
public static Callable<int[][]> confusionMatrixBinarySlice(ij.process.ImageProcessor proposal,
                                                           ij.process.ImageProcessor expectedLabels,
                                                           double threshold)
```
    Calculate the confusion matrix of a slice (2 classes)
    
    Parameters:
    
    proposal - probability image (single 2D slice)
    
    expectedLabels - original binary labels
    
    threshold - threshold to apply to proposal
    
    Returns:
    
    confusion matrix (first row: black, second raw: white)
  - getTestConfusionMatrix
```
public int[][] getTestConfusionMatrix(ij.ImagePlus image,
                                      ij.ImagePlus filters,
                                      ij.ImagePlus expectedLabels,
                                      int whiteClassIndex,
                                      int blackClassIndex)
```
    Get the confusion matrix for an input image and its expected labels
    
    Parameters:
    
    image - input image
    
    filters - stack of filters to apply to the original image in order to create the features
    
    expectedLabels - binary labels
    
    whiteClassIndex - index of the white class
    
    blackClassIndex - index of the black class
    
    Returns:
    
    confusion matrix
  - getTestError
```
public double getTestError(ij.ImagePlus image,
                           ij.ImagePlus labels,
                           ij.ImagePlus filters,
                           int whiteClassIndex,
                           int blackClassIndex,
                           boolean verbose)
```
    Get test error of current classifier on a specific image and its binary labels
    
    Parameters:
    
    image - input image
    
    labels - binary labels
    
    filters - list of filters to create features
    
    whiteClassIndex - index of the white class
    
    blackClassIndex - index of the black class
    
    verbose - option to display evaluation information in the log window
    
    Returns:
    
    pixel classification error
  - udpateDataClassification
```
public void udpateDataClassification(ij.ImagePlus labels,
                                     String className1,
                                     String className2)
```
    Update the class attribute of "loadedTrainingData" from the input binary labels. The number of instances of "loadedTrainingData" must match the size of the input labels image (or stack)
    
    Parameters:
    
    labels - input binary labels (single image or stack)
    
    className1 - name of the white (different from 0) class
    
    className2 - name of the black (0) class
  - updateDataClassification
```
public static void updateDataClassification(Instances data,
                                            ij.ImagePlus labels,
                                            int classIndex1,
                                            int classIndex2)
```
    Update the class attribute of "data" from the input binary labels. The number of instances of "data" must match the size of the input labels image (or stack)
    
    Parameters:
    
    data - input instances
    
    labels - binary labels
    
    classIndex1 - index of the white (different from 0) class
    
    classIndex2 - index of the black (0) class
  - updateDataClassification
```
public static void updateDataClassification(Instances data,
                                            ij.ImagePlus labels,
                                            int classIndex1,
                                            int classIndex2,
                                            ArrayList<Point3f>[] mismatches)
```
    Update the class attribute of "data" from the input binary labels. The number of instances of "data" must match the size of the input labels image (or stack)
    
    Parameters:
    
    data - input instances
    
    labels - binary labels
    
    classIndex1 - index of the white (different from 0) class
    
    classIndex2 - index of the black (0) class
    
    mismatches -
  - readDataFromARFF
```
public Instances readDataFromARFF(String filename)
```
    Read ARFF file
    
    Parameters:
    
    filename - ARFF file name
    
    Returns:
    
    set of instances read from the file
  - writeDataToARFF
```
public boolean writeDataToARFF(Instances data,
                               String filename)
```
    Write current instances into an ARFF file
    
    Parameters:
    
    data - set of instances
    
    filename - ARFF file name
    
    Returns:
    
    false if error
  - adjustSegmentationStateToData
```
public boolean adjustSegmentationStateToData(Instances data)
```
    Adjust current segmentation state (attributes and classes) to loaded data
    
    Parameters:
    
    data - loaded instances
    
    Returns:
    
    false if error
  - createHeaderName
```
public String createHeaderName(boolean bool3d,
                               boolean boolRGB)
```
    Create the name of the training header. It takes into account the plugin version, the dimensionality of the training images and if it is RGB or grayscale.
    
    Parameters:
    
    bool3d - true if training image is 3D
    
    boolRGB - true if traning image is grayscale
    
    Returns:
    
    name of the training header
  - createTrainingInstances
```
public Instances createTrainingInstances()
```
    Create training instances out of the user markings
    
    Returns:
    
    set of instances (feature vectors in Weka format)
  - createInstances
```
public Callable<Instances> createInstances(ArrayList<String> classNames,
                                           FeatureStack featureStack)
```
    Create instances of a feature stack (to be submitted to an Executor Service)
    
    Parameters:
    
    classNames - names of the classes of data
    
    featureStack - feature stack to create the instances from
    
    Returns:
    
    set of instances
  - trainClassifier
```
public boolean trainClassifier()
```
    Train classifier with the current instances
    
    Returns:
    
    false if error
  - applyClassifier
```
public ij.ImagePlus applyClassifier(ij.ImagePlus imp)
```
    Apply current classifier to a given image. If the input image is a stack, the classification task will be carried out by slice in parallel by each available thread (number of threads read on Prefs.getThreads()). Each thread will sequentially process a whole number of slices (first feature calculation then classification).
    
    Parameters:
    
    imp - image (2D single image or stack)
    
    Returns:
    
    result image (classification)
  - applyClassifier
```
public ij.ImagePlus applyClassifier(ij.ImagePlus imp,
                                    int numThreads,
                                    boolean probabilityMaps)
```
    Apply current classifier to a given image. It divides the whole slices of the input image into the selected number of threads. Each thread will sequentially process a whole number of slices (first feature calculation then classification).
    
    Parameters:
    
    imp - image (2D single image or stack)
    
    numThreads - The number of threads to use. Set to zero for auto-detection (set by the user on the ImageJ preferences)
    
    probabilityMaps - create probability maps for each class instead of a classification
    
    Returns:
    
    result image
  - applyClassifierMT
```
public ij.ImagePlus applyClassifierMT(ij.ImagePlus imp,
                                      int numThreads,
                                      boolean probabilityMaps)
```
    Apply current classifier to a given image in a complete concurrent way. This method is experimental, it divides the image(s) in pieces and can cause artifacts using some filters.
    
    Parameters:
    
    imp - image (2D single image or stack)
    
    numThreads - The number of threads to use. Set to zero for auto-detection.
    
    probabilityMaps - create probability maps for each class instead of a classification
    
    Returns:
    
    result image
  - classifySlice
```
public Callable<ij.ImagePlus> classifySlice(ij.ImagePlus slice,
                                            Instances dataInfo,
                                            AbstractClassifier classifier,
                                            AtomicInteger counter,
                                            boolean probabilityMaps)
```
    Classify a slice in a concurrent way
    
    Parameters:
    
    slice - image to classify
    
    dataInfo - empty set of instances containing the data structure (attributes and classes)
    
    classifier - classifier to use
    
    counter - counter used to display the progress in the tool bar
    
    probabilityMaps - flag to calculate probabilities or binary results
    
    Returns:
    
    classification result
  - classifyListOfImages
```
public Callable<ArrayList<ij.ImagePlus>> classifyListOfImages(ArrayList<ij.ImagePlus> images,
                                                              Instances dataInfo,
                                                              AbstractClassifier classifier,
                                                              AtomicInteger counter,
                                                              boolean probabilityMaps)
```
    Classify a list of images in a concurrent way
    
    Parameters:
    
    images - list of images to classify
    
    dataInfo - empty set of instances containing the data structure (attributes and classes)
    
    classifier - classifier to use
    
    counter - counter used to display the progress in the tool bar
    
    probabilityMaps - flag to calculate probabilities or binary results
    
    Returns:
    
    classification result
  - applyClassifier
```
public ij.ImagePlus applyClassifier(ij.ImagePlus imp,
                                    ij.ImagePlus filters,
                                    int numThreads,
                                    boolean probabilityMaps)
```
    Apply current classifier to a given image with precomputed features.
    
    Parameters:
    
    imp - image (2D single image or stack)
    
    filters - stack of filters to apply to the original image in order to create the features
    
    numThreads - The number of threads to use. Set to zero for auto-detection.
    
    probabilityMaps - create probability maps for each class instead of a classification
    
    Returns:
    
    result image
  - applyClassifier
```
public ij.ImagePlus applyClassifier(ij.ImagePlus imp,
                                    FeatureStackArray fsa,
                                    int numThreads,
                                    boolean probabilityMaps)
```
    Apply current classifier to a given image with precomputed features.
    
    Parameters:
    
    imp - image (2D single image or stack)
    
    fsa - precomputed feature stack array
    
    numThreads - The number of threads to use. Set to zero for auto-detection.
    
    probabilityMaps - create probability maps for each class instead of a classification
    
    Returns:
    
    result image
  - applyClassifier
```
public void applyClassifier(boolean classify)
```
    Apply current classifier to current image. Classification is performed in a multi-threaded way, using as many threads as defined by the user in the ImageJ options. Note: all image features are first calculated in parallel and then the classifier is applied.
    
    Parameters:
    
    classify - flag to get labels or probability maps (false = labels)
  - applyClassifier
```
public void applyClassifier(int numThreads,
                            boolean classify)
```
    Apply current classifier to current image. Note: all image features are first calculated in parallel and then the classifier is applied.
    
    Parameters:
    
    numThreads - The number of threads to use. Set to zero for auto-detection (defined by the user in the ImageJ options).
    
    classify - flag to get labels or probability maps (false = labels)
  - applyClassifier
```
public ij.ImagePlus applyClassifier(ij.ImagePlus imp,
                                    int[] tilesPerDim,
                                    int numThreads,
                                    boolean probabilityMaps)
```
    Apply the current classifier to an image subdividing the image in tiles for memory saving.
    
    Parameters:
    
    imp - input image to be classified
    
    tilesPerDim - number of tiles to be used on each dimension of the image
    
    numThreads - number of threads to use per tile (0 for autodetection)
    
    probabilityMaps - flag to get labels or probability maps (false = labels)
    
    Returns:
    
    classified image with probability maps or labels
  - applyClassifier
```
public ij.ImagePlus applyClassifier(ij.ImagePlus imp,
                                    int[] origin,
                                    int[] cropDims,
                                    int numThreads,
                                    boolean probabilityMaps)
```
    Apply current classifier to a user-defined ROI of a given image. Use a 2D ROI for single images and a 3D ROI for TWS 3D. Notice a padding based on the maximum sigma used in the image features will be applied to guarantee and output as close as possible to the one using the whole image as input.
    
    Parameters:
    
    imp - image to classify (2D or 3D)
    
    origin - coordinates of the origin of the ROI (cropping box)
    
    cropDims - dimensions of the ROI (cropping box)
    
    numThreads - The number of threads to use. Set to zero for auto-detection (set by the user on the ImageJ preferences)
    
    probabilityMaps - create probability maps for each class instead of a classification
    
    Returns:
    
    result image
  - updateWholeImageData
```
public Instances updateWholeImageData()
```
    Create the whole image data (instances) from the current image and feature stack.
    
    Returns:
    
    feature vectors (Weka instances) of the entire image
  - applyClassifier
```
public ij.ImagePlus applyClassifier(Instances data,
                                    int w,
                                    int h,
                                    int numThreads,
                                    boolean probabilityMaps)
```
    Apply current classifier to set of instances
    
    Parameters:
    
    data - set of instances
    
    w - image width
    
    h - image height
    
    numThreads - The number of threads to use. Set to zero for auto-detection.
    
    probabilityMaps - flag to indicate probability map (true) or segmentation output (false)
    
    Returns:
    
    result image
  - applyClassifier
```
public ij.ImagePlus applyClassifier(FeatureStackArray fsa,
                                    int numThreads,
                                    boolean probabilityMaps)
```
    Apply current classifier to a set of feature vectors (given in a feature stack array). The classification if performed in a multi-threaded way using as many threads as defined by the user.
    
    Parameters:
    
    fsa - feature stack array
    
    numThreads - The number of threads to use. Set to zero for auto-detection.
    
    probabilityMaps - probability flag. Tue: probability maps are calculated, false: binary classification
    
    Returns:
    
    result image containing the probability maps or the binary classification
  - setFeatures
```
public boolean setFeatures(ArrayList<String> featureNames)
```
    Set features to use during training
    
    Parameters:
    
    featureNames - list of feature names to use
    
    Returns:
    
    false if error
  - setMembraneThickness
```
public void setMembraneThickness(int thickness)
```
    Set expected membrane thickness (this will be the width of the center column of the membrane filter)
    
    Parameters:
    
    thickness - expected membrane thickness (in pixels)
  - getMembraneThickness
```
public int getMembraneThickness()
```
    Get current expected membrane thickness
    
    Returns:
    
    expected membrane thickness
  - setMembranePatchSize
```
public void setMembranePatchSize(int patchSize)
```
    Set the membrane patch size (it must be an odd number)
    
    Parameters:
    
    patchSize - membrane patch size
  - getMembranePatchSize
```
public int getMembranePatchSize()
```
    Get the membrane patch size
    
    Returns:
    
    membrane patch size
  - setMaximumSigma
```
public void setMaximumSigma(float sigma)
```
    Set the maximum sigma/radius to use in the features
    
    Parameters:
    
    sigma - maximum sigma to use in the features filters
  - getMaximumSigma
```
public float getMaximumSigma()
```
    Get the maximum sigma/radius to use in the features
    
    Returns:
    
    maximum sigma/radius to use in the features
  - setMinimumSigma
```
public void setMinimumSigma(float sigma)
```
    Set the minimum sigma (radius) to use in the features
    
    Parameters:
    
    sigma - minimum sigma (radius) to use in the features filters
  - getMinimumSigma
```
public float getMinimumSigma()
```
    Get the minimum sigma (radius) to use in the features
    
    Returns:
    
    minimum sigma (radius) to use in the features
  - getNumOfTrees
```
public int getNumOfTrees()
```
    Get current number of trees (for random forest training)
    
    Returns:
    
    number of trees
  - getNumRandomFeatures
```
public int getNumRandomFeatures()
```
    Get number of random features (random forest training)
    
    Returns:
    
    number of random feature per node of the random forest
  - getMaxDepth
```
public int getMaxDepth()
```
    Get maximum depth of the random forest
    
    Returns:
    
    maximum depth of the random forest
  - setDoHomogenizeClasses
```
public void setDoHomogenizeClasses(boolean homogenizeClasses)
```
    Deprecated. use setDoClassBalance
    
    Set the flag to balance the class distributions
    
    Parameters:
    
    homogenizeClasses - boolean flag to enable/disable the class balance
  - doHomogenizeClasses
```
public boolean doHomogenizeClasses()
```
    Deprecated. use doClassBalance
    
    Get the boolean flag to enable/disable the class balance
    
    Returns:
    
    flag to enable/disable the class balance
  - setDoClassBalance
```
public void setDoClassBalance(boolean balanceClasses)
```
    Set the flag to balance the class distributions
    
    Parameters:
    
    balanceClasses - boolean flag to enable/disable the class balance
  - doClassBalance
```
public boolean doClassBalance()
```
    Get the boolean flag to enable/disable the class balance
    
    Returns:
    
    flag to enable/disable the class balance
  - setUpdateFeatures
```
public void setUpdateFeatures(boolean updateFeatures)
```
    Set feature update flag
    
    Parameters:
    
    updateFeatures - new feature update flag
  - setFeaturesDirty
```
public void setFeaturesDirty()
```
    Forces the feature stack to be updated whenever it is needed next.
  - updateClassifier
```
public boolean updateClassifier(int newNumTrees,
                                int newRandomFeatures,
                                int newMaxDepth)
```
    Update fast random forest classifier with new values
    
    Parameters:
    
    newNumTrees - new number of trees
    
    newRandomFeatures - new number of random features per tree
    
    newMaxDepth - new maximum depth per tree
    
    Returns:
    
    false if error
  - setEnabledFeatures
```
public void setEnabledFeatures(boolean[] newFeatures)
```
    Set the new enabled features
    
    Parameters:
    
    newFeatures - new enabled feature flags
  - getEnabledFeatures
```
public boolean[] getEnabledFeatures()
```
    Get the current enabled features
    
    Returns:
    
    current enabled feature flags
  - mergeDataInPlace
```
public void mergeDataInPlace(Instances first,
                             Instances second)
```
    Merge two datasets of Weka instances in place
    
    Parameters:
    
    first - first (and destination) dataset
    
    second - second dataset
  - shutDownNow
```
public void shutDownNow()
```
    Shut down the executor service for training and feature creation
  - setFeatureStackArray
```
public void setFeatureStackArray(FeatureStackArray fsa)
```
    Assign an arbitrary filter stack array
    
    Parameters:
    
    fsa - new filter stack array
  - setLoadedClassNames
```
public void setLoadedClassNames(ArrayList<String> classNames)
```
    Set the list of loaded class names
    
    Parameters:
    
    classNames - new list of class names
  - saveFeatureStack
```
public void saveFeatureStack(int slice,
                             String dir,
                             String fileWithExt)
```
    Save specific slice feature stack
    
    Parameters:
    
    slice - slice number
    
    dir - directory to save the stack(s)
    
    fileWithExt - file name with extension for the file(s)
  - setClassLabels
```
public void setClassLabels(String[] classLabels)
```
    Set the labels for each class
    
    Parameters:
    
    classLabels - array containing all the class labels
  - getClassLabels
```
public String[] getClassLabels()
```
    Get the current class labels
    
    Returns:
    
    array containing all the class labels
  - isProcessing3D
```
public boolean isProcessing3D()
```
    Check the use of 3D or 2D features
    
    Returns:
    
    true if working in 3D, false if 2D
  - getModelVersion
```
public String getModelVersion()
```
    Get the version of the plugin used for creating the model. It will be "segment" for any version previous to 3.2.25, and the model relation name if it was not created using TWS.
    
    Returns:
    
    version of the plugin used for creating the model.

Class WekaSegmentation

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_NUM_CLASSES

Constructor Detail

WekaSegmentation

WekaSegmentation

WekaSegmentation

Method Detail

setTrainingImage

addExample

deleteExample

getExamples

setHomogenizeClasses

setClassBalance

setNumOfClasses

getNumOfClasses

addClass

setClassLabel

getClassLabel

loadTrainingData

getLoadedTrainingData

getTraceTrainingData

getClassifiedImage

getTrainHeader

loadClassifier

loadClassifier

containsColorFeatures

containsExclusive2DFeatures

containsExclusive3DFeatures

getClassifier

saveClassifier

saveData

setUseNeighbors

addBinaryData

addBinaryData

addLabeledData

addRandomBalancedLabeledData

addRandomBalancedLabeledData

addRandomBalancedBinaryData

addRandomBalancedLabeledData

addLabeledData

addLabeledData

addRandomBalancedBinaryData

addRandomBalancedBinaryData

addBinaryData

addRandomBalancedBinaryData

addRandomBalancedBinaryData

addRandomData

getFeatureStack

getFeatureStackArray

getTrainingInstances

setClassifier

setTrainHeader

loadNewImage

addCenterLinesBinaryData

filterFeatureStackByList

filterFeatureStackByList

addBinaryData

addBinaryData

addLabeledData

addRandomBalancedBinaryData

addRandomBalancedLabeledData

addRandomBalancedLabeledData

addLabeledData

addLabeledData

addRandomBalancedLabeledData

addRandomBalancedBinaryData

addRandomBalancedBinaryData

addRandomData

addRandomBalancedBinaryData

addBinaryData

addErodedBinaryData

setLoadedTrainingData

useAllFeatures

setProjectFolder

homogenizeTrainingData