weka.filters

## Class SimpleStreamFilter

- java.lang.Object
- - weka.filters.Filter
  - - weka.filters.SimpleFilter
    - - weka.filters.SimpleStreamFilter

- All Implemented Interfaces:
    java.io.Serializable, CapabilitiesHandler, CapabilitiesIgnorer, OptionHandler, RevisionHandler, StreamableFilter
  Direct Known Subclasses:
    ClassAssigner, MultiFilter, NumericCleaner, RandomSubset, RemoveByName, RenameAttribute, SortLabels

      public abstract class SimpleStreamFilter
      extends SimpleFilter
      implements StreamableFilter

  This filter is a superclass for simple stream filters.

  General notes:
  - After the first call of batchFinished() the field m_FirstBatchDone is set to `true`.

  Example:
  The following code snippet uses the filter `SomeFilter` on a dataset that is loaded from `filename`.

       import weka.core.*;
       import weka.filters.*;
       import java.io.*;
       ...
       SomeFilter filter = new SomeFilter();
       // set necessary options for the filter
       Instances data = new Instances(
                          new BufferedReader(
                            new FileReader(filename)));
       Instances filteredData = Filter.useFilter(data, filter);

  Implementation:
  Only the following abstract methods need to be implemented:
  - globalInfo()
  - determineOutputFormat(Instances)
  - process(Instance)
  And the getCapabilities() method must return what kind of attributes and classes the filter can handle.

  If more options are necessary, then the following methods need to be overriden:
  - listOptions()
  - setOptions(String[])
  - getOptions()

  To make the filter available from commandline one must add the following main method for correct execution (<Filtername> must be replaced with the actual filter classname):

        public static void main(String[] args) {
          runFilter(new <Filtername>(), args);
        }

  Example implementation:

       import weka.core.*;
       import weka.core.Capabilities.*;
       import weka.filters.*;

       import java.util.Random;

       public class SimpleStream extends SimpleStreamFilter {

         public String globalInfo() {
           return "A simple stream filter that adds an attribute 'bla' at the end containing a random number.";
         }

         public Capabilities getCapabilities() {
           Capabilities result = super.getCapabilities();
           result.enableAllAttributes();
           result.enableAllClasses();
           result.enable(Capability.NO_CLASS); // filter doesn't need class to be set
           return result;
         }

         protected Instances determineOutputFormat(Instances inputFormat) {
           Instances result = new Instances(inputFormat, 0);
           result.insertAttributeAt(new Attribute("bla"), result.numAttributes());
           return result;
         }

         protected Instance process(Instance inst) {
           double[] values = new double[inst.numAttributes() + 1];
           for (int n = 0; n < inst.numAttributes(); n++)
             values[n] = inst.value(n);
           values[values.length - 1] = new Random().nextInt();
           Instance result = new DenseInstance(1, values);
           return result;
         }

         public static void main(String[] args) {
           runFilter(new SimpleStream(), args);
         }
       }

  Options:
  Valid filter-specific options are:

  -D
  Turns on output of debugging information.

  Version:
    $Revision: 10228 $
  Author:
    FracPete (fracpete at waikato dot ac dot nz)
  See Also:
    `SimpleBatchFilter`, `input(Instance)`, `batchFinished()`, `Filter.m_FirstBatchDone`, Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `SimpleStreamFilter()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `batchFinished()` Signify that this batch of input to the filter is finished.
    `boolean` | `input(Instance instance)` Input an instance for filtering.

    - ### Methods inherited from class weka.filters.SimpleFilter

      `globalInfo, setInputFormat`

    - ### Methods inherited from class weka.filters.Filter

      `batchFilterFile, debugTipText, doNotCheckCapabilitiesTipText, filterFile, getCapabilities, getCapabilities, getDebug, getDoNotCheckCapabilities, getOptions, getOutputFormat, getRevision, isFirstBatchDone, isNewBatch, isOutputFormatDefined, listOptions, main, makeCopies, makeCopy, mayRemoveInstanceAfterFirstBatchDone, numPendingOutput, output, outputPeek, runFilter, setDebug, setDoNotCheckCapabilities, setOptions, toString, useFilter, wekaStaticWrapper`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### SimpleStreamFilter

          public SimpleStreamFilter()

  - ### Method Detail

    - #### input

          public boolean input(Instance instance)
                        throws java.lang.Exception

      Input an instance for filtering. Filter requires all training instances be read before producing output.
      Overrides:
        `input` in class `Filter`
      Parameters:
        `instance` - the input instance
      Returns:
        true if the filtered instance may now be collected with output().
      Throws:
        `java.lang.IllegalStateException` - if no input structure has been defined
        `java.lang.Exception` - if something goes wrong

    - #### batchFinished

          public boolean batchFinished()
                                throws java.lang.Exception

      Signify that this batch of input to the filter is finished. If the filter requires all instances prior to filtering, output() may now be called to retrieve the filtered instances. Any subsequent instances filtered should be filtered based on setting obtained from the first batch (unless the setInputFormat has been re-assigned or new options have been set).
      Overrides:
        `batchFinished` in class `Filter`
      Returns:
        true if there are instances pending output
      Throws:
        `java.lang.IllegalStateException` - if no input format has been set.
        `java.lang.NullPointerException` - if no input structure has been defined,
        `java.lang.Exception` - if there was a problem finishing the batch.