id -> potID

id is a python method. We should avoid replacing these.
* timestream/manipulate/plantSegmenter.py (ImagePotHandler__init__): id->potID
Add softBindings

* timestream/manipulate/plantSegmenter.py (ImagePotHandler): Add softBindings
dictionary. This will contain relations of the pot to other elements in other
contexts. This will set us up for relating pot ID to chamber ID and will
ultimately allow de-randomization.
Add ImagePotRectangle class.

* timestream/manipulate/pipecomponents.py (plantExtractor.__call__): Perform the
growM calculation at this stage instead of in the ImagePotMatrix class.
* timestream/manipulate/plantSegmenter.py (ImagePotRectangle): New class with
all the nitty gritty calculations for rectangles in images.
(ImagePotHandler): Put all the rectangle previously contained in ImagePotHandler
in the new ImagePotRectangle.
Remove "trays" from ImagePotMatrix

ImagePotMatrix will organize pots by ID, not by tray. The tray information can
still by added as an additional binding.
* timestream/manipulate/pipecomponents.py (PotDetector.__call__): Create the
ImagePotMatrix as soon as we detect the pots in PotDetector.
(PlantExtractor): We now expect a ImagePotMatrix object in the arguments.
* timestream/manipulate/plantSegmenter.py (ImagePotHandleriphPrev): We put this
in a property and use _iphPrev internally.
(ImagePotHandler.setSbind): Allows the creation of an arbitrary binding for each
pot.
(ImagePotMatrix): We remove the tray class and have a simple dictionary of pots
indexed by the potId.
(ImagePotMatrix.addPot): New method that adds pots to the matrix dictionary.
Add tray binding to each pot

* timestream/manipulate/pipecomponents.py (PotDetector.__call__): Add tray id
for each pot.
* timestream/manipulate/plantSegmenter.py (setSbind): Fix error in var name.
Create a new file timestrea/manipulate/pot.py

This will have the pot related logic.
* timestream/manipulate/pipecomponents.py: Remove pot related logic
* timestream/manipulate/pot.py: Copy paste from pipecomponents.py
Rename binding to metaids

Metaids in the pots reflects more the purpose of these variables and methods.
* timestream/manipulate/pot.py (getMetaKeys, getSbindList): Replaced old method
with Metaids method.
(getMeta, getSbind): Likewise.
(setMeta, setSbind): Likewise.
Create new component PopulatePotMetaIds

* timestream/manipulate/pipecomponents.py (PopulatePotMetaIds): new component
that will create additional meta ids for each pot in ImagePotMatrirx instance.
Though we have populated the meta ids, we have not way of accessing because we
can't (yet) make the ImagePotMatrix instance persistant. We don't make it
persistante because the ImagePotMatrix instance cannot be handled by json.
* timestream/manipulate/pipeline.py (complist): Fix small bug.
Start passing TimeStreamImage

* timestream/manipulate/pipecomponents.py: For all the components that passed an
nd.array as the image, we have changed it to a TimeStreamImage object.
* util/pipeline_demo.py : We now start of the process with a
TimeStreamImage instead of an nd.array.
Allow user to change configuration parameters.

We are not able to change parameters that are more complex: like a list of
values.
* util/pipeline_demo.py: Add a --set options that will parse comma (,) separated
option specifications.
* timestream/manipulate/configuration.py : Fix error where we were evaluating a
non-existing element.
Remove Tester component

* timestream/manipulate/pipecomponents.py (Tester): We are not really using it.
Remove it.
Remove un-used lines from PotDetector

* timestream/manipulate/pipecomponents.py (__call__): date is not used.
Subsec should be a TimeStream specific value

subsec is used to create image paths that increment if the path already exists.
TimeStreamImage should not worry about this as the context of adding an image
with a counter should be in TimeStream.
* timestream/__init__.py (TimeStream): Maintain the "increment" option, but
use a subsec var instead of image.subsec.
(TimeStreamImage.clone, subsec): Remove subsec from TimeStreamImage
Add a write method to TimeStreamImage.

* timestream/__init__.py (TimeStream.write_image): Call the new write method
(write, read): New methods to take care of the array writing. The read method is
added to be consistent with write but it just assigns path.
Path existence check should be in pixels

* timestream/__init__.py (pixels): Move the check to see if image file exists to
pixels method. The user should be able to set the path without an actuall file
existing so she can then call image.write()
Reset _pixels when changing _path

* timestream/__init__.py (path): We reset _pixels to None when chaning _path.
The logic behind this is that whenever you change _path you invalidate whatever
is in _pixels.
Avoid inconsistencies when setting pixels.

* timestream/__init__.py (pixels): When we set _pixels, _path becomes
inconsistent. We reset the _path to None. If the default timestream image is an
actual file, this leads to inconsistencies inside the instance (the _path does
not point to whatever is in _pixels) therefore we raise an exception.
* util/pipeline_demo.py: Remove the timestream reference from every image before
going into the pipeline.
Use the configuration Class for context instance.

* timestream/manipulate/pipecomponents.py: Uset the context variable as a
configuration object.
* util/pipeline_demo.py: Initialize context as ctx and pass along to the
pipeline.
Initialize instance vars not class vars.

* timestream/__init__.py (TimeStreamImage.__init__): Initialize instance vars in
the __init__ method.
Use TimeStreamImage in ImagePotMatrix

* timestream/manipulate/pipecomponents.py: Initialize ImagePotMatrix with
TimeStreamImage
* timestream/manipulate/pot.py (image): We handle the image internally with
_image. Once image is set, it cannot be unset.