DataVideoGather.java

/*
 * Created on May 12, 2004
 * ******************************************************************************
 * CVS Header $Header: /disks/cvs/neesgrid/turbine/src/org/nees/rbnb/DataVideoGather.java,v 1.10 2004/08/02 17:02:09 weymouth Exp $
 * ******************************************************************************
 */
package org.nees.rbnb;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.FileWriter;
import java.io.File;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.Iterator;
import java.util.Stack;
import java.util.Date;
import java.util.TimeZone;
import java.text.SimpleDateFormat;

import java.util.regex.*;

import com.rbnb.sapi.*;
import com.rbnb.utility.ArgHandler; //for argument parsing
//import COM.Creare.Utility.ArgHandler; //for argument parsing

public class DataVideoGather extends RBNBBase {
    
    private final String SINK_NAME_NAME = "SinkName";
    private final String CHANNEL_PATTERN_NAME = "ChannelPattern";
    private final String CHANNEL_LIST_NAME = "ChannelList";
    private final String INCLUDE_HIDDEN_NAME = "IncludeHidden";
    private final String ZERO_FOR_MISSING_NAME = "ZeroForMissingData";
    private final String VIDEO_SOURCE_PATH_NAME = "VideoSourcePath";
    private final String ARCHIVE_DIRECTORY_NAME = "ArchiveDirectory";
    private final String MOVIE_FILE_NAME_NAME = "MovieFileName";
    private final String DATA_FILE_NAME_NAME = "DataFileName";
    private final String USER_GIVEN_FRAME_RATE_NAME = "UserGivenFrameRate";
    private final String ITEMS_TO_SKIP_NAME = "ItemsToSkip";
    private final String WAIT_TIME_NAME = "WaitTime";
    private final String COLLECTION_TIME_NAME = "CollectionTime";

    private static final String SINK_NAME = "DataVideoGather";
    private static final String ARCHIVE_DIRECTORY = ".";
    private static final String DATA_FILE_NAME = "Data.txt";
    private static final String MOVIE_FILE_NAME = "Movie.mov";

    private static final String CHANNEL_PATTERN = "";
    private static final String CHANNEL_LIST = "";
    private static final boolean INCLUDE_HIDDEN = false;
    private static final boolean ZERO_FOR_MISSING = false;
    private static final String VIDEO_SOURCE_PATH = "";
    
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MMM d, yyyy h:mm aa");
    private static final TimeZone TZ = TimeZone.getTimeZone("GMT");

    private static float USER_GIVEN_FRAME_RATE = 1.0F;
    private static int ITEMS_TO_SKIP = 0;
    
    private static long WAIT_TIME = 30*60; // in seconds
    private static long COLLECTION_TIME = WAIT_TIME;

    private static final SimpleDateFormat OUTPUT_FORMAT = new SimpleDateFormat("yyyy-MM-dd:hh:mm:ss.SSS");

    static
    {
        DATE_FORMAT.setTimeZone(TZ);
        OUTPUT_FORMAT.setTimeZone(TZ);
    }

    private String sinkName = SINK_NAME;
    private String channelPathPattern = null;
    private String channelPathListString = null;
    private Vector channelPathList = new Vector();
    private String videoChannelPath = null;
    private String[] channelPathArray;
    private boolean includeHidden = false;
    private String archiveDirectory = ARCHIVE_DIRECTORY;
    private String dataFileName = DATA_FILE_NAME;
    private String movieFileName = MOVIE_FILE_NAME;
    private float userGivenFrameRate = USER_GIVEN_FRAME_RATE;
    private int itemsToSkip = ITEMS_TO_SKIP;
    private boolean repeatMissingValue  = true;
    
    private boolean connected = false;
    private boolean runit = true;
    private Thread fetchDataThread;
    private long waitTime = WAIT_TIME; // in seconds
//  private long waitTime = 60; // one minute
    private long collectionTime = waitTime;

    // This should be fixed now
//  private double uglyOffset = 5.0;
    
    private String[] parameterNameArray;
    private String[] parameterTypeArray;
    private Object[] parameterDefaultArray;
    
    public static void main(String[] args) {
        DataVideoGather d = new DataVideoGather();
        d.setArgs(args);
        d.testConnect();
        d.startThread();
    } // main
    
    public void printUsage() {
        System.out.println("DataVideoGather: usage is...");     
        System.out.println("DataVideoGather ");
        super.printUsage();
        System.out.println("[-k Sink Name *" + SINK_NAME + " ]");
        System.out.println("[-c Data Channels Path Pattern - pearl-like pattern to match] ");
        System.out.println("[-C Data Channels list - comma seperated lsit of Paths]");
        System.out.println("[-x Include Hidden channels (true|false) *false]");
        System.out.println("[-Z zero for missing data; otherzise last value repeats]");
        System.out.println("[-v Video Source path - no path for no movie]");
        System.out.println("[-d Archive directory root *" + ARCHIVE_DIRECTORY + "]");
        System.out.println("[-M Movie output file name *" + MOVIE_FILE_NAME + "]");
        System.out.println("[-D Data output file name *" + DATA_FILE_NAME + "]");
        System.out.println("[-f Frame Rate of final movie *" + USER_GIVEN_FRAME_RATE + "]");
        System.out.println("[-i Items to skip in data for each movie frame *" + 
            ITEMS_TO_SKIP +"]");
        System.out.println("[-w Wait Time in seconds; the time between cycles *"
            + WAIT_TIME + "]");
        System.out.println("[-W Collection time in seconds; defaults to Wait Time]");
//      System.out.println("[-u magic offset *"+ uglyOffset + "]");
    } // printUsage
    
    public DataVideoGather() {
        setParamterArrays();
        initialize();
    }

    public boolean setInstanceArgs (String[] args) {
        //parse args
        try {
            ArgHandler ah=new ArgHandler(args);
            if (ah.checkFlag('k')) {
                String a=ah.getOption('k');
                if (a!=null) sinkName=a;
            }
            if (ah.checkFlag('c')) {
                String a=ah.getOption('c');
                if (a!=null) channelPathPattern=a;
            }
            if (ah.checkFlag('C')) {
                String a=ah.getOption('C');
                if (a!=null) channelPathListString=a;
            }
            if (ah.checkFlag('w')) {
                String a=ah.getOption('w');
                if (a!=null)
                {
                    try
                    {
                        long value = Long.parseLong(a);
                        waitTime = value;
                    }
                    catch (Exception ex)
                    {
                        System.out.println("Failed to parse Wait Time (" + a + "): " + ex);
                    }
                }
            }
            if (ah.checkFlag('W')) {
                String a=ah.getOption('W');
                if (a!=null)
                {
                    try
                    {
                        long value = Long.parseLong(a);
                        collectionTime = value;
                    }
                    catch (Exception ex)
                    {
                        System.out.println("Failed to parse Collection Time (" + a + "): " + ex);
                    }
                }
            }           
            if (ah.checkFlag('x')) {
                String a=ah.getOption('x');
                if (a!=null)
                {
                    if (a.equals("true")) includeHidden = true;
                    if (a.equals("false")) includeHidden = false;
                } 
            }
            if (ah.checkFlag('v')) {
                String a=ah.getOption('v');
                if (a!=null) videoChannelPath=a;
            }
            if (ah.checkFlag('d')) {
                String a=ah.getOption('d');
                if (a!=null) archiveDirectory=a;
            }
            if (ah.checkFlag('M')) {
                String a=ah.getOption('M');
                if (a!=null) movieFileName=a;
            }
            if (ah.checkFlag('D')) {
                String a=ah.getOption('D');
                if (a!=null) dataFileName=a;
            }
            if (ah.checkFlag('f')) {
                String a=ah.getOption('f');
                if (a!=null)
                {
                    try
                    {
                        float value = Float.parseFloat(a);
                        userGivenFrameRate = value;
                    }
                    catch (Exception ex)
                    {
                        System.out.println("Failed to parse Frame Rate (" + a + "): " + ex);
                    }
                }
            }
            if (ah.checkFlag('i')) {
                String a=ah.getOption('i');
                if (a!=null)
                {
                    try
                    {
                        int value = Integer.parseInt(a);
                        itemsToSkip = value;
                    }
                    catch (Exception ex)
                    {
                        System.out.println("Failed to parse Frame Rate (" + a + "): " + ex);
                    }
                }
            }
            if (ah.checkFlag('Z')) {
                repeatMissingValue = false;
            }           
//          if (ah.checkFlag('u')) {
//              String a=ah.getOption('u');
//              if (a!=null)
//              {
//                  try
//                  {
//                      double value = Double.parseDouble(a);
//                      uglyOffset = value;
//                  }
//                  catch (Exception ex)
//                  {
//                      System.out.println("Failed to parse magic offset (" + a + "): " + ex);
//                  }
//              }
//          }
        } catch (Exception e) {
            System.err.println("DataVideoGather argument exception "+e.getMessage());
            e.printStackTrace();
            System.exit(0);
        }
        
        setupChannelList();
        
        System.out.println("Starting DataVideoGather on " + getServer() + " as " + sinkName);
        System.out.println("Gatering data from: ");
        for (int i = 0; i < channelPathArray.length; i++)
        {
            System.out.println("  " + channelPathArray[i]);
        }
        if ((videoChannelPath != null) && (!videoChannelPath.equals("")))
        {
            System.out.println("Gatering video from:  " + videoChannelPath);
            System.out.println("Frame rate = " + userGivenFrameRate + " frames per second.");
            System.out.println("Data frames to skip between video frame = " + itemsToSkip);
        }
        
        System.out.println("  Use DataVideoGather -h to see optional parameters");
        
        return true;
    } // sestArgs

    private void setupChannelList()
    {
        channelPathList = new Vector();

        if ((channelPathPattern != null) && !channelPathPattern.equals(""))
            appendChannelListFromPattern();
        if ((channelPathListString != null) && !channelPathListString.equals(""))
            appendChannelListFromString();
    
        Iterator channels = channelPathList.iterator();
        if (!channels.hasNext())
        {
            System.out.println("DataVideoGather: No data channels to monitor.");
            this.printUsage();
            System.exit(0);
        }
            
        channelPathArray = new String[channelPathList.size()];
        for (int i = 0; i < channelPathArray.length; i++)
        {
            ChannelTree.Node candidate = (ChannelTree.Node)channels.next();
            channelPathArray[i] = candidate.getFullName();
        }
    }


    public void appendChannelListFromPattern()
    {
        try {
            // Create a sink and connect:
            Sink sink=new Sink();
            sink.OpenRBNBConnection(getServer(),sinkName);
            
            // get all the channel paths that match the pattern
            ChannelMap sMap = new ChannelMap();
            sink.RequestRegistration();     
            sMap = sink.Fetch(-1,sMap);
            ChannelTree tree = ChannelTree.createFromChannelMap(sMap);

            Pattern p = Pattern.compile(channelPathPattern);
            // for each channel path, check match, collect matches...
            
            Iterator nodes = tree.iterator();
            while (nodes.hasNext())
            {
                ChannelTree.Node n = (ChannelTree.Node)nodes.next();
                // System.out.println("Checking " + n.getFullName() + ";" + n.getName());
                if (!includeHidden && n.getFullName().startsWith("_")) continue;
                if (n.getType() != ChannelTree.CHANNEL) continue;
                String name = n.getFullName();
                Matcher m = p.matcher(name);
                if (m.matches())
                {
//                  System.out.println("Matches");
                    boolean isSource = false;
                    ChannelTree.Node upNode = n.getParent();
                    while ((!isSource) || (upNode != null))
                    {
                        if (upNode.getType() == ChannelTree.SOURCE) isSource = true;
                        upNode = upNode.getParent();
                    }
                    if (isSource)
                    {
                        // System.out.println("... and is a source.");
                        channelPathList.add(n);
                    }
                    else
                    {
                        // System.out.println("... and is NOT a source.");
                    }
                }                   
            }
            
        } catch (SAPIException se) { se.printStackTrace(); }
    } // appendChannelListFromPattern

    public void appendChannelListFromString()
    {
        try
        {
            StringTokenizer st = new StringTokenizer(channelPathListString,","); 
    
            // Create a sink and connect:
            Sink sink=new Sink();
            sink.OpenRBNBConnection(getServer(),sinkName);
                
            // get all the channel paths that match the pattern
            ChannelMap sMap = new ChannelMap();
            sink.RequestRegistration();     
            sMap = sink.Fetch(-1,sMap);
            ChannelTree tree = ChannelTree.createFromChannelMap(sMap);
    
            Pattern p = Pattern.compile(channelPathPattern);
            // for each channel path, check match, collect matches...

            while (st.hasMoreTokens()) {
                String path = st.nextToken();
//              System.out.println("Checking " + path);
                            
                ChannelTree.Node n = tree.findNode(path);
                if (n == null) continue;
                if (n.getType() != ChannelTree.CHANNEL) continue;
                String name = n.getFullName();
//              System.out.println("Found it...");
                boolean isSource = false;
                ChannelTree.Node upNode = n.getParent();
                while ((!isSource) || (upNode != null))
                {
                    if (upNode.getType() == ChannelTree.SOURCE) isSource = true;
                    upNode = upNode.getParent();
                }
                if (isSource)
                {
//                  System.out.println("... and is a source.");
                    channelPathList.add(n);
                }
                else
                {
//                  System.out.println("... and is NOT a source.");
                }
            } // while next token
        } catch (SAPIException se) { se.printStackTrace(); }
    } // appendChannelListFromString
    
    private void testConnect()
    {
        try {
            // test the connection to the server
            Sink sink = new Sink();
            sink.OpenRBNBConnection(getServer(),sinkName);
            connected = true;
            System.out.println("DataVideoGather: Test connection made to server = "
                + getServer() + " as " + sinkName +".");
            sink.CloseRBNBConnection();
        } catch (SAPIException se) { se.printStackTrace(); }
    }
    
    private void disconnect()
    {
        // nothing, really, to do as the connections are closed each cycle???
        connected = false;
    }
    
    public void startThread()
    {
        
        if (!connected) return;
        
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runWork();
            }
        };
        runit = true;
        fetchDataThread = new Thread(r, "DataVideoGather");
        fetchDataThread.start();
        System.out.println("DataVideoGather: Started thread.");
    }

    public void stopThread()
    {
        runit = false;
        fetchDataThread.interrupt();
        System.out.println("DataVideoGather: Stopped thread.");
    }
    
    private void runWork ()
    {
        long lastTime = System.currentTimeMillis();
        try {
//          while(isRunning())
//          {
//              doOneCycle();
//              long actualWait = (waitTime * 1000) - (System.currentTimeMillis() - lastTime);
//              lastTime = System.currentTimeMillis();
//              System.out.println("Actual Wait Time = " + actualWait);
//              if (actualWait < 0) actualWait = 0;
//              Thread.sleep(actualWait);               
//          }
        
            // modified to do one cycle only so that it can be 
            // scripted; tew Aug 02, 2004
            if (isRunning())
                doOneCycle();
                
        } catch (Exception se) {
            se.printStackTrace(); 
        }
        fetchDataThread = null;
    }
    
    public boolean isRunning()
    {
        return (connected && runit);
    }

    private void doOneCycle()
    {
        System.out.println("One Cycle:");
        System.out.println("Wait time = " + waitTime);
        System.out.println("Collection time = " + collectionTime);
        
        long startTime = System.currentTimeMillis();

        DataVideoSink.DEBUG = true;
//      DataVideoSink.setUglyOffest(uglyOffset);
        DataVideoSink dataVideoSink = new DataVideoSink();
        dataVideoSink.connect(getServer(),sinkName + "_data");

        double[][] data = new double[channelPathArray.length][0];
        double[][] time = new double[channelPathArray.length][0];
        
        // collectionTime (long) in secods
        double duration = (double)collectionTime; // in seconds
        
        if (dataVideoSink.connect(getServer(),sinkName))
        {
            for (int i = 0; i < channelPathArray.length; i ++)
            {
                String dataSourcePath = channelPathArray[i];
                // with "newest" time is figured backward from the present...
                dataVideoSink.fetchData(dataSourcePath, 0.0, duration,"newest");
                data[i] = dataVideoSink.getDataArray();
                time[i] = dataVideoSink.getTimeArray();
            }
            
//          for (int i = 0; i < channelPathArray.length; i ++)
//          {
//              System.out.println("Array lengths (" + i + ") are: "
//                  + data[i].length + "," + time[i].length);
//          }
            
            double[] referenceTime = time[0];
            double[][] filledData = new double[channelPathArray.length][referenceTime.length];
            int[] indexFront = new int[channelPathArray.length]; // initally zero
            int[] lastUsed = new int[channelPathArray.length];
            
            // force initial condition; no index last used
            for (int i = 0; i < lastUsed.length; i++) lastUsed[i] = -1;

            // for each possible data slot determine the data with the correct time
            // filled in slots are eather duplications or zero          
            for (int timeIndex = 0; timeIndex < referenceTime.length; timeIndex++)
            {
                // channel 0 is the referance channel, it's data value are always there
                filledData[0][timeIndex] = data[0][timeIndex];
                for (int channelIndex = 1; channelIndex < channelPathArray.length; channelIndex++)
                {
//System.out.println(" " + timeIndex + "," + channelIndex 
//  + "," + lastUsed[channelIndex] + "," + indexFront[channelIndex]);

                    if (lastUsed[channelIndex] == indexFront[channelIndex])
                    {
                        // filling data with and index that was already used
                        if (repeatMissingValue)
                            filledData[channelIndex][timeIndex]
                                = data[channelIndex][indexFront[channelIndex]];
                        else
                            filledData[channelIndex][timeIndex] = 0.0;
                    }
                    else
                    {
                        filledData[channelIndex][timeIndex]
                            = data[channelIndex][indexFront[channelIndex]];
                        lastUsed[channelIndex] = indexFront[channelIndex];
                    }
//System.out.print(" " + timeIndex + "," + channelIndex 
//  + "," + referenceTime[timeIndex] + "," + time[channelIndex][indexFront[channelIndex]]);
//if (referenceTime[timeIndex] >= time[channelIndex][indexFront[channelIndex]])
//System.out.println(" yes");
//else
//System.out.println(" no");
                    if (referenceTime[timeIndex] >= time[channelIndex][indexFront[channelIndex]])
                    {
                        if (indexFront[channelIndex] < (data[channelIndex].length - 1))
                            ++indexFront[channelIndex];
                    }
                }
                
//              System.out.println("Time Index = " + timeIndex);
//              System.out.println("Filled data: ");
//              for (int i = 0; i < channelPathArray.length; i++)
//              {
//                  System.out.print("  " + filledData[i][timeIndex]);
//              }
//              System.out.println();
//              System.out.println("Last Used and Front are: ");
//              for (int i = 0; i < channelPathArray.length; i++)
//              {
//                  System.out.println("  " + i + ": " + lastUsed[i] + "," + indexFront[i]);
//              }
                
            }

            try {
                writeDataToFile(channelPathArray,referenceTime,filledData);
            } catch (IOException e) {
                e.printStackTrace();
            }
            
            if ((videoChannelPath != null) && (!videoChannelPath.equals("")))
            {
                if (!probeVideo())
                    System.out.println("No matching video available ");
                else
                {
                    String outputURL = "file:" + archiveDirectory 
                        + "/" + movieFileName; 
                    try {
                        dataVideoSink.makeMovie(userGivenFrameRate, 
                            outputURL, videoChannelPath, itemsToSkip);
                    } catch (Exception e1) {
                        e1.printStackTrace();
                    }
                }
            }

        }
        dataVideoSink.disconnect();
        long endTime = System.currentTimeMillis();
        long elaspedTime = endTime - startTime;
        System.out.println("Cycle took " + elaspedTime + " milliseconds.");
    }
    
    private boolean probeVideo()
    {
        // TODO: fix test for vidoe data
        return true;
    }
    
    private void writeDataToFile(String[] names, double[] times, double[][] data) throws IOException
    {
        String path = archiveDirectory + "/" + dataFileName;
        PrintWriter out = new PrintWriter(new FileWriter(path));
        
        // write header
        /*
        * Active channels: ATL1,ATT1,ATL3,ATT3
        * Sample rate: 10.000000
        * Channel units: g,g,in,kip (unknown at this time!)
        * Time ATL1 ATT1 ATL3 ATT3
        */
        out.print("Active channels: ");
        out.print(names[0]);
        for (int i = 1; i < names.length; i++)
        {
            out.print("," + names[i]);
        }
        out.println();

        double rate = 0.0;
        for (int i = 1; i < times.length; i++)
        {
            rate += times[i]-times[i-1]; // in seconds
        }
        rate = rate/(double)(times.length - 1);
        out.println("Sample rate: " + rate);
        
        // Channel units are unknown at this time!
        
        out.print("Time");
        for (int i = 0; i < names.length; i++)
        {
            out.print(" " + names[i]);
        }
        out.println();

        // write data

        for (int i = 0; i < times.length; i++)
        {
            long unixTime = (long)(times[i] * 1000.0); // convert sec to millisec
            //  SimpleDateFormat("yyyy-MM-dd:hh:mm:ss.SSS");
            String time = OUTPUT_FORMAT.format(new Date(unixTime));
            time = time.substring(0,10) + "T" + time.substring(11);
            out.print(time);
            for (int j = 0; j < data.length; j++)
            {
                out.print(" " + data[j][i]);
            }
            out.println();
            out.flush();
        }
        out.close();
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setParamterArrays()
     */
    protected void setParamterArrays() {
        String [] pNameArray = super.getBaseParameterNameArray();
        String [] pTypeArray = super.getBaseParameterTypeArray();
        Object [] pDefaultArray = super.getBaseParameterDefaultArray();
        
        int base = pNameArray.length;
        int numberOfparameters = 13;
        parameterNameArray = new String[base + numberOfparameters];
        parameterTypeArray = new String[base + numberOfparameters];
        parameterDefaultArray = new Object[base + numberOfparameters];
        
        for (int i = 0; i < base; i++)
        {
            parameterNameArray[i] = pNameArray[i];
            parameterTypeArray[i] = pTypeArray[i];
            parameterDefaultArray[i] = pDefaultArray[i];
        }

        parameterNameArray[base + 0] = SINK_NAME_NAME;
        parameterTypeArray[base + 0] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 0] = new String(SINK_NAME);        

        parameterNameArray[base + 1] = CHANNEL_PATTERN_NAME;
        parameterTypeArray[base + 1] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 1] = new String(CHANNEL_PATTERN);      

        parameterNameArray[base + 2] = CHANNEL_LIST_NAME;
        parameterTypeArray[base + 2] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 2] = new String(CHANNEL_LIST);     

        parameterNameArray[base + 3] = INCLUDE_HIDDEN_NAME;
        parameterTypeArray[base + 3] = RBNBBaseParameterHolder.BOOLEAN_TYPE;
        parameterDefaultArray[base + 3] = new Boolean(INCLUDE_HIDDEN);      

        parameterNameArray[base + 4] = ZERO_FOR_MISSING_NAME;
        parameterTypeArray[base + 4] = RBNBBaseParameterHolder.BOOLEAN_TYPE;
        parameterDefaultArray[base + 4] = new Boolean(ZERO_FOR_MISSING);        

        parameterNameArray[base + 5] = VIDEO_SOURCE_PATH_NAME;
        parameterTypeArray[base + 5] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 5] = new String(VIDEO_SOURCE_PATH);        

        parameterNameArray[base + 6] = ARCHIVE_DIRECTORY_NAME;
        parameterTypeArray[base + 6] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 6] = new String(ARCHIVE_DIRECTORY);        

        parameterNameArray[base + 7] = MOVIE_FILE_NAME_NAME;
        parameterTypeArray[base + 7] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 7] = new String(MOVIE_FILE_NAME);      

        parameterNameArray[base + 8] = DATA_FILE_NAME_NAME;
        parameterTypeArray[base + 8] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 8] = new String(DATA_FILE_NAME);       

        parameterNameArray[base + 9] = USER_GIVEN_FRAME_RATE_NAME;
        parameterTypeArray[base + 9] = RBNBBaseParameterHolder.FLOAT_TYPE;
        parameterDefaultArray[base + 9] = new Float(USER_GIVEN_FRAME_RATE);     

        parameterNameArray[base + 10] = ITEMS_TO_SKIP_NAME;
        parameterTypeArray[base + 10] = RBNBBaseParameterHolder.INTEGER_TYPE;
        parameterDefaultArray[base + 10] = new Integer(ITEMS_TO_SKIP);      

        parameterNameArray[base + 11] = WAIT_TIME_NAME;
        parameterTypeArray[base + 11] = RBNBBaseParameterHolder.LONG_TYPE;
        parameterDefaultArray[base + 11] = new Long(WAIT_TIME);     

        parameterNameArray[base + 12] = COLLECTION_TIME_NAME;
        parameterTypeArray[base + 12] = RBNBBaseParameterHolder.LONG_TYPE;
        parameterDefaultArray[base + 12] = new Long(COLLECTION_TIME);
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setVariablesFromParameters()
     */
    public void setVariablesFromParameters() {
        super.setBaseVarialbesFromParametes();
        
        sinkName = SINK_NAME;
        try{
            Object obj = getValueWithDefault(SINK_NAME_NAME, SINK_NAME);
            sinkName = (String)obj;
        } catch (Throwable ignore){}

        channelPathPattern = CHANNEL_PATTERN;
        try{
            Object obj = getValueWithDefault(CHANNEL_PATTERN_NAME, CHANNEL_PATTERN);
            channelPathPattern = (String)obj;
        } catch (Throwable ignore){}

        channelPathListString = CHANNEL_LIST;
        try{
            Object obj = getValueWithDefault(CHANNEL_LIST_NAME, CHANNEL_LIST);
            channelPathListString = (String)obj;
        } catch (Throwable ignore){}

        includeHidden = INCLUDE_HIDDEN;
        try{
            Boolean b = new Boolean(INCLUDE_HIDDEN);
            Object obj = getValueWithDefault(INCLUDE_HIDDEN_NAME, b);
            includeHidden = ((Boolean)obj).booleanValue();
        } catch (Throwable ignore){}

        repeatMissingValue  = !ZERO_FOR_MISSING; // negate!
        try{
            Boolean b = new Boolean(ZERO_FOR_MISSING);
            Object obj = getValueWithDefault(ZERO_FOR_MISSING_NAME, b);
            repeatMissingValue = !((Boolean)obj).booleanValue();
        } catch (Throwable ignore){}

        videoChannelPath = VIDEO_SOURCE_PATH;
        try{
            Object obj = getValueWithDefault(VIDEO_SOURCE_PATH_NAME, VIDEO_SOURCE_PATH);
            videoChannelPath = (String)obj;
        } catch (Throwable ignore){}

        archiveDirectory = ARCHIVE_DIRECTORY;
        try{
            Object obj = getValueWithDefault(ARCHIVE_DIRECTORY_NAME, ARCHIVE_DIRECTORY);
            archiveDirectory = (String)obj;
        } catch (Throwable ignore){}

        movieFileName = MOVIE_FILE_NAME;
        try{
            Object obj = getValueWithDefault(MOVIE_FILE_NAME_NAME, MOVIE_FILE_NAME);
            movieFileName = (String)obj;
        } catch (Throwable ignore){}

        dataFileName = DATA_FILE_NAME;
        try{
            Object obj = getValueWithDefault(DATA_FILE_NAME_NAME, DATA_FILE_NAME);
            dataFileName = (String)obj;
        } catch (Throwable ignore){}

        userGivenFrameRate = USER_GIVEN_FRAME_RATE;
        try{
            Float f = new Float(USER_GIVEN_FRAME_RATE);
            Object obj = getValueWithDefault(USER_GIVEN_FRAME_RATE_NAME, f);
            userGivenFrameRate = ((Float)obj).floatValue();
        } catch (Throwable ignore){}

        itemsToSkip = ITEMS_TO_SKIP;
        try{
            Integer i = new Integer(ITEMS_TO_SKIP);
            Object obj = getValueWithDefault(ITEMS_TO_SKIP_NAME, i);
            itemsToSkip = ((Integer)obj).intValue();
        } catch (Throwable ignore){}

        waitTime = WAIT_TIME; // in seconds
        try{
            Long l = new Long(WAIT_TIME);
            Object obj = getValueWithDefault(WAIT_TIME_NAME, l);
            waitTime = ((Long)obj).longValue();
        } catch (Throwable ignore){}

        collectionTime = COLLECTION_TIME;
        try{
            Long l = new Long(COLLECTION_TIME);
            Object obj = getValueWithDefault(COLLECTION_TIME_NAME, l);
            collectionTime = ((Long)obj).longValue();
        } catch (Throwable ignore){}

    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterNameArray()
     */
    public String[] getParameterNameArray() {
        return parameterNameArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterTypeArray()
     */
    public String[] getParameterTypeArray() {
        return parameterTypeArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterDefaultArray()
     */
    public Object[] getParameterDefaultArray() {
        return parameterDefaultArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#start()
     */
    public boolean start() {
        if (isRunning()) return false;
        if (connected) disconnect();
        setVariablesFromParameters();
        setupChannelList();
        testConnect();
        if (!connected) return false;
        startThread();
        return true;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#stop()
     */
    public boolean stop() {
        if (!isRunning()) return false;
        stopThread();
        disconnect();
        return true;
    }

}

---