diff --git a/README.md b/README.md
new file mode 100644
index 0000000..93f2b68
--- /dev/null
+++ b/README.md
@@ -0,0 +1,47 @@
+This is a collection of tools for working with 3D image stacks of microvessel networks
+
+### All Dependencies (individual scripts have only a subset of these dependencies)
+* [bftools](http://www.openmicroscopy.org/site/support/bio-formats5.3/users/comlinetools/)
+* [pyxb](https://pypi.python.org/pypi/PyXB)
+* [VTK with Python Interface](http://www.vtk.org/download/)
+* [Scikit Image]
+* [VMTK](http://www.vmtk.org/)
+* [Microvessel Chaste](https://jmsgrogan.github.io/MicrovesselChaste/)
+
+### Working with ZEISS (IMS, LSM, CZI) Image Data
+It is useful to first extract the image metadata. This requires a copy of [bftools](http://www.openmicroscopy.org/site/support/bio-formats5.3/users/comlinetools/).
+Download it and set`$BFTOOLS_DIR` to the directory obtained after unzipping. Then do:
+
+```bash
+python format_conversion/extract_zeiss_metadata.py -i $IMAGE_PATH -o $OUTPUT_FILE --verbose 1
+```
+
+To proceed we need to convert the format to an OME TIFF and then a generic TIFF. It is easiest to work with 
+one series and one channel at a time. Since we work with large images it is best to split the images into tiles and 
+work in parallel. 
+
+```bash
+python format_conversion/zeiss_to_tiff.py -i $IMAGE_PATH -o $OUTPUT_FOLDER
+```
+
+### Working with 3D TIFFs
+After conversion we can work with the 3D TIFFs using packages like sci-kit. It is important to remember that
+the generic TIFFs we have produced have all of their physical dimensions stripped. We do not trust any tools to
+preserve physical dimensions. The original OME metadata XML is the only reference we use.
+
+For easy visualization it is useful to downsample and then re-assemble the tiles.
+
+```bash
+python image/downsample_tiffs.py -i $IMAGE_PATH -x 3 -y 3 -z 1
+```
+
+### Visualizing
+We can use FIJI or VTK to visualize. VTK is nicer, but struggles with full resolution datasets. We can downsample
+as described previoulsy and then create VTK files for use in paraview.
+
+```bash
+python format_conversion/tiff_to_vtk.py -i $IMAGE_PATH -m $METADATA_FILE -tx 1024 -ty 1024 -dx 3 -dy 3 -dz 1
+```
+
+Even with this it is difficult to make nice volume renders as resource use is high. To launch a simple VTK window do:
+
diff --git a/format_conversion/__init__.py b/format_conversion/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/format_conversion/bftools_wrapper.py b/format_conversion/bftools_wrapper.py
new file mode 100644
index 0000000..26f5abe
--- /dev/null
+++ b/format_conversion/bftools_wrapper.py
@@ -0,0 +1,50 @@
+"""
+Wrapper over bftools
+"""
+
+import os
+import subprocess
+
+def convert(input_path, output_path, tile_x=None, tile_y=None, 
+            channel=0, series=0, crop_indices = None, bigtiff=False):
+    
+    """
+    Convert an input image in ZEISS LSM or CZI format to an OME TIFF.
+    Slice spacing information is lost in this operation for some reason.
+    """
+
+    # Set up the command for bfconvert
+    bf_tools_dir = os.getenv('BFTOOLS_DIR', os.getcwd()) + "/"
+    command = bf_tools_dir + "/bfconvert "
+    if not os.path.exists(output_path):
+        os.makedirs(output_path)
+    output_path += "/" + os.path.splitext(input_path)[0] + "_T%t"
+    
+    # Only one channel at a time
+    command += " -channel " + str(channel) + " "
+    output_path += "_C%c"
+    # Only one series at a time
+    command += " -series " + str(series) + " "
+    output_path += "_S%s"
+
+    # Set up tiles
+    if tile_x is not None and tile_y is not None:
+        command += " -tilex " + str(tile_x) + " -tiley " + str(tile_y) + " "
+        output_path += "_tile_X%x_Y%y_ID_%m"
+        
+    
+    # bigtiff
+    if bigtiff:
+        command += " -bigtiff "
+        
+    # crop
+    if crop_indices is not None:
+        command += " -crop " + str(int(crop_indices[4])) + "," + str(int(crop_indices[5])) 
+        command += "," + str(int(crop_indices[6]))  + "," + str(int(crop_indices[7])) + " "
+        global_index = crop_indices[0] + crop_indices[1]*crop_indices[2]
+        output_path += "_x_"+ str(int(crop_indices[0])) + "_y_" + str(int(crop_indices[1])) + "_m_" + str(int(global_index))
+    command += input_path + " " + output_path + ".tiff"
+
+    # Do the conversion
+    p = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
+    p.wait()
diff --git a/format_conversion/extract_zeiss_metadata.py b/format_conversion/extract_zeiss_metadata.py
new file mode 100644
index 0000000..1f6148e
--- /dev/null
+++ b/format_conversion/extract_zeiss_metadata.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+"""
+Extract and Parse Metadata from IMS/LSM/CZI files.
+"""
+
+from argparse import ArgumentParser
+import os
+import subprocess
+import logging
+import utility
+import ome_schema
+
+def extract_metadata(input_path, output_path):
+    
+    """
+    Extract OME metadata from the input file and write it out as a nicely formatted xml using
+    bftools. (http://www.openmicroscopy.org/site/support/bio-formats5.3/users/comlinetools/display.html)
+    """
+    
+    bf_tools_dir = os.getenv('BFTOOLS_DIR', os.getcwd()) + "/"
+    command = bf_tools_dir +"showinf -omexml-only -nopix " + input_path + " | " + bf_tools_dir + "xmlindent > " + output_path
+    p = subprocess.Popen(command, shell=True)
+    p.wait()
+    
+def get_metadata_as_class(input_xml_path):
+    
+    """
+    Return the OME metadata from the input XML file as a Python class. The class is automatically generated
+    using pyxbgen (http://pyxb.sourceforge.net/pyxbgen_cli.html) and the current OME XML Schema 
+    (https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd).
+    
+    If you need to use a newer schema you need to regenerate the file ome_schema.py by doing:
+    pip install pyxb
+    pyxbgen -m ome_schema -u https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd
+    
+    where the web address points to the new schema. You can then access the elements of the OME XML as
+    instance attributes etc.
+    """
+    
+    xml = open(input_xml_path).read()
+    image_metadata = ome_schema.CreateFromDocument(xml)
+    return image_metadata
+
+def integer_color_to_rgb(color):
+    
+    """
+    Convert integer color to (r,g,b)
+    """
+
+    return ((color >> 16) & 255, (color >> 8) & 255, color & 255)
+    
+
+def print_metadata_overview(image_metadata):
+    
+    """
+    Print a reader-friendly metadata summary
+    """
+    
+    print "Number of Images: ", len(image_metadata.Image)
+    print "Image '0' - Name: ", image_metadata.Image[0].Name
+    print "Image '0' - Num Channels: ", image_metadata.Image[0].Pixels.SizeC
+    print "Image '0' - Num Times: ", image_metadata.Image[0].Pixels.SizeT
+    pixel_size_x = image_metadata.Image[0].Pixels.PhysicalSizeX
+    pixel_size_y = image_metadata.Image[0].Pixels.PhysicalSizeY
+    pixel_size_z = image_metadata.Image[0].Pixels.PhysicalSizeZ
+    pixel_unit_x = image_metadata.Image[0].Pixels.PhysicalSizeXUnit
+    pixel_unit_y = image_metadata.Image[0].Pixels.PhysicalSizeYUnit
+    pixel_unit_z = image_metadata.Image[0].Pixels.PhysicalSizeZUnit
+    print "Image '0' - Pixel Physical Size X: ", pixel_size_x, pixel_unit_x
+    print "Image '0' - Pixel Physical Size Y: ", pixel_size_y, pixel_unit_y
+    print "Image '0' - Pixel Physical Size Z: ", pixel_size_z, pixel_unit_z
+    print "Image '0' - Pixel Size X: ", image_metadata.Image[0].Pixels.SizeX
+    print "Image '0' - Pixel Size Y:", image_metadata.Image[0].Pixels.SizeY
+    print "Image '0' - Pixel Size Z:", image_metadata.Image[0].Pixels.SizeZ
+    print "Image '0' - Pixel Dimension Order: ", image_metadata.Image[0].Pixels.DimensionOrder
+    print "Image '0' - Pixel Bits: ", image_metadata.Image[0].Pixels.SignificantBits
+    for idx, eachChannel in enumerate(image_metadata.Image[0].Pixels.Channel):
+        print "Image '0' - Channel " +str(idx) + " Color: ", integer_color_to_rgb(eachChannel.Color)
+    
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "extract_metadata"
+    utility.do_setup(tool_name)
+    logger1 = logging.getLogger('format_conversion.'+tool_name)
+    
+    # Suppress XML Parse warnings
+    pyxb_logger = logging.getLogger('pyxb')
+    pyxb_logger.setLevel(logging.CRITICAL)
+    
+    parser = ArgumentParser()
+    parser.add_argument("-i", "--input_file", type=str, help='Input file in a ZEISS format.')
+    parser.add_argument("-o", "--output_file", type=str, help='Output metadata file.')
+    parser.add_argument("--verbose", type=bool, help='Output a simple metadata summary.')
+    args = parser.parse_args()
+    
+    logger1.info('Reading Metadata At: ' + args.input_file)
+    extract_metadata(args.input_file, args.output_file)
+    
+    if(args.verbose):
+        image_metadata = get_metadata_as_class(args.output_file)
+        print_metadata_overview(image_metadata)
+    logger1.info('Completed Reading Metadata')
\ No newline at end of file
diff --git a/format_conversion/ome_schema.py b/format_conversion/ome_schema.py
new file mode 100644
index 0000000..044e749
--- /dev/null
+++ b/format_conversion/ome_schema.py
@@ -0,0 +1,12562 @@
+# ./ome_schema.py
+# -*- coding: utf-8 -*-
+# PyXB bindings for NM:b0644015d26f3c1073fb3fe883cedd8da00569f4
+# Generated 2017-02-14 13:51:21.108802 by PyXB version 1.2.5 using Python 2.7.12.final.0
+# Namespace http://www.openmicroscopy.org/Schemas/OME/2016-06
+
+from __future__ import unicode_literals
+import pyxb
+import pyxb.binding
+import pyxb.binding.saxer
+import io
+import pyxb.utils.utility
+import pyxb.utils.domutils
+import sys
+import pyxb.utils.six as _six
+# Unique identifier for bindings created at the same time
+_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:a9ef9b74-f2bc-11e6-9b87-d850e6bacf71')
+
+# Version of PyXB used to generate the bindings
+_PyXBVersion = '1.2.5'
+# Generated bindings are not compatible across PyXB versions
+if pyxb.__version__ != _PyXBVersion:
+    raise pyxb.PyXBVersionError(_PyXBVersion)
+
+# A holder for module-level binding classes so we can access them from
+# inside class definitions where property names may conflict.
+_module_typeBindings = pyxb.utils.utility.Object()
+
+# Import bindings for namespaces imported into schema
+import pyxb.binding.datatypes
+
+# NOTE: All namespace declarations are reserved within the binding
+Namespace = pyxb.namespace.NamespaceForURI('http://www.openmicroscopy.org/Schemas/OME/2016-06', create_if_missing=True)
+Namespace.configureCategories(['typeBinding', 'elementBinding'])
+
+def CreateFromDocument (xml_text, default_namespace=None, location_base=None):
+    """Parse the given XML and use the document element to create a
+    Python instance.
+
+    @param xml_text An XML document.  This should be data (Python 2
+    str or Python 3 bytes), or a text (Python 2 unicode or Python 3
+    str) in the L{pyxb._InputEncoding} encoding.
+
+    @keyword default_namespace The L{pyxb.Namespace} instance to use as the
+    default namespace where there is no default namespace in scope.
+    If unspecified or C{None}, the namespace of the module containing
+    this function will be used.
+
+    @keyword location_base: An object to be recorded as the base of all
+    L{pyxb.utils.utility.Location} instances associated with events and
+    objects handled by the parser.  You might pass the URI from which
+    the document was obtained.
+    """
+
+    if pyxb.XMLStyle_saxer != pyxb._XMLStyle:
+        dom = pyxb.utils.domutils.StringToDOM(xml_text)
+        return CreateFromDOM(dom.documentElement, default_namespace=default_namespace)
+    if default_namespace is None:
+        default_namespace = Namespace.fallbackNamespace()
+    saxer = pyxb.binding.saxer.make_parser(fallback_namespace=default_namespace, location_base=location_base)
+    handler = saxer.getContentHandler()
+    xmld = xml_text
+    if isinstance(xmld, _six.text_type):
+        xmld = xmld.encode(pyxb._InputEncoding)
+    saxer.parse(io.BytesIO(xmld))
+    instance = handler.rootObject()
+    return instance
+
+def CreateFromDOM (node, default_namespace=None):
+    """Create a Python instance from the given DOM node.
+    The node tag must correspond to an element declaration in this module.
+
+    @deprecated: Forcing use of DOM interface is unnecessary; use L{CreateFromDocument}."""
+    if default_namespace is None:
+        default_namespace = Namespace.fallbackNamespace()
+    return pyxb.binding.basis.element.AnyCreateFromDOM(node, default_namespace)
+
+
+# Atomic simple type: [anonymous]
+class STD_ANON (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 274, 10)
+    _Documentation = None
+STD_ANON._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON._InitializeFacetMap(STD_ANON._CF_whiteSpace)
+_module_typeBindings.STD_ANON = STD_ANON
+
+# Atomic simple type: [anonymous]
+class STD_ANON_ (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 358, 8)
+    _Documentation = None
+STD_ANON_._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_, enum_prefix=None)
+STD_ANON_.XYZCT = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYZCT', tag='XYZCT')
+STD_ANON_.XYZTC = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYZTC', tag='XYZTC')
+STD_ANON_.XYCTZ = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYCTZ', tag='XYCTZ')
+STD_ANON_.XYCZT = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYCZT', tag='XYCZT')
+STD_ANON_.XYTCZ = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYTCZ', tag='XYTCZ')
+STD_ANON_.XYTZC = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='XYTZC', tag='XYTZC')
+STD_ANON_._InitializeFacetMap(STD_ANON_._CF_enumeration)
+_module_typeBindings.STD_ANON_ = STD_ANON_
+
+# Atomic simple type: [anonymous]
+class STD_ANON_2 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 641, 8)
+    _Documentation = None
+STD_ANON_2._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_2, enum_prefix=None)
+STD_ANON_2.Transmitted = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Transmitted', tag='Transmitted')
+STD_ANON_2.Epifluorescence = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Epifluorescence', tag='Epifluorescence')
+STD_ANON_2.Oblique = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Oblique', tag='Oblique')
+STD_ANON_2.NonLinear = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='NonLinear', tag='NonLinear')
+STD_ANON_2.Other = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_2._InitializeFacetMap(STD_ANON_2._CF_enumeration)
+_module_typeBindings.STD_ANON_2 = STD_ANON_2
+
+# Atomic simple type: [anonymous]
+class STD_ANON_3 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 670, 8)
+    _Documentation = None
+STD_ANON_3._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_3, enum_prefix=None)
+STD_ANON_3.WideField = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='WideField', tag='WideField')
+STD_ANON_3.LaserScanningConfocalMicroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='LaserScanningConfocalMicroscopy', tag='LaserScanningConfocalMicroscopy')
+STD_ANON_3.SpinningDiskConfocal = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SpinningDiskConfocal', tag='SpinningDiskConfocal')
+STD_ANON_3.SlitScanConfocal = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SlitScanConfocal', tag='SlitScanConfocal')
+STD_ANON_3.MultiPhotonMicroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='MultiPhotonMicroscopy', tag='MultiPhotonMicroscopy')
+STD_ANON_3.StructuredIllumination = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='StructuredIllumination', tag='StructuredIllumination')
+STD_ANON_3.SingleMoleculeImaging = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SingleMoleculeImaging', tag='SingleMoleculeImaging')
+STD_ANON_3.TotalInternalReflection = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='TotalInternalReflection', tag='TotalInternalReflection')
+STD_ANON_3.FluorescenceLifetime = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='FluorescenceLifetime', tag='FluorescenceLifetime')
+STD_ANON_3.SpectralImaging = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SpectralImaging', tag='SpectralImaging')
+STD_ANON_3.FluorescenceCorrelationSpectroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='FluorescenceCorrelationSpectroscopy', tag='FluorescenceCorrelationSpectroscopy')
+STD_ANON_3.NearFieldScanningOpticalMicroscopy = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='NearFieldScanningOpticalMicroscopy', tag='NearFieldScanningOpticalMicroscopy')
+STD_ANON_3.SecondHarmonicGenerationImaging = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SecondHarmonicGenerationImaging', tag='SecondHarmonicGenerationImaging')
+STD_ANON_3.PALM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='PALM', tag='PALM')
+STD_ANON_3.STORM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='STORM', tag='STORM')
+STD_ANON_3.STED = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='STED', tag='STED')
+STD_ANON_3.TIRF = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='TIRF', tag='TIRF')
+STD_ANON_3.FSM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='FSM', tag='FSM')
+STD_ANON_3.LCM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='LCM', tag='LCM')
+STD_ANON_3.Other = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_3.BrightField = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='BrightField', tag='BrightField')
+STD_ANON_3.SweptFieldConfocal = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SweptFieldConfocal', tag='SweptFieldConfocal')
+STD_ANON_3.SPIM = STD_ANON_3._CF_enumeration.addEnumeration(unicode_value='SPIM', tag='SPIM')
+STD_ANON_3._InitializeFacetMap(STD_ANON_3._CF_enumeration)
+_module_typeBindings.STD_ANON_3 = STD_ANON_3
+
+# Atomic simple type: [anonymous]
+class STD_ANON_4 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 704, 8)
+    _Documentation = None
+STD_ANON_4._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_4, enum_prefix=None)
+STD_ANON_4.Brightfield = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Brightfield', tag='Brightfield')
+STD_ANON_4.Phase = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Phase', tag='Phase')
+STD_ANON_4.DIC = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='DIC', tag='DIC')
+STD_ANON_4.HoffmanModulation = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='HoffmanModulation', tag='HoffmanModulation')
+STD_ANON_4.ObliqueIllumination = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='ObliqueIllumination', tag='ObliqueIllumination')
+STD_ANON_4.PolarizedLight = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='PolarizedLight', tag='PolarizedLight')
+STD_ANON_4.Darkfield = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Darkfield', tag='Darkfield')
+STD_ANON_4.Fluorescence = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Fluorescence', tag='Fluorescence')
+STD_ANON_4.Other = STD_ANON_4._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_4._InitializeFacetMap(STD_ANON_4._CF_enumeration)
+_module_typeBindings.STD_ANON_4 = STD_ANON_4
+
+# Atomic simple type: [anonymous]
+class STD_ANON_5 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 937, 10)
+    _Documentation = None
+STD_ANON_5._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_5._InitializeFacetMap(STD_ANON_5._CF_whiteSpace)
+_module_typeBindings.STD_ANON_5 = STD_ANON_5
+
+# Atomic simple type: [anonymous]
+class STD_ANON_6 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 960, 12)
+    _Documentation = None
+STD_ANON_6._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_6, enum_prefix=None)
+STD_ANON_6.FRAP = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='FRAP', tag='FRAP')
+STD_ANON_6.FLIP = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='FLIP', tag='FLIP')
+STD_ANON_6.InverseFRAP = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='InverseFRAP', tag='InverseFRAP')
+STD_ANON_6.Photoablation = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Photoablation', tag='Photoablation')
+STD_ANON_6.Photoactivation = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Photoactivation', tag='Photoactivation')
+STD_ANON_6.Uncaging = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Uncaging', tag='Uncaging')
+STD_ANON_6.OpticalTrapping = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='OpticalTrapping', tag='OpticalTrapping')
+STD_ANON_6.Other = STD_ANON_6._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_6._InitializeFacetMap(STD_ANON_6._CF_enumeration)
+_module_typeBindings.STD_ANON_6 = STD_ANON_6
+
+# Atomic simple type: [anonymous]
+class STD_ANON_7 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1025, 12)
+    _Documentation = None
+STD_ANON_7._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_7, enum_prefix=None)
+STD_ANON_7.Upright = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Upright', tag='Upright')
+STD_ANON_7.Inverted = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Inverted', tag='Inverted')
+STD_ANON_7.Dissection = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Dissection', tag='Dissection')
+STD_ANON_7.Electrophysiology = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Electrophysiology', tag='Electrophysiology')
+STD_ANON_7.Other = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_7._InitializeFacetMap(STD_ANON_7._CF_enumeration)
+_module_typeBindings.STD_ANON_7 = STD_ANON_7
+
+# Atomic simple type: [anonymous]
+class STD_ANON_8 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1119, 10)
+    _Documentation = None
+STD_ANON_8._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_8._InitializeFacetMap(STD_ANON_8._CF_whiteSpace)
+_module_typeBindings.STD_ANON_8 = STD_ANON_8
+
+# Atomic simple type: [anonymous]
+class STD_ANON_9 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1159, 10)
+    _Documentation = None
+STD_ANON_9._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_9._InitializeFacetMap(STD_ANON_9._CF_whiteSpace)
+_module_typeBindings.STD_ANON_9 = STD_ANON_9
+
+# Atomic simple type: [anonymous]
+class STD_ANON_10 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1222, 10)
+    _Documentation = None
+STD_ANON_10._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_10._InitializeFacetMap(STD_ANON_10._CF_whiteSpace)
+_module_typeBindings.STD_ANON_10 = STD_ANON_10
+
+# Atomic simple type: [anonymous]
+class STD_ANON_11 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1270, 10)
+    _Documentation = None
+STD_ANON_11._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_11._InitializeFacetMap(STD_ANON_11._CF_whiteSpace)
+_module_typeBindings.STD_ANON_11 = STD_ANON_11
+
+# Atomic simple type: [anonymous]
+class STD_ANON_12 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1293, 12)
+    _Documentation = None
+STD_ANON_12._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_12, enum_prefix=None)
+STD_ANON_12.FP = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FP', tag='FP')
+STD_ANON_12.FRET = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FRET', tag='FRET')
+STD_ANON_12.TimeLapse = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='TimeLapse', tag='TimeLapse')
+STD_ANON_12.FourDPlus = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FourDPlus', tag='FourDPlus')
+STD_ANON_12.Screen = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Screen', tag='Screen')
+STD_ANON_12.Immunocytochemistry = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Immunocytochemistry', tag='Immunocytochemistry')
+STD_ANON_12.Immunofluorescence = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Immunofluorescence', tag='Immunofluorescence')
+STD_ANON_12.FISH = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FISH', tag='FISH')
+STD_ANON_12.Electrophysiology = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Electrophysiology', tag='Electrophysiology')
+STD_ANON_12.IonImaging = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='IonImaging', tag='IonImaging')
+STD_ANON_12.Colocalization = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Colocalization', tag='Colocalization')
+STD_ANON_12.PGIDocumentation = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='PGIDocumentation', tag='PGIDocumentation')
+STD_ANON_12.FluorescenceLifetime = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='FluorescenceLifetime', tag='FluorescenceLifetime')
+STD_ANON_12.SpectralImaging = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='SpectralImaging', tag='SpectralImaging')
+STD_ANON_12.Photobleaching = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Photobleaching', tag='Photobleaching')
+STD_ANON_12.SPIM = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='SPIM', tag='SPIM')
+STD_ANON_12.Other = STD_ANON_12._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_12._InitializeFacetMap(STD_ANON_12._CF_enumeration)
+_module_typeBindings.STD_ANON_12 = STD_ANON_12
+
+# Atomic simple type: [anonymous]
+class STD_ANON_13 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1394, 10)
+    _Documentation = None
+STD_ANON_13._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_13._InitializeFacetMap(STD_ANON_13._CF_whiteSpace)
+_module_typeBindings.STD_ANON_13 = STD_ANON_13
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Hex40
+class Hex40 (pyxb.binding.datatypes.hexBinary):
+
+    """
+        Binary contents coded in hexadecimal (20 characters long)
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Hex40')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1467, 2)
+    _Documentation = '\n        Binary contents coded in hexadecimal (20 characters long)\n      '
+Hex40._CF_length = pyxb.binding.facets.CF_length(value=pyxb.binding.datatypes.nonNegativeInteger(20))
+Hex40._InitializeFacetMap(Hex40._CF_length)
+Namespace.addCategoryObject('typeBinding', 'Hex40', Hex40)
+_module_typeBindings.Hex40 = Hex40
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NonNegativeFloat
+class NonNegativeFloat (pyxb.binding.datatypes.float):
+
+    """
+        A simple type that restricts the value to a float between >=0 and max 32-bit float {i.e. (2−2^-23) × 2^27 ≈ 3.4 × 10^38}
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NonNegativeFloat')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1477, 2)
+    _Documentation = '\n        A simple type that restricts the value to a float between >=0 and max 32-bit float {i.e. (2\u22122^-23) \xd7 2^27 \u2248 3.4 \xd7 10^38}\n      '
+NonNegativeFloat._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=NonNegativeFloat, value=pyxb.binding.datatypes.float(0.0))
+NonNegativeFloat._InitializeFacetMap(NonNegativeFloat._CF_minInclusive)
+Namespace.addCategoryObject('typeBinding', 'NonNegativeFloat', NonNegativeFloat)
+_module_typeBindings.NonNegativeFloat = NonNegativeFloat
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NonNegativeLong
+class NonNegativeLong (pyxb.binding.datatypes.long):
+
+    """
+        A simple type that restricts the value to a long between 0 and 9223372036854775807 (inclusive).
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NonNegativeLong')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1487, 2)
+    _Documentation = '\n        A simple type that restricts the value to a long between 0 and 9223372036854775807 (inclusive).\n      '
+NonNegativeLong._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=NonNegativeLong, value=pyxb.binding.datatypes.long(0))
+NonNegativeLong._InitializeFacetMap(NonNegativeLong._CF_minInclusive)
+Namespace.addCategoryObject('typeBinding', 'NonNegativeLong', NonNegativeLong)
+_module_typeBindings.NonNegativeLong = NonNegativeLong
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NonNegativeInt
+class NonNegativeInt (pyxb.binding.datatypes.int):
+
+    """
+        A simple type that restricts the value to an integer between 0 and 2,147,483,647 (inclusive).
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NonNegativeInt')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1497, 2)
+    _Documentation = '\n        A simple type that restricts the value to an integer between 0 and 2,147,483,647 (inclusive).\n      '
+NonNegativeInt._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=NonNegativeInt, value=pyxb.binding.datatypes.int(0))
+NonNegativeInt._InitializeFacetMap(NonNegativeInt._CF_minInclusive)
+Namespace.addCategoryObject('typeBinding', 'NonNegativeInt', NonNegativeInt)
+_module_typeBindings.NonNegativeInt = NonNegativeInt
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PositiveInt
+class PositiveInt (pyxb.binding.datatypes.int):
+
+    """
+        A simple type that restricts the value to an integer between 1 and 2,147,483,647 (inclusive).
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PositiveInt')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1507, 2)
+    _Documentation = '\n        A simple type that restricts the value to an integer between 1 and 2,147,483,647 (inclusive).\n      '
+PositiveInt._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=PositiveInt, value=pyxb.binding.datatypes.int(1))
+PositiveInt._InitializeFacetMap(PositiveInt._CF_minInclusive)
+Namespace.addCategoryObject('typeBinding', 'PositiveInt', PositiveInt)
+_module_typeBindings.PositiveInt = PositiveInt
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PositiveFloat
+class PositiveFloat (pyxb.binding.datatypes.float):
+
+    """
+        A simple type that restricts the value to a float between >0 and max 32-bit float {i.e. (2−2^-23) × 2^27 ≈ 3.4 × 10^38}
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PositiveFloat')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1517, 2)
+    _Documentation = '\n        A simple type that restricts the value to a float between >0 and max 32-bit float {i.e. (2\u22122^-23) \xd7 2^27 \u2248 3.4 \xd7 10^38}\n      '
+PositiveFloat._CF_minExclusive = pyxb.binding.facets.CF_minExclusive(value_datatype=pyxb.binding.datatypes.float, value=pyxb.binding.datatypes._fp(0.0))
+PositiveFloat._InitializeFacetMap(PositiveFloat._CF_minExclusive)
+Namespace.addCategoryObject('typeBinding', 'PositiveFloat', PositiveFloat)
+_module_typeBindings.PositiveFloat = PositiveFloat
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PercentFraction
+class PercentFraction (pyxb.binding.datatypes.float):
+
+    """
+        A simple type that restricts the value to a float between 0 and 1 (inclusive).
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PercentFraction')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1527, 2)
+    _Documentation = '\n        A simple type that restricts the value to a float between 0 and 1 (inclusive).\n      '
+PercentFraction._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=PercentFraction, value=pyxb.binding.datatypes.float(0.0))
+PercentFraction._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=PercentFraction, value=pyxb.binding.datatypes.float(1.0))
+PercentFraction._InitializeFacetMap(PercentFraction._CF_minInclusive,
+   PercentFraction._CF_maxInclusive)
+Namespace.addCategoryObject('typeBinding', 'PercentFraction', PercentFraction)
+_module_typeBindings.PercentFraction = PercentFraction
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UniversallyUniqueIdentifier
+class UniversallyUniqueIdentifier (pyxb.binding.datatypes.anyURI):
+
+    """
+        This is a unique ID for the file but does not conform to the ID pattern used in the rest of the file.
+        The rest of the IDs are either an full LSID or an internal ID which is a string that is simply unique in this file.
+        As the UniversallyUniqueIdentifier is used from outside this file to identify it having the same ID in another file could cause problems.
+        A UUID is 32 hexadecimal digits, in 5 groups, 8-4-4-4-12, separated by hyphens
+        e.g. urn:uuid:3e450fae-b8f2-4d35-aa54-702168b2487f
+        There are methods to generate these in most modern languages.
+        http://www.ietf.org/rfc/rfc4122.txt
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UniversallyUniqueIdentifier')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1538, 2)
+    _Documentation = '\n        This is a unique ID for the file but does not conform to the ID pattern used in the rest of the file.\n        The rest of the IDs are either an full LSID or an internal ID which is a string that is simply unique in this file.\n        As the UniversallyUniqueIdentifier is used from outside this file to identify it having the same ID in another file could cause problems.\n        A UUID is 32 hexadecimal digits, in 5 groups, 8-4-4-4-12, separated by hyphens\n        e.g. urn:uuid:3e450fae-b8f2-4d35-aa54-702168b2487f\n        There are methods to generate these in most modern languages.\n        http://www.ietf.org/rfc/rfc4122.txt\n      '
+UniversallyUniqueIdentifier._CF_pattern = pyxb.binding.facets.CF_pattern()
+UniversallyUniqueIdentifier._CF_pattern.addPattern(pattern='(urn:uuid:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})')
+UniversallyUniqueIdentifier._InitializeFacetMap(UniversallyUniqueIdentifier._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'UniversallyUniqueIdentifier', UniversallyUniqueIdentifier)
+_module_typeBindings.UniversallyUniqueIdentifier = UniversallyUniqueIdentifier
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Binning
+class Binning (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        Represents the number of pixels that are combined to form larger pixels. {used:CCD,EMCCD}
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Binning')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1582, 2)
+    _Documentation = '\n        Represents the number of pixels that are combined to form larger pixels. {used:CCD,EMCCD}\n      '
+Binning._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=Binning, enum_prefix=None)
+Binning.n1x1 = Binning._CF_enumeration.addEnumeration(unicode_value='1x1', tag='n1x1')
+Binning.n2x2 = Binning._CF_enumeration.addEnumeration(unicode_value='2x2', tag='n2x2')
+Binning.n4x4 = Binning._CF_enumeration.addEnumeration(unicode_value='4x4', tag='n4x4')
+Binning.n8x8 = Binning._CF_enumeration.addEnumeration(unicode_value='8x8', tag='n8x8')
+Binning.Other = Binning._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+Binning._InitializeFacetMap(Binning._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'Binning', Binning)
+_module_typeBindings.Binning = Binning
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FontFamily
+class FontFamily (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The font family used to draw the text. [enumeration]
+        Note: these values are all lower case so they match
+        the standard HTML/CSS values. "fantasy" has been
+        included for completeness we do not recommended its
+        regular use.
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FontFamily')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1632, 2)
+    _Documentation = '\n        The font family used to draw the text. [enumeration]\n        Note: these values are all lower case so they match\n        the standard HTML/CSS values. "fantasy" has been\n        included for completeness we do not recommended its\n        regular use.\n      '
+FontFamily._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=FontFamily, enum_prefix=None)
+FontFamily.serif = FontFamily._CF_enumeration.addEnumeration(unicode_value='serif', tag='serif')
+FontFamily.sans_serif = FontFamily._CF_enumeration.addEnumeration(unicode_value='sans-serif', tag='sans_serif')
+FontFamily.cursive = FontFamily._CF_enumeration.addEnumeration(unicode_value='cursive', tag='cursive')
+FontFamily.fantasy = FontFamily._CF_enumeration.addEnumeration(unicode_value='fantasy', tag='fantasy')
+FontFamily.monospace = FontFamily._CF_enumeration.addEnumeration(unicode_value='monospace', tag='monospace')
+FontFamily._InitializeFacetMap(FontFamily._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'FontFamily', FontFamily)
+_module_typeBindings.FontFamily = FontFamily
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PixelType
+class PixelType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The number size/kind used to represent a pixel
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PixelType')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1686, 2)
+    _Documentation = '\n        The number size/kind used to represent a pixel\n      '
+PixelType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=PixelType, enum_prefix=None)
+PixelType.int8 = PixelType._CF_enumeration.addEnumeration(unicode_value='int8', tag='int8')
+PixelType.int16 = PixelType._CF_enumeration.addEnumeration(unicode_value='int16', tag='int16')
+PixelType.int32 = PixelType._CF_enumeration.addEnumeration(unicode_value='int32', tag='int32')
+PixelType.uint8 = PixelType._CF_enumeration.addEnumeration(unicode_value='uint8', tag='uint8')
+PixelType.uint16 = PixelType._CF_enumeration.addEnumeration(unicode_value='uint16', tag='uint16')
+PixelType.uint32 = PixelType._CF_enumeration.addEnumeration(unicode_value='uint32', tag='uint32')
+PixelType.float = PixelType._CF_enumeration.addEnumeration(unicode_value='float', tag='float')
+PixelType.double = PixelType._CF_enumeration.addEnumeration(unicode_value='double', tag='double')
+PixelType.complex = PixelType._CF_enumeration.addEnumeration(unicode_value='complex', tag='complex')
+PixelType.double_complex = PixelType._CF_enumeration.addEnumeration(unicode_value='double-complex', tag='double_complex')
+PixelType.bit = PixelType._CF_enumeration.addEnumeration(unicode_value='bit', tag='bit')
+PixelType._InitializeFacetMap(PixelType._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'PixelType', PixelType)
+_module_typeBindings.PixelType = PixelType
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Color
+class Color (pyxb.binding.datatypes.int):
+
+    """
+        A simple type that identifies itself as a Color, the value is an integer between -2,147,483,648 and 2,147,483,647 (inclusive).
+        The value is a signed 32 bit encoding of RGBA so "-1" is #FFFFFFFF or solid white.
+        NOTE: Prior to the 2012-06 schema the default values were incorrect and produced a transparent red not solid white.
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Color')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1761, 2)
+    _Documentation = '\n        A simple type that identifies itself as a Color, the value is an integer between -2,147,483,648 and 2,147,483,647 (inclusive).\n        The value is a signed 32 bit encoding of RGBA so "-1" is #FFFFFFFF or solid white.\n        NOTE: Prior to the 2012-06 schema the default values were incorrect and produced a transparent red not solid white.\n      '
+Color._InitializeFacetMap()
+Namespace.addCategoryObject('typeBinding', 'Color', Color)
+_module_typeBindings.Color = Color
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsLength
+class UnitsLength (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent a length
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsLength')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1773, 2)
+    _Documentation = '\n        The units used to represent a length\n      '
+UnitsLength._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsLength, enum_prefix=None)
+UnitsLength.Ym = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Ym', tag='Ym')
+UnitsLength.Zm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Zm', tag='Zm')
+UnitsLength.Em = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Em', tag='Em')
+UnitsLength.Pm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Pm', tag='Pm')
+UnitsLength.Tm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Tm', tag='Tm')
+UnitsLength.Gm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Gm', tag='Gm')
+UnitsLength.Mm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='Mm', tag='Mm')
+UnitsLength.km = UnitsLength._CF_enumeration.addEnumeration(unicode_value='km', tag='km')
+UnitsLength.hm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='hm', tag='hm')
+UnitsLength.dam = UnitsLength._CF_enumeration.addEnumeration(unicode_value='dam', tag='dam')
+UnitsLength.m = UnitsLength._CF_enumeration.addEnumeration(unicode_value='m', tag='m')
+UnitsLength.dm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='dm', tag='dm')
+UnitsLength.cm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='cm', tag='cm')
+UnitsLength.mm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='mm', tag='mm')
+UnitsLength.m_ = UnitsLength._CF_enumeration.addEnumeration(unicode_value='\xb5m', tag='m_')
+UnitsLength.nm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='nm', tag='nm')
+UnitsLength.pm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pm', tag='pm')
+UnitsLength.fm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='fm', tag='fm')
+UnitsLength.am = UnitsLength._CF_enumeration.addEnumeration(unicode_value='am', tag='am')
+UnitsLength.zm = UnitsLength._CF_enumeration.addEnumeration(unicode_value='zm', tag='zm')
+UnitsLength.ym = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ym', tag='ym')
+UnitsLength.emptyString = UnitsLength._CF_enumeration.addEnumeration(unicode_value='\xc5', tag='emptyString')
+UnitsLength.thou = UnitsLength._CF_enumeration.addEnumeration(unicode_value='thou', tag='thou')
+UnitsLength.li = UnitsLength._CF_enumeration.addEnumeration(unicode_value='li', tag='li')
+UnitsLength.in_ = UnitsLength._CF_enumeration.addEnumeration(unicode_value='in', tag='in_')
+UnitsLength.ft = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ft', tag='ft')
+UnitsLength.yd = UnitsLength._CF_enumeration.addEnumeration(unicode_value='yd', tag='yd')
+UnitsLength.mi = UnitsLength._CF_enumeration.addEnumeration(unicode_value='mi', tag='mi')
+UnitsLength.ua = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ua', tag='ua')
+UnitsLength.ly = UnitsLength._CF_enumeration.addEnumeration(unicode_value='ly', tag='ly')
+UnitsLength.pc = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pc', tag='pc')
+UnitsLength.pt = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pt', tag='pt')
+UnitsLength.pixel = UnitsLength._CF_enumeration.addEnumeration(unicode_value='pixel', tag='pixel')
+UnitsLength.reference_frame = UnitsLength._CF_enumeration.addEnumeration(unicode_value='reference frame', tag='reference_frame')
+UnitsLength._InitializeFacetMap(UnitsLength._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsLength', UnitsLength)
+_module_typeBindings.UnitsLength = UnitsLength
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsTime
+class UnitsTime (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent a time interval
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsTime')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1822, 2)
+    _Documentation = '\n        The units used to represent a time interval\n      '
+UnitsTime._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsTime, enum_prefix=None)
+UnitsTime.Ys = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ys', tag='Ys')
+UnitsTime.Zs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Zs', tag='Zs')
+UnitsTime.Es = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Es', tag='Es')
+UnitsTime.Ps = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ps', tag='Ps')
+UnitsTime.Ts = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ts', tag='Ts')
+UnitsTime.Gs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Gs', tag='Gs')
+UnitsTime.Ms = UnitsTime._CF_enumeration.addEnumeration(unicode_value='Ms', tag='Ms')
+UnitsTime.ks = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ks', tag='ks')
+UnitsTime.hs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='hs', tag='hs')
+UnitsTime.das = UnitsTime._CF_enumeration.addEnumeration(unicode_value='das', tag='das')
+UnitsTime.s = UnitsTime._CF_enumeration.addEnumeration(unicode_value='s', tag='s')
+UnitsTime.ds = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ds', tag='ds')
+UnitsTime.cs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='cs', tag='cs')
+UnitsTime.ms = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ms', tag='ms')
+UnitsTime.s_ = UnitsTime._CF_enumeration.addEnumeration(unicode_value='\xb5s', tag='s_')
+UnitsTime.ns = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ns', tag='ns')
+UnitsTime.ps = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ps', tag='ps')
+UnitsTime.fs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='fs', tag='fs')
+UnitsTime.as_ = UnitsTime._CF_enumeration.addEnumeration(unicode_value='as', tag='as_')
+UnitsTime.zs = UnitsTime._CF_enumeration.addEnumeration(unicode_value='zs', tag='zs')
+UnitsTime.ys = UnitsTime._CF_enumeration.addEnumeration(unicode_value='ys', tag='ys')
+UnitsTime.min = UnitsTime._CF_enumeration.addEnumeration(unicode_value='min', tag='min')
+UnitsTime.h = UnitsTime._CF_enumeration.addEnumeration(unicode_value='h', tag='h')
+UnitsTime.d = UnitsTime._CF_enumeration.addEnumeration(unicode_value='d', tag='d')
+UnitsTime._InitializeFacetMap(UnitsTime._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsTime', UnitsTime)
+_module_typeBindings.UnitsTime = UnitsTime
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsPressure
+class UnitsPressure (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent a pressure
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsPressure')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1857, 2)
+    _Documentation = '\n        The units used to represent a pressure\n      '
+UnitsPressure._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsPressure, enum_prefix=None)
+UnitsPressure.YPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='YPa', tag='YPa')
+UnitsPressure.ZPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='ZPa', tag='ZPa')
+UnitsPressure.EPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='EPa', tag='EPa')
+UnitsPressure.PPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='PPa', tag='PPa')
+UnitsPressure.TPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='TPa', tag='TPa')
+UnitsPressure.GPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='GPa', tag='GPa')
+UnitsPressure.MPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='MPa', tag='MPa')
+UnitsPressure.kPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='kPa', tag='kPa')
+UnitsPressure.hPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='hPa', tag='hPa')
+UnitsPressure.daPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='daPa', tag='daPa')
+UnitsPressure.Pa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='Pa', tag='Pa')
+UnitsPressure.dPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='dPa', tag='dPa')
+UnitsPressure.cPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='cPa', tag='cPa')
+UnitsPressure.mPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mPa', tag='mPa')
+UnitsPressure.Pa_ = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='\xb5Pa', tag='Pa_')
+UnitsPressure.nPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='nPa', tag='nPa')
+UnitsPressure.pPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='pPa', tag='pPa')
+UnitsPressure.fPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='fPa', tag='fPa')
+UnitsPressure.aPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='aPa', tag='aPa')
+UnitsPressure.zPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='zPa', tag='zPa')
+UnitsPressure.yPa = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='yPa', tag='yPa')
+UnitsPressure.bar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='bar', tag='bar')
+UnitsPressure.Mbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='Mbar', tag='Mbar')
+UnitsPressure.kbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='kbar', tag='kbar')
+UnitsPressure.dbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='dbar', tag='dbar')
+UnitsPressure.cbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='cbar', tag='cbar')
+UnitsPressure.mbar = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mbar', tag='mbar')
+UnitsPressure.atm = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='atm', tag='atm')
+UnitsPressure.psi = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='psi', tag='psi')
+UnitsPressure.Torr = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='Torr', tag='Torr')
+UnitsPressure.mTorr = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mTorr', tag='mTorr')
+UnitsPressure.mm_Hg = UnitsPressure._CF_enumeration.addEnumeration(unicode_value='mm Hg', tag='mm_Hg')
+UnitsPressure._InitializeFacetMap(UnitsPressure._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsPressure', UnitsPressure)
+_module_typeBindings.UnitsPressure = UnitsPressure
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsAngle
+class UnitsAngle (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent an angle
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsAngle')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1903, 2)
+    _Documentation = '\n        The units used to represent an angle\n      '
+UnitsAngle._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsAngle, enum_prefix=None)
+UnitsAngle.deg = UnitsAngle._CF_enumeration.addEnumeration(unicode_value='deg', tag='deg')
+UnitsAngle.rad = UnitsAngle._CF_enumeration.addEnumeration(unicode_value='rad', tag='rad')
+UnitsAngle.gon = UnitsAngle._CF_enumeration.addEnumeration(unicode_value='gon', tag='gon')
+UnitsAngle._InitializeFacetMap(UnitsAngle._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsAngle', UnitsAngle)
+_module_typeBindings.UnitsAngle = UnitsAngle
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsTemperature
+class UnitsTemperature (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent a temperature
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsTemperature')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1916, 2)
+    _Documentation = '\n        The units used to represent a temperature\n      '
+UnitsTemperature._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsTemperature, enum_prefix=None)
+UnitsTemperature.C = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='\xb0C', tag='C')
+UnitsTemperature.F = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='\xb0F', tag='F')
+UnitsTemperature.K = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='K', tag='K')
+UnitsTemperature.R = UnitsTemperature._CF_enumeration.addEnumeration(unicode_value='\xb0R', tag='R')
+UnitsTemperature._InitializeFacetMap(UnitsTemperature._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsTemperature', UnitsTemperature)
+_module_typeBindings.UnitsTemperature = UnitsTemperature
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsElectricPotential
+class UnitsElectricPotential (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent an electric potential
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsElectricPotential')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1930, 2)
+    _Documentation = '\n        The units used to represent an electric potential\n      '
+UnitsElectricPotential._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsElectricPotential, enum_prefix=None)
+UnitsElectricPotential.YV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='YV', tag='YV')
+UnitsElectricPotential.ZV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='ZV', tag='ZV')
+UnitsElectricPotential.EV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='EV', tag='EV')
+UnitsElectricPotential.PV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='PV', tag='PV')
+UnitsElectricPotential.TV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='TV', tag='TV')
+UnitsElectricPotential.GV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='GV', tag='GV')
+UnitsElectricPotential.MV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='MV', tag='MV')
+UnitsElectricPotential.kV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='kV', tag='kV')
+UnitsElectricPotential.hV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='hV', tag='hV')
+UnitsElectricPotential.daV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='daV', tag='daV')
+UnitsElectricPotential.V = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='V', tag='V')
+UnitsElectricPotential.dV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='dV', tag='dV')
+UnitsElectricPotential.cV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='cV', tag='cV')
+UnitsElectricPotential.mV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='mV', tag='mV')
+UnitsElectricPotential.V_ = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='\xb5V', tag='V_')
+UnitsElectricPotential.nV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='nV', tag='nV')
+UnitsElectricPotential.pV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='pV', tag='pV')
+UnitsElectricPotential.fV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='fV', tag='fV')
+UnitsElectricPotential.aV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='aV', tag='aV')
+UnitsElectricPotential.zV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='zV', tag='zV')
+UnitsElectricPotential.yV = UnitsElectricPotential._CF_enumeration.addEnumeration(unicode_value='yV', tag='yV')
+UnitsElectricPotential._InitializeFacetMap(UnitsElectricPotential._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsElectricPotential', UnitsElectricPotential)
+_module_typeBindings.UnitsElectricPotential = UnitsElectricPotential
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsPower
+class UnitsPower (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent power
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsPower')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1961, 2)
+    _Documentation = '\n        The units used to represent power\n      '
+UnitsPower._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsPower, enum_prefix=None)
+UnitsPower.YW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='YW', tag='YW')
+UnitsPower.ZW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='ZW', tag='ZW')
+UnitsPower.EW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='EW', tag='EW')
+UnitsPower.PW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='PW', tag='PW')
+UnitsPower.TW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='TW', tag='TW')
+UnitsPower.GW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='GW', tag='GW')
+UnitsPower.MW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='MW', tag='MW')
+UnitsPower.kW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='kW', tag='kW')
+UnitsPower.hW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='hW', tag='hW')
+UnitsPower.daW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='daW', tag='daW')
+UnitsPower.W = UnitsPower._CF_enumeration.addEnumeration(unicode_value='W', tag='W')
+UnitsPower.dW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='dW', tag='dW')
+UnitsPower.cW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='cW', tag='cW')
+UnitsPower.mW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='mW', tag='mW')
+UnitsPower.W_ = UnitsPower._CF_enumeration.addEnumeration(unicode_value='\xb5W', tag='W_')
+UnitsPower.nW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='nW', tag='nW')
+UnitsPower.pW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='pW', tag='pW')
+UnitsPower.fW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='fW', tag='fW')
+UnitsPower.aW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='aW', tag='aW')
+UnitsPower.zW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='zW', tag='zW')
+UnitsPower.yW = UnitsPower._CF_enumeration.addEnumeration(unicode_value='yW', tag='yW')
+UnitsPower._InitializeFacetMap(UnitsPower._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsPower', UnitsPower)
+_module_typeBindings.UnitsPower = UnitsPower
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}UnitsFrequency
+class UnitsFrequency (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        The units used to represent frequency
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'UnitsFrequency')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1992, 2)
+    _Documentation = '\n        The units used to represent frequency\n      '
+UnitsFrequency._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=UnitsFrequency, enum_prefix=None)
+UnitsFrequency.YHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='YHz', tag='YHz')
+UnitsFrequency.ZHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='ZHz', tag='ZHz')
+UnitsFrequency.EHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='EHz', tag='EHz')
+UnitsFrequency.PHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='PHz', tag='PHz')
+UnitsFrequency.THz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='THz', tag='THz')
+UnitsFrequency.GHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='GHz', tag='GHz')
+UnitsFrequency.MHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='MHz', tag='MHz')
+UnitsFrequency.kHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='kHz', tag='kHz')
+UnitsFrequency.hHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='hHz', tag='hHz')
+UnitsFrequency.daHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='daHz', tag='daHz')
+UnitsFrequency.Hz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='Hz', tag='Hz')
+UnitsFrequency.dHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='dHz', tag='dHz')
+UnitsFrequency.cHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='cHz', tag='cHz')
+UnitsFrequency.mHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='mHz', tag='mHz')
+UnitsFrequency.Hz_ = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='\xb5Hz', tag='Hz_')
+UnitsFrequency.nHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='nHz', tag='nHz')
+UnitsFrequency.pHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='pHz', tag='pHz')
+UnitsFrequency.fHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='fHz', tag='fHz')
+UnitsFrequency.aHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='aHz', tag='aHz')
+UnitsFrequency.zHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='zHz', tag='zHz')
+UnitsFrequency.yHz = UnitsFrequency._CF_enumeration.addEnumeration(unicode_value='yHz', tag='yHz')
+UnitsFrequency._InitializeFacetMap(UnitsFrequency._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'UnitsFrequency', UnitsFrequency)
+_module_typeBindings.UnitsFrequency = UnitsFrequency
+
+# Atomic simple type: [anonymous]
+class STD_ANON_14 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2061, 12)
+    _Documentation = None
+STD_ANON_14._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_14, enum_prefix=None)
+STD_ANON_14.UV = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='UV', tag='UV')
+STD_ANON_14.PlanApo = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='PlanApo', tag='PlanApo')
+STD_ANON_14.PlanFluor = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='PlanFluor', tag='PlanFluor')
+STD_ANON_14.SuperFluor = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='SuperFluor', tag='SuperFluor')
+STD_ANON_14.VioletCorrected = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='VioletCorrected', tag='VioletCorrected')
+STD_ANON_14.Achro = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Achro', tag='Achro')
+STD_ANON_14.Achromat = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Achromat', tag='Achromat')
+STD_ANON_14.Fluor = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fluor', tag='Fluor')
+STD_ANON_14.Fl = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fl', tag='Fl')
+STD_ANON_14.Fluar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fluar', tag='Fluar')
+STD_ANON_14.Neofluar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Neofluar', tag='Neofluar')
+STD_ANON_14.Fluotar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Fluotar', tag='Fluotar')
+STD_ANON_14.Apo = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Apo', tag='Apo')
+STD_ANON_14.PlanNeofluar = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='PlanNeofluar', tag='PlanNeofluar')
+STD_ANON_14.Other = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_14._InitializeFacetMap(STD_ANON_14._CF_enumeration)
+_module_typeBindings.STD_ANON_14 = STD_ANON_14
+
+# Atomic simple type: [anonymous]
+class STD_ANON_15 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2085, 12)
+    _Documentation = None
+STD_ANON_15._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_15, enum_prefix=None)
+STD_ANON_15.Oil = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Oil', tag='Oil')
+STD_ANON_15.Water = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Water', tag='Water')
+STD_ANON_15.WaterDipping = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='WaterDipping', tag='WaterDipping')
+STD_ANON_15.Air = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Air', tag='Air')
+STD_ANON_15.Multi = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Multi', tag='Multi')
+STD_ANON_15.Glycerol = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Glycerol', tag='Glycerol')
+STD_ANON_15.Other = STD_ANON_15._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_15._InitializeFacetMap(STD_ANON_15._CF_enumeration)
+_module_typeBindings.STD_ANON_15 = STD_ANON_15
+
+# Atomic simple type: [anonymous]
+class STD_ANON_16 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2217, 12)
+    _Documentation = None
+STD_ANON_16._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_16, enum_prefix=None)
+STD_ANON_16.CCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='CCD', tag='CCD')
+STD_ANON_16.IntensifiedCCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='IntensifiedCCD', tag='IntensifiedCCD')
+STD_ANON_16.AnalogVideo = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='AnalogVideo', tag='AnalogVideo')
+STD_ANON_16.PMT = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='PMT', tag='PMT')
+STD_ANON_16.Photodiode = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='Photodiode', tag='Photodiode')
+STD_ANON_16.Spectroscopy = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='Spectroscopy', tag='Spectroscopy')
+STD_ANON_16.LifetimeImaging = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='LifetimeImaging', tag='LifetimeImaging')
+STD_ANON_16.CorrelationSpectroscopy = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='CorrelationSpectroscopy', tag='CorrelationSpectroscopy')
+STD_ANON_16.FTIR = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='FTIR', tag='FTIR')
+STD_ANON_16.EMCCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='EMCCD', tag='EMCCD')
+STD_ANON_16.APD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='APD', tag='APD')
+STD_ANON_16.CMOS = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='CMOS', tag='CMOS')
+STD_ANON_16.EBCCD = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='EBCCD', tag='EBCCD')
+STD_ANON_16.Other = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_16._InitializeFacetMap(STD_ANON_16._CF_enumeration)
+_module_typeBindings.STD_ANON_16 = STD_ANON_16
+
+# Atomic simple type: [anonymous]
+class STD_ANON_17 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2300, 12)
+    _Documentation = None
+STD_ANON_17._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_17, enum_prefix=None)
+STD_ANON_17.Dichroic = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='Dichroic', tag='Dichroic')
+STD_ANON_17.LongPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='LongPass', tag='LongPass')
+STD_ANON_17.ShortPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='ShortPass', tag='ShortPass')
+STD_ANON_17.BandPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='BandPass', tag='BandPass')
+STD_ANON_17.MultiPass = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='MultiPass', tag='MultiPass')
+STD_ANON_17.NeutralDensity = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='NeutralDensity', tag='NeutralDensity')
+STD_ANON_17.Tuneable = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='Tuneable', tag='Tuneable')
+STD_ANON_17.Other = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_17._InitializeFacetMap(STD_ANON_17._CF_enumeration)
+_module_typeBindings.STD_ANON_17 = STD_ANON_17
+
+# Atomic simple type: [anonymous]
+class STD_ANON_18 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2523, 12)
+    _Documentation = None
+STD_ANON_18._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_18, enum_prefix=None)
+STD_ANON_18.Excimer = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Excimer', tag='Excimer')
+STD_ANON_18.Gas = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Gas', tag='Gas')
+STD_ANON_18.MetalVapor = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='MetalVapor', tag='MetalVapor')
+STD_ANON_18.SolidState = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='SolidState', tag='SolidState')
+STD_ANON_18.Dye = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Dye', tag='Dye')
+STD_ANON_18.Semiconductor = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Semiconductor', tag='Semiconductor')
+STD_ANON_18.FreeElectron = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='FreeElectron', tag='FreeElectron')
+STD_ANON_18.Other = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_18._InitializeFacetMap(STD_ANON_18._CF_enumeration)
+_module_typeBindings.STD_ANON_18 = STD_ANON_18
+
+# Atomic simple type: [anonymous]
+class STD_ANON_19 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2543, 12)
+    _Documentation = None
+STD_ANON_19._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_19, enum_prefix=None)
+STD_ANON_19.Cu = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Cu', tag='Cu')
+STD_ANON_19.Ag = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Ag', tag='Ag')
+STD_ANON_19.ArFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ArFl', tag='ArFl')
+STD_ANON_19.ArCl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ArCl', tag='ArCl')
+STD_ANON_19.KrFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='KrFl', tag='KrFl')
+STD_ANON_19.KrCl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='KrCl', tag='KrCl')
+STD_ANON_19.XeFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='XeFl', tag='XeFl')
+STD_ANON_19.XeCl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='XeCl', tag='XeCl')
+STD_ANON_19.XeBr = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='XeBr', tag='XeBr')
+STD_ANON_19.N = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='N', tag='N')
+STD_ANON_19.Ar = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Ar', tag='Ar')
+STD_ANON_19.Kr = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Kr', tag='Kr')
+STD_ANON_19.Xe = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Xe', tag='Xe')
+STD_ANON_19.HeNe = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HeNe', tag='HeNe')
+STD_ANON_19.HeCd = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HeCd', tag='HeCd')
+STD_ANON_19.CO = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='CO', tag='CO')
+STD_ANON_19.CO2 = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='CO2', tag='CO2')
+STD_ANON_19.H2O = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='H2O', tag='H2O')
+STD_ANON_19.HFl = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HFl', tag='HFl')
+STD_ANON_19.NdGlass = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='NdGlass', tag='NdGlass')
+STD_ANON_19.NdYAG = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='NdYAG', tag='NdYAG')
+STD_ANON_19.ErGlass = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ErGlass', tag='ErGlass')
+STD_ANON_19.ErYAG = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='ErYAG', tag='ErYAG')
+STD_ANON_19.HoYLF = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HoYLF', tag='HoYLF')
+STD_ANON_19.HoYAG = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='HoYAG', tag='HoYAG')
+STD_ANON_19.Ruby = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Ruby', tag='Ruby')
+STD_ANON_19.TiSapphire = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='TiSapphire', tag='TiSapphire')
+STD_ANON_19.Alexandrite = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Alexandrite', tag='Alexandrite')
+STD_ANON_19.Rhodamine6G = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Rhodamine6G', tag='Rhodamine6G')
+STD_ANON_19.CoumarinC30 = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='CoumarinC30', tag='CoumarinC30')
+STD_ANON_19.GaAs = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='GaAs', tag='GaAs')
+STD_ANON_19.GaAlAs = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='GaAlAs', tag='GaAlAs')
+STD_ANON_19.EMinus = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='EMinus', tag='EMinus')
+STD_ANON_19.Other = STD_ANON_19._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_19._InitializeFacetMap(STD_ANON_19._CF_enumeration)
+_module_typeBindings.STD_ANON_19 = STD_ANON_19
+
+# Atomic simple type: [anonymous]
+class STD_ANON_20 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2622, 12)
+    _Documentation = None
+STD_ANON_20._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_20, enum_prefix=None)
+STD_ANON_20.CW = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='CW', tag='CW')
+STD_ANON_20.Single = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='Single', tag='Single')
+STD_ANON_20.QSwitched = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='QSwitched', tag='QSwitched')
+STD_ANON_20.Repetitive = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='Repetitive', tag='Repetitive')
+STD_ANON_20.ModeLocked = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='ModeLocked', tag='ModeLocked')
+STD_ANON_20.Other = STD_ANON_20._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_20._InitializeFacetMap(STD_ANON_20._CF_enumeration)
+_module_typeBindings.STD_ANON_20 = STD_ANON_20
+
+# Atomic simple type: [anonymous]
+class STD_ANON_21 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2675, 12)
+    _Documentation = None
+STD_ANON_21._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_21, enum_prefix=None)
+STD_ANON_21.Hg = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='Hg', tag='Hg')
+STD_ANON_21.Xe = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='Xe', tag='Xe')
+STD_ANON_21.HgXe = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='HgXe', tag='HgXe')
+STD_ANON_21.Other = STD_ANON_21._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_21._InitializeFacetMap(STD_ANON_21._CF_enumeration)
+_module_typeBindings.STD_ANON_21 = STD_ANON_21
+
+# Atomic simple type: [anonymous]
+class STD_ANON_22 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2705, 12)
+    _Documentation = None
+STD_ANON_22._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_22, enum_prefix=None)
+STD_ANON_22.Incandescent = STD_ANON_22._CF_enumeration.addEnumeration(unicode_value='Incandescent', tag='Incandescent')
+STD_ANON_22.Halogen = STD_ANON_22._CF_enumeration.addEnumeration(unicode_value='Halogen', tag='Halogen')
+STD_ANON_22.Other = STD_ANON_22._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_22._InitializeFacetMap(STD_ANON_22._CF_enumeration)
+_module_typeBindings.STD_ANON_22 = STD_ANON_22
+
+# Atomic simple type: [anonymous]
+class STD_ANON_23 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2809, 10)
+    _Documentation = None
+STD_ANON_23._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_23._InitializeFacetMap(STD_ANON_23._CF_whiteSpace)
+_module_typeBindings.STD_ANON_23 = STD_ANON_23
+
+# Atomic simple type: [anonymous]
+class STD_ANON_24 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2822, 10)
+    _Documentation = None
+STD_ANON_24._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_24._InitializeFacetMap(STD_ANON_24._CF_whiteSpace)
+_module_typeBindings.STD_ANON_24 = STD_ANON_24
+
+# Atomic simple type: [anonymous]
+class STD_ANON_25 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+                  A description of a Medium used for the lens.
+                  The Medium is the actual immersion medium used in this case.
+                """
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3152, 12)
+    _Documentation = '\n                  A description of a Medium used for the lens.\n                  The Medium is the actual immersion medium used in this case.\n                '
+STD_ANON_25._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_25, enum_prefix=None)
+STD_ANON_25.Air = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Air', tag='Air')
+STD_ANON_25.Oil = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Oil', tag='Oil')
+STD_ANON_25.Water = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Water', tag='Water')
+STD_ANON_25.Glycerol = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Glycerol', tag='Glycerol')
+STD_ANON_25.Other = STD_ANON_25._CF_enumeration.addEnumeration(unicode_value='Other', tag='Other')
+STD_ANON_25._InitializeFacetMap(STD_ANON_25._CF_enumeration)
+_module_typeBindings.STD_ANON_25 = STD_ANON_25
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}LSID
+class LSID (pyxb.binding.datatypes.string):
+
+    """
+        Either LSID or internal consistent IDs for the file
+        See: http://www.openmicroscopy.org/site/support/file-formats/working-with-ome-xml/id-and-lsid
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'LSID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3182, 2)
+    _Documentation = '\n        Either LSID or internal consistent IDs for the file\n        See: http://www.openmicroscopy.org/site/support/file-formats/working-with-ome-xml/id-and-lsid\n      '
+LSID._CF_pattern = pyxb.binding.facets.CF_pattern()
+LSID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:\\S+:\\S+)|(\\S+:\\S+)')
+LSID._InitializeFacetMap(LSID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'LSID', LSID)
+_module_typeBindings.LSID = LSID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}base64Binary
+class base64Binary (pyxb.binding.datatypes.base64Binary):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'base64Binary')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3285, 2)
+    _Documentation = None
+base64Binary._InitializeFacetMap()
+Namespace.addCategoryObject('typeBinding', 'base64Binary', base64Binary)
+_module_typeBindings.base64Binary = base64Binary
+
+# Atomic simple type: [anonymous]
+class STD_ANON_26 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3310, 8)
+    _Documentation = None
+STD_ANON_26._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_26, enum_prefix=None)
+STD_ANON_26.zlib = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='zlib', tag='zlib')
+STD_ANON_26.bzip2 = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='bzip2', tag='bzip2')
+STD_ANON_26.none = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='none', tag='none')
+STD_ANON_26._InitializeFacetMap(STD_ANON_26._CF_enumeration)
+_module_typeBindings.STD_ANON_26 = STD_ANON_26
+
+# Atomic simple type: [anonymous]
+class STD_ANON_27 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3332, 12)
+    _Documentation = None
+STD_ANON_27._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_27, enum_prefix=None)
+STD_ANON_27.zlib = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='zlib', tag='zlib')
+STD_ANON_27.bzip2 = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='bzip2', tag='bzip2')
+STD_ANON_27.none = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='none', tag='none')
+STD_ANON_27._InitializeFacetMap(STD_ANON_27._CF_enumeration)
+_module_typeBindings.STD_ANON_27 = STD_ANON_27
+
+# Atomic simple type: [anonymous]
+class STD_ANON_28 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3466, 8)
+    _Documentation = None
+STD_ANON_28._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_28._InitializeFacetMap(STD_ANON_28._CF_whiteSpace)
+_module_typeBindings.STD_ANON_28 = STD_ANON_28
+
+# Atomic simple type: [anonymous]
+class STD_ANON_29 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3778, 10)
+    _Documentation = None
+STD_ANON_29._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_29._InitializeFacetMap(STD_ANON_29._CF_whiteSpace)
+_module_typeBindings.STD_ANON_29 = STD_ANON_29
+
+# Atomic simple type: [anonymous]
+class STD_ANON_30 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+            The rule used to decide which parts of the shape to
+            fill. [enumeration]
+          """
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3831, 6)
+    _Documentation = '\n            The rule used to decide which parts of the shape to\n            fill. [enumeration]\n          '
+STD_ANON_30._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_30, enum_prefix=None)
+STD_ANON_30.EvenOdd = STD_ANON_30._CF_enumeration.addEnumeration(unicode_value='EvenOdd', tag='EvenOdd')
+STD_ANON_30.NonZero = STD_ANON_30._CF_enumeration.addEnumeration(unicode_value='NonZero', tag='NonZero')
+STD_ANON_30._InitializeFacetMap(STD_ANON_30._CF_enumeration)
+_module_typeBindings.STD_ANON_30 = STD_ANON_30
+
+# Atomic simple type: [anonymous]
+class STD_ANON_31 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+            The font family used to draw the text. [enumeration]
+            Note: these values are all lower case so they match
+            the standard HTML/CSS values. "fantasy" has been
+            included for completeness; we do not recommend its
+            regular use. This attribute is under consideration
+            for removal from the OME-XML schema.
+          """
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3876, 6)
+    _Documentation = '\n            The font family used to draw the text. [enumeration]\n            Note: these values are all lower case so they match\n            the standard HTML/CSS values. "fantasy" has been\n            included for completeness; we do not recommend its\n            regular use. This attribute is under consideration\n            for removal from the OME-XML schema.\n          '
+STD_ANON_31._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_31, enum_prefix=None)
+STD_ANON_31.serif = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='serif', tag='serif')
+STD_ANON_31.sans_serif = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='sans-serif', tag='sans_serif')
+STD_ANON_31.cursive = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='cursive', tag='cursive')
+STD_ANON_31.fantasy = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='fantasy', tag='fantasy')
+STD_ANON_31.monospace = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='monospace', tag='monospace')
+STD_ANON_31._InitializeFacetMap(STD_ANON_31._CF_enumeration)
+_module_typeBindings.STD_ANON_31 = STD_ANON_31
+
+# Atomic simple type: [anonymous]
+class STD_ANON_32 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+            The style and weight applied to the text.  [enumeration]
+            This is a simplified combination of the HTML/CSS
+            attributes font-style AND font-weight.
+          """
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3911, 6)
+    _Documentation = '\n            The style and weight applied to the text.  [enumeration]\n            This is a simplified combination of the HTML/CSS\n            attributes font-style AND font-weight.\n          '
+STD_ANON_32._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_32, enum_prefix=None)
+STD_ANON_32.Bold = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='Bold', tag='Bold')
+STD_ANON_32.BoldItalic = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='BoldItalic', tag='BoldItalic')
+STD_ANON_32.Italic = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='Italic', tag='Italic')
+STD_ANON_32.Normal = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='Normal', tag='Normal')
+STD_ANON_32._InitializeFacetMap(STD_ANON_32._CF_enumeration)
+_module_typeBindings.STD_ANON_32 = STD_ANON_32
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}Marker
+class Marker (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        Shape of marker on the end of a line. [enumeration]
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Marker')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4287, 2)
+    _Documentation = '\n        Shape of marker on the end of a line. [enumeration]\n      '
+Marker._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=Marker, enum_prefix=None)
+Marker.Arrow = Marker._CF_enumeration.addEnumeration(unicode_value='Arrow', tag='Arrow')
+Marker._InitializeFacetMap(Marker._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'Marker', Marker)
+_module_typeBindings.Marker = Marker
+
+# Atomic simple type: [anonymous]
+class STD_ANON_33 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4320, 10)
+    _Documentation = None
+STD_ANON_33._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_33._InitializeFacetMap(STD_ANON_33._CF_whiteSpace)
+_module_typeBindings.STD_ANON_33 = STD_ANON_33
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}NamingConvention
+class NamingConvention (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
+
+    """
+        Predefined list of values for the well labels
+      """
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NamingConvention')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4447, 2)
+    _Documentation = '\n        Predefined list of values for the well labels\n      '
+NamingConvention._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=NamingConvention, enum_prefix=None)
+NamingConvention.letter = NamingConvention._CF_enumeration.addEnumeration(unicode_value='letter', tag='letter')
+NamingConvention.number = NamingConvention._CF_enumeration.addEnumeration(unicode_value='number', tag='number')
+NamingConvention._InitializeFacetMap(NamingConvention._CF_enumeration)
+Namespace.addCategoryObject('typeBinding', 'NamingConvention', NamingConvention)
+_module_typeBindings.NamingConvention = NamingConvention
+
+# Atomic simple type: [anonymous]
+class STD_ANON_34 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4513, 10)
+    _Documentation = None
+STD_ANON_34._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_34._InitializeFacetMap(STD_ANON_34._CF_whiteSpace)
+_module_typeBindings.STD_ANON_34 = STD_ANON_34
+
+# Atomic simple type: [anonymous]
+class STD_ANON_35 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4580, 10)
+    _Documentation = None
+STD_ANON_35._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_35._InitializeFacetMap(STD_ANON_35._CF_whiteSpace)
+_module_typeBindings.STD_ANON_35 = STD_ANON_35
+
+# Atomic simple type: [anonymous]
+class STD_ANON_36 (pyxb.binding.datatypes.string):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4678, 10)
+    _Documentation = None
+STD_ANON_36._CF_whiteSpace = pyxb.binding.facets.CF_whiteSpace(value=pyxb.binding.facets._WhiteSpace_enum.preserve)
+STD_ANON_36._InitializeFacetMap(STD_ANON_36._CF_whiteSpace)
+_module_typeBindings.STD_ANON_36 = STD_ANON_36
+
+# List simple type: [anonymous]
+# superclasses pyxb.binding.datatypes.anySimpleType
+class STD_ANON_37 (pyxb.binding.basis.STD_list):
+
+    """Simple type that is a list of STD_ANON_6."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 958, 8)
+    _Documentation = None
+
+    _ItemType = STD_ANON_6
+STD_ANON_37._InitializeFacetMap()
+_module_typeBindings.STD_ANON_37 = STD_ANON_37
+
+# List simple type: [anonymous]
+# superclasses pyxb.binding.datatypes.anySimpleType
+class STD_ANON_38 (pyxb.binding.basis.STD_list):
+
+    """Simple type that is a list of STD_ANON_12."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1291, 8)
+    _Documentation = None
+
+    _ItemType = STD_ANON_12
+STD_ANON_38._InitializeFacetMap()
+_module_typeBindings.STD_ANON_38 = STD_ANON_38
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ProjectID
+class ProjectID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ProjectID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3193, 2)
+    _Documentation = None
+ProjectID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ProjectID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Project:\\S+)|(Project:\\S+)')
+ProjectID._InitializeFacetMap(ProjectID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ProjectID', ProjectID)
+_module_typeBindings.ProjectID = ProjectID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}DatasetID
+class DatasetID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'DatasetID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3198, 2)
+    _Documentation = None
+DatasetID._CF_pattern = pyxb.binding.facets.CF_pattern()
+DatasetID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Dataset:\\S+)|(Dataset:\\S+)')
+DatasetID._InitializeFacetMap(DatasetID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'DatasetID', DatasetID)
+_module_typeBindings.DatasetID = DatasetID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageID
+class ImageID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ImageID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3203, 2)
+    _Documentation = None
+ImageID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ImageID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Image:\\S+)|(Image:\\S+)')
+ImageID._InitializeFacetMap(ImageID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ImageID', ImageID)
+_module_typeBindings.ImageID = ImageID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FolderID
+class FolderID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FolderID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3208, 2)
+    _Documentation = None
+FolderID._CF_pattern = pyxb.binding.facets.CF_pattern()
+FolderID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Folder:\\S+)|(Folder:\\S+)')
+FolderID._InitializeFacetMap(FolderID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'FolderID', FolderID)
+_module_typeBindings.FolderID = FolderID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterID
+class ExperimenterID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExperimenterID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3213, 2)
+    _Documentation = None
+ExperimenterID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ExperimenterID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Experimenter:\\S+)|(Experimenter:\\S+)')
+ExperimenterID._InitializeFacetMap(ExperimenterID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ExperimenterID', ExperimenterID)
+_module_typeBindings.ExperimenterID = ExperimenterID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupID
+class ExperimenterGroupID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3218, 2)
+    _Documentation = None
+ExperimenterGroupID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ExperimenterGroupID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:ExperimenterGroup:\\S+)|(ExperimenterGroup:\\S+)')
+ExperimenterGroupID._InitializeFacetMap(ExperimenterGroupID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ExperimenterGroupID', ExperimenterGroupID)
+_module_typeBindings.ExperimenterGroupID = ExperimenterGroupID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimentID
+class ExperimentID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExperimentID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3223, 2)
+    _Documentation = None
+ExperimentID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ExperimentID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Experiment:\\S+)|(Experiment:\\S+)')
+ExperimentID._InitializeFacetMap(ExperimentID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ExperimentID', ExperimentID)
+_module_typeBindings.ExperimentID = ExperimentID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}MicrobeamManipulationID
+class MicrobeamManipulationID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3228, 2)
+    _Documentation = None
+MicrobeamManipulationID._CF_pattern = pyxb.binding.facets.CF_pattern()
+MicrobeamManipulationID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:MicrobeamManipulation:\\S+)|(MicrobeamManipulation:\\S+)')
+MicrobeamManipulationID._InitializeFacetMap(MicrobeamManipulationID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'MicrobeamManipulationID', MicrobeamManipulationID)
+_module_typeBindings.MicrobeamManipulationID = MicrobeamManipulationID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}InstrumentID
+class InstrumentID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'InstrumentID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3233, 2)
+    _Documentation = None
+InstrumentID._CF_pattern = pyxb.binding.facets.CF_pattern()
+InstrumentID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Instrument:\\S+)|(Instrument:\\S+)')
+InstrumentID._InitializeFacetMap(InstrumentID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'InstrumentID', InstrumentID)
+_module_typeBindings.InstrumentID = InstrumentID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ObjectiveID
+class ObjectiveID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ObjectiveID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3238, 2)
+    _Documentation = None
+ObjectiveID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ObjectiveID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Objective:\\S+)|(Objective:\\S+)')
+ObjectiveID._InitializeFacetMap(ObjectiveID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ObjectiveID', ObjectiveID)
+_module_typeBindings.ObjectiveID = ObjectiveID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceID
+class LightSourceID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'LightSourceID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3243, 2)
+    _Documentation = None
+LightSourceID._CF_pattern = pyxb.binding.facets.CF_pattern()
+LightSourceID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:LightSource:\\S+)|(LightSource:\\S+)')
+LightSourceID._InitializeFacetMap(LightSourceID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'LightSourceID', LightSourceID)
+_module_typeBindings.LightSourceID = LightSourceID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}DichroicID
+class DichroicID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'DichroicID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3248, 2)
+    _Documentation = None
+DichroicID._CF_pattern = pyxb.binding.facets.CF_pattern()
+DichroicID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Dichroic:\\S+)|(Dichroic:\\S+)')
+DichroicID._InitializeFacetMap(DichroicID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'DichroicID', DichroicID)
+_module_typeBindings.DichroicID = DichroicID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterID
+class FilterID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FilterID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3253, 2)
+    _Documentation = None
+FilterID._CF_pattern = pyxb.binding.facets.CF_pattern()
+FilterID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Filter:\\S+)|(Filter:\\S+)')
+FilterID._InitializeFacetMap(FilterID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'FilterID', FilterID)
+_module_typeBindings.FilterID = FilterID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterSetID
+class FilterSetID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FilterSetID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3258, 2)
+    _Documentation = None
+FilterSetID._CF_pattern = pyxb.binding.facets.CF_pattern()
+FilterSetID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:FilterSet:\\S+)|(FilterSet:\\S+)')
+FilterSetID._InitializeFacetMap(FilterSetID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'FilterSetID', FilterSetID)
+_module_typeBindings.FilterSetID = FilterSetID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}DetectorID
+class DetectorID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'DetectorID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3263, 2)
+    _Documentation = None
+DetectorID._CF_pattern = pyxb.binding.facets.CF_pattern()
+DetectorID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Detector:\\S+)|(Detector:\\S+)')
+DetectorID._InitializeFacetMap(DetectorID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'DetectorID', DetectorID)
+_module_typeBindings.DetectorID = DetectorID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PixelsID
+class PixelsID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PixelsID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3268, 2)
+    _Documentation = None
+PixelsID._CF_pattern = pyxb.binding.facets.CF_pattern()
+PixelsID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Pixels:\\S+)|(Pixels:\\S+)')
+PixelsID._InitializeFacetMap(PixelsID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'PixelsID', PixelsID)
+_module_typeBindings.PixelsID = PixelsID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ChannelID
+class ChannelID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ChannelID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3273, 2)
+    _Documentation = None
+ChannelID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ChannelID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Channel:\\S+)|(Channel:\\S+)')
+ChannelID._InitializeFacetMap(ChannelID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ChannelID', ChannelID)
+_module_typeBindings.ChannelID = ChannelID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ModuleID
+class ModuleID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ModuleID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3278, 2)
+    _Documentation = None
+ModuleID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ModuleID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Module:\\S+)|(Module:\\S+)')
+ModuleID._InitializeFacetMap(ModuleID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ModuleID', ModuleID)
+_module_typeBindings.ModuleID = ModuleID
+
+# Atomic simple type: [anonymous]
+class STD_ANON_39 (NonNegativeLong):
+
+    """An atomic simple type."""
+
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3353, 12)
+    _Documentation = None
+STD_ANON_39._InitializeFacetMap()
+_module_typeBindings.STD_ANON_39 = STD_ANON_39
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationID
+class AnnotationID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'AnnotationID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3500, 2)
+    _Documentation = None
+AnnotationID._CF_pattern = pyxb.binding.facets.CF_pattern()
+AnnotationID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Annotation:\\S+)|(Annotation:\\S+)')
+AnnotationID._InitializeFacetMap(AnnotationID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'AnnotationID', AnnotationID)
+_module_typeBindings.AnnotationID = AnnotationID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIID
+class ROIID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ROIID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4275, 2)
+    _Documentation = None
+ROIID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ROIID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:\\S+)|(\\S+)')
+ROIID._InitializeFacetMap(ROIID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ROIID', ROIID)
+_module_typeBindings.ROIID = ROIID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ShapeID
+class ShapeID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ShapeID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4281, 2)
+    _Documentation = None
+ShapeID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ShapeID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Shape:\\S+)|(Shape:\\S+)')
+ShapeID._InitializeFacetMap(ShapeID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ShapeID', ShapeID)
+_module_typeBindings.ShapeID = ShapeID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateID
+class PlateID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PlateID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4492, 2)
+    _Documentation = None
+PlateID._CF_pattern = pyxb.binding.facets.CF_pattern()
+PlateID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Plate:\\S+)|(Plate:\\S+)')
+PlateID._InitializeFacetMap(PlateID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'PlateID', PlateID)
+_module_typeBindings.PlateID = PlateID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ReagentID
+class ReagentID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ReagentID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4554, 2)
+    _Documentation = None
+ReagentID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ReagentID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Reagent:\\S+)|(Reagent:\\S+)')
+ReagentID._InitializeFacetMap(ReagentID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ReagentID', ReagentID)
+_module_typeBindings.ReagentID = ReagentID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}ScreenID
+class ScreenID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ScreenID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4654, 2)
+    _Documentation = None
+ScreenID._CF_pattern = pyxb.binding.facets.CF_pattern()
+ScreenID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Screen:\\S+)|(Screen:\\S+)')
+ScreenID._InitializeFacetMap(ScreenID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'ScreenID', ScreenID)
+_module_typeBindings.ScreenID = ScreenID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateAcquisitionID
+class PlateAcquisitionID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisitionID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4720, 2)
+    _Documentation = None
+PlateAcquisitionID._CF_pattern = pyxb.binding.facets.CF_pattern()
+PlateAcquisitionID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:PlateAcquisition:\\S+)|(PlateAcquisition:\\S+)')
+PlateAcquisitionID._InitializeFacetMap(PlateAcquisitionID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'PlateAcquisitionID', PlateAcquisitionID)
+_module_typeBindings.PlateAcquisitionID = PlateAcquisitionID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellID
+class WellID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'WellID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4804, 2)
+    _Documentation = None
+WellID._CF_pattern = pyxb.binding.facets.CF_pattern()
+WellID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:Well:\\S+)|(Well:\\S+)')
+WellID._InitializeFacetMap(WellID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'WellID', WellID)
+_module_typeBindings.WellID = WellID
+
+# Atomic simple type: {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellSampleID
+class WellSampleID (LSID):
+
+    """An atomic simple type."""
+
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'WellSampleID')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4877, 2)
+    _Documentation = None
+WellSampleID._CF_pattern = pyxb.binding.facets.CF_pattern()
+WellSampleID._CF_pattern.addPattern(pattern='(urn:lsid:([\\w\\-\\.]+\\.[\\w\\-\\.]+)+:WellSample:\\S+)|(WellSample:\\S+)')
+WellSampleID._InitializeFacetMap(WellSampleID._CF_pattern)
+Namespace.addCategoryObject('typeBinding', 'WellSampleID', WellSampleID)
+_module_typeBindings.WellSampleID = WellSampleID
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec with content type EMPTY
+class ManufacturerSpec (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This is the base from which many microscope components are extended. E.g Objective, Filter etc.
+        Provides attributes for recording common properties of these components such as Manufacturer name, Model etc,
+        all of which are optional.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ManufacturerSpec')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1429, 2)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Attribute Manufacturer uses Python identifier Manufacturer
+    __Manufacturer = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Manufacturer'), 'Manufacturer', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_Manufacturer', pyxb.binding.datatypes.string)
+    __Manufacturer._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1438, 4)
+    __Manufacturer._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1438, 4)
+    
+    Manufacturer = property(__Manufacturer.value, __Manufacturer.set, None, '\n          The manufacturer of the component. [plain text string]\n        ')
+
+    
+    # Attribute Model uses Python identifier Model
+    __Model = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Model'), 'Model', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_Model', pyxb.binding.datatypes.string)
+    __Model._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1445, 4)
+    __Model._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1445, 4)
+    
+    Model = property(__Model.value, __Model.set, None, '\n          The Model of the component. [plain text string]\n        ')
+
+    
+    # Attribute SerialNumber uses Python identifier SerialNumber
+    __SerialNumber = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SerialNumber'), 'SerialNumber', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_SerialNumber', pyxb.binding.datatypes.string)
+    __SerialNumber._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1452, 4)
+    __SerialNumber._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1452, 4)
+    
+    SerialNumber = property(__SerialNumber.value, __SerialNumber.set, None, '\n          The serial number of the component. [plain text string]\n        ')
+
+    
+    # Attribute LotNumber uses Python identifier LotNumber
+    __LotNumber = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LotNumber'), 'LotNumber', '__httpwww_openmicroscopy_orgSchemasOME2016_06_ManufacturerSpec_LotNumber', pyxb.binding.datatypes.string)
+    __LotNumber._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1459, 4)
+    __LotNumber._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1459, 4)
+    
+    LotNumber = property(__LotNumber.value, __LotNumber.set, None, '\n          The lot number of the component. [plain text string]\n        ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Manufacturer.name() : __Manufacturer,
+        __Model.name() : __Model,
+        __SerialNumber.name() : __SerialNumber,
+        __LotNumber.name() : __LotNumber
+    })
+_module_typeBindings.ManufacturerSpec = ManufacturerSpec
+Namespace.addCategoryObject('typeBinding', 'ManufacturerSpec', ManufacturerSpec)
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Map with content type ELEMENT_ONLY
+class Map (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This is a Mapping of key/value pairs.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Map')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1555, 2)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}M uses Python identifier M
+    __M = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'M'), 'M', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Map_httpwww_openmicroscopy_orgSchemasOME2016_06M', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 6), )
+
+    
+    M = property(__M.value, __M.set, None, ' This is a key/value pair used to build up a Mapping. The\n          Element and Attribute name are kept to single letters to minimize the\n          length at the expense of readability as they are likely to occur many\n          times. ')
+
+    _ElementMap.update({
+        __M.name() : __M
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.Map = Map
+Namespace.addCategoryObject('typeBinding', 'Map', Map)
+
+
+# Complex type [anonymous] with content type SIMPLE
+class CTD_ANON (pyxb.binding.basis.complexTypeDefinition):
+    """ This is a key/value pair used to build up a Mapping. The
+          Element and Attribute name are kept to single letters to minimize the
+          length at the expense of readability as they are likely to occur many
+          times. """
+    _TypeDefinition = pyxb.binding.datatypes.string
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1571, 8)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.string
+    
+    # Attribute K uses Python identifier K
+    __K = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'K'), 'K', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_K', pyxb.binding.datatypes.string)
+    __K._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1574, 14)
+    __K._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1574, 14)
+    
+    K = property(__K.value, __K.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __K.name() : __K
+    })
+_module_typeBindings.CTD_ANON = CTD_ANON
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_ (pyxb.binding.basis.complexTypeDefinition):
+    """A description of the light path"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2416, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExcitationFilterRef uses Python identifier ExcitationFilterRef
+    __ExcitationFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), 'ExcitationFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06ExcitationFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 8), )
+
+    
+    ExcitationFilterRef = property(__ExcitationFilterRef.value, __ExcitationFilterRef.set, None, '\n              The Filters placed in the Excitation light path.\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}EmissionFilterRef uses Python identifier EmissionFilterRef
+    __EmissionFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), 'EmissionFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06EmissionFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8), )
+
+    
+    EmissionFilterRef = property(__EmissionFilterRef.value, __EmissionFilterRef.set, None, '\n              The Filters placed in the Emission light path.\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DichroicRef uses Python identifier DichroicRef
+    __DichroicRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), 'DichroicRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06DichroicRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2), )
+
+    
+    DichroicRef = property(__DichroicRef.value, __DichroicRef.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON__httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    _ElementMap.update({
+        __ExcitationFilterRef.name() : __ExcitationFilterRef,
+        __EmissionFilterRef.name() : __EmissionFilterRef,
+        __DichroicRef.name() : __DichroicRef,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_ = CTD_ANON_
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_2 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The rights holder of this data and the rights held.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2801, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}RightsHolder uses Python identifier RightsHolder
+    __RightsHolder = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'RightsHolder'), 'RightsHolder', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_2_httpwww_openmicroscopy_orgSchemasOME2016_06RightsHolder', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 8), )
+
+    
+    RightsHolder = property(__RightsHolder.value, __RightsHolder.set, None, ' The rights holder for this data. [plain-text multi-line string]\n            e.g. "Copyright (C) 2002 - 2016 Open Microscopy Environment"\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}RightsHeld uses Python identifier RightsHeld
+    __RightsHeld = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'RightsHeld'), 'RightsHeld', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_2_httpwww_openmicroscopy_orgSchemasOME2016_06RightsHeld', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8), )
+
+    
+    RightsHeld = property(__RightsHeld.value, __RightsHeld.set, None, '\n              The rights held by the rights holder. [plain-text multi-line string]\n              e.g. "All rights reserved" or "Creative Commons Attribution 3.0 Unported License"\n            ')
+
+    _ElementMap.update({
+        __RightsHolder.name() : __RightsHolder,
+        __RightsHeld.name() : __RightsHeld
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_2 = CTD_ANON_2
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Reference with content type EMPTY
+class Reference (pyxb.binding.basis.complexTypeDefinition):
+    """
+        Reference is an empty complex type that is contained and extended by all the *Ref elements and also the Settings Complex Type
+        Each *Ref element defines an attribute named ID of simple type *ID and no other information
+        Each simple type *ID is restricted to the base type LSID with an appropriate pattern
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Reference')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2833, 2)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.Reference = Reference
+Namespace.addCategoryObject('typeBinding', 'Reference', Reference)
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_3 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        An unordered collection of annotation attached to objects in the OME data model.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3419, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FileAnnotation uses Python identifier FileAnnotation
+    __FileAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation'), 'FileAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06FileAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3554, 2), )
+
+    
+    FileAnnotation = property(__FileAnnotation.value, __FileAnnotation.set, None, '\n        A file object annotation\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}XMLAnnotation uses Python identifier XMLAnnotation
+    __XMLAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation'), 'XMLAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06XMLAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3571, 2), )
+
+    
+    XMLAnnotation = property(__XMLAnnotation.value, __XMLAnnotation.set, None, '\n        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ListAnnotation uses Python identifier ListAnnotation
+    __ListAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation'), 'ListAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06ListAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3594, 2), )
+
+    
+    ListAnnotation = property(__ListAnnotation.value, __ListAnnotation.set, None, '\n        This annotation is a grouping object. It uses the sequence of\n        annotation refs from the base Annotation to form the list.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}CommentAnnotation uses Python identifier CommentAnnotation
+    __CommentAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation'), 'CommentAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06CommentAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3608, 2), )
+
+    
+    CommentAnnotation = property(__CommentAnnotation.value, __CommentAnnotation.set, None, '\n        A simple comment annotation\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LongAnnotation uses Python identifier LongAnnotation
+    __LongAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation'), 'LongAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06LongAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3625, 2), )
+
+    
+    LongAnnotation = property(__LongAnnotation.value, __LongAnnotation.set, None, '\n        A simple numerical annotation of type xsd:long\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DoubleAnnotation uses Python identifier DoubleAnnotation
+    __DoubleAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation'), 'DoubleAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06DoubleAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3642, 2), )
+
+    
+    DoubleAnnotation = property(__DoubleAnnotation.value, __DoubleAnnotation.set, None, '\n        A simple numerical annotation of type xsd:double\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BooleanAnnotation uses Python identifier BooleanAnnotation
+    __BooleanAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation'), 'BooleanAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06BooleanAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3659, 2), )
+
+    
+    BooleanAnnotation = property(__BooleanAnnotation.value, __BooleanAnnotation.set, None, '\n        A simple boolean annotation of type xsd:boolean\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TimestampAnnotation uses Python identifier TimestampAnnotation
+    __TimestampAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation'), 'TimestampAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06TimestampAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3676, 2), )
+
+    
+    TimestampAnnotation = property(__TimestampAnnotation.value, __TimestampAnnotation.set, None, '\n        A date/time annotation of type xsd:dateTime\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TagAnnotation uses Python identifier TagAnnotation
+    __TagAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation'), 'TagAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06TagAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3693, 2), )
+
+    
+    TagAnnotation = property(__TagAnnotation.value, __TagAnnotation.set, None, '\n        A tag annotation (represents a tag or a tagset)\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TermAnnotation uses Python identifier TermAnnotation
+    __TermAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation'), 'TermAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06TermAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3710, 2), )
+
+    
+    TermAnnotation = property(__TermAnnotation.value, __TermAnnotation.set, None, '\n        A ontology term annotation\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MapAnnotation uses Python identifier MapAnnotation
+    __MapAnnotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation'), 'MapAnnotation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_3_httpwww_openmicroscopy_orgSchemasOME2016_06MapAnnotation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3727, 2), )
+
+    
+    MapAnnotation = property(__MapAnnotation.value, __MapAnnotation.set, None, '\n        An map annotation. The contents of this is a list of key/value pairs.\n      ')
+
+    _ElementMap.update({
+        __FileAnnotation.name() : __FileAnnotation,
+        __XMLAnnotation.name() : __XMLAnnotation,
+        __ListAnnotation.name() : __ListAnnotation,
+        __CommentAnnotation.name() : __CommentAnnotation,
+        __LongAnnotation.name() : __LongAnnotation,
+        __DoubleAnnotation.name() : __DoubleAnnotation,
+        __BooleanAnnotation.name() : __BooleanAnnotation,
+        __TimestampAnnotation.name() : __TimestampAnnotation,
+        __TagAnnotation.name() : __TagAnnotation,
+        __TermAnnotation.name() : __TermAnnotation,
+        __MapAnnotation.name() : __MapAnnotation
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_3 = CTD_ANON_3
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_4 (pyxb.binding.basis.complexTypeDefinition):
+    """Complex type [anonymous] with content type ELEMENT_ONLY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3583, 14)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    _HasWildcardElement = True
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_4 = CTD_ANON_4
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_5 (pyxb.binding.basis.complexTypeDefinition):
+    """Complex type [anonymous] with content type ELEMENT_ONLY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3760, 12)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ShapeGroup uses Python identifier ShapeGroup
+    __ShapeGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup'), 'ShapeGroup', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_5_httpwww_openmicroscopy_orgSchemasOME2016_06ShapeGroup', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3795, 2), )
+
+    
+    ShapeGroup = property(__ShapeGroup.value, __ShapeGroup.set, None, None)
+
+    _ElementMap.update({
+        __ShapeGroup.name() : __ShapeGroup
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_5 = CTD_ANON_5
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}AffineTransform with content type EMPTY
+class AffineTransform (pyxb.binding.basis.complexTypeDefinition):
+    """
+        A matrix used to transform the shape.
+        ⎡ A00, A01, A02 ⎤
+        ⎢ A10, A11, A12 ⎥
+        ⎣ 0,   0,   1   ⎦
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'AffineTransform')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4258, 2)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Attribute A00 uses Python identifier A00
+    __A00 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A00'), 'A00', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A00', pyxb.binding.datatypes.float, required=True)
+    __A00._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4267, 4)
+    __A00._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4267, 4)
+    
+    A00 = property(__A00.value, __A00.set, None, None)
+
+    
+    # Attribute A10 uses Python identifier A10
+    __A10 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A10'), 'A10', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A10', pyxb.binding.datatypes.float, required=True)
+    __A10._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4268, 4)
+    __A10._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4268, 4)
+    
+    A10 = property(__A10.value, __A10.set, None, None)
+
+    
+    # Attribute A01 uses Python identifier A01
+    __A01 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A01'), 'A01', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A01', pyxb.binding.datatypes.float, required=True)
+    __A01._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4269, 4)
+    __A01._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4269, 4)
+    
+    A01 = property(__A01.value, __A01.set, None, None)
+
+    
+    # Attribute A11 uses Python identifier A11
+    __A11 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A11'), 'A11', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A11', pyxb.binding.datatypes.float, required=True)
+    __A11._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4270, 4)
+    __A11._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4270, 4)
+    
+    A11 = property(__A11.value, __A11.set, None, None)
+
+    
+    # Attribute A02 uses Python identifier A02
+    __A02 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A02'), 'A02', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A02', pyxb.binding.datatypes.float, required=True)
+    __A02._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4271, 4)
+    __A02._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4271, 4)
+    
+    A02 = property(__A02.value, __A02.set, None, None)
+
+    
+    # Attribute A12 uses Python identifier A12
+    __A12 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'A12'), 'A12', '__httpwww_openmicroscopy_orgSchemasOME2016_06_AffineTransform_A12', pyxb.binding.datatypes.float, required=True)
+    __A12._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4272, 4)
+    __A12._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4272, 4)
+    
+    A12 = property(__A12.value, __A12.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __A00.name() : __A00,
+        __A10.name() : __A10,
+        __A01.name() : __A01,
+        __A11.name() : __A11,
+        __A02.name() : __A02,
+        __A12.name() : __A12
+    })
+_module_typeBindings.AffineTransform = AffineTransform
+Namespace.addCategoryObject('typeBinding', 'AffineTransform', AffineTransform)
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_6 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The OME element is a container for all information objects accessible by OME.
+        These information objects include descriptions of the imaging experiments
+        and the people who perform them, descriptions of the microscope, the resulting
+        images and how they were acquired, the analyses performed on those images,
+        and the analysis results themselves.
+        An OME file may contain any or all of this information.
+
+        With the creation of the Metadata Only Companion OME-XML and Binary Only OME-TIFF files
+        the top level OME node has changed slightly.
+        It can EITHER:
+        Contain all the previously expected elements
+        OR:
+        Contain a single BinaryOnly element that points at
+        its Metadata Only Companion OME-XML file.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 59, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinaryOnly uses Python identifier BinaryOnly
+    __BinaryOnly = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinaryOnly'), 'BinaryOnly', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06BinaryOnly', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 79, 10), )
+
+    
+    BinaryOnly = property(__BinaryOnly.value, __BinaryOnly.set, None, ' Pointer to an external metadata file. If this\n              element is present, then no other metadata may be present in this\n              file, i.e. this file is a place-holder. ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Image uses Python identifier Image
+    __Image = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Image'), 'Image', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Image', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 209, 2), )
+
+    
+    Image = property(__Image.value, __Image.set, None, "\n        This element describes the actual image and its meta-data.\n        The elements that are references (ending in Ref or Settings) refer to\n        elements defined outside of the Image element. Ref elements are simple\n        links, while Settings elements are links with additional values.\n\n        If any of the required Image attributes or elements are missing, its\n        guaranteed to be an invalid document. The required attributes and\n        elements are ID and Pixels.\n\n        ExperimenterRef is required for all Images with well formed LSIDs.\n        ImageType is a vendor-specific designation of the type of image this is.\n        Examples of ImageType include 'STK', 'SoftWorx', etc.\n        The Name attributes are in all cases the name of the element\n        instance. In this case, the name of the image, not necessarily the filename.\n        Physical size of pixels are microns[\xb5m].\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Instrument uses Python identifier Instrument
+    __Instrument = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Instrument'), 'Instrument', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Instrument', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 979, 2), )
+
+    
+    Instrument = property(__Instrument.value, __Instrument.set, None, "\n        This element describes the instrument used to capture the Image.\n        It is primarily a container for manufacturer's model and catalog\n        numbers for the Microscope, LightSource, Detector, Objective and\n        Filters components.\n        The Objective element contains the additional elements LensNA and Magnification.\n        The Filters element can be composed either of separate excitation,\n        emission filters and a dichroic mirror or a single filter set.\n        Within the Image itself, a reference is made to this one Filter element.\n        There may be multiple light sources, detectors, objectives and filters on a microscope.\n        Each of these has their own ID attribute, which can be referred to from Channel.\n        It is understood that the light path configuration can be different\n        for each channel, but cannot be different for each timepoint or\n        each plane of an XYZ stack.\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Project uses Python identifier Project
+    __Project = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Project'), 'Project', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Project', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1101, 2), )
+
+    
+    Project = property(__Project.value, __Project.set, None, '\n        The Project ID is required.\n        Datasets can be grouped into projects using a many-to-many relationship.\n        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.\n        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroup uses Python identifier ExperimenterGroup
+    __ExperimenterGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup'), 'ExperimenterGroup', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroup', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1142, 2), )
+
+    
+    ExperimenterGroup = property(__ExperimenterGroup.value, __ExperimenterGroup.set, None, '\n        The ExperimenterGroupID is required.\n        Information should ideally be specified for at least one Leader as a contact for the group.\n        The Leaders are themselves Experimenters.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Dataset uses Python identifier Dataset
+    __Dataset = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Dataset'), 'Dataset', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Dataset', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1201, 2), )
+
+    
+    Dataset = property(__Dataset.value, __Dataset.set, None, '\n        An element specifying a collection of images that are always processed together.\n        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.\n        Images contain one or more DatasetRef elements to specify what datasets they belong to.\n        Once a Dataset has been processed in any way, its collection of images cannot be altered.\n        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.\n        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.\n        This relationship is specified by listing DatasetRef elements within the Project element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Experiment uses Python identifier Experiment
+    __Experiment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Experiment'), 'Experiment', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Experiment', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1251, 2), )
+
+    
+    Experiment = property(__Experiment.value, __Experiment.set, None, "\n        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:\n        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation\n        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other\n        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.\n        The optional Description element may contain free text to further describe the experiment.\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Experimenter uses Python identifier Experimenter
+    __Experimenter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Experimenter'), 'Experimenter', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Experimenter', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1320, 2), )
+
+    
+    Experimenter = property(__Experimenter.value, __Experimenter.set, None, '\n        This element describes a person who performed an imaging experiment.\n        This person may also be a user of the OME system, in which case the UserName element contains their login name.\n        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Folder uses Python identifier Folder
+    __Folder = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Folder'), 'Folder', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Folder', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1377, 2), )
+
+    
+    Folder = property(__Folder.value, __Folder.set, None, '\n        An element specifying a possibly heterogeneous collection of data.\n        Folders may contain Folders so that data may be organized within a tree of Folders.\n        Data may be in multiple Folders but a Folder may not be in more than one other Folder.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Rights uses Python identifier Rights
+    __Rights = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Rights'), 'Rights', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Rights', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2794, 2), )
+
+    
+    Rights = property(__Rights.value, __Rights.set, None, '\n        The rights holder of this data and the rights held.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}StructuredAnnotations uses Python identifier StructuredAnnotations
+    __StructuredAnnotations = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations'), 'StructuredAnnotations', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06StructuredAnnotations', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3413, 2), )
+
+    
+    StructuredAnnotations = property(__StructuredAnnotations.value, __StructuredAnnotations.set, None, '\n        An unordered collection of annotation attached to objects in the OME data model.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROI uses Python identifier ROI
+    __ROI = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROI'), 'ROI', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06ROI', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3746, 2), )
+
+    
+    ROI = property(__ROI.value, __ROI.set, None, "\n        A four dimensional 'Region of Interest'.\n        If they are not used, and the Image has more than one plane,\n        the entire set of planes is assumed to be included in the ROI.\n        Multiple ROIs may be specified.\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Plate uses Python identifier Plate
+    __Plate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Plate'), 'Plate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Plate', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4300, 2), )
+
+    
+    Plate = property(__Plate.value, __Plate.set, None, '\n        This element identifies microtiter plates within a screen.\n        A plate can belong to more than one screen.\n        The Screen(s) that a plate belongs to are specified by the ScreenRef element.\n        The Plate ID and Name attributes are required.\n        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.\n        i.e. The top-left well of a plate is index (0,0)\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Screen uses Python identifier Screen
+    __Screen = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Screen'), 'Screen', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_httpwww_openmicroscopy_orgSchemasOME2016_06Screen', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4560, 2), )
+
+    
+    Screen = property(__Screen.value, __Screen.set, None, "\n        The Screen element is a grouping for Plates.\n        The required attribute is the Screen's Name and ID - both must be unique within the document.\n        The Screen element may contain an ExternalRef attribute that refers to an external database.\n        A description of the screen may be specified in the Description element.\n        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.\n        Plates contain one or more ScreenRef elements to specify what screens they belong to.\n      ")
+
+    
+    # Attribute UUID uses Python identifier UUID
+    __UUID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'UUID'), 'UUID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_UUID', _module_typeBindings.UniversallyUniqueIdentifier)
+    __UUID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 107, 6)
+    __UUID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 107, 6)
+    
+    UUID = property(__UUID.value, __UUID.set, None, '\n            This unique identifier is used to keep track of multi part files.\n            It allows the links between files to survive renaming.\n\n            While OPTIONAL in the general case this is REQUIRED in a\n            MetadataOnly Companion to a collection of BinaryOnly files.\n          ')
+
+    
+    # Attribute Creator uses Python identifier Creator
+    __Creator = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Creator'), 'Creator', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_6_Creator', pyxb.binding.datatypes.string)
+    __Creator._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 118, 6)
+    __Creator._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 118, 6)
+    
+    Creator = property(__Creator.value, __Creator.set, None, '\n            This is the name of the creating application of the OME-XML\n            and preferably its full version.\n            e.g "CompanyName, SoftwareName, V2.6.3456"\n            This is optional but we hope it will be set by applications\n            writing out OME-XML from scratch.\n          ')
+
+    _ElementMap.update({
+        __BinaryOnly.name() : __BinaryOnly,
+        __Image.name() : __Image,
+        __Instrument.name() : __Instrument,
+        __Project.name() : __Project,
+        __ExperimenterGroup.name() : __ExperimenterGroup,
+        __Dataset.name() : __Dataset,
+        __Experiment.name() : __Experiment,
+        __Experimenter.name() : __Experimenter,
+        __Folder.name() : __Folder,
+        __Rights.name() : __Rights,
+        __StructuredAnnotations.name() : __StructuredAnnotations,
+        __ROI.name() : __ROI,
+        __Plate.name() : __Plate,
+        __Screen.name() : __Screen
+    })
+    _AttributeMap.update({
+        __UUID.name() : __UUID,
+        __Creator.name() : __Creator
+    })
+_module_typeBindings.CTD_ANON_6 = CTD_ANON_6
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_7 (pyxb.binding.basis.complexTypeDefinition):
+    """ Pointer to an external metadata file. If this
+              element is present, then no other metadata may be present in this
+              file, i.e. this file is a place-holder. """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 85, 12)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Attribute MetadataFile uses Python identifier MetadataFile
+    __MetadataFile = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MetadataFile'), 'MetadataFile', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_7_MetadataFile', pyxb.binding.datatypes.string, required=True)
+    __MetadataFile._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 86, 14)
+    __MetadataFile._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 86, 14)
+    
+    MetadataFile = property(__MetadataFile.value, __MetadataFile.set, None, ' Filename of the OME-XML metadata file for\n                  this binary data. If the file cannot be found, a search can\n                  be performed based on the UUID. ')
+
+    
+    # Attribute UUID uses Python identifier UUID
+    __UUID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'UUID'), 'UUID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_7_UUID', _module_typeBindings.UniversallyUniqueIdentifier, required=True)
+    __UUID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 93, 14)
+    __UUID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 93, 14)
+    
+    UUID = property(__UUID.value, __UUID.set, None, ' The unique identifier of another OME-XML\n                  block whose metadata describes the binary data in this file.\n                  This UUID is considered authoritative regardless of\n                  mismatches in the filename. ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __MetadataFile.name() : __MetadataFile,
+        __UUID.name() : __UUID
+    })
+_module_typeBindings.CTD_ANON_7 = CTD_ANON_7
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_8 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The Plane object holds microscope stage and image timing data
+        for a given channel/z-section/timepoint.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 486, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}HashSHA1 uses Python identifier HashSHA1
+    __HashSHA1 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'HashSHA1'), 'HashSHA1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_httpwww_openmicroscopy_orgSchemasOME2016_06HashSHA1', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 496, 10), )
+
+    
+    HashSHA1 = property(__HashSHA1.value, __HashSHA1.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute TheZ uses Python identifier TheZ
+    __TheZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheZ'), 'TheZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_TheZ', _module_typeBindings.NonNegativeInt, required=True)
+    __TheZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 504, 6)
+    __TheZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 504, 6)
+    
+    TheZ = property(__TheZ.value, __TheZ.set, None, '\n            The Z-section this plane is for. [units:none]\n            This is numbered from 0.\n          ')
+
+    
+    # Attribute TheT uses Python identifier TheT
+    __TheT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheT'), 'TheT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_TheT', _module_typeBindings.NonNegativeInt, required=True)
+    __TheT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 512, 6)
+    __TheT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 512, 6)
+    
+    TheT = property(__TheT.value, __TheT.set, None, '\n            The timepoint this plane is for. [units:none]\n            This is numbered from 0.\n          ')
+
+    
+    # Attribute TheC uses Python identifier TheC
+    __TheC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheC'), 'TheC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_TheC', _module_typeBindings.NonNegativeInt, required=True)
+    __TheC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 520, 6)
+    __TheC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 520, 6)
+    
+    TheC = property(__TheC.value, __TheC.set, None, '\n            The channel this plane is for. [units:none]\n            This is numbered from 0.\n          ')
+
+    
+    # Attribute DeltaT uses Python identifier DeltaT
+    __DeltaT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'DeltaT'), 'DeltaT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_DeltaT', pyxb.binding.datatypes.float)
+    __DeltaT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 528, 6)
+    __DeltaT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 528, 6)
+    
+    DeltaT = property(__DeltaT.value, __DeltaT.set, None, '\n            Time since the beginning of the experiment.\n            Units are set by DeltaTUnit.\n          ')
+
+    
+    # Attribute DeltaTUnit uses Python identifier DeltaTUnit
+    __DeltaTUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'DeltaTUnit'), 'DeltaTUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_DeltaTUnit', _module_typeBindings.UnitsTime, unicode_default='s')
+    __DeltaTUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 536, 6)
+    __DeltaTUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 536, 6)
+    
+    DeltaTUnit = property(__DeltaTUnit.value, __DeltaTUnit.set, None, 'The units of the DeltaT - default:seconds[s].')
+
+    
+    # Attribute ExposureTime uses Python identifier ExposureTime
+    __ExposureTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExposureTime'), 'ExposureTime', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_ExposureTime', pyxb.binding.datatypes.float)
+    __ExposureTime._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 541, 6)
+    __ExposureTime._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 541, 6)
+    
+    ExposureTime = property(__ExposureTime.value, __ExposureTime.set, None, '\n            The length of the exposure.\n            Units are set by ExposureTimeUnit.\n          ')
+
+    
+    # Attribute ExposureTimeUnit uses Python identifier ExposureTimeUnit
+    __ExposureTimeUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExposureTimeUnit'), 'ExposureTimeUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_ExposureTimeUnit', _module_typeBindings.UnitsTime, unicode_default='s')
+    __ExposureTimeUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 549, 6)
+    __ExposureTimeUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 549, 6)
+    
+    ExposureTimeUnit = property(__ExposureTimeUnit.value, __ExposureTimeUnit.set, None, 'The units of the ExposureTime - default:seconds[s].')
+
+    
+    # Attribute PositionX uses Python identifier PositionX
+    __PositionX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionX'), 'PositionX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionX', pyxb.binding.datatypes.float)
+    __PositionX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 554, 6)
+    __PositionX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 554, 6)
+    
+    PositionX = property(__PositionX.value, __PositionX.set, None, '\n            The X position of the stage. Units are set by PositionXUnit.\n          ')
+
+    
+    # Attribute PositionXUnit uses Python identifier PositionXUnit
+    __PositionXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionXUnit'), 'PositionXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionXUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __PositionXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 561, 6)
+    __PositionXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 561, 6)
+    
+    PositionXUnit = property(__PositionXUnit.value, __PositionXUnit.set, None, 'The units of the X stage position - default:[reference frame].')
+
+    
+    # Attribute PositionY uses Python identifier PositionY
+    __PositionY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionY'), 'PositionY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionY', pyxb.binding.datatypes.float)
+    __PositionY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 566, 6)
+    __PositionY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 566, 6)
+    
+    PositionY = property(__PositionY.value, __PositionY.set, None, '\n            The Y position of the stage. Units are set by PositionYUnit.\n          ')
+
+    
+    # Attribute PositionYUnit uses Python identifier PositionYUnit
+    __PositionYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionYUnit'), 'PositionYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionYUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __PositionYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 573, 6)
+    __PositionYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 573, 6)
+    
+    PositionYUnit = property(__PositionYUnit.value, __PositionYUnit.set, None, 'The units of the Y stage position - default:[reference frame].')
+
+    
+    # Attribute PositionZ uses Python identifier PositionZ
+    __PositionZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionZ'), 'PositionZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionZ', pyxb.binding.datatypes.float)
+    __PositionZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 578, 6)
+    __PositionZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 578, 6)
+    
+    PositionZ = property(__PositionZ.value, __PositionZ.set, None, '\n            The Z position of the stage. Units are set by PositionZUnit.\n          ')
+
+    
+    # Attribute PositionZUnit uses Python identifier PositionZUnit
+    __PositionZUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionZUnit'), 'PositionZUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_8_PositionZUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __PositionZUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 585, 6)
+    __PositionZUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 585, 6)
+    
+    PositionZUnit = property(__PositionZUnit.value, __PositionZUnit.set, None, 'The units of the Z stage position - default:[reference frame].')
+
+    _ElementMap.update({
+        __HashSHA1.name() : __HashSHA1,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __TheZ.name() : __TheZ,
+        __TheT.name() : __TheT,
+        __TheC.name() : __TheC,
+        __DeltaT.name() : __DeltaT,
+        __DeltaTUnit.name() : __DeltaTUnit,
+        __ExposureTime.name() : __ExposureTime,
+        __ExposureTimeUnit.name() : __ExposureTimeUnit,
+        __PositionX.name() : __PositionX,
+        __PositionXUnit.name() : __PositionXUnit,
+        __PositionY.name() : __PositionY,
+        __PositionYUnit.name() : __PositionYUnit,
+        __PositionZ.name() : __PositionZ,
+        __PositionZUnit.name() : __PositionZUnit
+    })
+_module_typeBindings.CTD_ANON_8 = CTD_ANON_8
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_9 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This described the location of the pixel data in a tiff file.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 799, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}UUID uses Python identifier UUID
+    __UUID = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'UUID'), 'UUID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_httpwww_openmicroscopy_orgSchemasOME2016_06UUID', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8), )
+
+    
+    UUID = property(__UUID.value, __UUID.set, None, '\n              This must be used when the IFDs are located in another file.\n              Note: It is permissible for this to be self referential.\n            ')
+
+    
+    # Attribute IFD uses Python identifier IFD
+    __IFD = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'IFD'), 'IFD', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_IFD', _module_typeBindings.NonNegativeInt, unicode_default='0')
+    __IFD._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 828, 6)
+    __IFD._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 828, 6)
+    
+    IFD = property(__IFD.value, __IFD.set, None, '\n            Gives the IFD(s) for which this element is applicable. Indexed from 0.\n            Default is 0 (the first IFD). [units:none]\n          ')
+
+    
+    # Attribute FirstZ uses Python identifier FirstZ
+    __FirstZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstZ'), 'FirstZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_FirstZ', _module_typeBindings.NonNegativeInt, unicode_default='0')
+    __FirstZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 836, 6)
+    __FirstZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 836, 6)
+    
+    FirstZ = property(__FirstZ.value, __FirstZ.set, None, '\n            Gives the Z position of the image plane at the specified IFD. Indexed from 0.\n            Default is 0 (the first Z position). [units:none]\n          ')
+
+    
+    # Attribute FirstT uses Python identifier FirstT
+    __FirstT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstT'), 'FirstT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_FirstT', _module_typeBindings.NonNegativeInt, unicode_default='0')
+    __FirstT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 844, 6)
+    __FirstT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 844, 6)
+    
+    FirstT = property(__FirstT.value, __FirstT.set, None, '\n            Gives the T position of the image plane at the specified IFD. Indexed from 0.\n            Default is 0 (the first T position). [units:none]\n          ')
+
+    
+    # Attribute FirstC uses Python identifier FirstC
+    __FirstC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstC'), 'FirstC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_FirstC', _module_typeBindings.NonNegativeInt, unicode_default='0')
+    __FirstC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 852, 6)
+    __FirstC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 852, 6)
+    
+    FirstC = property(__FirstC.value, __FirstC.set, None, '\n            Gives the C position of the image plane at the specified IFD. Indexed from 0.\n            Default is 0 (the first C position). [units:none]\n          ')
+
+    
+    # Attribute PlaneCount uses Python identifier PlaneCount
+    __PlaneCount = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PlaneCount'), 'PlaneCount', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_9_PlaneCount', _module_typeBindings.NonNegativeInt)
+    __PlaneCount._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 860, 6)
+    __PlaneCount._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 860, 6)
+    
+    PlaneCount = property(__PlaneCount.value, __PlaneCount.set, None, "\n            Gives the number of IFDs affected. Dimension order of IFDs is given by the enclosing\n            Pixels element's DimensionOrder attribute. Default is the number of IFDs in the TIFF\n            file, unless an IFD is specified, in which case the default is 1. [units:none]\n          ")
+
+    _ElementMap.update({
+        __UUID.name() : __UUID
+    })
+    _AttributeMap.update({
+        __IFD.name() : __IFD,
+        __FirstZ.name() : __FirstZ,
+        __FirstT.name() : __FirstT,
+        __FirstC.name() : __FirstC,
+        __PlaneCount.name() : __PlaneCount
+    })
+_module_typeBindings.CTD_ANON_9 = CTD_ANON_9
+
+
+# Complex type [anonymous] with content type SIMPLE
+class CTD_ANON_10 (pyxb.binding.basis.complexTypeDefinition):
+    """
+              This must be used when the IFDs are located in another file.
+              Note: It is permissible for this to be self referential.
+            """
+    _TypeDefinition = UniversallyUniqueIdentifier
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 808, 10)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is UniversallyUniqueIdentifier
+    
+    # Attribute FileName uses Python identifier FileName
+    __FileName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FileName'), 'FileName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_10_FileName', pyxb.binding.datatypes.string)
+    __FileName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 811, 16)
+    __FileName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 811, 16)
+    
+    FileName = property(__FileName.value, __FileName.set, None, '\n                      This can be used when the IFDs are located in another file.\n                      The / (forward slash) is used as the path separator.\n                      A relative path is recommended. However an absolute path can be specified.\n                      Default is to use the file the ome-xml data has been pulled from.\n                      Note: It is permissible for this to be self referential. The file image1.tiff\n                      may contain ome-xml data that has FilePath="image1.tiff" or "./image1.tiff"\n                    ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __FileName.name() : __FileName
+    })
+_module_typeBindings.CTD_ANON_10 = CTD_ANON_10
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_11 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 878, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_Name', pyxb.binding.datatypes.string, required=True)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 879, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 879, 6)
+    
+    Name = property(__Name.value, __Name.set, None, None)
+
+    
+    # Attribute X uses Python identifier X
+    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_X', pyxb.binding.datatypes.float)
+    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 880, 6)
+    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 880, 6)
+    
+    X = property(__X.value, __X.set, None, '\n            The X position of the stage label. Units are set by XUnit.\n          ')
+
+    
+    # Attribute XUnit uses Python identifier XUnit
+    __XUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'XUnit'), 'XUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_XUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __XUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 887, 6)
+    __XUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 887, 6)
+    
+    XUnit = property(__XUnit.value, __XUnit.set, None, 'The units of the X stage position - default:[reference frame].')
+
+    
+    # Attribute Y uses Python identifier Y
+    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_Y', pyxb.binding.datatypes.float)
+    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 892, 6)
+    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 892, 6)
+    
+    Y = property(__Y.value, __Y.set, None, '\n            The Y position of the stage label. Units are set by YUnit.\n          ')
+
+    
+    # Attribute YUnit uses Python identifier YUnit
+    __YUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'YUnit'), 'YUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_YUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __YUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 899, 6)
+    __YUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 899, 6)
+    
+    YUnit = property(__YUnit.value, __YUnit.set, None, 'The units of the Y stage position - default:[reference frame].')
+
+    
+    # Attribute Z uses Python identifier Z
+    __Z = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Z'), 'Z', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_Z', pyxb.binding.datatypes.float)
+    __Z._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 904, 6)
+    __Z._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 904, 6)
+    
+    Z = property(__Z.value, __Z.set, None, '\n            The Z position of the stage label. Units are set by ZUnit.\n          ')
+
+    
+    # Attribute ZUnit uses Python identifier ZUnit
+    __ZUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ZUnit'), 'ZUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_11_ZUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __ZUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 911, 6)
+    __ZUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 911, 6)
+    
+    ZUnit = property(__ZUnit.value, __ZUnit.set, None, 'The units of the Z  stage position - default:[reference frame].')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Name.name() : __Name,
+        __X.name() : __X,
+        __XUnit.name() : __XUnit,
+        __Y.name() : __Y,
+        __YUnit.name() : __YUnit,
+        __Z.name() : __Z,
+        __ZUnit.name() : __ZUnit
+    })
+_module_typeBindings.CTD_ANON_11 = CTD_ANON_11
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_12 (ManufacturerSpec):
+    """The microscope's manufacturer specification."""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1021, 4)
+    _ElementMap = ManufacturerSpec._ElementMap.copy()
+    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
+    # Base type is ManufacturerSpec
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_12_Type', _module_typeBindings.STD_ANON_7)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1024, 10)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1024, 10)
+    
+    Type = property(__Type.value, __Type.set, None, None)
+
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Type.name() : __Type
+    })
+_module_typeBindings.CTD_ANON_12 = CTD_ANON_12
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_13 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This describes the environment that the biological sample was in
+        during the experiment.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1049, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Map uses Python identifier Map
+    __Map = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Map'), 'Map', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_httpwww_openmicroscopy_orgSchemasOME2016_06Map', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8), )
+
+    
+    Map = property(__Map.value, __Map.set, None, None)
+
+    
+    # Attribute Temperature uses Python identifier Temperature
+    __Temperature = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Temperature'), 'Temperature', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_Temperature', pyxb.binding.datatypes.float)
+    __Temperature._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1053, 6)
+    __Temperature._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1053, 6)
+    
+    Temperature = property(__Temperature.value, __Temperature.set, None, '\n            The Temperature is the define units.\n          ')
+
+    
+    # Attribute TemperatureUnit uses Python identifier TemperatureUnit
+    __TemperatureUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TemperatureUnit'), 'TemperatureUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_TemperatureUnit', _module_typeBindings.UnitsTemperature, unicode_default='\xb0C')
+    __TemperatureUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1060, 6)
+    __TemperatureUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1060, 6)
+    
+    TemperatureUnit = property(__TemperatureUnit.value, __TemperatureUnit.set, None, '\n            The units the Temperature is in - default:Celsius[\xb0C].\n          ')
+
+    
+    # Attribute AirPressure uses Python identifier AirPressure
+    __AirPressure = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AirPressure'), 'AirPressure', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_AirPressure', pyxb.binding.datatypes.float)
+    __AirPressure._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1067, 6)
+    __AirPressure._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1067, 6)
+    
+    AirPressure = property(__AirPressure.value, __AirPressure.set, None, '\n            AirPressure is the define units.\n          ')
+
+    
+    # Attribute AirPressureUnit uses Python identifier AirPressureUnit
+    __AirPressureUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AirPressureUnit'), 'AirPressureUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_AirPressureUnit', _module_typeBindings.UnitsPressure, unicode_default='mbar')
+    __AirPressureUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1074, 6)
+    __AirPressureUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1074, 6)
+    
+    AirPressureUnit = property(__AirPressureUnit.value, __AirPressureUnit.set, None, '\n            The units the AirPressure is in - default:millibars[mbar].\n          ')
+
+    
+    # Attribute Humidity uses Python identifier Humidity
+    __Humidity = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Humidity'), 'Humidity', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_Humidity', _module_typeBindings.PercentFraction)
+    __Humidity._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1081, 6)
+    __Humidity._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1081, 6)
+    
+    Humidity = property(__Humidity.value, __Humidity.set, None, '\n            Humidity around the sample [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n          ')
+
+    
+    # Attribute CO2Percent uses Python identifier CO2Percent
+    __CO2Percent = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO2Percent'), 'CO2Percent', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_13_CO2Percent', _module_typeBindings.PercentFraction)
+    __CO2Percent._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1089, 6)
+    __CO2Percent._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1089, 6)
+    
+    CO2Percent = property(__CO2Percent.value, __CO2Percent.set, None, '\n            Carbon Dioxide concentration around the sample [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n          ')
+
+    _ElementMap.update({
+        __Map.name() : __Map
+    })
+    _AttributeMap.update({
+        __Temperature.name() : __Temperature,
+        __TemperatureUnit.name() : __TemperatureUnit,
+        __AirPressure.name() : __AirPressure,
+        __AirPressureUnit.name() : __AirPressureUnit,
+        __Humidity.name() : __Humidity,
+        __CO2Percent.name() : __CO2Percent
+    })
+_module_typeBindings.CTD_ANON_13 = CTD_ANON_13
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_14 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2332, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Attribute CutIn uses Python identifier CutIn
+    __CutIn = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutIn'), 'CutIn', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutIn', _module_typeBindings.PositiveFloat)
+    __CutIn._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2333, 6)
+    __CutIn._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2333, 6)
+    
+    CutIn = property(__CutIn.value, __CutIn.set, None, '\n            CutIn is the wavelength below which there is less than 50% transmittance for a filter. Units are set by CutInUnit.\n          ')
+
+    
+    # Attribute CutInUnit uses Python identifier CutInUnit
+    __CutInUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutInUnit'), 'CutInUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutInUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __CutInUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2340, 6)
+    __CutInUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2340, 6)
+    
+    CutInUnit = property(__CutInUnit.value, __CutInUnit.set, None, 'The units of the CutIn - default:nanometres[nm].')
+
+    
+    # Attribute CutOut uses Python identifier CutOut
+    __CutOut = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOut'), 'CutOut', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOut', _module_typeBindings.PositiveFloat)
+    __CutOut._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2345, 6)
+    __CutOut._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2345, 6)
+    
+    CutOut = property(__CutOut.value, __CutOut.set, None, '\n            CutOut is the wavelength above which there is less than 50% transmittance for a filter. Units are set by CutOutUnit.\n          ')
+
+    
+    # Attribute CutOutUnit uses Python identifier CutOutUnit
+    __CutOutUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOutUnit'), 'CutOutUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOutUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __CutOutUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2352, 6)
+    __CutOutUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2352, 6)
+    
+    CutOutUnit = property(__CutOutUnit.value, __CutOutUnit.set, None, 'The units of the CutOut - default:nanometres[nm].')
+
+    
+    # Attribute CutInTolerance uses Python identifier CutInTolerance
+    __CutInTolerance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutInTolerance'), 'CutInTolerance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutInTolerance', _module_typeBindings.NonNegativeFloat)
+    __CutInTolerance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2357, 6)
+    __CutInTolerance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2357, 6)
+    
+    CutInTolerance = property(__CutInTolerance.value, __CutInTolerance.set, None, '\n            CutInTolerance. Units are set by CutInToleranceUnit.\n          ')
+
+    
+    # Attribute CutInToleranceUnit uses Python identifier CutInToleranceUnit
+    __CutInToleranceUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutInToleranceUnit'), 'CutInToleranceUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutInToleranceUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __CutInToleranceUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2364, 6)
+    __CutInToleranceUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2364, 6)
+    
+    CutInToleranceUnit = property(__CutInToleranceUnit.value, __CutInToleranceUnit.set, None, 'The units of the CutInTolerance - default:nanometres[nm].')
+
+    
+    # Attribute CutOutTolerance uses Python identifier CutOutTolerance
+    __CutOutTolerance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOutTolerance'), 'CutOutTolerance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOutTolerance', _module_typeBindings.NonNegativeFloat)
+    __CutOutTolerance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2369, 6)
+    __CutOutTolerance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2369, 6)
+    
+    CutOutTolerance = property(__CutOutTolerance.value, __CutOutTolerance.set, None, '\n            CutOutTolerance. Units are set by CutOutToleranceUnit.\n          ')
+
+    
+    # Attribute CutOutToleranceUnit uses Python identifier CutOutToleranceUnit
+    __CutOutToleranceUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CutOutToleranceUnit'), 'CutOutToleranceUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_CutOutToleranceUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __CutOutToleranceUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2376, 6)
+    __CutOutToleranceUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2376, 6)
+    
+    CutOutToleranceUnit = property(__CutOutToleranceUnit.value, __CutOutToleranceUnit.set, None, 'The units of the CutOutTolerance - default:nanometres[nm].')
+
+    
+    # Attribute Transmittance uses Python identifier Transmittance
+    __Transmittance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Transmittance'), 'Transmittance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_14_Transmittance', _module_typeBindings.PercentFraction)
+    __Transmittance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2381, 6)
+    __Transmittance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2381, 6)
+    
+    Transmittance = property(__Transmittance.value, __Transmittance.set, None, '\n            The amount of light the filter transmits at a maximum [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n          ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __CutIn.name() : __CutIn,
+        __CutInUnit.name() : __CutInUnit,
+        __CutOut.name() : __CutOut,
+        __CutOutUnit.name() : __CutOutUnit,
+        __CutInTolerance.name() : __CutInTolerance,
+        __CutInToleranceUnit.name() : __CutInToleranceUnit,
+        __CutOutTolerance.name() : __CutOutTolerance,
+        __CutOutToleranceUnit.name() : __CutOutToleranceUnit,
+        __Transmittance.name() : __Transmittance
+    })
+_module_typeBindings.CTD_ANON_14 = CTD_ANON_14
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Settings with content type EMPTY
+class Settings (Reference):
+    """
+        Settings is an empty complex type that is contained and extended by all the *Settings elements
+        Each *Settings element defines an attribute named ID of simple type *ID and the other information that is needed.
+        Each simple type *ID is restricted to the base type LSID with an appropriate pattern
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Settings')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2992, 2)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.Settings = Settings
+Namespace.addCategoryObject('typeBinding', 'Settings', Settings)
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_15 (pyxb.binding.basis.complexTypeDefinition):
+    """Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.
+      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3295, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Attribute href uses Python identifier href
+    __href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'href'), 'href', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_15_href', pyxb.binding.datatypes.anyURI, required=True)
+    __href._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3296, 6)
+    __href._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3296, 6)
+    
+    href = property(__href.value, __href.set, None, 'file location')
+
+    
+    # Attribute SHA1 uses Python identifier SHA1
+    __SHA1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SHA1'), 'SHA1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_15_SHA1', _module_typeBindings.Hex40, required=True)
+    __SHA1._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3301, 6)
+    __SHA1._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3301, 6)
+    
+    SHA1 = property(__SHA1.value, __SHA1.set, None, 'The digest of the file specified in href.')
+
+    
+    # Attribute Compression uses Python identifier Compression
+    __Compression = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Compression'), 'Compression', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_15_Compression', _module_typeBindings.STD_ANON_26, unicode_default='none')
+    __Compression._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3306, 6)
+    __Compression._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3306, 6)
+    
+    Compression = property(__Compression.value, __Compression.set, None, 'Specifies the compression scheme used to encode the data.')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __href.name() : __href,
+        __SHA1.name() : __SHA1,
+        __Compression.name() : __Compression
+    })
+_module_typeBindings.CTD_ANON_15 = CTD_ANON_15
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_16 (pyxb.binding.basis.complexTypeDefinition):
+    """Describes a binary file."""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3367, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}External uses Python identifier External
+    __External = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'External'), 'External', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_httpwww_openmicroscopy_orgSchemasOME2016_06External', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3288, 2), )
+
+    
+    External = property(__External.value, __External.set, None, 'Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.\n      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinData uses Python identifier BinData
+    __BinData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinData'), 'BinData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_httpwww_openmicroscopy_orgSchemasOME2016_06BinData', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2), )
+
+    
+    BinData = property(__BinData.value, __BinData.set, None, 'The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.')
+
+    
+    # Attribute FileName uses Python identifier FileName
+    __FileName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FileName'), 'FileName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_FileName', pyxb.binding.datatypes.string, required=True)
+    __FileName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3372, 6)
+    __FileName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3372, 6)
+    
+    FileName = property(__FileName.value, __FileName.set, None, None)
+
+    
+    # Attribute Size uses Python identifier Size
+    __Size = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Size'), 'Size', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_Size', _module_typeBindings.NonNegativeLong, required=True)
+    __Size._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3373, 6)
+    __Size._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3373, 6)
+    
+    Size = property(__Size.value, __Size.set, None, '\n            Size of the uncompressed file. [unit:bytes]\n          ')
+
+    
+    # Attribute MIMEType uses Python identifier MIMEType
+    __MIMEType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MIMEType'), 'MIMEType', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_16_MIMEType', pyxb.binding.datatypes.string)
+    __MIMEType._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3380, 6)
+    __MIMEType._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3380, 6)
+    
+    MIMEType = property(__MIMEType.value, __MIMEType.set, None, None)
+
+    _ElementMap.update({
+        __External.name() : __External,
+        __BinData.name() : __BinData
+    })
+    _AttributeMap.update({
+        __FileName.name() : __FileName,
+        __Size.name() : __Size,
+        __MIMEType.name() : __MIMEType
+    })
+_module_typeBindings.CTD_ANON_16 = CTD_ANON_16
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_17 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This element describes the actual image and its meta-data.
+        The elements that are references (ending in Ref or Settings) refer to
+        elements defined outside of the Image element. Ref elements are simple
+        links, while Settings elements are links with additional values.
+
+        If any of the required Image attributes or elements are missing, its
+        guaranteed to be an invalid document. The required attributes and
+        elements are ID and Pixels.
+
+        ExperimenterRef is required for all Images with well formed LSIDs.
+        ImageType is a vendor-specific designation of the type of image this is.
+        Examples of ImageType include 'STK', 'SoftWorx', etc.
+        The Name attributes are in all cases the name of the element
+        instance. In this case, the name of the image, not necessarily the filename.
+        Physical size of pixels are microns[µm].
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 230, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AcquisitionDate uses Python identifier AcquisitionDate
+    __AcquisitionDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AcquisitionDate'), 'AcquisitionDate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06AcquisitionDate', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8), )
+
+    
+    AcquisitionDate = property(__AcquisitionDate.value, __AcquisitionDate.set, None, "\n              The acquisition date of the Image.\n              The element contains an xsd:dateTime string based on the ISO 8601 format (i.e. 1988-04-07T18:39:09.359)\n\n              YYYY-MM-DDTHH:mm:SS.sssZ\n              Y - Year\n              M - Month\n              D - Day\n              H - Hour\n              m - minutes\n              S - Seconds\n              s - sub-seconds (optional)\n              Z - Zone (optional) +HH:mm or -HH:mm or Z for UTC\n\n              Note: xsd:dataTime supports a very wide date range with unlimited precision. The full date range\n              and precision are not typically supported by platform- and language-specific libraries.\n              Where the supported time precision is less than the precision used by the xsd:dateTime\n              timestamp there will be loss of precision; this will typically occur via direct truncation\n              or (less commonly) rounding.\n\n              The year value can be large and/or negative. Any value covering the current or last century\n              should be correctly processed, but some systems cannot process earlier dates.\n\n              The sub-second value is defined as an unlimited number of digits after the decimal point.\n              In Java a minimum of millisecond precision is guaranteed.\n              In C++ microsecond precision is guaranteed, with nanosecond precision being available on\n              some platforms.\n\n              Time zones are supported, eg '2013-10-24T11:52:33+01:00' for Paris, but in most cases it will\n              be converted to UTC when the timestamp is written.\n            ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the image. [plain-text multi-line string]\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Pixels uses Python identifier Pixels
+    __Pixels = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Pixels'), 'Pixels', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06Pixels', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 307, 2), )
+
+    
+    Pixels = property(__Pixels.value, __Pixels.set, None, "\n        Pixels is going to be removed in the future, but it is still required.\n\n        This is just notice that the contents of Pixels will be\n        moved up to Image in a future release. This is because there\n        has only been 1 Pixels object in each Image for some time.\n        The concept of multiple Pixels sets for one Image failed to\n        take off. It is therefore redundant.\n\n        The Image will be unreadable if any of the required Pixel attributes are missing.\n\n        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded\n        in Base64.\n        Or the Pixels may be stored in TIFF format.\n\n        The Pixels element should contain a list of BinData or TiffData, each containing a\n        single plane of pixels. These Pixels elements, when read in document order,\n        must produce a 5-D pixel array of the size specified in this element, and in the\n        dimension order specified by 'DimensionOrder'.\n\n        All of the values in the Pixels object when present should match the same value\n        stored in any associated TIFF format (e.g. SizeX should be the same). Where there\n        is a mismatch our readers will take the value from the TIFF structure as overriding\n        the value in the OME-XML. This is simply a pragmatic decision as it increases the\n        likelihood of reading data from a slightly incorrect file.\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}StageLabel uses Python identifier StageLabel
+    __StageLabel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'StageLabel'), 'StageLabel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06StageLabel', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 871, 2), )
+
+    
+    StageLabel = property(__StageLabel.value, __StageLabel.set, None, "\n        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImagingEnvironment uses Python identifier ImagingEnvironment
+    __ImagingEnvironment = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment'), 'ImagingEnvironment', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ImagingEnvironment', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1041, 2), )
+
+    
+    ImagingEnvironment = property(__ImagingEnvironment.value, __ImagingEnvironment.set, None, '\n        This describes the environment that the biological sample was in\n        during the experiment.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MicrobeamManipulationRef uses Python identifier MicrobeamManipulationRef
+    __MicrobeamManipulationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef'), 'MicrobeamManipulationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06MicrobeamManipulationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2867, 2), )
+
+    
+    MicrobeamManipulationRef = property(__MicrobeamManipulationRef.value, __MicrobeamManipulationRef.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimentRef uses Python identifier ExperimentRef
+    __ExperimentRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef'), 'ExperimentRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimentRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2876, 2), )
+
+    
+    ExperimentRef = property(__ExperimentRef.value, __ExperimentRef.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
+    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )
+
+    
+    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupRef uses Python identifier ExperimenterGroupRef
+    __ExperimenterGroupRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), 'ExperimenterGroupRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroupRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2), )
+
+    
+    ExperimenterGroupRef = property(__ExperimenterGroupRef.value, __ExperimenterGroupRef.set, None, 'This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}InstrumentRef uses Python identifier InstrumentRef
+    __InstrumentRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef'), 'InstrumentRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06InstrumentRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2935, 2), )
+
+    
+    InstrumentRef = property(__InstrumentRef.value, __InstrumentRef.set, None, '\n        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ObjectiveSettings uses Python identifier ObjectiveSettings
+    __ObjectiveSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings'), 'ObjectiveSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ObjectiveSettings', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3129, 2), )
+
+    
+    ObjectiveSettings = property(__ObjectiveSettings.value, __ObjectiveSettings.set, None, '\n        This holds the setting applied to an objective as well as a\n        reference to the objective.\n        The ID is the objective used in this case.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIRef uses Python identifier ROIRef
+    __ROIRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), 'ROIRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_httpwww_openmicroscopy_orgSchemasOME2016_06ROIRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2), )
+
+    
+    ROIRef = property(__ROIRef.value, __ROIRef.set, None, None)
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_ID', _module_typeBindings.ImageID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 303, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 303, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_17_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 304, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 304, 6)
+    
+    Name = property(__Name.value, __Name.set, None, None)
+
+    _ElementMap.update({
+        __AcquisitionDate.name() : __AcquisitionDate,
+        __Description.name() : __Description,
+        __Pixels.name() : __Pixels,
+        __StageLabel.name() : __StageLabel,
+        __ImagingEnvironment.name() : __ImagingEnvironment,
+        __MicrobeamManipulationRef.name() : __MicrobeamManipulationRef,
+        __ExperimentRef.name() : __ExperimentRef,
+        __ExperimenterRef.name() : __ExperimenterRef,
+        __ExperimenterGroupRef.name() : __ExperimenterGroupRef,
+        __InstrumentRef.name() : __InstrumentRef,
+        __ObjectiveSettings.name() : __ObjectiveSettings,
+        __AnnotationRef.name() : __AnnotationRef,
+        __ROIRef.name() : __ROIRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name
+    })
+_module_typeBindings.CTD_ANON_17 = CTD_ANON_17
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_18 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        Pixels is going to be removed in the future, but it is still required.
+
+        This is just notice that the contents of Pixels will be
+        moved up to Image in a future release. This is because there
+        has only been 1 Pixels object in each Image for some time.
+        The concept of multiple Pixels sets for one Image failed to
+        take off. It is therefore redundant.
+
+        The Image will be unreadable if any of the required Pixel attributes are missing.
+
+        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded
+        in Base64.
+        Or the Pixels may be stored in TIFF format.
+
+        The Pixels element should contain a list of BinData or TiffData, each containing a
+        single plane of pixels. These Pixels elements, when read in document order,
+        must produce a 5-D pixel array of the size specified in this element, and in the
+        dimension order specified by 'DimensionOrder'.
+
+        All of the values in the Pixels object when present should match the same value
+        stored in any associated TIFF format (e.g. SizeX should be the same). Where there
+        is a mismatch our readers will take the value from the TIFF structure as overriding
+        the value in the OME-XML. This is simply a pragmatic decision as it increases the
+        likelihood of reading data from a slightly incorrect file.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 337, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Plane uses Python identifier Plane
+    __Plane = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Plane'), 'Plane', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06Plane', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 478, 2), )
+
+    
+    Plane = property(__Plane.value, __Plane.set, None, '\n        The Plane object holds microscope stage and image timing data\n        for a given channel/z-section/timepoint.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Channel uses Python identifier Channel
+    __Channel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Channel'), 'Channel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06Channel', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 592, 2), )
+
+    
+    Channel = property(__Channel.value, __Channel.set, None, "\n        There must be one per channel in the Image, even for a single-plane image.\n        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more\n        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum\n        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are\n        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.\n        The total number of ChannelComponents for a set of pixels must equal SizeC.\n        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.\n        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:\n        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MetadataOnly uses Python identifier MetadataOnly
+    __MetadataOnly = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly'), 'MetadataOnly', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06MetadataOnly', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 784, 2), )
+
+    
+    MetadataOnly = property(__MetadataOnly.value, __MetadataOnly.set, None, '\n        This place holder means there is on pixel data in this file.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TiffData uses Python identifier TiffData
+    __TiffData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TiffData'), 'TiffData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06TiffData', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 792, 2), )
+
+    
+    TiffData = property(__TiffData.value, __TiffData.set, None, '\n        This described the location of the pixel data in a tiff file.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinData uses Python identifier BinData
+    __BinData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinData'), 'BinData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_httpwww_openmicroscopy_orgSchemasOME2016_06BinData', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2), )
+
+    
+    BinData = property(__BinData.value, __BinData.set, None, 'The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_ID', _module_typeBindings.PixelsID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 351, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 351, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute DimensionOrder uses Python identifier DimensionOrder
+    __DimensionOrder = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'DimensionOrder'), 'DimensionOrder', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_DimensionOrder', _module_typeBindings.STD_ANON_, required=True)
+    __DimensionOrder._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 352, 6)
+    __DimensionOrder._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 352, 6)
+    
+    DimensionOrder = property(__DimensionOrder.value, __DimensionOrder.set, None, '\n            The order in which the individual planes of data are interleaved.\n          ')
+
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_Type', _module_typeBindings.PixelType, required=True)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 369, 6)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 369, 6)
+    
+    Type = property(__Type.value, __Type.set, None, '\n            The variable type used to represent each pixel in the image.\n          ')
+
+    
+    # Attribute SignificantBits uses Python identifier SignificantBits
+    __SignificantBits = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SignificantBits'), 'SignificantBits', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SignificantBits', _module_typeBindings.PositiveInt)
+    __SignificantBits._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 376, 6)
+    __SignificantBits._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 376, 6)
+    
+    SignificantBits = property(__SignificantBits.value, __SignificantBits.set, None, '\n            The number of bits within the type storing each pixel that are significant.\n            e.g. you can store 12 bit data within a 16 bit type.\n            This does not reduce the storage requirements but can be a useful indicator\n            when processing or viewing the image data.\n          ')
+
+    
+    # Attribute Interleaved uses Python identifier Interleaved
+    __Interleaved = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Interleaved'), 'Interleaved', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_Interleaved', pyxb.binding.datatypes.boolean)
+    __Interleaved._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 386, 6)
+    __Interleaved._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 386, 6)
+    
+    Interleaved = property(__Interleaved.value, __Interleaved.set, None, '\n            How the channels are arranged within the data block:\n            true if channels are stored RGBRGBRGB...;\n            false if channels are stored RRR...GGG...BBB...\n          ')
+
+    
+    # Attribute BigEndian uses Python identifier BigEndian
+    __BigEndian = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'BigEndian'), 'BigEndian', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_BigEndian', pyxb.binding.datatypes.boolean)
+    __BigEndian._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 395, 6)
+    __BigEndian._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 395, 6)
+    
+    BigEndian = property(__BigEndian.value, __BigEndian.set, None, '\n            This is true if the pixels data was written in BigEndian order.\n\n            If this value is present it should match the value used in BinData\n            or TiffData. If it does not a reader should honour the value used\n            in the BinData or TiffData. This values is useful for MetadataOnly\n            files and is to allow for future storage solutions.\n          ')
+
+    
+    # Attribute SizeX uses Python identifier SizeX
+    __SizeX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeX'), 'SizeX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeX', _module_typeBindings.PositiveInt, required=True)
+    __SizeX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 407, 6)
+    __SizeX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 407, 6)
+    
+    SizeX = property(__SizeX.value, __SizeX.set, None, 'Dimensional size of pixel data array [units:none]')
+
+    
+    # Attribute SizeY uses Python identifier SizeY
+    __SizeY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeY'), 'SizeY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeY', _module_typeBindings.PositiveInt, required=True)
+    __SizeY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 412, 6)
+    __SizeY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 412, 6)
+    
+    SizeY = property(__SizeY.value, __SizeY.set, None, 'Dimensional size of pixel data array [units:none]')
+
+    
+    # Attribute SizeZ uses Python identifier SizeZ
+    __SizeZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeZ'), 'SizeZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeZ', _module_typeBindings.PositiveInt, required=True)
+    __SizeZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 417, 6)
+    __SizeZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 417, 6)
+    
+    SizeZ = property(__SizeZ.value, __SizeZ.set, None, 'Dimensional size of pixel data array [units:none]')
+
+    
+    # Attribute SizeC uses Python identifier SizeC
+    __SizeC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeC'), 'SizeC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeC', _module_typeBindings.PositiveInt, required=True)
+    __SizeC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 422, 6)
+    __SizeC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 422, 6)
+    
+    SizeC = property(__SizeC.value, __SizeC.set, None, 'Dimensional size of pixel data array [units:none]')
+
+    
+    # Attribute SizeT uses Python identifier SizeT
+    __SizeT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SizeT'), 'SizeT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_SizeT', _module_typeBindings.PositiveInt, required=True)
+    __SizeT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 427, 6)
+    __SizeT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 427, 6)
+    
+    SizeT = property(__SizeT.value, __SizeT.set, None, 'Dimensional size of pixel data array [units:none]')
+
+    
+    # Attribute PhysicalSizeX uses Python identifier PhysicalSizeX
+    __PhysicalSizeX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeX'), 'PhysicalSizeX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeX', _module_typeBindings.PositiveFloat)
+    __PhysicalSizeX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 432, 6)
+    __PhysicalSizeX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 432, 6)
+    
+    PhysicalSizeX = property(__PhysicalSizeX.value, __PhysicalSizeX.set, None, 'Physical size of a pixel. Units are set by PhysicalSizeXUnit.')
+
+    
+    # Attribute PhysicalSizeXUnit uses Python identifier PhysicalSizeXUnit
+    __PhysicalSizeXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeXUnit'), 'PhysicalSizeXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeXUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
+    __PhysicalSizeXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 437, 6)
+    __PhysicalSizeXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 437, 6)
+    
+    PhysicalSizeXUnit = property(__PhysicalSizeXUnit.value, __PhysicalSizeXUnit.set, None, 'The units of the physical size of a pixel - default:microns[\xb5m].')
+
+    
+    # Attribute PhysicalSizeY uses Python identifier PhysicalSizeY
+    __PhysicalSizeY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeY'), 'PhysicalSizeY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeY', _module_typeBindings.PositiveFloat)
+    __PhysicalSizeY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 442, 6)
+    __PhysicalSizeY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 442, 6)
+    
+    PhysicalSizeY = property(__PhysicalSizeY.value, __PhysicalSizeY.set, None, 'Physical size of a pixel. Units are set by PhysicalSizeYUnit.')
+
+    
+    # Attribute PhysicalSizeYUnit uses Python identifier PhysicalSizeYUnit
+    __PhysicalSizeYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeYUnit'), 'PhysicalSizeYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeYUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
+    __PhysicalSizeYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 447, 6)
+    __PhysicalSizeYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 447, 6)
+    
+    PhysicalSizeYUnit = property(__PhysicalSizeYUnit.value, __PhysicalSizeYUnit.set, None, 'The units of the physical size of a pixel - default:microns[\xb5m].')
+
+    
+    # Attribute PhysicalSizeZ uses Python identifier PhysicalSizeZ
+    __PhysicalSizeZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeZ'), 'PhysicalSizeZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeZ', _module_typeBindings.PositiveFloat)
+    __PhysicalSizeZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 452, 6)
+    __PhysicalSizeZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 452, 6)
+    
+    PhysicalSizeZ = property(__PhysicalSizeZ.value, __PhysicalSizeZ.set, None, 'Physical size of a pixel. Units are set by PhysicalSizeZUnit.')
+
+    
+    # Attribute PhysicalSizeZUnit uses Python identifier PhysicalSizeZUnit
+    __PhysicalSizeZUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PhysicalSizeZUnit'), 'PhysicalSizeZUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_PhysicalSizeZUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
+    __PhysicalSizeZUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 457, 6)
+    __PhysicalSizeZUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 457, 6)
+    
+    PhysicalSizeZUnit = property(__PhysicalSizeZUnit.value, __PhysicalSizeZUnit.set, None, 'The units of the physical size of a pixel - default:microns[\xb5m].')
+
+    
+    # Attribute TimeIncrement uses Python identifier TimeIncrement
+    __TimeIncrement = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TimeIncrement'), 'TimeIncrement', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_TimeIncrement', pyxb.binding.datatypes.float)
+    __TimeIncrement._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 462, 6)
+    __TimeIncrement._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 462, 6)
+    
+    TimeIncrement = property(__TimeIncrement.value, __TimeIncrement.set, None, '\n            TimeIncrement is used for time series that have a global\n            timing specification instead of per-timepoint timing info.\n            For example in a video stream. Units are set by TimeIncrementUnit.\n          ')
+
+    
+    # Attribute TimeIncrementUnit uses Python identifier TimeIncrementUnit
+    __TimeIncrementUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TimeIncrementUnit'), 'TimeIncrementUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_18_TimeIncrementUnit', _module_typeBindings.UnitsTime, unicode_default='s')
+    __TimeIncrementUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 471, 6)
+    __TimeIncrementUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 471, 6)
+    
+    TimeIncrementUnit = property(__TimeIncrementUnit.value, __TimeIncrementUnit.set, None, 'The units of the TimeIncrement - default:seconds[s].')
+
+    _ElementMap.update({
+        __Plane.name() : __Plane,
+        __Channel.name() : __Channel,
+        __MetadataOnly.name() : __MetadataOnly,
+        __TiffData.name() : __TiffData,
+        __BinData.name() : __BinData
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __DimensionOrder.name() : __DimensionOrder,
+        __Type.name() : __Type,
+        __SignificantBits.name() : __SignificantBits,
+        __Interleaved.name() : __Interleaved,
+        __BigEndian.name() : __BigEndian,
+        __SizeX.name() : __SizeX,
+        __SizeY.name() : __SizeY,
+        __SizeZ.name() : __SizeZ,
+        __SizeC.name() : __SizeC,
+        __SizeT.name() : __SizeT,
+        __PhysicalSizeX.name() : __PhysicalSizeX,
+        __PhysicalSizeXUnit.name() : __PhysicalSizeXUnit,
+        __PhysicalSizeY.name() : __PhysicalSizeY,
+        __PhysicalSizeYUnit.name() : __PhysicalSizeYUnit,
+        __PhysicalSizeZ.name() : __PhysicalSizeZ,
+        __PhysicalSizeZUnit.name() : __PhysicalSizeZUnit,
+        __TimeIncrement.name() : __TimeIncrement,
+        __TimeIncrementUnit.name() : __TimeIncrementUnit
+    })
+_module_typeBindings.CTD_ANON_18 = CTD_ANON_18
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_19 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        There must be one per channel in the Image, even for a single-plane image.
+        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more
+        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum
+        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are
+        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.
+        The total number of ChannelComponents for a set of pixels must equal SizeC.
+        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.
+        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:
+        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 607, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightPath uses Python identifier LightPath
+    __LightPath = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightPath'), 'LightPath', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06LightPath', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2411, 2), )
+
+    
+    LightPath = property(__LightPath.value, __LightPath.set, None, 'A description of the light path')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterSetRef uses Python identifier FilterSetRef
+    __FilterSetRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef'), 'FilterSetRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06FilterSetRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2981, 2), )
+
+    
+    FilterSetRef = property(__FilterSetRef.value, __FilterSetRef.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceSettings uses Python identifier LightSourceSettings
+    __LightSourceSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), 'LightSourceSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06LightSourceSettings', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2), )
+
+    
+    LightSourceSettings = property(__LightSourceSettings.value, __LightSourceSettings.set, None, '')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DetectorSettings uses Python identifier DetectorSettings
+    __DetectorSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings'), 'DetectorSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06DetectorSettings', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3040, 2), )
+
+    
+    DetectorSettings = property(__DetectorSettings.value, __DetectorSettings.set, None, '\n        This holds the setting applied to a detector as well as a\n        reference to the detector.\n        The ID is the detector used in this case.\n        The values stored in DetectorSettings represent the variable values,\n        fixed values not modified during the acquisition go in Detector.\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ID', _module_typeBindings.ChannelID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 619, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 619, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 620, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 620, 6)
+    
+    Name = property(__Name.value, __Name.set, None, '\n            A name for the channel that is suitable for presentation to the user.\n          ')
+
+    
+    # Attribute SamplesPerPixel uses Python identifier SamplesPerPixel
+    __SamplesPerPixel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'SamplesPerPixel'), 'SamplesPerPixel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_SamplesPerPixel', _module_typeBindings.PositiveInt)
+    __SamplesPerPixel._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 627, 6)
+    __SamplesPerPixel._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 627, 6)
+    
+    SamplesPerPixel = property(__SamplesPerPixel.value, __SamplesPerPixel.set, None, '\n            The number of samples the detector takes to form each pixel value. [units:none]\n            Note: This is not the same as "Frame Averaging" - see Integration in DetectorSettings\n          ')
+
+    
+    # Attribute IlluminationType uses Python identifier IlluminationType
+    __IlluminationType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'IlluminationType'), 'IlluminationType', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_IlluminationType', _module_typeBindings.STD_ANON_2)
+    __IlluminationType._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 635, 6)
+    __IlluminationType._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 635, 6)
+    
+    IlluminationType = property(__IlluminationType.value, __IlluminationType.set, None, '\n            The method of illumination used to capture the channel.\n          ')
+
+    
+    # Attribute PinholeSize uses Python identifier PinholeSize
+    __PinholeSize = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PinholeSize'), 'PinholeSize', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_PinholeSize', pyxb.binding.datatypes.float)
+    __PinholeSize._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 651, 6)
+    __PinholeSize._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 651, 6)
+    
+    PinholeSize = property(__PinholeSize.value, __PinholeSize.set, None, '\n            The optional PinholeSize attribute allows specifying adjustable\n            pin hole diameters for confocal microscopes. Units are set by PinholeSizeUnit.\n          ')
+
+    
+    # Attribute PinholeSizeUnit uses Python identifier PinholeSizeUnit
+    __PinholeSizeUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PinholeSizeUnit'), 'PinholeSizeUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_PinholeSizeUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
+    __PinholeSizeUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 659, 6)
+    __PinholeSizeUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 659, 6)
+    
+    PinholeSizeUnit = property(__PinholeSizeUnit.value, __PinholeSizeUnit.set, None, 'The units of the pin hole diameter for confocal microscopes - default:microns[\xb5m].')
+
+    
+    # Attribute AcquisitionMode uses Python identifier AcquisitionMode
+    __AcquisitionMode = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AcquisitionMode'), 'AcquisitionMode', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_AcquisitionMode', _module_typeBindings.STD_ANON_3)
+    __AcquisitionMode._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 664, 6)
+    __AcquisitionMode._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 664, 6)
+    
+    AcquisitionMode = property(__AcquisitionMode.value, __AcquisitionMode.set, None, '\n            AcquisitionMode describes the type of microscopy performed for each channel\n          ')
+
+    
+    # Attribute ContrastMethod uses Python identifier ContrastMethod
+    __ContrastMethod = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ContrastMethod'), 'ContrastMethod', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ContrastMethod', _module_typeBindings.STD_ANON_4)
+    __ContrastMethod._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 698, 6)
+    __ContrastMethod._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 698, 6)
+    
+    ContrastMethod = property(__ContrastMethod.value, __ContrastMethod.set, None, '\n            ContrastMethod describes the technique used to achieve contrast for each channel\n          ')
+
+    
+    # Attribute ExcitationWavelength uses Python identifier ExcitationWavelength
+    __ExcitationWavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExcitationWavelength'), 'ExcitationWavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ExcitationWavelength', _module_typeBindings.PositiveFloat)
+    __ExcitationWavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 718, 6)
+    __ExcitationWavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 718, 6)
+    
+    ExcitationWavelength = property(__ExcitationWavelength.value, __ExcitationWavelength.set, None, '\n            Wavelength of excitation for a particular channel. Units are set by ExcitationWavelengthUnit.\n          ')
+
+    
+    # Attribute ExcitationWavelengthUnit uses Python identifier ExcitationWavelengthUnit
+    __ExcitationWavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExcitationWavelengthUnit'), 'ExcitationWavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_ExcitationWavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __ExcitationWavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 725, 6)
+    __ExcitationWavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 725, 6)
+    
+    ExcitationWavelengthUnit = property(__ExcitationWavelengthUnit.value, __ExcitationWavelengthUnit.set, None, 'The units of the wavelength of excitation - default:nanometres[nm].')
+
+    
+    # Attribute EmissionWavelength uses Python identifier EmissionWavelength
+    __EmissionWavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'EmissionWavelength'), 'EmissionWavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_EmissionWavelength', _module_typeBindings.PositiveFloat)
+    __EmissionWavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 730, 6)
+    __EmissionWavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 730, 6)
+    
+    EmissionWavelength = property(__EmissionWavelength.value, __EmissionWavelength.set, None, '\n            Wavelength of emission for a particular channel. Units are set by EmissionWavelengthUnit.\n          ')
+
+    
+    # Attribute EmissionWavelengthUnit uses Python identifier EmissionWavelengthUnit
+    __EmissionWavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'EmissionWavelengthUnit'), 'EmissionWavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_EmissionWavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __EmissionWavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 737, 6)
+    __EmissionWavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 737, 6)
+    
+    EmissionWavelengthUnit = property(__EmissionWavelengthUnit.value, __EmissionWavelengthUnit.set, None, 'The units of the wavelength of emission - default:nanometres[nm].')
+
+    
+    # Attribute Fluor uses Python identifier Fluor
+    __Fluor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Fluor'), 'Fluor', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_Fluor', pyxb.binding.datatypes.string)
+    __Fluor._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 742, 6)
+    __Fluor._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 742, 6)
+    
+    Fluor = property(__Fluor.value, __Fluor.set, None, '\n            The Fluor attribute is used for fluorescence images.\n            This is the name of the fluorophore used to produce this channel [plain text string]\n          ')
+
+    
+    # Attribute NDFilter uses Python identifier NDFilter
+    __NDFilter = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'NDFilter'), 'NDFilter', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_NDFilter', pyxb.binding.datatypes.float)
+    __NDFilter._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 750, 6)
+    __NDFilter._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 750, 6)
+    
+    NDFilter = property(__NDFilter.value, __NDFilter.set, None, '\n            The NDfilter attribute is used to specify the combined effect of any neutral density filters used.\n            The amount of light the filter transmits at a maximum [units:none]\n            A fraction, as a value from 0.0 to 1.0.\n\n            NOTE: This was formerly described as "units optical density expressed as a PercentFraction".\n            This was how the field had been described in the schema from the beginning but all\n            the use of it has been in the opposite direction, i.e. as a amount transmitted,\n            not the amount blocked. This change has been made to make the model reflect this usage.\n          ')
+
+    
+    # Attribute PockelCellSetting uses Python identifier PockelCellSetting
+    __PockelCellSetting = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PockelCellSetting'), 'PockelCellSetting', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_PockelCellSetting', pyxb.binding.datatypes.int)
+    __PockelCellSetting._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 764, 6)
+    __PockelCellSetting._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 764, 6)
+    
+    PockelCellSetting = property(__PockelCellSetting.value, __PockelCellSetting.set, None, '\n            The PockelCellSetting used for this channel. This is the amount the polarization of the beam is rotated by. [units:none]\n          ')
+
+    
+    # Attribute Color uses Python identifier Color
+    __Color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Color'), 'Color', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_19_Color', _module_typeBindings.Color, unicode_default='-1')
+    __Color._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 771, 6)
+    __Color._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 771, 6)
+    
+    Color = property(__Color.value, __Color.set, None, '\n            A color used to render this channel - encoded as RGBA\n            The default value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n            NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n          ')
+
+    _ElementMap.update({
+        __LightPath.name() : __LightPath,
+        __FilterSetRef.name() : __FilterSetRef,
+        __LightSourceSettings.name() : __LightSourceSettings,
+        __DetectorSettings.name() : __DetectorSettings,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name,
+        __SamplesPerPixel.name() : __SamplesPerPixel,
+        __IlluminationType.name() : __IlluminationType,
+        __PinholeSize.name() : __PinholeSize,
+        __PinholeSizeUnit.name() : __PinholeSizeUnit,
+        __AcquisitionMode.name() : __AcquisitionMode,
+        __ContrastMethod.name() : __ContrastMethod,
+        __ExcitationWavelength.name() : __ExcitationWavelength,
+        __ExcitationWavelengthUnit.name() : __ExcitationWavelengthUnit,
+        __EmissionWavelength.name() : __EmissionWavelength,
+        __EmissionWavelengthUnit.name() : __EmissionWavelengthUnit,
+        __Fluor.name() : __Fluor,
+        __NDFilter.name() : __NDFilter,
+        __PockelCellSetting.name() : __PockelCellSetting,
+        __Color.name() : __Color
+    })
+_module_typeBindings.CTD_ANON_19 = CTD_ANON_19
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_20 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        Defines a microbeam operation type and the region of the image it was applied to.
+        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for
+        the purpose of imaging. For example, a laser used for photobleaching.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 929, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the Microbeam Manipulation. [plain-text multi-line string]\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
+    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )
+
+    
+    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceSettings uses Python identifier LightSourceSettings
+    __LightSourceSettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), 'LightSourceSettings', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06LightSourceSettings', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2), )
+
+    
+    LightSourceSettings = property(__LightSourceSettings.value, __LightSourceSettings.set, None, '')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIRef uses Python identifier ROIRef
+    __ROIRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), 'ROIRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_httpwww_openmicroscopy_orgSchemasOME2016_06ROIRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2), )
+
+    
+    ROIRef = property(__ROIRef.value, __ROIRef.set, None, None)
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_ID', _module_typeBindings.MicrobeamManipulationID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 951, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 951, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_20_Type', _module_typeBindings.STD_ANON_37)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 952, 6)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 952, 6)
+    
+    Type = property(__Type.value, __Type.set, None, '\n            The type of manipulation performed.\n          ')
+
+    _ElementMap.update({
+        __Description.name() : __Description,
+        __ExperimenterRef.name() : __ExperimenterRef,
+        __LightSourceSettings.name() : __LightSourceSettings,
+        __ROIRef.name() : __ROIRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Type.name() : __Type
+    })
+_module_typeBindings.CTD_ANON_20 = CTD_ANON_20
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_21 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This element describes the instrument used to capture the Image.
+        It is primarily a container for manufacturer's model and catalog
+        numbers for the Microscope, LightSource, Detector, Objective and
+        Filters components.
+        The Objective element contains the additional elements LensNA and Magnification.
+        The Filters element can be composed either of separate excitation,
+        emission filters and a dichroic mirror or a single filter set.
+        Within the Image itself, a reference is made to this one Filter element.
+        There may be multiple light sources, detectors, objectives and filters on a microscope.
+        Each of these has their own ID attribute, which can be referred to from Channel.
+        It is understood that the light path configuration can be different
+        for each channel, but cannot be different for each timepoint or
+        each plane of an XYZ stack.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 998, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Microscope uses Python identifier Microscope
+    __Microscope = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Microscope'), 'Microscope', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Microscope', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1016, 2), )
+
+    
+    Microscope = property(__Microscope.value, __Microscope.set, None, "The microscope's manufacturer specification.")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Objective uses Python identifier Objective
+    __Objective = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Objective'), 'Objective', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Objective', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2024, 2), )
+
+    
+    Objective = property(__Objective.value, __Objective.set, None, "\n        A description of the microscope's objective lens.\n        Required elements include the lens numerical aperture,\n        and the magnification, both of which a floating\n        point (real) numbers.\n        The values are those that are fixed for a particular\n        objective: either because it has been manufactured to\n        this specification or the value has been measured on\n        this particular objective.\n        Correction: This is the type of correction coating applied to this lens.\n        Immersion: This is the types of immersion medium the lens is designed to\n        work with. It is not the same as 'Medium' in ObjectiveRef (a\n        single type) as here Immersion can have compound values like 'Multi'.\n        LensNA: The numerical aperture of the lens (as a float)\n        NominalMagnification: The specified magnification e.g. x10\n        CalibratedMagnification: The measured magnification e.g. x10.3\n        WorkingDistance: WorkingDistance of the lens.\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Detector uses Python identifier Detector
+    __Detector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Detector'), 'Detector', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Detector', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2144, 2), )
+
+    
+    Detector = property(__Detector.value, __Detector.set, None, '\n        The type of detector used to capture the image.\n        The Detector ID can be used as a reference within the Channel element in the Image element.\n        The values stored in Detector represent the fixed values,\n        variable values modified during the acquisition go in DetectorSettings\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterSet uses Python identifier FilterSet
+    __FilterSet = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FilterSet'), 'FilterSet', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06FilterSet', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2242, 2), )
+
+    
+    FilterSet = property(__FilterSet.value, __FilterSet.set, None, 'Filter set manufacturer specification')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Filter uses Python identifier Filter
+    __Filter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Filter'), 'Filter', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Filter', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2274, 2), )
+
+    
+    Filter = property(__Filter.value, __Filter.set, None, "\n        A filter is either an excitation or emission filters.\n        There should be one filter element specified per wavelength in the image.\n        The channel number associated with a filter set is specified in Channel.\n        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.\n        It may also contain a Type attribute which may be set to\n        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',\n        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.\n        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet\n      ")
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Dichroic uses Python identifier Dichroic
+    __Dichroic = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Dichroic'), 'Dichroic', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06Dichroic', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2391, 2), )
+
+    
+    Dichroic = property(__Dichroic.value, __Dichroic.set, None, 'The dichromatic beamsplitter or dichroic mirror used for this filter combination.')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSourceGroup uses Python identifier LightSourceGroup
+    __LightSourceGroup = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup'), 'LightSourceGroup', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06LightSourceGroup', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2454, 2), )
+
+    
+    LightSourceGroup = property(__LightSourceGroup.value, __LightSourceGroup.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_21_ID', _module_typeBindings.InstrumentID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1013, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1013, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __Microscope.name() : __Microscope,
+        __Objective.name() : __Objective,
+        __Detector.name() : __Detector,
+        __FilterSet.name() : __FilterSet,
+        __Filter.name() : __Filter,
+        __Dichroic.name() : __Dichroic,
+        __LightSourceGroup.name() : __LightSourceGroup,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_21 = CTD_ANON_21
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_22 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The Project ID is required.
+        Datasets can be grouped into projects using a many-to-many relationship.
+        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.
+        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1111, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the project. [plain-text multi-line string]\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
+    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )
+
+    
+    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupRef uses Python identifier ExperimenterGroupRef
+    __ExperimenterGroupRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), 'ExperimenterGroupRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroupRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2), )
+
+    
+    ExperimenterGroupRef = property(__ExperimenterGroupRef.value, __ExperimenterGroupRef.set, None, 'This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DatasetRef uses Python identifier DatasetRef
+    __DatasetRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef'), 'DatasetRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06DatasetRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2949, 2), )
+
+    
+    DatasetRef = property(__DatasetRef.value, __DatasetRef.set, None, '\n        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.\n        One or more DatasetRef elements may be listed within the Image element to specify what Datasets\n        the Image belongs to.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1138, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1138, 6)
+    
+    Name = property(__Name.value, __Name.set, None, None)
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_22_ID', _module_typeBindings.ProjectID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1139, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1139, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __Description.name() : __Description,
+        __ExperimenterRef.name() : __ExperimenterRef,
+        __ExperimenterGroupRef.name() : __ExperimenterGroupRef,
+        __DatasetRef.name() : __DatasetRef,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __Name.name() : __Name,
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_22 = CTD_ANON_22
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_23 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The ExperimenterGroupID is required.
+        Information should ideally be specified for at least one Leader as a contact for the group.
+        The Leaders are themselves Experimenters.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1151, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the group. [plain-text multi-line string]\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Leader uses Python identifier Leader
+    __Leader = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Leader'), 'Leader', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06Leader', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1185, 2), )
+
+    
+    Leader = property(__Leader.value, __Leader.set, None, '\n        Contact information for a ExperimenterGroup leader specified using a reference\n        to an Experimenter element defined elsewhere in the document.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
+    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )
+
+    
+    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1177, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1177, 6)
+    
+    Name = property(__Name.value, __Name.set, None, '')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_23_ID', _module_typeBindings.ExperimenterGroupID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1182, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1182, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __Description.name() : __Description,
+        __Leader.name() : __Leader,
+        __ExperimenterRef.name() : __ExperimenterRef,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __Name.name() : __Name,
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_23 = CTD_ANON_23
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_24 (Reference):
+    """
+        Contact information for a ExperimenterGroup leader specified using a reference
+        to an Experimenter element defined elsewhere in the document.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1193, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_24_ID', _module_typeBindings.ExperimenterID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1196, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1196, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_24 = CTD_ANON_24
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_25 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        An element specifying a collection of images that are always processed together.
+        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.
+        Images contain one or more DatasetRef elements to specify what datasets they belong to.
+        Once a Dataset has been processed in any way, its collection of images cannot be altered.
+        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.
+        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.
+        This relationship is specified by listing DatasetRef elements within the Project element.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1214, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the dataset. [plain-text multi-line string]\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageRef uses Python identifier ImageRef
+    __ImageRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), 'ImageRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06ImageRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2), )
+
+    
+    ImageRef = property(__ImageRef.value, __ImageRef.set, None, '\n        The ImageRef element is a reference to an Image element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
+    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )
+
+    
+    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterGroupRef uses Python identifier ExperimenterGroupRef
+    __ExperimenterGroupRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), 'ExperimenterGroupRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterGroupRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2), )
+
+    
+    ExperimenterGroupRef = property(__ExperimenterGroupRef.value, __ExperimenterGroupRef.set, None, 'This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1241, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1241, 6)
+    
+    Name = property(__Name.value, __Name.set, None, '\n            A name for the dataset that is suitable for presentation to the user.\n          ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_25_ID', _module_typeBindings.DatasetID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1248, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1248, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __Description.name() : __Description,
+        __ImageRef.name() : __ImageRef,
+        __ExperimenterRef.name() : __ExperimenterRef,
+        __ExperimenterGroupRef.name() : __ExperimenterGroupRef,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __Name.name() : __Name,
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_25 = CTD_ANON_25
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_26 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:
+        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation
+        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other
+        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.
+        The optional Description element may contain free text to further describe the experiment.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1262, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}MicrobeamManipulation uses Python identifier MicrobeamManipulation
+    __MicrobeamManipulation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation'), 'MicrobeamManipulation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_httpwww_openmicroscopy_orgSchemasOME2016_06MicrobeamManipulation', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 920, 2), )
+
+    
+    MicrobeamManipulation = property(__MicrobeamManipulation.value, __MicrobeamManipulation.set, None, '\n        Defines a microbeam operation type and the region of the image it was applied to.\n        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for\n        the purpose of imaging. For example, a laser used for photobleaching.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the experiment. [plain-text multi-line string]\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExperimenterRef uses Python identifier ExperimenterRef
+    __ExperimenterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), 'ExperimenterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_httpwww_openmicroscopy_orgSchemasOME2016_06ExperimenterRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2), )
+
+    
+    ExperimenterRef = property(__ExperimenterRef.value, __ExperimenterRef.set, None, '\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ')
+
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_Type', _module_typeBindings.STD_ANON_38)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1285, 6)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1285, 6)
+    
+    Type = property(__Type.value, __Type.set, None, '\n            A term to describe the type of experiment.\n          ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_26_ID', _module_typeBindings.ExperimentID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1317, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1317, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __MicrobeamManipulation.name() : __MicrobeamManipulation,
+        __Description.name() : __Description,
+        __ExperimenterRef.name() : __ExperimenterRef
+    })
+    _AttributeMap.update({
+        __Type.name() : __Type,
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_26 = CTD_ANON_26
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_27 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This element describes a person who performed an imaging experiment.
+        This person may also be a user of the OME system, in which case the UserName element contains their login name.
+        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1329, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_ID', _module_typeBindings.ExperimenterID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1337, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1337, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute FirstName uses Python identifier FirstName
+    __FirstName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FirstName'), 'FirstName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_FirstName', pyxb.binding.datatypes.string)
+    __FirstName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1338, 6)
+    __FirstName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1338, 6)
+    
+    FirstName = property(__FirstName.value, __FirstName.set, None, 'First name, sometime called christian name or given name or forename. [plain text string]')
+
+    
+    # Attribute MiddleName uses Python identifier MiddleName
+    __MiddleName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MiddleName'), 'MiddleName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_MiddleName', pyxb.binding.datatypes.string)
+    __MiddleName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1343, 6)
+    __MiddleName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1343, 6)
+    
+    MiddleName = property(__MiddleName.value, __MiddleName.set, None, 'Any other names. [plain text string]')
+
+    
+    # Attribute LastName uses Python identifier LastName
+    __LastName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LastName'), 'LastName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_LastName', pyxb.binding.datatypes.string)
+    __LastName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1348, 6)
+    __LastName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1348, 6)
+    
+    LastName = property(__LastName.value, __LastName.set, None, "A person's last name sometimes called surname or family name. [plain text string]")
+
+    
+    # Attribute Email uses Python identifier Email
+    __Email = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Email'), 'Email', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_Email', pyxb.binding.datatypes.string)
+    __Email._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1353, 6)
+    __Email._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1353, 6)
+    
+    Email = property(__Email.value, __Email.set, None, "A person's email address. [valid email address as string]")
+
+    
+    # Attribute Institution uses Python identifier Institution
+    __Institution = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Institution'), 'Institution', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_Institution', pyxb.binding.datatypes.string)
+    __Institution._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1358, 6)
+    __Institution._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1358, 6)
+    
+    Institution = property(__Institution.value, __Institution.set, None, "\n            A person's Institution\n            The organizing structure that people belong to other than groups.  A university, or company, etc.\n            We do not specify a department element, and do not mean for Institution to be used in this way.\n            We simply wish to say XXX at YYY.  Where YYY has a better chance of being tied to a geographically fixed location\n            and of being more recognizable than a group of experimenters. [plain text string]\n          ")
+
+    
+    # Attribute UserName uses Python identifier UserName
+    __UserName = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'UserName'), 'UserName', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_27_UserName', pyxb.binding.datatypes.string)
+    __UserName._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1369, 6)
+    __UserName._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1369, 6)
+    
+    UserName = property(__UserName.value, __UserName.set, None, "This is the username of the experimenter (in a 'unix' or 'database' sense). [plain text string]")
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __FirstName.name() : __FirstName,
+        __MiddleName.name() : __MiddleName,
+        __LastName.name() : __LastName,
+        __Email.name() : __Email,
+        __Institution.name() : __Institution,
+        __UserName.name() : __UserName
+    })
+_module_typeBindings.CTD_ANON_27 = CTD_ANON_27
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_28 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        An element specifying a possibly heterogeneous collection of data.
+        Folders may contain Folders so that data may be organized within a tree of Folders.
+        Data may be in multiple Folders but a Folder may not be in more than one other Folder.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1386, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the folder. [plain-text multi-line string]\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageRef uses Python identifier ImageRef
+    __ImageRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), 'ImageRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06ImageRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2), )
+
+    
+    ImageRef = property(__ImageRef.value, __ImageRef.set, None, '\n        The ImageRef element is a reference to an Image element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}FolderRef uses Python identifier FolderRef
+    __FolderRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FolderRef'), 'FolderRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06FolderRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2965, 2), )
+
+    
+    FolderRef = property(__FolderRef.value, __FolderRef.set, None, '\n        The FolderRef element refers to a Folder by specifying the Folder ID attribute.\n        One or more FolderRef elements may be listed within the Folder element to specify what Folders\n        the Folder contains. This tree hierarchy must be acyclic.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ROIRef uses Python identifier ROIRef
+    __ROIRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), 'ROIRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_httpwww_openmicroscopy_orgSchemasOME2016_06ROIRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2), )
+
+    
+    ROIRef = property(__ROIRef.value, __ROIRef.set, None, None)
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_ID', _module_typeBindings.FolderID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1417, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1417, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_28_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1418, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1418, 6)
+    
+    Name = property(__Name.value, __Name.set, None, '\n            A name for the folder that is suitable for presentation to the user.\n          ')
+
+    _ElementMap.update({
+        __Description.name() : __Description,
+        __ImageRef.name() : __ImageRef,
+        __FolderRef.name() : __FolderRef,
+        __AnnotationRef.name() : __AnnotationRef,
+        __ROIRef.name() : __ROIRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name
+    })
+_module_typeBindings.CTD_ANON_28 = CTD_ANON_28
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_29 (ManufacturerSpec):
+    """
+        A description of the microscope's objective lens.
+        Required elements include the lens numerical aperture,
+        and the magnification, both of which a floating
+        point (real) numbers.
+        The values are those that are fixed for a particular
+        objective: either because it has been manufactured to
+        this specification or the value has been measured on
+        this particular objective.
+        Correction: This is the type of correction coating applied to this lens.
+        Immersion: This is the types of immersion medium the lens is designed to
+        work with. It is not the same as 'Medium' in ObjectiveRef (a
+        single type) as here Immersion can have compound values like 'Multi'.
+        LensNA: The numerical aperture of the lens (as a float)
+        NominalMagnification: The specified magnification e.g. x10
+        CalibratedMagnification: The measured magnification e.g. x10.3
+        WorkingDistance: WorkingDistance of the lens.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2046, 4)
+    _ElementMap = ManufacturerSpec._ElementMap.copy()
+    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
+    # Base type is ManufacturerSpec
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_ID', _module_typeBindings.ObjectiveID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2056, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2056, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Correction uses Python identifier Correction
+    __Correction = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Correction'), 'Correction', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_Correction', _module_typeBindings.STD_ANON_14)
+    __Correction._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2057, 10)
+    __Correction._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2057, 10)
+    
+    Correction = property(__Correction.value, __Correction.set, None, 'The correction applied to the lens')
+
+    
+    # Attribute Immersion uses Python identifier Immersion
+    __Immersion = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Immersion'), 'Immersion', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_Immersion', _module_typeBindings.STD_ANON_15)
+    __Immersion._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2081, 10)
+    __Immersion._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2081, 10)
+    
+    Immersion = property(__Immersion.value, __Immersion.set, None, 'The immersion medium the lens is designed for')
+
+    
+    # Attribute LensNA uses Python identifier LensNA
+    __LensNA = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LensNA'), 'LensNA', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_LensNA', pyxb.binding.datatypes.float)
+    __LensNA._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2097, 10)
+    __LensNA._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2097, 10)
+    
+    LensNA = property(__LensNA.value, __LensNA.set, None, '\n                The numerical aperture of the lens expressed as a floating point (real) number.\n                Expected range 0.02 - 1.5 [units:none]\n              ')
+
+    
+    # Attribute NominalMagnification uses Python identifier NominalMagnification
+    __NominalMagnification = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'NominalMagnification'), 'NominalMagnification', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_NominalMagnification', pyxb.binding.datatypes.float)
+    __NominalMagnification._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2105, 10)
+    __NominalMagnification._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2105, 10)
+    
+    NominalMagnification = property(__NominalMagnification.value, __NominalMagnification.set, None, "\n                The magnification of the lens as specified by the manufacturer - i.e. '60' is a 60X lens. [units:none]\n                Note: The type of this has been changed from int to float to allow\n                the specification of additional lenses e.g. 0.5X lens\n              ")
+
+    
+    # Attribute CalibratedMagnification uses Python identifier CalibratedMagnification
+    __CalibratedMagnification = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CalibratedMagnification'), 'CalibratedMagnification', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_CalibratedMagnification', pyxb.binding.datatypes.float)
+    __CalibratedMagnification._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2114, 10)
+    __CalibratedMagnification._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2114, 10)
+    
+    CalibratedMagnification = property(__CalibratedMagnification.value, __CalibratedMagnification.set, None, "\n                The magnification of the lens as measured by a calibration process- i.e. '59.987' for a 60X lens. [units:none]\n              ")
+
+    
+    # Attribute WorkingDistance uses Python identifier WorkingDistance
+    __WorkingDistance = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WorkingDistance'), 'WorkingDistance', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_WorkingDistance', pyxb.binding.datatypes.float)
+    __WorkingDistance._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2121, 10)
+    __WorkingDistance._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2121, 10)
+    
+    WorkingDistance = property(__WorkingDistance.value, __WorkingDistance.set, None, '\n                The working distance of the lens expressed as a floating point (real) number. Units are set by WorkingDistanceUnit.\n              ')
+
+    
+    # Attribute WorkingDistanceUnit uses Python identifier WorkingDistanceUnit
+    __WorkingDistanceUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WorkingDistanceUnit'), 'WorkingDistanceUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_WorkingDistanceUnit', _module_typeBindings.UnitsLength, unicode_default='\xb5m')
+    __WorkingDistanceUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2128, 10)
+    __WorkingDistanceUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2128, 10)
+    
+    WorkingDistanceUnit = property(__WorkingDistanceUnit.value, __WorkingDistanceUnit.set, None, 'The units of the working distance - default:microns[\xb5m].')
+
+    
+    # Attribute Iris uses Python identifier Iris
+    __Iris = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Iris'), 'Iris', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_29_Iris', pyxb.binding.datatypes.boolean)
+    __Iris._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2133, 10)
+    __Iris._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2133, 10)
+    
+    Iris = property(__Iris.value, __Iris.set, None, '\n                Records whether or not the objective was fitted with an Iris. [flag]\n              ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Correction.name() : __Correction,
+        __Immersion.name() : __Immersion,
+        __LensNA.name() : __LensNA,
+        __NominalMagnification.name() : __NominalMagnification,
+        __CalibratedMagnification.name() : __CalibratedMagnification,
+        __WorkingDistance.name() : __WorkingDistance,
+        __WorkingDistanceUnit.name() : __WorkingDistanceUnit,
+        __Iris.name() : __Iris
+    })
+_module_typeBindings.CTD_ANON_29 = CTD_ANON_29
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_30 (ManufacturerSpec):
+    """
+        The type of detector used to capture the image.
+        The Detector ID can be used as a reference within the Channel element in the Image element.
+        The values stored in Detector represent the fixed values,
+        variable values modified during the acquisition go in DetectorSettings
+
+        Each attribute now has an indication of what type of detector
+        it applies to. This is preparatory work for cleaning up and
+        possibly splitting this object into sub-types.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2158, 4)
+    _ElementMap = ManufacturerSpec._ElementMap.copy()
+    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
+    # Base type is ManufacturerSpec
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Gain uses Python identifier Gain
+    __Gain = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Gain'), 'Gain', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Gain', pyxb.binding.datatypes.float)
+    __Gain._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2168, 10)
+    __Gain._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2168, 10)
+    
+    Gain = property(__Gain.value, __Gain.set, None, '\n                The Detector Gain for this detector, as a float. [units:none] {used:CCD,EMCCD,PMT}\n              ')
+
+    
+    # Attribute Voltage uses Python identifier Voltage
+    __Voltage = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Voltage'), 'Voltage', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Voltage', pyxb.binding.datatypes.float)
+    __Voltage._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2175, 10)
+    __Voltage._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2175, 10)
+    
+    Voltage = property(__Voltage.value, __Voltage.set, None, '\n                The Voltage of the detector (e.g. PMT voltage) as a float. {used:PMT}\n                Units are set by VoltageUnit.\n              ')
+
+    
+    # Attribute VoltageUnit uses Python identifier VoltageUnit
+    __VoltageUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'VoltageUnit'), 'VoltageUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_VoltageUnit', _module_typeBindings.UnitsElectricPotential, unicode_default='V')
+    __VoltageUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2183, 10)
+    __VoltageUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2183, 10)
+    
+    VoltageUnit = property(__VoltageUnit.value, __VoltageUnit.set, None, 'The units of the Voltage - default:volts[V].')
+
+    
+    # Attribute Offset uses Python identifier Offset
+    __Offset = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Offset'), 'Offset', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Offset', pyxb.binding.datatypes.float)
+    __Offset._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2188, 10)
+    __Offset._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2188, 10)
+    
+    Offset = property(__Offset.value, __Offset.set, None, '\n                The Detector Offset. [units:none] {used:CCD,EMCCD}\n              ')
+
+    
+    # Attribute Zoom uses Python identifier Zoom
+    __Zoom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Zoom'), 'Zoom', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Zoom', pyxb.binding.datatypes.float)
+    __Zoom._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2195, 10)
+    __Zoom._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2195, 10)
+    
+    Zoom = property(__Zoom.value, __Zoom.set, None, '\n                The fixed Zoom for a detector. [units:none] {used:PMT}\n              ')
+
+    
+    # Attribute AmplificationGain uses Python identifier AmplificationGain
+    __AmplificationGain = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'AmplificationGain'), 'AmplificationGain', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_AmplificationGain', pyxb.binding.datatypes.float)
+    __AmplificationGain._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2202, 10)
+    __AmplificationGain._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2202, 10)
+    
+    AmplificationGain = property(__AmplificationGain.value, __AmplificationGain.set, None, '\n                Gain applied to the detector signal.\n                This is the electronic gain (as apposed to the inherent gain) that is set for the detector. [units:none] {used:EMCCD#EMGain}\n              ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_ID', _module_typeBindings.DetectorID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2210, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2210, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_30_Type', _module_typeBindings.STD_ANON_16)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2211, 10)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2211, 10)
+    
+    Type = property(__Type.value, __Type.set, None, '\n                The Type of detector. E.g. CCD, PMT, EMCCD etc.\n              ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __Gain.name() : __Gain,
+        __Voltage.name() : __Voltage,
+        __VoltageUnit.name() : __VoltageUnit,
+        __Offset.name() : __Offset,
+        __Zoom.name() : __Zoom,
+        __AmplificationGain.name() : __AmplificationGain,
+        __ID.name() : __ID,
+        __Type.name() : __Type
+    })
+_module_typeBindings.CTD_ANON_30 = CTD_ANON_30
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_31 (ManufacturerSpec):
+    """Filter set manufacturer specification"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2247, 4)
+    _ElementMap = ManufacturerSpec._ElementMap.copy()
+    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
+    # Base type is ManufacturerSpec
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ExcitationFilterRef uses Python identifier ExcitationFilterRef
+    __ExcitationFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), 'ExcitationFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_httpwww_openmicroscopy_orgSchemasOME2016_06ExcitationFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12), )
+
+    
+    ExcitationFilterRef = property(__ExcitationFilterRef.value, __ExcitationFilterRef.set, None, '\n                  The Filters placed in the Excitation light path.\n                ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}EmissionFilterRef uses Python identifier EmissionFilterRef
+    __EmissionFilterRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), 'EmissionFilterRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_httpwww_openmicroscopy_orgSchemasOME2016_06EmissionFilterRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12), )
+
+    
+    EmissionFilterRef = property(__EmissionFilterRef.value, __EmissionFilterRef.set, None, '\n                  The Filters placed in the Emission light path.\n                ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}DichroicRef uses Python identifier DichroicRef
+    __DichroicRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), 'DichroicRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_httpwww_openmicroscopy_orgSchemasOME2016_06DichroicRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2), )
+
+    
+    DichroicRef = property(__DichroicRef.value, __DichroicRef.set, None, None)
+
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_31_ID', _module_typeBindings.FilterSetID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2269, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2269, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __ExcitationFilterRef.name() : __ExcitationFilterRef,
+        __EmissionFilterRef.name() : __EmissionFilterRef,
+        __DichroicRef.name() : __DichroicRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_31 = CTD_ANON_31
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_32 (ManufacturerSpec):
+    """
+        A filter is either an excitation or emission filters.
+        There should be one filter element specified per wavelength in the image.
+        The channel number associated with a filter set is specified in Channel.
+        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.
+        It may also contain a Type attribute which may be set to
+        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',
+        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.
+        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2288, 4)
+    _ElementMap = ManufacturerSpec._ElementMap.copy()
+    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
+    # Base type is ManufacturerSpec
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}TransmittanceRange uses Python identifier TransmittanceRange
+    __TransmittanceRange = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange'), 'TransmittanceRange', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_httpwww_openmicroscopy_orgSchemasOME2016_06TransmittanceRange', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2325, 2), )
+
+    
+    TransmittanceRange = property(__TransmittanceRange.value, __TransmittanceRange.set, None, '\n        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_Type', _module_typeBindings.STD_ANON_17)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2299, 10)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2299, 10)
+    
+    Type = property(__Type.value, __Type.set, None, None)
+
+    
+    # Attribute FilterWheel uses Python identifier FilterWheel
+    __FilterWheel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FilterWheel'), 'FilterWheel', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_FilterWheel', pyxb.binding.datatypes.string)
+    __FilterWheel._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2313, 10)
+    __FilterWheel._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2313, 10)
+    
+    FilterWheel = property(__FilterWheel.value, __FilterWheel.set, None, "\n                A filter 'wheel' in OME can refer to any arrangement of filters in a filter holder of any shape. It could, for example, be a filter slider. [plain text string]\n              ")
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_32_ID', _module_typeBindings.FilterID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2320, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2320, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __TransmittanceRange.name() : __TransmittanceRange,
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __Type.name() : __Type,
+        __FilterWheel.name() : __FilterWheel,
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_32 = CTD_ANON_32
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_33 (ManufacturerSpec):
+    """The dichromatic beamsplitter or dichroic mirror used for this filter combination."""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2396, 4)
+    _ElementMap = ManufacturerSpec._ElementMap.copy()
+    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
+    # Base type is ManufacturerSpec
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_33_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_33_ID', _module_typeBindings.DichroicID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2406, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2406, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_33 = CTD_ANON_33
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_34 (Reference):
+    """Complex type [anonymous] with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2444, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_34_ID', _module_typeBindings.DichroicID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2447, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2447, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_34 = CTD_ANON_34
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource with content type ELEMENT_ONLY
+class LightSource (ManufacturerSpec):
+    """
+        The lightsource for the instrument.  An instrument may have several light sources.
+        The type of lightsource is specified by one of the child-elements which are 'Laser', 'Filament', 'Arc' or 'LightEmittingDiode'.
+        Each of the light source types has its own Type attribute to further differentiate the light source
+        (eg, Nd-YAG for Laser or Hg for Arc).
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'LightSource')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2455, 2)
+    _ElementMap = ManufacturerSpec._ElementMap.copy()
+    _AttributeMap = ManufacturerSpec._AttributeMap.copy()
+    # Base type is ManufacturerSpec
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_ID', _module_typeBindings.LightSourceID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2474, 8)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2474, 8)
+    
+    ID = property(__ID.value, __ID.set, None, '\n              A LightSource ID must be specified for each light source, and the individual\n              light sources can be referred to by their LightSource IDs (eg from Channel).\n            ')
+
+    
+    # Attribute Power uses Python identifier Power
+    __Power = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Power'), 'Power', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_Power', pyxb.binding.datatypes.float)
+    __Power._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2482, 8)
+    __Power._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2482, 8)
+    
+    Power = property(__Power.value, __Power.set, None, '\n              The light-source power. Units are set by PowerUnit.\n            ')
+
+    
+    # Attribute PowerUnit uses Python identifier PowerUnit
+    __PowerUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PowerUnit'), 'PowerUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_LightSource_PowerUnit', _module_typeBindings.UnitsPower, unicode_default='mW')
+    __PowerUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2489, 8)
+    __PowerUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2489, 8)
+    
+    PowerUnit = property(__PowerUnit.value, __PowerUnit.set, None, 'The units of the Power - default:milliwatts[mW].')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Power.name() : __Power,
+        __PowerUnit.name() : __PowerUnit
+    })
+_module_typeBindings.LightSource = LightSource
+Namespace.addCategoryObject('typeBinding', 'LightSource', LightSource)
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_35 (Reference):
+    """
+        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2785, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_35_ID', _module_typeBindings.LightSourceID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2788, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2788, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_35 = CTD_ANON_35
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_36 (Reference):
+    """
+        The ImageRef element is a reference to an Image element.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2850, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_36_ID', _module_typeBindings.ImageID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2853, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2853, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_36 = CTD_ANON_36
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterRef with content type EMPTY
+class FilterRef (Reference):
+    """Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}FilterRef with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'FilterRef')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2859, 2)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_FilterRef_ID', _module_typeBindings.FilterID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2862, 8)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2862, 8)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.FilterRef = FilterRef
+Namespace.addCategoryObject('typeBinding', 'FilterRef', FilterRef)
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_37 (Reference):
+    """Complex type [anonymous] with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2868, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_37_ID', _module_typeBindings.MicrobeamManipulationID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2871, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2871, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_37 = CTD_ANON_37
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_38 (Reference):
+    """Complex type [anonymous] with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2877, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_38_ID', _module_typeBindings.ExperimentID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2880, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2880, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_38 = CTD_ANON_38
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_39 (Reference):
+    """Complex type [anonymous] with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2886, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_39_ID', _module_typeBindings.ChannelID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2889, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2889, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_39 = CTD_ANON_39
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_40 (Reference):
+    """
+        There may be one or more of these in a Dataset.
+        This empty element has a required Project ID attribute that refers to Projects defined within the OME element.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2901, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_40_ID', _module_typeBindings.ProjectID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2904, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2904, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_40 = CTD_ANON_40
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_41 (Reference):
+    """
+        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2915, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_41_ID', _module_typeBindings.ExperimenterID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2918, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2918, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_41 = CTD_ANON_41
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_42 (Reference):
+    """This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME."""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2927, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_42_ID', _module_typeBindings.ExperimenterGroupID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2930, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2930, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_42 = CTD_ANON_42
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_43 (Reference):
+    """
+        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2941, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_43_ID', _module_typeBindings.InstrumentID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2944, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2944, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_43 = CTD_ANON_43
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_44 (Reference):
+    """
+        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.
+        One or more DatasetRef elements may be listed within the Image element to specify what Datasets
+        the Image belongs to.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2957, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_44_ID', _module_typeBindings.DatasetID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2960, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2960, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_44 = CTD_ANON_44
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_45 (Reference):
+    """
+        The FolderRef element refers to a Folder by specifying the Folder ID attribute.
+        One or more FolderRef elements may be listed within the Folder element to specify what Folders
+        the Folder contains. This tree hierarchy must be acyclic.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2973, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_45_ID', _module_typeBindings.FolderID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2976, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2976, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_45 = CTD_ANON_45
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_46 (Reference):
+    """Complex type [anonymous] with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2982, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_46_ID', _module_typeBindings.FilterSetID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2985, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2985, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_46 = CTD_ANON_46
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_47 (Settings):
+    """"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3010, 4)
+    _ElementMap = Settings._ElementMap.copy()
+    _AttributeMap = Settings._AttributeMap.copy()
+    # Base type is Settings
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_ID', _module_typeBindings.LightSourceID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3013, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3013, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Attenuation uses Python identifier Attenuation
+    __Attenuation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Attenuation'), 'Attenuation', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_Attenuation', _module_typeBindings.PercentFraction)
+    __Attenuation._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3014, 10)
+    __Attenuation._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3014, 10)
+    
+    Attenuation = property(__Attenuation.value, __Attenuation.set, None, '\n                The Attenuation of the light source [units:none]\n                A fraction, as a value from 0.0 to 1.0.\n              ')
+
+    
+    # Attribute Wavelength uses Python identifier Wavelength
+    __Wavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Wavelength'), 'Wavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_Wavelength', _module_typeBindings.PositiveFloat)
+    __Wavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3022, 10)
+    __Wavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3022, 10)
+    
+    Wavelength = property(__Wavelength.value, __Wavelength.set, None, '\n                The Wavelength of the light source. Units are set by WavelengthUnit.\n              ')
+
+    
+    # Attribute WavelengthUnit uses Python identifier WavelengthUnit
+    __WavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WavelengthUnit'), 'WavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_47_WavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __WavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3029, 10)
+    __WavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3029, 10)
+    
+    WavelengthUnit = property(__WavelengthUnit.value, __WavelengthUnit.set, None, '\n                The units of the Wavelength of the light source - default:nanometres[nm]\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Attenuation.name() : __Attenuation,
+        __Wavelength.name() : __Wavelength,
+        __WavelengthUnit.name() : __WavelengthUnit
+    })
+_module_typeBindings.CTD_ANON_47 = CTD_ANON_47
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_48 (Settings):
+    """
+        This holds the setting applied to a detector as well as a
+        reference to the detector.
+        The ID is the detector used in this case.
+        The values stored in DetectorSettings represent the variable values,
+        fixed values not modified during the acquisition go in Detector.
+
+        Each attribute now has an indication of what type of detector
+        it applies to. This is preparatory work for cleaning up and
+        possibly splitting this object into sub-types.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3055, 4)
+    _ElementMap = Settings._ElementMap.copy()
+    _AttributeMap = Settings._AttributeMap.copy()
+    # Base type is Settings
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_ID', _module_typeBindings.DetectorID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3058, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3058, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Offset uses Python identifier Offset
+    __Offset = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Offset'), 'Offset', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Offset', pyxb.binding.datatypes.float)
+    __Offset._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3059, 10)
+    __Offset._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3059, 10)
+    
+    Offset = property(__Offset.value, __Offset.set, None, '\n                The Offset of the detector. [units none] {used:CCD,EMCCD}\n              ')
+
+    
+    # Attribute Gain uses Python identifier Gain
+    __Gain = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Gain'), 'Gain', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Gain', pyxb.binding.datatypes.float)
+    __Gain._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3066, 10)
+    __Gain._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3066, 10)
+    
+    Gain = property(__Gain.value, __Gain.set, None, '\n                The Gain of the detector. [units:none] {used:CCD,EMCCD,PMT}\n              ')
+
+    
+    # Attribute Voltage uses Python identifier Voltage
+    __Voltage = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Voltage'), 'Voltage', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Voltage', pyxb.binding.datatypes.float)
+    __Voltage._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3073, 10)
+    __Voltage._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3073, 10)
+    
+    Voltage = property(__Voltage.value, __Voltage.set, None, '\n                The Voltage of the detector. {used:PMT}\n                Units are set by VoltageUnit.\n              ')
+
+    
+    # Attribute VoltageUnit uses Python identifier VoltageUnit
+    __VoltageUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'VoltageUnit'), 'VoltageUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_VoltageUnit', _module_typeBindings.UnitsElectricPotential, unicode_default='V')
+    __VoltageUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3081, 10)
+    __VoltageUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3081, 10)
+    
+    VoltageUnit = property(__VoltageUnit.value, __VoltageUnit.set, None, '\n                The units of the Voltage of the detector - default:volts[V]\n              ')
+
+    
+    # Attribute Zoom uses Python identifier Zoom
+    __Zoom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Zoom'), 'Zoom', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Zoom', pyxb.binding.datatypes.float)
+    __Zoom._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3088, 10)
+    __Zoom._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3088, 10)
+    
+    Zoom = property(__Zoom.value, __Zoom.set, None, '\n                The Zoom or "Confocal Zoom" or "Scan Zoom" for a detector. [units:none] {used:PMT}\n              ')
+
+    
+    # Attribute ReadOutRate uses Python identifier ReadOutRate
+    __ReadOutRate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReadOutRate'), 'ReadOutRate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_ReadOutRate', pyxb.binding.datatypes.float)
+    __ReadOutRate._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3095, 10)
+    __ReadOutRate._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3095, 10)
+    
+    ReadOutRate = property(__ReadOutRate.value, __ReadOutRate.set, None, '\n                The speed at which the detector can count pixels.  {used:CCD,EMCCD}\n                This is the bytes per second that\n                can be read from the detector (like a baud rate).\n                Units are set by ReadOutRateUnit.\n              ')
+
+    
+    # Attribute ReadOutRateUnit uses Python identifier ReadOutRateUnit
+    __ReadOutRateUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReadOutRateUnit'), 'ReadOutRateUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_ReadOutRateUnit', _module_typeBindings.UnitsFrequency, unicode_default='MHz')
+    __ReadOutRateUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3105, 10)
+    __ReadOutRateUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3105, 10)
+    
+    ReadOutRateUnit = property(__ReadOutRateUnit.value, __ReadOutRateUnit.set, None, 'The units of the ReadOutRate - default:megahertz[Hz].')
+
+    
+    # Attribute Binning uses Python identifier Binning
+    __Binning = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Binning'), 'Binning', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Binning', _module_typeBindings.Binning)
+    __Binning._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3110, 10)
+    __Binning._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3110, 10)
+    
+    Binning = property(__Binning.value, __Binning.set, None, '\n                Represents the number of pixels that are combined to form larger pixels. {used:CCD,EMCCD}\n              ')
+
+    
+    # Attribute Integration uses Python identifier Integration
+    __Integration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Integration'), 'Integration', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_48_Integration', _module_typeBindings.PositiveInt)
+    __Integration._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3117, 10)
+    __Integration._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3117, 10)
+    
+    Integration = property(__Integration.value, __Integration.set, None, '\n                This is the number of sequential frames that get averaged,\n                to improve the signal-to-noise ratio. [units:none] {used:CCD,EMCCD}\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Offset.name() : __Offset,
+        __Gain.name() : __Gain,
+        __Voltage.name() : __Voltage,
+        __VoltageUnit.name() : __VoltageUnit,
+        __Zoom.name() : __Zoom,
+        __ReadOutRate.name() : __ReadOutRate,
+        __ReadOutRateUnit.name() : __ReadOutRateUnit,
+        __Binning.name() : __Binning,
+        __Integration.name() : __Integration
+    })
+_module_typeBindings.CTD_ANON_48 = CTD_ANON_48
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_49 (Settings):
+    """
+        This holds the setting applied to an objective as well as a
+        reference to the objective.
+        The ID is the objective used in this case.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3138, 4)
+    _ElementMap = Settings._ElementMap.copy()
+    _AttributeMap = Settings._AttributeMap.copy()
+    # Base type is Settings
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_ID', _module_typeBindings.ObjectiveID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3141, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3141, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute CorrectionCollar uses Python identifier CorrectionCollar
+    __CorrectionCollar = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CorrectionCollar'), 'CorrectionCollar', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_CorrectionCollar', pyxb.binding.datatypes.float)
+    __CorrectionCollar._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3142, 10)
+    __CorrectionCollar._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3142, 10)
+    
+    CorrectionCollar = property(__CorrectionCollar.value, __CorrectionCollar.set, None, '\n                The CorrectionCollar is normally an adjustable ring on the\n                objective. Each has an arbitrary scale on it so the values\n                is unit-less. [units:none]\n              ')
+
+    
+    # Attribute Medium uses Python identifier Medium
+    __Medium = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Medium'), 'Medium', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_Medium', _module_typeBindings.STD_ANON_25)
+    __Medium._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3151, 10)
+    __Medium._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3151, 10)
+    
+    Medium = property(__Medium.value, __Medium.set, None, None)
+
+    
+    # Attribute RefractiveIndex uses Python identifier RefractiveIndex
+    __RefractiveIndex = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RefractiveIndex'), 'RefractiveIndex', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_49_RefractiveIndex', pyxb.binding.datatypes.float)
+    __RefractiveIndex._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3168, 10)
+    __RefractiveIndex._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3168, 10)
+    
+    RefractiveIndex = property(__RefractiveIndex.value, __RefractiveIndex.set, None, '\n                The RefractiveIndex is that of the immersion medium. This is\n                a ratio so it also unit-less. [units:none]\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __CorrectionCollar.name() : __CorrectionCollar,
+        __Medium.name() : __Medium,
+        __RefractiveIndex.name() : __RefractiveIndex
+    })
+_module_typeBindings.CTD_ANON_49 = CTD_ANON_49
+
+
+# Complex type [anonymous] with content type SIMPLE
+class CTD_ANON_50 (pyxb.binding.basis.complexTypeDefinition):
+    """The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream."""
+    _TypeDefinition = base64Binary
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3325, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is base64Binary
+    
+    # Attribute Compression uses Python identifier Compression
+    __Compression = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Compression'), 'Compression', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_50_Compression', _module_typeBindings.STD_ANON_27, unicode_default='none')
+    __Compression._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3328, 10)
+    __Compression._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3328, 10)
+    
+    Compression = property(__Compression.value, __Compression.set, None, 'Specifies the compression scheme used to encode the data. ')
+
+    
+    # Attribute BigEndian uses Python identifier BigEndian
+    __BigEndian = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'BigEndian'), 'BigEndian', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_50_BigEndian', pyxb.binding.datatypes.boolean, required=True)
+    __BigEndian._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3340, 10)
+    __BigEndian._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3340, 10)
+    
+    BigEndian = property(__BigEndian.value, __BigEndian.set, None, '\n                This is true if the binary data was written in BigEndian order. This is dependent on the system architecture of the machine that wrote the pixels. True for essentially all modern CPUs other than Intel and Alpha. All Binary data must be written in the same endian order.\n              ')
+
+    
+    # Attribute Length uses Python identifier Length
+    __Length = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Length'), 'Length', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_50_Length', _module_typeBindings.STD_ANON_39, required=True)
+    __Length._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3347, 10)
+    __Length._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3347, 10)
+    
+    Length = property(__Length.value, __Length.set, None, '\n                Character count attribute for the BinData field. This is the length of the base-64 encoded block. It allows easy skipping of the block when parsing the file. [unit:bytes]\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Compression.name() : __Compression,
+        __BigEndian.name() : __BigEndian,
+        __Length.name() : __Length
+    })
+_module_typeBindings.CTD_ANON_50 = CTD_ANON_50
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_51 (Reference):
+    """
+        The AnnotationRef element is a reference to an element derived
+        from the CommonAnnotation element.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3442, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_51_ID', _module_typeBindings.AnnotationID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3445, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3445, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_51 = CTD_ANON_51
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation with content type ELEMENT_ONLY
+class Annotation (pyxb.binding.basis.complexTypeDefinition):
+    """
+        An annotation from which all others are ultimately derived.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Annotation')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3452, 2)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n            A description for the annotation. [plain-text multi-line string]\n          ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_ID', _module_typeBindings.AnnotationID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3480, 4)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3480, 4)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Namespace uses Python identifier Namespace_
+    __Namespace = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Namespace'), 'Namespace_', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_Namespace', pyxb.binding.datatypes.anyURI)
+    __Namespace._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3481, 4)
+    __Namespace._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3481, 4)
+    
+    Namespace_ = property(__Namespace.value, __Namespace.set, None, "\n          We recommend the inclusion of a namespace for annotations you\n          define. If it is absent then we assume the annotation is to\n          use our (OME's) default interpretation for this type.\n        ")
+
+    
+    # Attribute Annotator uses Python identifier Annotator
+    __Annotator = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Annotator'), 'Annotator', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Annotation_Annotator', _module_typeBindings.ExperimenterID)
+    __Annotator._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3490, 4)
+    __Annotator._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3490, 4)
+    
+    Annotator = property(__Annotator.value, __Annotator.set, None, '\n          The Annotator is the person who attached this annotation.\n          e.g. If UserA annotates something with TagB, owned by UserB,\n          UserA is still the Annotator.\n        ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __Description.name() : __Description
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Namespace.name() : __Namespace,
+        __Annotator.name() : __Annotator
+    })
+_module_typeBindings.Annotation = Annotation
+Namespace.addCategoryObject('typeBinding', 'Annotation', Annotation)
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_52 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        A four dimensional 'Region of Interest'.
+        If they are not used, and the Image has more than one plane,
+        the entire set of planes is assumed to be included in the ROI.
+        Multiple ROIs may be specified.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3756, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Union uses Python identifier Union
+    __Union = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Union'), 'Union', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_httpwww_openmicroscopy_orgSchemasOME2016_06Union', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3759, 10), )
+
+    
+    Union = property(__Union.value, __Union.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the ROI. [plain-text multi-line string]\n            ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_ID', _module_typeBindings.ROIID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3785, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3785, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_52_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3786, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3786, 6)
+    
+    Name = property(__Name.value, __Name.set, None, '\n            The Name identifies the ROI to the user. [plain-text string]\n          ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __Union.name() : __Union,
+        __Description.name() : __Description
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name
+    })
+_module_typeBindings.CTD_ANON_52 = CTD_ANON_52
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape with content type ELEMENT_ONLY
+class Shape (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The shape element contains a single specific ROI shape and links
+        that to any channels, and a timepoint and a z-section. It also
+        records any transform applied to the ROI shape.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Shape')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3796, 2)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform uses Python identifier Transform
+    __Transform = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Transform'), 'Transform', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_httpwww_openmicroscopy_orgSchemasOME2016_06Transform', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6), )
+
+    
+    Transform = property(__Transform.value, __Transform.set, None, '\n            This is a matrix used to transform the shape.\n            The element has 6 xsd:float attributes. If the element\n            is present then all 6 values must be included.\n          ')
+
+    
+    # Attribute FillColor uses Python identifier FillColor
+    __FillColor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FillColor'), 'FillColor', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FillColor', _module_typeBindings.Color)
+    __FillColor._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3821, 4)
+    __FillColor._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3821, 4)
+    
+    FillColor = property(__FillColor.value, __FillColor.set, None, '\n          The color of the fill - encoded as RGBA\n          The value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n          NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n        ')
+
+    
+    # Attribute FillRule uses Python identifier FillRule
+    __FillRule = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FillRule'), 'FillRule', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FillRule', _module_typeBindings.STD_ANON_30)
+    __FillRule._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3830, 4)
+    __FillRule._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3830, 4)
+    
+    FillRule = property(__FillRule.value, __FillRule.set, None, None)
+
+    
+    # Attribute StrokeColor uses Python identifier StrokeColor
+    __StrokeColor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeColor'), 'StrokeColor', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeColor', _module_typeBindings.Color)
+    __StrokeColor._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3844, 4)
+    __StrokeColor._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3844, 4)
+    
+    StrokeColor = property(__StrokeColor.value, __StrokeColor.set, None, '\n          The color of the stroke  - encoded as RGBA\n          The value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n          NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n        ')
+
+    
+    # Attribute StrokeWidth uses Python identifier StrokeWidth
+    __StrokeWidth = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeWidth'), 'StrokeWidth', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeWidth', pyxb.binding.datatypes.float)
+    __StrokeWidth._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3853, 4)
+    __StrokeWidth._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3853, 4)
+    
+    StrokeWidth = property(__StrokeWidth.value, __StrokeWidth.set, None, '\n          The width of the stroke. Units are set by StrokeWidthUnit.\n        ')
+
+    
+    # Attribute StrokeWidthUnit uses Python identifier StrokeWidthUnit
+    __StrokeWidthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeWidthUnit'), 'StrokeWidthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeWidthUnit', _module_typeBindings.UnitsLength, unicode_default='pixel')
+    __StrokeWidthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3860, 4)
+    __StrokeWidthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3860, 4)
+    
+    StrokeWidthUnit = property(__StrokeWidthUnit.value, __StrokeWidthUnit.set, None, '\n          The units used for the stroke width.\n        ')
+
+    
+    # Attribute StrokeDashArray uses Python identifier StrokeDashArray
+    __StrokeDashArray = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StrokeDashArray'), 'StrokeDashArray', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_StrokeDashArray', pyxb.binding.datatypes.string)
+    __StrokeDashArray._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3867, 4)
+    __StrokeDashArray._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3867, 4)
+    
+    StrokeDashArray = property(__StrokeDashArray.value, __StrokeDashArray.set, None, '\n          e.g. "none", "10 20 30 10"\n        ')
+
+    
+    # Attribute Text uses Python identifier Text
+    __Text = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Text'), 'Text', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_Text', pyxb.binding.datatypes.string)
+    __Text._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3874, 4)
+    __Text._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3874, 4)
+    
+    Text = property(__Text.value, __Text.set, None, None)
+
+    
+    # Attribute FontFamily uses Python identifier FontFamily
+    __FontFamily = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontFamily'), 'FontFamily', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontFamily', _module_typeBindings.STD_ANON_31)
+    __FontFamily._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3875, 4)
+    __FontFamily._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3875, 4)
+    
+    FontFamily = property(__FontFamily.value, __FontFamily.set, None, None)
+
+    
+    # Attribute FontSize uses Python identifier FontSize
+    __FontSize = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontSize'), 'FontSize', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontSize', _module_typeBindings.NonNegativeInt)
+    __FontSize._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3896, 4)
+    __FontSize._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3896, 4)
+    
+    FontSize = property(__FontSize.value, __FontSize.set, None, '\n          Size of the font. Units are set by FontSizeUnit.\n        ')
+
+    
+    # Attribute FontSizeUnit uses Python identifier FontSizeUnit
+    __FontSizeUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontSizeUnit'), 'FontSizeUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontSizeUnit', _module_typeBindings.UnitsLength, unicode_default='pt')
+    __FontSizeUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3903, 4)
+    __FontSizeUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3903, 4)
+    
+    FontSizeUnit = property(__FontSizeUnit.value, __FontSizeUnit.set, None, '\n          The units used for the font size.\n        ')
+
+    
+    # Attribute FontStyle uses Python identifier FontStyle
+    __FontStyle = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FontStyle'), 'FontStyle', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_FontStyle', _module_typeBindings.STD_ANON_32)
+    __FontStyle._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3910, 4)
+    __FontStyle._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3910, 4)
+    
+    FontStyle = property(__FontStyle.value, __FontStyle.set, None, None)
+
+    
+    # Attribute Locked uses Python identifier Locked
+    __Locked = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Locked'), 'Locked', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_Locked', pyxb.binding.datatypes.boolean)
+    __Locked._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3927, 4)
+    __Locked._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3927, 4)
+    
+    Locked = property(__Locked.value, __Locked.set, None, '\n          Controls whether the shape is locked and read only,\n          true is locked, false is editable.\n        ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_ID', _module_typeBindings.ShapeID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3935, 4)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3935, 4)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute TheZ uses Python identifier TheZ
+    __TheZ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheZ'), 'TheZ', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_TheZ', _module_typeBindings.NonNegativeInt)
+    __TheZ._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3936, 4)
+    __TheZ._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3936, 4)
+    
+    TheZ = property(__TheZ.value, __TheZ.set, None, '\n          The z-section the ROI applies to. If not specified then\n          the ROI applies to all the z-sections of the image. [units:none]\n          This is numbered from 0.\n        ')
+
+    
+    # Attribute TheT uses Python identifier TheT
+    __TheT = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheT'), 'TheT', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_TheT', _module_typeBindings.NonNegativeInt)
+    __TheT._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3945, 4)
+    __TheT._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3945, 4)
+    
+    TheT = property(__TheT.value, __TheT.set, None, '\n          The timepoint the ROI applies to. If not specified then\n          the ROI applies to all the timepoints of the image. [units:none]\n          This is numbered from 0.\n        ')
+
+    
+    # Attribute TheC uses Python identifier TheC
+    __TheC = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'TheC'), 'TheC', '__httpwww_openmicroscopy_orgSchemasOME2016_06_Shape_TheC', _module_typeBindings.NonNegativeInt)
+    __TheC._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3954, 4)
+    __TheC._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3954, 4)
+    
+    TheC = property(__TheC.value, __TheC.set, None, '\n          The channel the ROI applies to. If not specified then\n          the ROI applies to all the channels of the image. [units:none]\n          This is numbered from 0.\n        ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __Transform.name() : __Transform
+    })
+    _AttributeMap.update({
+        __FillColor.name() : __FillColor,
+        __FillRule.name() : __FillRule,
+        __StrokeColor.name() : __StrokeColor,
+        __StrokeWidth.name() : __StrokeWidth,
+        __StrokeWidthUnit.name() : __StrokeWidthUnit,
+        __StrokeDashArray.name() : __StrokeDashArray,
+        __Text.name() : __Text,
+        __FontFamily.name() : __FontFamily,
+        __FontSize.name() : __FontSize,
+        __FontSizeUnit.name() : __FontSizeUnit,
+        __FontStyle.name() : __FontStyle,
+        __Locked.name() : __Locked,
+        __ID.name() : __ID,
+        __TheZ.name() : __TheZ,
+        __TheT.name() : __TheT,
+        __TheC.name() : __TheC
+    })
+_module_typeBindings.Shape = Shape
+Namespace.addCategoryObject('typeBinding', 'Shape', Shape)
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_53 (Reference):
+    """Complex type [anonymous] with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4248, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_53_ID', _module_typeBindings.ROIID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4251, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4251, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_53 = CTD_ANON_53
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_54 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        This element identifies microtiter plates within a screen.
+        A plate can belong to more than one screen.
+        The Screen(s) that a plate belongs to are specified by the ScreenRef element.
+        The Plate ID and Name attributes are required.
+        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.
+        i.e. The top-left well of a plate is index (0,0)
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4312, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the plate.\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateAcquisition uses Python identifier PlateAcquisition
+    __PlateAcquisition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition'), 'PlateAcquisition', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06PlateAcquisition', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4660, 2), )
+
+    
+    PlateAcquisition = property(__PlateAcquisition.value, __PlateAcquisition.set, None, '\n        PlateAcquisition is used to describe a single acquisition run for a plate.\n        This object is used to record the set of images acquired in a single\n        acquisition run. The Images for this run are linked to PlateAcquisition\n        through WellSample.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Well uses Python identifier Well
+    __Well = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Well'), 'Well', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_httpwww_openmicroscopy_orgSchemasOME2016_06Well', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4726, 2), )
+
+    
+    Well = property(__Well.value, __Well.set, None, '\n        A Well is a component of the Well/Plate/Screen construct to describe screening applications.\n        A Well has a number of WellSample elements that link to the Images collected in this well.\n        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.\n        The origin for the row and column identifiers is the top left corner of the plate starting at zero.\n        i.e The top left well of a plate is index (0,0)\n      ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_ID', _module_typeBindings.PlateID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4334, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4334, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4335, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4335, 6)
+    
+    Name = property(__Name.value, __Name.set, None, '\n            The Name identifies the plate to the user.\n            It is used much like the ID, and so must be\n            unique within the document.\n\n            If a plate name is not available when one is needed\n            it will be constructed in the following order:\n            1. If name is available use it.\n            2. If not use "Start time - End time"\n            (NOTE: Not a subtraction! A string representation\n            of the two times separated by a dash.)\n            3. If these times are not available use the Plate ID.\n          ')
+
+    
+    # Attribute Status uses Python identifier Status
+    __Status = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Status'), 'Status', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Status', pyxb.binding.datatypes.string)
+    __Status._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4352, 6)
+    __Status._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4352, 6)
+    
+    Status = property(__Status.value, __Status.set, None, '\n            A textual annotation of the current state of the plate with respect to the\n            experiment work-flow; e.g.\n            1. Seed cell: done; 2. Transfection: done;      3. Gel doc: todo.\n          ')
+
+    
+    # Attribute ExternalIdentifier uses Python identifier ExternalIdentifier
+    __ExternalIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExternalIdentifier'), 'ExternalIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_ExternalIdentifier', pyxb.binding.datatypes.string)
+    __ExternalIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4361, 6)
+    __ExternalIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4361, 6)
+    
+    ExternalIdentifier = property(__ExternalIdentifier.value, __ExternalIdentifier.set, None, '\n            The ExternalIdentifier attribute may contain a reference to an external database.\n          ')
+
+    
+    # Attribute ColumnNamingConvention uses Python identifier ColumnNamingConvention
+    __ColumnNamingConvention = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ColumnNamingConvention'), 'ColumnNamingConvention', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_ColumnNamingConvention', _module_typeBindings.NamingConvention)
+    __ColumnNamingConvention._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4368, 6)
+    __ColumnNamingConvention._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4368, 6)
+    
+    ColumnNamingConvention = property(__ColumnNamingConvention.value, __ColumnNamingConvention.set, None, '\n            The ColumnNamingConvention\n          ')
+
+    
+    # Attribute RowNamingConvention uses Python identifier RowNamingConvention
+    __RowNamingConvention = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RowNamingConvention'), 'RowNamingConvention', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_RowNamingConvention', _module_typeBindings.NamingConvention)
+    __RowNamingConvention._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4375, 6)
+    __RowNamingConvention._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4375, 6)
+    
+    RowNamingConvention = property(__RowNamingConvention.value, __RowNamingConvention.set, None, '\n            The RowNamingConvention\n          ')
+
+    
+    # Attribute WellOriginX uses Python identifier WellOriginX
+    __WellOriginX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginX'), 'WellOriginX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginX', pyxb.binding.datatypes.float)
+    __WellOriginX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4382, 6)
+    __WellOriginX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4382, 6)
+    
+    WellOriginX = property(__WellOriginX.value, __WellOriginX.set, None, '\n            This defines the X position to use for the origin of the\n            fields (individual images) taken in a well. It is used\n            with the X in the WellSample to display the fields\n            in the correct position relative to each other. Each Well\n            in the plate has the same well origin. Units are set by WellOriginXUnit.\n\n            In the OMERO clients by convention we display the WellOrigin\n            in the center of the view.\n          ')
+
+    
+    # Attribute WellOriginXUnit uses Python identifier WellOriginXUnit
+    __WellOriginXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginXUnit'), 'WellOriginXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginXUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __WellOriginXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4396, 6)
+    __WellOriginXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4396, 6)
+    
+    WellOriginXUnit = property(__WellOriginXUnit.value, __WellOriginXUnit.set, None, 'The units of the well origin in X - default:reference frame.')
+
+    
+    # Attribute WellOriginY uses Python identifier WellOriginY
+    __WellOriginY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginY'), 'WellOriginY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginY', pyxb.binding.datatypes.float)
+    __WellOriginY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4401, 6)
+    __WellOriginY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4401, 6)
+    
+    WellOriginY = property(__WellOriginY.value, __WellOriginY.set, None, '\n            This defines the Y position to use for the origin of the\n            fields (individual images) taken in a well. It is used\n            with the Y in the WellSample to display the fields\n            in the correct position relative to each other. Each Well\n            in the plate has the same well origin.  Units are set by WellOriginYUnit.\n\n            In the OMERO clients by convention we display the WellOrigin\n            in the center of the view.\n          ')
+
+    
+    # Attribute WellOriginYUnit uses Python identifier WellOriginYUnit
+    __WellOriginYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WellOriginYUnit'), 'WellOriginYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_WellOriginYUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __WellOriginYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4415, 6)
+    __WellOriginYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4415, 6)
+    
+    WellOriginYUnit = property(__WellOriginYUnit.value, __WellOriginYUnit.set, None, 'The units of the well origin in Y - default:reference frame.')
+
+    
+    # Attribute Rows uses Python identifier Rows
+    __Rows = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Rows'), 'Rows', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Rows', _module_typeBindings.PositiveInt)
+    __Rows._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4420, 6)
+    __Rows._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4420, 6)
+    
+    Rows = property(__Rows.value, __Rows.set, None, '\n            The number of rows in the plate\n          ')
+
+    
+    # Attribute Columns uses Python identifier Columns
+    __Columns = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Columns'), 'Columns', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_Columns', _module_typeBindings.PositiveInt)
+    __Columns._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4427, 6)
+    __Columns._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4427, 6)
+    
+    Columns = property(__Columns.value, __Columns.set, None, '\n            The number of columns in the plate\n          ')
+
+    
+    # Attribute FieldIndex uses Python identifier FieldIndex
+    __FieldIndex = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FieldIndex'), 'FieldIndex', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_54_FieldIndex', _module_typeBindings.NonNegativeInt)
+    __FieldIndex._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4434, 6)
+    __FieldIndex._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4434, 6)
+    
+    FieldIndex = property(__FieldIndex.value, __FieldIndex.set, None, '\n            The index of the WellSample to display as the default Field\n          ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __Description.name() : __Description,
+        __PlateAcquisition.name() : __PlateAcquisition,
+        __Well.name() : __Well
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name,
+        __Status.name() : __Status,
+        __ExternalIdentifier.name() : __ExternalIdentifier,
+        __ColumnNamingConvention.name() : __ColumnNamingConvention,
+        __RowNamingConvention.name() : __RowNamingConvention,
+        __WellOriginX.name() : __WellOriginX,
+        __WellOriginXUnit.name() : __WellOriginXUnit,
+        __WellOriginY.name() : __WellOriginY,
+        __WellOriginYUnit.name() : __WellOriginYUnit,
+        __Rows.name() : __Rows,
+        __Columns.name() : __Columns,
+        __FieldIndex.name() : __FieldIndex
+    })
+_module_typeBindings.CTD_ANON_54 = CTD_ANON_54
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_55 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        Reagent is used to describe a chemical or some other physical experimental parameter.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4505, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A long description for the reagent.\n            ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_ID', _module_typeBindings.ReagentID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4525, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4525, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4526, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4526, 6)
+    
+    Name = property(__Name.value, __Name.set, None, '\n            A short name for the reagent\n          ')
+
+    
+    # Attribute ReagentIdentifier uses Python identifier ReagentIdentifier
+    __ReagentIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReagentIdentifier'), 'ReagentIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_55_ReagentIdentifier', pyxb.binding.datatypes.string)
+    __ReagentIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4533, 6)
+    __ReagentIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4533, 6)
+    
+    ReagentIdentifier = property(__ReagentIdentifier.value, __ReagentIdentifier.set, None, '\n            This is a reference to an external (to OME) representation of the Reagent.\n            It serves as a foreign key into an external database. - It is sometimes referred to as ExternalIdentifier.\n          ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __Description.name() : __Description
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name,
+        __ReagentIdentifier.name() : __ReagentIdentifier
+    })
+_module_typeBindings.CTD_ANON_55 = CTD_ANON_55
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_56 (Reference):
+    """Complex type [anonymous] with content type EMPTY"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4545, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_56_ID', _module_typeBindings.ReagentID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4548, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4548, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_56 = CTD_ANON_56
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_57 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        The Screen element is a grouping for Plates.
+        The required attribute is the Screen's Name and ID - both must be unique within the document.
+        The Screen element may contain an ExternalRef attribute that refers to an external database.
+        A description of the screen may be specified in the Description element.
+        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.
+        Plates contain one or more ScreenRef elements to specify what screens they belong to.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4572, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Reagent uses Python identifier Reagent
+    __Reagent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Reagent'), 'Reagent', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06Reagent', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4498, 2), )
+
+    
+    Reagent = property(__Reagent.value, __Reagent.set, None, '\n        Reagent is used to describe a chemical or some other physical experimental parameter.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the screen.\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}PlateRef uses Python identifier PlateRef
+    __PlateRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'PlateRef'), 'PlateRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_httpwww_openmicroscopy_orgSchemasOME2016_06PlateRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8), )
+
+    
+    PlateRef = property(__PlateRef.value, __PlateRef.set, None, '\n              The PlateRef element is a reference to a Plate element.\n              Screen elements may have one or more PlateRef elements to define the plates that are part of the screen.\n              Plates may belong to more than one screen.\n            ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ID', _module_typeBindings.ScreenID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4610, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4610, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4611, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4611, 6)
+    
+    Name = property(__Name.value, __Name.set, None, None)
+
+    
+    # Attribute ProtocolIdentifier uses Python identifier ProtocolIdentifier
+    __ProtocolIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ProtocolIdentifier'), 'ProtocolIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ProtocolIdentifier', pyxb.binding.datatypes.string)
+    __ProtocolIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4612, 6)
+    __ProtocolIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4612, 6)
+    
+    ProtocolIdentifier = property(__ProtocolIdentifier.value, __ProtocolIdentifier.set, None, '\n            A pointer to an externally defined protocol, usually in a screening database.\n          ')
+
+    
+    # Attribute ProtocolDescription uses Python identifier ProtocolDescription
+    __ProtocolDescription = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ProtocolDescription'), 'ProtocolDescription', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ProtocolDescription', pyxb.binding.datatypes.string)
+    __ProtocolDescription._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4619, 6)
+    __ProtocolDescription._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4619, 6)
+    
+    ProtocolDescription = property(__ProtocolDescription.value, __ProtocolDescription.set, None, '\n            A description of the screen protocol; may contain very detailed information to\n            reproduce some of that found in a screening database.\n          ')
+
+    
+    # Attribute ReagentSetDescription uses Python identifier ReagentSetDescription
+    __ReagentSetDescription = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReagentSetDescription'), 'ReagentSetDescription', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ReagentSetDescription', pyxb.binding.datatypes.string)
+    __ReagentSetDescription._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4627, 6)
+    __ReagentSetDescription._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4627, 6)
+    
+    ReagentSetDescription = property(__ReagentSetDescription.value, __ReagentSetDescription.set, None, '\n            A description of the set of reagents; may contain very detailed information to\n            reproduce some of that information found in a screening database.\n          ')
+
+    
+    # Attribute ReagentSetIdentifier uses Python identifier ReagentSetIdentifier
+    __ReagentSetIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ReagentSetIdentifier'), 'ReagentSetIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_ReagentSetIdentifier', pyxb.binding.datatypes.string)
+    __ReagentSetIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4635, 6)
+    __ReagentSetIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4635, 6)
+    
+    ReagentSetIdentifier = property(__ReagentSetIdentifier.value, __ReagentSetIdentifier.set, None, '\n            A pointer to an externally defined set of reagents, usually in a screening\n            database/automation database.\n          ')
+
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_57_Type', pyxb.binding.datatypes.string)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4643, 6)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4643, 6)
+    
+    Type = property(__Type.value, __Type.set, None, '\n            A human readable identifier for the screen type; e.g. RNAi, cDNA, SiRNA, etc.\n            This string is likely to become an enumeration in future releases.\n          ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __Reagent.name() : __Reagent,
+        __Description.name() : __Description,
+        __PlateRef.name() : __PlateRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name,
+        __ProtocolIdentifier.name() : __ProtocolIdentifier,
+        __ProtocolDescription.name() : __ProtocolDescription,
+        __ReagentSetDescription.name() : __ReagentSetDescription,
+        __ReagentSetIdentifier.name() : __ReagentSetIdentifier,
+        __Type.name() : __Type
+    })
+_module_typeBindings.CTD_ANON_57 = CTD_ANON_57
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_58 (Reference):
+    """
+              The PlateRef element is a reference to a Plate element.
+              Screen elements may have one or more PlateRef elements to define the plates that are part of the screen.
+              Plates may belong to more than one screen.
+            """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4596, 10)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_58_ID', _module_typeBindings.PlateID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4599, 16)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4599, 16)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_58 = CTD_ANON_58
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_59 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        PlateAcquisition is used to describe a single acquisition run for a plate.
+        This object is used to record the set of images acquired in a single
+        acquisition run. The Images for this run are linked to PlateAcquisition
+        through WellSample.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4670, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Description uses Python identifier Description
+    __Description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Description'), 'Description', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_httpwww_openmicroscopy_orgSchemasOME2016_06Description', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 8), )
+
+    
+    Description = property(__Description.value, __Description.set, None, '\n              A description for the PlateAcquisition.\n            ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellSampleRef uses Python identifier WellSampleRef
+    __WellSampleRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef'), 'WellSampleRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_httpwww_openmicroscopy_orgSchemasOME2016_06WellSampleRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4883, 2), )
+
+    
+    WellSampleRef = property(__WellSampleRef.value, __WellSampleRef.set, None, '\n        The WellSampleRef element is a reference to a WellSample element.\n      ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_ID', _module_typeBindings.PlateAcquisitionID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4691, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4691, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Name uses Python identifier Name
+    __Name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Name'), 'Name', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_Name', pyxb.binding.datatypes.string)
+    __Name._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4692, 6)
+    __Name._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4692, 6)
+    
+    Name = property(__Name.value, __Name.set, None, None)
+
+    
+    # Attribute EndTime uses Python identifier EndTime
+    __EndTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'EndTime'), 'EndTime', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_EndTime', pyxb.binding.datatypes.dateTime)
+    __EndTime._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4693, 6)
+    __EndTime._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4693, 6)
+    
+    EndTime = property(__EndTime.value, __EndTime.set, None, '\n            Time when the last image of this acquisition was collected\n          ')
+
+    
+    # Attribute StartTime uses Python identifier StartTime
+    __StartTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'StartTime'), 'StartTime', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_StartTime', pyxb.binding.datatypes.dateTime)
+    __StartTime._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4700, 6)
+    __StartTime._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4700, 6)
+    
+    StartTime = property(__StartTime.value, __StartTime.set, None, '\n            Time when the first image of this acquisition was collected\n          ')
+
+    
+    # Attribute MaximumFieldCount uses Python identifier MaximumFieldCount
+    __MaximumFieldCount = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MaximumFieldCount'), 'MaximumFieldCount', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_59_MaximumFieldCount', _module_typeBindings.PositiveInt)
+    __MaximumFieldCount._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4707, 6)
+    __MaximumFieldCount._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4707, 6)
+    
+    MaximumFieldCount = property(__MaximumFieldCount.value, __MaximumFieldCount.set, None, '\n            The maximum number of fields (well samples) in any well\n            in this PlateAcquisition.\n            This is only used to speed up user interaction by stopping\n            the reading of every well sample.\n          ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __Description.name() : __Description,
+        __WellSampleRef.name() : __WellSampleRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Name.name() : __Name,
+        __EndTime.name() : __EndTime,
+        __StartTime.name() : __StartTime,
+        __MaximumFieldCount.name() : __MaximumFieldCount
+    })
+_module_typeBindings.CTD_ANON_59 = CTD_ANON_59
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_60 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        A Well is a component of the Well/Plate/Screen construct to describe screening applications.
+        A Well has a number of WellSample elements that link to the Images collected in this well.
+        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.
+        The origin for the row and column identifiers is the top left corner of the plate starting at zero.
+        i.e The top left well of a plate is index (0,0)
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4737, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef uses Python identifier AnnotationRef
+    __AnnotationRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), 'AnnotationRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_httpwww_openmicroscopy_orgSchemasOME2016_06AnnotationRef', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2), )
+
+    
+    AnnotationRef = property(__AnnotationRef.value, __AnnotationRef.set, None, '\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ')
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ReagentRef uses Python identifier ReagentRef
+    __ReagentRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef'), 'ReagentRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_httpwww_openmicroscopy_orgSchemasOME2016_06ReagentRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4544, 2), )
+
+    
+    ReagentRef = property(__ReagentRef.value, __ReagentRef.set, None, None)
+
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}WellSample uses Python identifier WellSample
+    __WellSample = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'WellSample'), 'WellSample', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_httpwww_openmicroscopy_orgSchemasOME2016_06WellSample', True, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4810, 2), )
+
+    
+    WellSample = property(__WellSample.value, __WellSample.set, None, '\n        WellSample is an individual image that has been captured within a Well.\n      ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_ID', _module_typeBindings.WellID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4751, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4751, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute Column uses Python identifier Column
+    __Column = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Column'), 'Column', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Column', _module_typeBindings.NonNegativeInt, required=True)
+    __Column._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4752, 6)
+    __Column._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4752, 6)
+    
+    Column = property(__Column.value, __Column.set, None, '\n            This is the column index of the well, the origin is the top left corner of the plate\n            with the first column of cells being column zero. i.e top left is (0,0)\n            The combination of Row, Column has to be unique for each well in a plate.\n          ')
+
+    
+    # Attribute Row uses Python identifier Row
+    __Row = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Row'), 'Row', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Row', _module_typeBindings.NonNegativeInt, required=True)
+    __Row._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4761, 6)
+    __Row._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4761, 6)
+    
+    Row = property(__Row.value, __Row.set, None, '\n            This is the row index of the well, the origin is the top left corner of the plate\n            with the first row of wells being row zero. i.e top left is (0,0)\n            The combination of Row, Column has to be unique for each well in a plate.\n          ')
+
+    
+    # Attribute ExternalDescription uses Python identifier ExternalDescription
+    __ExternalDescription = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExternalDescription'), 'ExternalDescription', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_ExternalDescription', pyxb.binding.datatypes.string)
+    __ExternalDescription._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4770, 6)
+    __ExternalDescription._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4770, 6)
+    
+    ExternalDescription = property(__ExternalDescription.value, __ExternalDescription.set, None, '\n            A description of the externally defined identifier for this plate.\n          ')
+
+    
+    # Attribute ExternalIdentifier uses Python identifier ExternalIdentifier
+    __ExternalIdentifier = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ExternalIdentifier'), 'ExternalIdentifier', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_ExternalIdentifier', pyxb.binding.datatypes.string)
+    __ExternalIdentifier._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4777, 6)
+    __ExternalIdentifier._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4777, 6)
+    
+    ExternalIdentifier = property(__ExternalIdentifier.value, __ExternalIdentifier.set, None, '\n            The ExternalIdentifier attribute may contain a reference to an external database.\n          ')
+
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Type', pyxb.binding.datatypes.string)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4784, 6)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4784, 6)
+    
+    Type = property(__Type.value, __Type.set, None, '\n            A human readable identifier for the screening status.\n            e.g. empty, positive control, negative control, control, experimental, etc.\n          ')
+
+    
+    # Attribute Color uses Python identifier Color
+    __Color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Color'), 'Color', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_60_Color', _module_typeBindings.Color, unicode_default='-1')
+    __Color._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4792, 6)
+    __Color._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4792, 6)
+    
+    Color = property(__Color.value, __Color.set, None, '\n            A marker color used to highlight the well - encoded as RGBA\n            The default value "-1" is #FFFFFFFF so solid white (it is a signed 32 bit value)\n            NOTE: Prior to the 2012-06 schema the default value was incorrect and produced a transparent red not solid white.\n          ')
+
+    _ElementMap.update({
+        __AnnotationRef.name() : __AnnotationRef,
+        __ReagentRef.name() : __ReagentRef,
+        __WellSample.name() : __WellSample
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __Column.name() : __Column,
+        __Row.name() : __Row,
+        __ExternalDescription.name() : __ExternalDescription,
+        __ExternalIdentifier.name() : __ExternalIdentifier,
+        __Type.name() : __Type,
+        __Color.name() : __Color
+    })
+_module_typeBindings.CTD_ANON_60 = CTD_ANON_60
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_61 (pyxb.binding.basis.complexTypeDefinition):
+    """
+        WellSample is an individual image that has been captured within a Well.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4817, 4)
+    _ElementMap = {}
+    _AttributeMap = {}
+    # Base type is pyxb.binding.datatypes.anyType
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}ImageRef uses Python identifier ImageRef
+    __ImageRef = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), 'ImageRef', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_httpwww_openmicroscopy_orgSchemasOME2016_06ImageRef', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2), )
+
+    
+    ImageRef = property(__ImageRef.value, __ImageRef.set, None, '\n        The ImageRef element is a reference to an Image element.\n      ')
+
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_ID', _module_typeBindings.WellSampleID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4828, 6)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4828, 6)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    
+    # Attribute PositionX uses Python identifier PositionX
+    __PositionX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionX'), 'PositionX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionX', pyxb.binding.datatypes.float)
+    __PositionX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4829, 6)
+    __PositionX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4829, 6)
+    
+    PositionX = property(__PositionX.value, __PositionX.set, None, '\n            The X position of the field (image) within the well relative to\n            the well origin defined on the Plate. Units are set by PositionXUnit.\n          ')
+
+    
+    # Attribute PositionXUnit uses Python identifier PositionXUnit
+    __PositionXUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionXUnit'), 'PositionXUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionXUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __PositionXUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4837, 6)
+    __PositionXUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4837, 6)
+    
+    PositionXUnit = property(__PositionXUnit.value, __PositionXUnit.set, None, 'The units of the position in X - default:reference frame.')
+
+    
+    # Attribute PositionY uses Python identifier PositionY
+    __PositionY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionY'), 'PositionY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionY', pyxb.binding.datatypes.float)
+    __PositionY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4842, 6)
+    __PositionY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4842, 6)
+    
+    PositionY = property(__PositionY.value, __PositionY.set, None, '\n            The Y position of the field (image) within the well relative to\n            the well origin defined on the Plate. Units are set by PositionYUnit.\n          ')
+
+    
+    # Attribute PositionYUnit uses Python identifier PositionYUnit
+    __PositionYUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PositionYUnit'), 'PositionYUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_PositionYUnit', _module_typeBindings.UnitsLength, unicode_default='reference frame')
+    __PositionYUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4850, 6)
+    __PositionYUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4850, 6)
+    
+    PositionYUnit = property(__PositionYUnit.value, __PositionYUnit.set, None, 'The units of the position in Y - default:reference frame.')
+
+    
+    # Attribute Timepoint uses Python identifier Timepoint
+    __Timepoint = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Timepoint'), 'Timepoint', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_Timepoint', pyxb.binding.datatypes.dateTime)
+    __Timepoint._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4855, 6)
+    __Timepoint._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4855, 6)
+    
+    Timepoint = property(__Timepoint.value, __Timepoint.set, None, '\n            The time-point at which the image started to be collected\n          ')
+
+    
+    # Attribute Index uses Python identifier Index
+    __Index = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Index'), 'Index', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_61_Index', _module_typeBindings.NonNegativeInt, required=True)
+    __Index._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4862, 6)
+    __Index._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4862, 6)
+    
+    Index = property(__Index.value, __Index.set, None, '\n            This records the order of the well samples. Each\n            index should be unique for a given plate but they do not\n            have to be sequential, there may be gaps if part of the\n            dataset is missing. In the user interface the displayed\n            value of the index will be calculated modulo the number\n            of PlateAcquisitions for the plate.\n          ')
+
+    _ElementMap.update({
+        __ImageRef.name() : __ImageRef
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID,
+        __PositionX.name() : __PositionX,
+        __PositionXUnit.name() : __PositionXUnit,
+        __PositionY.name() : __PositionY,
+        __PositionYUnit.name() : __PositionYUnit,
+        __Timepoint.name() : __Timepoint,
+        __Index.name() : __Index
+    })
+_module_typeBindings.CTD_ANON_61 = CTD_ANON_61
+
+
+# Complex type [anonymous] with content type EMPTY
+class CTD_ANON_62 (Reference):
+    """
+        The WellSampleRef element is a reference to a WellSample element.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4889, 4)
+    _ElementMap = Reference._ElementMap.copy()
+    _AttributeMap = Reference._AttributeMap.copy()
+    # Base type is Reference
+    
+    # Attribute ID uses Python identifier ID
+    __ID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ID'), 'ID', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_62_ID', _module_typeBindings.WellSampleID, required=True)
+    __ID._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4892, 10)
+    __ID._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4892, 10)
+    
+    ID = property(__ID.value, __ID.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __ID.name() : __ID
+    })
+_module_typeBindings.CTD_ANON_62 = CTD_ANON_62
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_63 (LightSource):
+    """
+        Laser types are specified using two attributes - the Type and the LaserMedium.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2504, 4)
+    _ElementMap = LightSource._ElementMap.copy()
+    _AttributeMap = LightSource._AttributeMap.copy()
+    # Base type is LightSource
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Pump uses Python identifier Pump
+    __Pump = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Pump'), 'Pump', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_httpwww_openmicroscopy_orgSchemasOME2016_06Pump', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2778, 2), )
+
+    
+    Pump = property(__Pump.value, __Pump.set, None, "\n        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).\n      ")
+
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Type', _module_typeBindings.STD_ANON_18)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2517, 10)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2517, 10)
+    
+    Type = property(__Type.value, __Type.set, None, '\n                Type is the general category of laser.\n              ')
+
+    
+    # Attribute LaserMedium uses Python identifier LaserMedium
+    __LaserMedium = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'LaserMedium'), 'LaserMedium', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_LaserMedium', _module_typeBindings.STD_ANON_19)
+    __LaserMedium._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2536, 10)
+    __LaserMedium._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2536, 10)
+    
+    LaserMedium = property(__LaserMedium.value, __LaserMedium.set, None, '\n                The Medium attribute specifies the actual lasing medium\n                for a given laser type.\n              ')
+
+    
+    # Attribute Wavelength uses Python identifier Wavelength
+    __Wavelength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Wavelength'), 'Wavelength', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Wavelength', _module_typeBindings.PositiveFloat)
+    __Wavelength._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2590, 10)
+    __Wavelength._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2590, 10)
+    
+    Wavelength = property(__Wavelength.value, __Wavelength.set, None, '\n                The Wavelength of the laser. Units are set by WavelengthUnit.\n              ')
+
+    
+    # Attribute WavelengthUnit uses Python identifier WavelengthUnit
+    __WavelengthUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'WavelengthUnit'), 'WavelengthUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_WavelengthUnit', _module_typeBindings.UnitsLength, unicode_default='nm')
+    __WavelengthUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2597, 10)
+    __WavelengthUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2597, 10)
+    
+    WavelengthUnit = property(__WavelengthUnit.value, __WavelengthUnit.set, None, 'The units of the Wavelength - default:nanometres[nm].')
+
+    
+    # Attribute FrequencyMultiplication uses Python identifier FrequencyMultiplication
+    __FrequencyMultiplication = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'FrequencyMultiplication'), 'FrequencyMultiplication', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_FrequencyMultiplication', _module_typeBindings.PositiveInt)
+    __FrequencyMultiplication._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2602, 10)
+    __FrequencyMultiplication._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2602, 10)
+    
+    FrequencyMultiplication = property(__FrequencyMultiplication.value, __FrequencyMultiplication.set, None, '\n                FrequencyMultiplication that may be specified. [units:none]\n              ')
+
+    
+    # Attribute Tuneable uses Python identifier Tuneable
+    __Tuneable = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Tuneable'), 'Tuneable', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Tuneable', pyxb.binding.datatypes.boolean)
+    __Tuneable._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2609, 10)
+    __Tuneable._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2609, 10)
+    
+    Tuneable = property(__Tuneable.value, __Tuneable.set, None, '\n                Whether or not the laser is Tuneable [flag]\n              ')
+
+    
+    # Attribute Pulse uses Python identifier Pulse
+    __Pulse = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Pulse'), 'Pulse', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_Pulse', _module_typeBindings.STD_ANON_20)
+    __Pulse._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2616, 10)
+    __Pulse._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2616, 10)
+    
+    Pulse = property(__Pulse.value, __Pulse.set, None, '\n                The Pulse mode of the laser.\n              ')
+
+    
+    # Attribute PockelCell uses Python identifier PockelCell
+    __PockelCell = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PockelCell'), 'PockelCell', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_PockelCell', pyxb.binding.datatypes.boolean)
+    __PockelCell._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2633, 10)
+    __PockelCell._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2633, 10)
+    
+    PockelCell = property(__PockelCell.value, __PockelCell.set, None, '\n                If true the laser has a PockelCell to rotate the polarization of the beam. [flag]\n              ')
+
+    
+    # Attribute RepetitionRate uses Python identifier RepetitionRate
+    __RepetitionRate = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RepetitionRate'), 'RepetitionRate', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_RepetitionRate', pyxb.binding.datatypes.float)
+    __RepetitionRate._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2640, 10)
+    __RepetitionRate._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2640, 10)
+    
+    RepetitionRate = property(__RepetitionRate.value, __RepetitionRate.set, None, "\n                The is the rate in Hz at which the laser pulses if\n                the Pulse type is 'Repetitive'. hertz[Hz]\n                Units are set by RepetitionRateUnit.\n              ")
+
+    
+    # Attribute RepetitionRateUnit uses Python identifier RepetitionRateUnit
+    __RepetitionRateUnit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RepetitionRateUnit'), 'RepetitionRateUnit', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_63_RepetitionRateUnit', _module_typeBindings.UnitsFrequency, unicode_default='Hz')
+    __RepetitionRateUnit._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2649, 10)
+    __RepetitionRateUnit._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2649, 10)
+    
+    RepetitionRateUnit = property(__RepetitionRateUnit.value, __RepetitionRateUnit.set, None, 'The units of the RepetitionRate - default:hertz[Hz].')
+
+    _ElementMap.update({
+        __Pump.name() : __Pump
+    })
+    _AttributeMap.update({
+        __Type.name() : __Type,
+        __LaserMedium.name() : __LaserMedium,
+        __Wavelength.name() : __Wavelength,
+        __WavelengthUnit.name() : __WavelengthUnit,
+        __FrequencyMultiplication.name() : __FrequencyMultiplication,
+        __Tuneable.name() : __Tuneable,
+        __Pulse.name() : __Pulse,
+        __PockelCell.name() : __PockelCell,
+        __RepetitionRate.name() : __RepetitionRate,
+        __RepetitionRateUnit.name() : __RepetitionRateUnit
+    })
+_module_typeBindings.CTD_ANON_63 = CTD_ANON_63
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_64 (LightSource):
+    """
+        The Arc element is used to describe various kinds of Arc lamps - Hg, Xe, HgXe.
+        The Power of the Arc is now stored in the LightSource.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2666, 4)
+    _ElementMap = LightSource._ElementMap.copy()
+    _AttributeMap = LightSource._AttributeMap.copy()
+    # Base type is LightSource
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_64_Type', _module_typeBindings.STD_ANON_21)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2669, 10)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2669, 10)
+    
+    Type = property(__Type.value, __Type.set, None, '\n                The type of Arc lamp.\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Type.name() : __Type
+    })
+_module_typeBindings.CTD_ANON_64 = CTD_ANON_64
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_65 (LightSource):
+    """
+        The Filament element is used to describe various kinds of filament bulbs such as Incadescent or Halogen.
+        The Power of the Filament is now stored in the LightSource.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2696, 4)
+    _ElementMap = LightSource._ElementMap.copy()
+    _AttributeMap = LightSource._AttributeMap.copy()
+    # Base type is LightSource
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Type uses Python identifier Type
+    __Type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Type'), 'Type', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_65_Type', _module_typeBindings.STD_ANON_22)
+    __Type._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2699, 10)
+    __Type._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2699, 10)
+    
+    Type = property(__Type.value, __Type.set, None, '\n                The type of filament.\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Type.name() : __Type
+    })
+_module_typeBindings.CTD_ANON_65 = CTD_ANON_65
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_66 (LightSource):
+    """
+        The LightEmittingDiode element is used to describe
+        various kinds of LED lamps.
+
+        As the LightEmittingDiode is inside a LightSource it already has
+        available the values from ManufacturerSpec
+        (Manufacturer, Model, SerialNumber, LotNumber)
+        And the values from LightSource which includes Power in milliwatts
+
+        We have looked at extending this element but have had a problem
+        producing a generic solution.
+
+        Possible attributes talked about adding include:
+        Power in lumens - but this is complicated by multi-channel
+        devices like CoolLED where each channel's power is different
+        Wavelength Range - not a simple value so would require
+        multiple attributes or a child element
+        Angle of Projection - this would be further affected by the
+        optics used for filtering the naked LED or that combine
+        power from multiple devices
+
+        These values are further affected if you over-drive the LED
+        resulting in a more complex system
+
+        Another issue is that LED's may not be used directly for
+        illumination but as drivers for secondary emissions from doped
+        fiber optics. This would require the fiber optics to be modeled.
+
+        Thanks to Paul Goodwin of Applied Precision of information about
+        this topic.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2752, 4)
+    _ElementMap = LightSource._ElementMap.copy()
+    _AttributeMap = LightSource._AttributeMap.copy()
+    # Base type is LightSource
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_66 = CTD_ANON_66
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_67 (LightSource):
+    """
+        The GenericExcitationSource element is used to represent
+        a source as a collection of key/value pairs, stored
+        in a Map. The other lightsource objects should
+        always be used in preference to this if possible.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2768, 4)
+    _ElementMap = LightSource._ElementMap.copy()
+    _AttributeMap = LightSource._AttributeMap.copy()
+    # Base type is LightSource
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Map uses Python identifier Map
+    __Map = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Map'), 'Map', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_67_httpwww_openmicroscopy_orgSchemasOME2016_06Map', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12), )
+
+    
+    Map = property(__Map.value, __Map.set, None, None)
+
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Manufacturer inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute Model inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute SerialNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute LotNumber inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}ManufacturerSpec
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute Power inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    
+    # Attribute PowerUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}LightSource
+    _ElementMap.update({
+        __Map.name() : __Map
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_67 = CTD_ANON_67
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}BasicAnnotation with content type ELEMENT_ONLY
+class BasicAnnotation (Annotation):
+    """
+        An abstract Basic Annotation from which some others are derived.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'BasicAnnotation')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3507, 2)
+    _ElementMap = Annotation._ElementMap.copy()
+    _AttributeMap = Annotation._AttributeMap.copy()
+    # Base type is Annotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.BasicAnnotation = BasicAnnotation
+Namespace.addCategoryObject('typeBinding', 'BasicAnnotation', BasicAnnotation)
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}TextAnnotation with content type ELEMENT_ONLY
+class TextAnnotation (Annotation):
+    """
+        An abstract Text Annotation from which some others are derived.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'TextAnnotation')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3529, 2)
+    _ElementMap = Annotation._ElementMap.copy()
+    _AttributeMap = Annotation._AttributeMap.copy()
+    # Base type is Annotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.TextAnnotation = TextAnnotation
+Namespace.addCategoryObject('typeBinding', 'TextAnnotation', TextAnnotation)
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}TypeAnnotation with content type ELEMENT_ONLY
+class TypeAnnotation (Annotation):
+    """
+        An abstract Type Annotation from which some others are derived.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'TypeAnnotation')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3540, 2)
+    _ElementMap = Annotation._ElementMap.copy()
+    _AttributeMap = Annotation._AttributeMap.copy()
+    # Base type is Annotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.TypeAnnotation = TypeAnnotation
+Namespace.addCategoryObject('typeBinding', 'TypeAnnotation', TypeAnnotation)
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_68 (Annotation):
+    """
+        This annotation is a grouping object. It uses the sequence of
+        annotation refs from the base Annotation to form the list.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3602, 4)
+    _ElementMap = Annotation._ElementMap.copy()
+    _AttributeMap = Annotation._AttributeMap.copy()
+    # Base type is Annotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_68 = CTD_ANON_68
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_69 (Annotation):
+    """
+        An map annotation. The contents of this is a list of key/value pairs.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3734, 4)
+    _ElementMap = Annotation._ElementMap.copy()
+    _AttributeMap = Annotation._AttributeMap.copy()
+    # Base type is Annotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_69_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3738, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_69 = CTD_ANON_69
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_70 (Shape):
+    """
+        A simple rectangle object. If rotation is required apply a
+        transformation at the Shape level.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3973, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute X uses Python identifier X
+    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_X', pyxb.binding.datatypes.float, required=True)
+    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3976, 10)
+    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3976, 10)
+    
+    X = property(__X.value, __X.set, None, '\n                The X value of the left edge or the rectangle. [units pixels]\n              ')
+
+    
+    # Attribute Y uses Python identifier Y
+    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_Y', pyxb.binding.datatypes.float, required=True)
+    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3983, 10)
+    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3983, 10)
+    
+    Y = property(__Y.value, __Y.set, None, '\n                The y value of the top edge or the rectangle. [units pixels]\n              ')
+
+    
+    # Attribute Width uses Python identifier Width
+    __Width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Width'), 'Width', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_Width', pyxb.binding.datatypes.float, required=True)
+    __Width._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3990, 10)
+    __Width._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3990, 10)
+    
+    Width = property(__Width.value, __Width.set, None, '\n                The width of the rectangle. [units pixels]\n              ')
+
+    
+    # Attribute Height uses Python identifier Height
+    __Height = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Height'), 'Height', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_70_Height', pyxb.binding.datatypes.float, required=True)
+    __Height._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3997, 10)
+    __Height._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3997, 10)
+    
+    Height = property(__Height.value, __Height.set, None, '\n                The height of the rectangle. [units pixels]\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __X.name() : __X,
+        __Y.name() : __Y,
+        __Width.name() : __Width,
+        __Height.name() : __Height
+    })
+_module_typeBindings.CTD_ANON_70 = CTD_ANON_70
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_71 (Shape):
+    """
+        The Mask ROI shape is a link to a BinData object that is
+        a BIT mask drawn on top of the image as an ROI. It is applied
+        at the same scale, pixel to pixel, as the Image the ROI is
+        applied to, unless a transform is applied at the shape level.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4019, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinData uses Python identifier BinData
+    __BinData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinData'), 'BinData', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_httpwww_openmicroscopy_orgSchemasOME2016_06BinData', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2), )
+
+    
+    BinData = property(__BinData.value, __BinData.set, None, 'The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.')
+
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute X uses Python identifier X
+    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_X', pyxb.binding.datatypes.float, required=True)
+    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4025, 10)
+    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4025, 10)
+    
+    X = property(__X.value, __X.set, None, '\n                The X coordinate of the left side of the image. [units pixels]\n              ')
+
+    
+    # Attribute Y uses Python identifier Y
+    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_Y', pyxb.binding.datatypes.float, required=True)
+    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4032, 10)
+    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4032, 10)
+    
+    Y = property(__Y.value, __Y.set, None, '\n                The Y coordinate of the top side of the image. [units pixels]\n              ')
+
+    
+    # Attribute Width uses Python identifier Width
+    __Width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Width'), 'Width', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_Width', pyxb.binding.datatypes.float, required=True)
+    __Width._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4039, 10)
+    __Width._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4039, 10)
+    
+    Width = property(__Width.value, __Width.set, None, '\n                The width of the mask. [units pixels]\n              ')
+
+    
+    # Attribute Height uses Python identifier Height
+    __Height = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Height'), 'Height', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_71_Height', pyxb.binding.datatypes.float, required=True)
+    __Height._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4046, 10)
+    __Height._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4046, 10)
+    
+    Height = property(__Height.value, __Height.set, None, '\n                The height of the mask. [units pixels]\n              ')
+
+    _ElementMap.update({
+        __BinData.name() : __BinData
+    })
+    _AttributeMap.update({
+        __X.name() : __X,
+        __Y.name() : __Y,
+        __Width.name() : __Width,
+        __Height.name() : __Height
+    })
+_module_typeBindings.CTD_ANON_71 = CTD_ANON_71
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_72 (Shape):
+    """"""
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4062, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute X uses Python identifier X
+    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_72_X', pyxb.binding.datatypes.float, required=True)
+    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4065, 10)
+    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4065, 10)
+    
+    X = property(__X.value, __X.set, None, '\n                The X coordinate of the point. [units pixels]\n              ')
+
+    
+    # Attribute Y uses Python identifier Y
+    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_72_Y', pyxb.binding.datatypes.float, required=True)
+    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4072, 10)
+    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4072, 10)
+    
+    Y = property(__Y.value, __Y.set, None, '\n                The Y coordinate of the point. [units pixels]\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __X.name() : __X,
+        __Y.name() : __Y
+    })
+_module_typeBindings.CTD_ANON_72 = CTD_ANON_72
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_73 (Shape):
+    """
+        A simple ellipse object. If rotation is required apply a
+        transformation at the Shape level.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4092, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute X uses Python identifier X
+    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_X', pyxb.binding.datatypes.float, required=True)
+    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4095, 10)
+    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4095, 10)
+    
+    X = property(__X.value, __X.set, None, '\n                The X coordinate of the center of the ellipse. [units pixels]\n              ')
+
+    
+    # Attribute Y uses Python identifier Y
+    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_Y', pyxb.binding.datatypes.float, required=True)
+    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4102, 10)
+    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4102, 10)
+    
+    Y = property(__Y.value, __Y.set, None, '\n                The Y coordinate of the center of the ellipse. [units pixels]\n              ')
+
+    
+    # Attribute RadiusX uses Python identifier RadiusX
+    __RadiusX = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RadiusX'), 'RadiusX', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_RadiusX', pyxb.binding.datatypes.float, required=True)
+    __RadiusX._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4109, 10)
+    __RadiusX._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4109, 10)
+    
+    RadiusX = property(__RadiusX.value, __RadiusX.set, None, '\n                The horizontal radius of the ellipse. [units pixels]\n              ')
+
+    
+    # Attribute RadiusY uses Python identifier RadiusY
+    __RadiusY = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'RadiusY'), 'RadiusY', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_73_RadiusY', pyxb.binding.datatypes.float, required=True)
+    __RadiusY._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4116, 10)
+    __RadiusY._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4116, 10)
+    
+    RadiusY = property(__RadiusY.value, __RadiusY.set, None, '\n                The vertical radius of the ellipse. [units pixels]\n              ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __X.name() : __X,
+        __Y.name() : __Y,
+        __RadiusX.name() : __RadiusX,
+        __RadiusY.name() : __RadiusY
+    })
+_module_typeBindings.CTD_ANON_73 = CTD_ANON_73
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_74 (Shape):
+    """
+        A straight line defined by it's end points.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4135, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute X1 uses Python identifier X1
+    __X1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X1'), 'X1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_X1', pyxb.binding.datatypes.float, required=True)
+    __X1._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4138, 10)
+    __X1._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4138, 10)
+    
+    X1 = property(__X1.value, __X1.set, None, ' The X coordinate of the start of the line. [units pixels]\n              ')
+
+    
+    # Attribute Y1 uses Python identifier Y1
+    __Y1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y1'), 'Y1', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_Y1', pyxb.binding.datatypes.float, required=True)
+    __Y1._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4144, 10)
+    __Y1._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4144, 10)
+    
+    Y1 = property(__Y1.value, __Y1.set, None, ' The Y coordinate of the start of the line. [units pixels]\n              ')
+
+    
+    # Attribute X2 uses Python identifier X2
+    __X2 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X2'), 'X2', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_X2', pyxb.binding.datatypes.float, required=True)
+    __X2._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4150, 10)
+    __X2._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4150, 10)
+    
+    X2 = property(__X2.value, __X2.set, None, ' The X coordinate of the end of the line. [units pixels]\n              ')
+
+    
+    # Attribute Y2 uses Python identifier Y2
+    __Y2 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y2'), 'Y2', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_Y2', pyxb.binding.datatypes.float, required=True)
+    __Y2._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4156, 10)
+    __Y2._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4156, 10)
+    
+    Y2 = property(__Y2.value, __Y2.set, None, ' The Y coordinate of the end of the line. [units pixels]\n              ')
+
+    
+    # Attribute MarkerStart uses Python identifier MarkerStart
+    __MarkerStart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerStart'), 'MarkerStart', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_MarkerStart', _module_typeBindings.Marker)
+    __MarkerStart._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4162, 10)
+    __MarkerStart._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4162, 10)
+    
+    MarkerStart = property(__MarkerStart.value, __MarkerStart.set, None, None)
+
+    
+    # Attribute MarkerEnd uses Python identifier MarkerEnd
+    __MarkerEnd = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerEnd'), 'MarkerEnd', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_74_MarkerEnd', _module_typeBindings.Marker)
+    __MarkerEnd._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4163, 10)
+    __MarkerEnd._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4163, 10)
+    
+    MarkerEnd = property(__MarkerEnd.value, __MarkerEnd.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __X1.name() : __X1,
+        __Y1.name() : __Y1,
+        __X2.name() : __X2,
+        __Y2.name() : __Y2,
+        __MarkerStart.name() : __MarkerStart,
+        __MarkerEnd.name() : __MarkerEnd
+    })
+_module_typeBindings.CTD_ANON_74 = CTD_ANON_74
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_75 (Shape):
+    """
+        The Polyline defines open shapes formed of straight
+        lines. Note: Polyline uses counterclockwise winding (this is the
+        default OpenGL behavior)
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4178, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Points uses Python identifier Points
+    __Points = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Points'), 'Points', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_75_Points', pyxb.binding.datatypes.string, required=True)
+    __Points._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4181, 10)
+    __Points._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4181, 10)
+    
+    Points = property(__Points.value, __Points.set, None, ' The points of the polyline are defined as a list of comma\n              separated x,y coordinates seperated by spaces like "x1,y1 x2,y2 x3,y3" e.g.\n              "0,0 1,2 3,5" ')
+
+    
+    # Attribute MarkerStart uses Python identifier MarkerStart
+    __MarkerStart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerStart'), 'MarkerStart', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_75_MarkerStart', _module_typeBindings.Marker)
+    __MarkerStart._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4188, 10)
+    __MarkerStart._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4188, 10)
+    
+    MarkerStart = property(__MarkerStart.value, __MarkerStart.set, None, None)
+
+    
+    # Attribute MarkerEnd uses Python identifier MarkerEnd
+    __MarkerEnd = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'MarkerEnd'), 'MarkerEnd', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_75_MarkerEnd', _module_typeBindings.Marker)
+    __MarkerEnd._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4189, 10)
+    __MarkerEnd._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4189, 10)
+    
+    MarkerEnd = property(__MarkerEnd.value, __MarkerEnd.set, None, None)
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Points.name() : __Points,
+        __MarkerStart.name() : __MarkerStart,
+        __MarkerEnd.name() : __MarkerEnd
+    })
+_module_typeBindings.CTD_ANON_75 = CTD_ANON_75
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_76 (Shape):
+    """
+        The Polygon defines closed shapes formed of straight
+        lines. Note: Polygon uses counterclockwise winding (this is the
+        default OpenGL behavior)
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4204, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Points uses Python identifier Points
+    __Points = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Points'), 'Points', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_76_Points', pyxb.binding.datatypes.string, required=True)
+    __Points._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4207, 10)
+    __Points._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4207, 10)
+    
+    Points = property(__Points.value, __Points.set, None, ' The points of the Polygon are defined as a list of comma\n              separated x,y coordinates seperated by spaces like "x1,y1 x2,y2 x3,y3" e.g.\n              "0,0 1,2 3,5" ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __Points.name() : __Points
+    })
+_module_typeBindings.CTD_ANON_76 = CTD_ANON_76
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_77 (Shape):
+    """
+        The text label. Any transformation should be applied at the
+        shape level.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4227, 4)
+    _ElementMap = Shape._ElementMap.copy()
+    _AttributeMap = Shape._AttributeMap.copy()
+    # Base type is Shape
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Element Transform ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Transform) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FillRule inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeColor inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidth inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeWidthUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute StrokeDashArray inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Text inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontFamily inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSize inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontSizeUnit inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute FontStyle inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute Locked inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheZ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheT inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute TheC inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Shape
+    
+    # Attribute X uses Python identifier X
+    __X = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'X'), 'X', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_77_X', pyxb.binding.datatypes.float, required=True)
+    __X._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4230, 10)
+    __X._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4230, 10)
+    
+    X = property(__X.value, __X.set, None, ' This defines the X coordinate of the current text position\n              of the first character in the string. [units pixels] ')
+
+    
+    # Attribute Y uses Python identifier Y
+    __Y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'Y'), 'Y', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_77_Y', pyxb.binding.datatypes.float, required=True)
+    __Y._DeclarationLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4236, 10)
+    __Y._UseLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4236, 10)
+    
+    Y = property(__Y.value, __Y.set, None, ' This defines the Y coordinate of the current text position\n              of the first character in the string. [units pixels] ')
+
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        __X.name() : __X,
+        __Y.name() : __Y
+    })
+_module_typeBindings.CTD_ANON_77 = CTD_ANON_77
+
+
+# Complex type {http://www.openmicroscopy.org/Schemas/OME/2016-06}NumericAnnotation with content type ELEMENT_ONLY
+class NumericAnnotation (BasicAnnotation):
+    """
+        An abstract Numeric Annotation from which some others are derived.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'NumericAnnotation')
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3518, 2)
+    _ElementMap = BasicAnnotation._ElementMap.copy()
+    _AttributeMap = BasicAnnotation._AttributeMap.copy()
+    # Base type is BasicAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.NumericAnnotation = NumericAnnotation
+Namespace.addCategoryObject('typeBinding', 'NumericAnnotation', NumericAnnotation)
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_78 (TypeAnnotation):
+    """
+        A file object annotation
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3561, 4)
+    _ElementMap = TypeAnnotation._ElementMap.copy()
+    _AttributeMap = TypeAnnotation._AttributeMap.copy()
+    # Base type is TypeAnnotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}BinaryFile uses Python identifier BinaryFile
+    __BinaryFile = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile'), 'BinaryFile', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_78_httpwww_openmicroscopy_orgSchemasOME2016_06BinaryFile', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3362, 2), )
+
+    
+    BinaryFile = property(__BinaryFile.value, __BinaryFile.set, None, 'Describes a binary file.')
+
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __BinaryFile.name() : __BinaryFile
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_78 = CTD_ANON_78
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_79 (TextAnnotation):
+    """
+        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3578, 4)
+    _ElementMap = TextAnnotation._ElementMap.copy()
+    _AttributeMap = TextAnnotation._AttributeMap.copy()
+    # Base type is TextAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_79_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3582, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_79 = CTD_ANON_79
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_80 (TextAnnotation):
+    """
+        A simple comment annotation
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3615, 4)
+    _ElementMap = TextAnnotation._ElementMap.copy()
+    _AttributeMap = TextAnnotation._AttributeMap.copy()
+    # Base type is TextAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_80_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3619, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_80 = CTD_ANON_80
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_81 (BasicAnnotation):
+    """
+        A simple boolean annotation of type xsd:boolean
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3666, 4)
+    _ElementMap = BasicAnnotation._ElementMap.copy()
+    _AttributeMap = BasicAnnotation._AttributeMap.copy()
+    # Base type is BasicAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_81_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3670, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_81 = CTD_ANON_81
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_82 (BasicAnnotation):
+    """
+        A date/time annotation of type xsd:dateTime
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3683, 4)
+    _ElementMap = BasicAnnotation._ElementMap.copy()
+    _AttributeMap = BasicAnnotation._AttributeMap.copy()
+    # Base type is BasicAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_82_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3687, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_82 = CTD_ANON_82
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_83 (TextAnnotation):
+    """
+        A tag annotation (represents a tag or a tagset)
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3700, 4)
+    _ElementMap = TextAnnotation._ElementMap.copy()
+    _AttributeMap = TextAnnotation._AttributeMap.copy()
+    # Base type is TextAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_83_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3704, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_83 = CTD_ANON_83
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_84 (BasicAnnotation):
+    """
+        A ontology term annotation
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3717, 4)
+    _ElementMap = BasicAnnotation._ElementMap.copy()
+    _AttributeMap = BasicAnnotation._AttributeMap.copy()
+    # Base type is BasicAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_84_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3721, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_84 = CTD_ANON_84
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_85 (NumericAnnotation):
+    """
+        A simple numerical annotation of type xsd:long
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3632, 4)
+    _ElementMap = NumericAnnotation._ElementMap.copy()
+    _AttributeMap = NumericAnnotation._AttributeMap.copy()
+    # Base type is NumericAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_85_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3636, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_85 = CTD_ANON_85
+
+
+# Complex type [anonymous] with content type ELEMENT_ONLY
+class CTD_ANON_86 (NumericAnnotation):
+    """
+        A simple numerical annotation of type xsd:double
+      """
+    _TypeDefinition = None
+    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
+    _Abstract = False
+    _ExpandedName = None
+    _XSDLocation = pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3649, 4)
+    _ElementMap = NumericAnnotation._ElementMap.copy()
+    _AttributeMap = NumericAnnotation._AttributeMap.copy()
+    # Base type is NumericAnnotation
+    
+    # Element AnnotationRef ({http://www.openmicroscopy.org/Schemas/OME/2016-06}AnnotationRef) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element Description ({http://www.openmicroscopy.org/Schemas/OME/2016-06}Description) inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Element {http://www.openmicroscopy.org/Schemas/OME/2016-06}Value uses Python identifier Value
+    __Value = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Value'), 'Value', '__httpwww_openmicroscopy_orgSchemasOME2016_06_CTD_ANON_86_httpwww_openmicroscopy_orgSchemasOME2016_06Value', False, pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3653, 12), )
+
+    
+    Value = property(__Value.value, __Value.set, None, None)
+
+    
+    # Attribute ID inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Namespace_ inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    
+    # Attribute Annotator inherited from {http://www.openmicroscopy.org/Schemas/OME/2016-06}Annotation
+    _ElementMap.update({
+        __Value.name() : __Value
+    })
+    _AttributeMap.update({
+        
+    })
+_module_typeBindings.CTD_ANON_86 = CTD_ANON_86
+
+
+MetadataOnly = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly'), pyxb.binding.datatypes.anyType, documentation='\n        This place holder means there is on pixel data in this file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 784, 2))
+Namespace.addCategoryObject('elementBinding', MetadataOnly.name().localName(), MetadataOnly)
+
+LightPath = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightPath'), CTD_ANON_, documentation='A description of the light path', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2411, 2))
+Namespace.addCategoryObject('elementBinding', LightPath.name().localName(), LightPath)
+
+Rights = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Rights'), CTD_ANON_2, documentation='\n        The rights holder of this data and the rights held.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2794, 2))
+Namespace.addCategoryObject('elementBinding', Rights.name().localName(), Rights)
+
+StructuredAnnotations = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations'), CTD_ANON_3, documentation='\n        An unordered collection of annotation attached to objects in the OME data model.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3413, 2))
+Namespace.addCategoryObject('elementBinding', StructuredAnnotations.name().localName(), StructuredAnnotations)
+
+OME = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'OME'), CTD_ANON_6, documentation='\n        The OME element is a container for all information objects accessible by OME.\n        These information objects include descriptions of the imaging experiments\n        and the people who perform them, descriptions of the microscope, the resulting\n        images and how they were acquired, the analyses performed on those images,\n        and the analysis results themselves.\n        An OME file may contain any or all of this information.\n\n        With the creation of the Metadata Only Companion OME-XML and Binary Only OME-TIFF files\n        the top level OME node has changed slightly.\n        It can EITHER:\n        Contain all the previously expected elements\n        OR:\n        Contain a single BinaryOnly element that points at\n        its Metadata Only Companion OME-XML file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 40, 2))
+Namespace.addCategoryObject('elementBinding', OME.name().localName(), OME)
+
+Plane = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plane'), CTD_ANON_8, documentation='\n        The Plane object holds microscope stage and image timing data\n        for a given channel/z-section/timepoint.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 478, 2))
+Namespace.addCategoryObject('elementBinding', Plane.name().localName(), Plane)
+
+TiffData = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TiffData'), CTD_ANON_9, documentation='\n        This described the location of the pixel data in a tiff file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 792, 2))
+Namespace.addCategoryObject('elementBinding', TiffData.name().localName(), TiffData)
+
+StageLabel = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StageLabel'), CTD_ANON_11, documentation="\n        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 871, 2))
+Namespace.addCategoryObject('elementBinding', StageLabel.name().localName(), StageLabel)
+
+Microscope = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Microscope'), CTD_ANON_12, documentation="The microscope's manufacturer specification.", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1016, 2))
+Namespace.addCategoryObject('elementBinding', Microscope.name().localName(), Microscope)
+
+ImagingEnvironment = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment'), CTD_ANON_13, documentation='\n        This describes the environment that the biological sample was in\n        during the experiment.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1041, 2))
+Namespace.addCategoryObject('elementBinding', ImagingEnvironment.name().localName(), ImagingEnvironment)
+
+TransmittanceRange = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange'), CTD_ANON_14, documentation='\n        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2325, 2))
+Namespace.addCategoryObject('elementBinding', TransmittanceRange.name().localName(), TransmittanceRange)
+
+External = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'External'), CTD_ANON_15, documentation='Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.\n      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3288, 2))
+Namespace.addCategoryObject('elementBinding', External.name().localName(), External)
+
+BinaryFile = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile'), CTD_ANON_16, documentation='Describes a binary file.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3362, 2))
+Namespace.addCategoryObject('elementBinding', BinaryFile.name().localName(), BinaryFile)
+
+Image = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Image'), CTD_ANON_17, documentation="\n        This element describes the actual image and its meta-data.\n        The elements that are references (ending in Ref or Settings) refer to\n        elements defined outside of the Image element. Ref elements are simple\n        links, while Settings elements are links with additional values.\n\n        If any of the required Image attributes or elements are missing, its\n        guaranteed to be an invalid document. The required attributes and\n        elements are ID and Pixels.\n\n        ExperimenterRef is required for all Images with well formed LSIDs.\n        ImageType is a vendor-specific designation of the type of image this is.\n        Examples of ImageType include 'STK', 'SoftWorx', etc.\n        The Name attributes are in all cases the name of the element\n        instance. In this case, the name of the image, not necessarily the filename.\n        Physical size of pixels are microns[\xb5m].\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 209, 2))
+Namespace.addCategoryObject('elementBinding', Image.name().localName(), Image)
+
+Pixels = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pixels'), CTD_ANON_18, documentation="\n        Pixels is going to be removed in the future, but it is still required.\n\n        This is just notice that the contents of Pixels will be\n        moved up to Image in a future release. This is because there\n        has only been 1 Pixels object in each Image for some time.\n        The concept of multiple Pixels sets for one Image failed to\n        take off. It is therefore redundant.\n\n        The Image will be unreadable if any of the required Pixel attributes are missing.\n\n        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded\n        in Base64.\n        Or the Pixels may be stored in TIFF format.\n\n        The Pixels element should contain a list of BinData or TiffData, each containing a\n        single plane of pixels. These Pixels elements, when read in document order,\n        must produce a 5-D pixel array of the size specified in this element, and in the\n        dimension order specified by 'DimensionOrder'.\n\n        All of the values in the Pixels object when present should match the same value\n        stored in any associated TIFF format (e.g. SizeX should be the same). Where there\n        is a mismatch our readers will take the value from the TIFF structure as overriding\n        the value in the OME-XML. This is simply a pragmatic decision as it increases the\n        likelihood of reading data from a slightly incorrect file.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 307, 2))
+Namespace.addCategoryObject('elementBinding', Pixels.name().localName(), Pixels)
+
+Channel = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Channel'), CTD_ANON_19, documentation="\n        There must be one per channel in the Image, even for a single-plane image.\n        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more\n        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum\n        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are\n        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.\n        The total number of ChannelComponents for a set of pixels must equal SizeC.\n        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.\n        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:\n        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 592, 2))
+Namespace.addCategoryObject('elementBinding', Channel.name().localName(), Channel)
+
+MicrobeamManipulation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation'), CTD_ANON_20, documentation='\n        Defines a microbeam operation type and the region of the image it was applied to.\n        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for\n        the purpose of imaging. For example, a laser used for photobleaching.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 920, 2))
+Namespace.addCategoryObject('elementBinding', MicrobeamManipulation.name().localName(), MicrobeamManipulation)
+
+Instrument = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Instrument'), CTD_ANON_21, documentation="\n        This element describes the instrument used to capture the Image.\n        It is primarily a container for manufacturer's model and catalog\n        numbers for the Microscope, LightSource, Detector, Objective and\n        Filters components.\n        The Objective element contains the additional elements LensNA and Magnification.\n        The Filters element can be composed either of separate excitation,\n        emission filters and a dichroic mirror or a single filter set.\n        Within the Image itself, a reference is made to this one Filter element.\n        There may be multiple light sources, detectors, objectives and filters on a microscope.\n        Each of these has their own ID attribute, which can be referred to from Channel.\n        It is understood that the light path configuration can be different\n        for each channel, but cannot be different for each timepoint or\n        each plane of an XYZ stack.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 979, 2))
+Namespace.addCategoryObject('elementBinding', Instrument.name().localName(), Instrument)
+
+Project = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Project'), CTD_ANON_22, documentation='\n        The Project ID is required.\n        Datasets can be grouped into projects using a many-to-many relationship.\n        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.\n        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1101, 2))
+Namespace.addCategoryObject('elementBinding', Project.name().localName(), Project)
+
+ExperimenterGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup'), CTD_ANON_23, documentation='\n        The ExperimenterGroupID is required.\n        Information should ideally be specified for at least one Leader as a contact for the group.\n        The Leaders are themselves Experimenters.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1142, 2))
+Namespace.addCategoryObject('elementBinding', ExperimenterGroup.name().localName(), ExperimenterGroup)
+
+Leader = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Leader'), CTD_ANON_24, documentation='\n        Contact information for a ExperimenterGroup leader specified using a reference\n        to an Experimenter element defined elsewhere in the document.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1185, 2))
+Namespace.addCategoryObject('elementBinding', Leader.name().localName(), Leader)
+
+Dataset = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dataset'), CTD_ANON_25, documentation='\n        An element specifying a collection of images that are always processed together.\n        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.\n        Images contain one or more DatasetRef elements to specify what datasets they belong to.\n        Once a Dataset has been processed in any way, its collection of images cannot be altered.\n        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.\n        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.\n        This relationship is specified by listing DatasetRef elements within the Project element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1201, 2))
+Namespace.addCategoryObject('elementBinding', Dataset.name().localName(), Dataset)
+
+Experiment = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experiment'), CTD_ANON_26, documentation="\n        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:\n        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation\n        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other\n        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.\n        The optional Description element may contain free text to further describe the experiment.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1251, 2))
+Namespace.addCategoryObject('elementBinding', Experiment.name().localName(), Experiment)
+
+Experimenter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experimenter'), CTD_ANON_27, documentation='\n        This element describes a person who performed an imaging experiment.\n        This person may also be a user of the OME system, in which case the UserName element contains their login name.\n        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1320, 2))
+Namespace.addCategoryObject('elementBinding', Experimenter.name().localName(), Experimenter)
+
+Folder = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Folder'), CTD_ANON_28, documentation='\n        An element specifying a possibly heterogeneous collection of data.\n        Folders may contain Folders so that data may be organized within a tree of Folders.\n        Data may be in multiple Folders but a Folder may not be in more than one other Folder.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1377, 2))
+Namespace.addCategoryObject('elementBinding', Folder.name().localName(), Folder)
+
+Objective = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Objective'), CTD_ANON_29, documentation="\n        A description of the microscope's objective lens.\n        Required elements include the lens numerical aperture,\n        and the magnification, both of which a floating\n        point (real) numbers.\n        The values are those that are fixed for a particular\n        objective: either because it has been manufactured to\n        this specification or the value has been measured on\n        this particular objective.\n        Correction: This is the type of correction coating applied to this lens.\n        Immersion: This is the types of immersion medium the lens is designed to\n        work with. It is not the same as 'Medium' in ObjectiveRef (a\n        single type) as here Immersion can have compound values like 'Multi'.\n        LensNA: The numerical aperture of the lens (as a float)\n        NominalMagnification: The specified magnification e.g. x10\n        CalibratedMagnification: The measured magnification e.g. x10.3\n        WorkingDistance: WorkingDistance of the lens.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2024, 2))
+Namespace.addCategoryObject('elementBinding', Objective.name().localName(), Objective)
+
+Detector = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Detector'), CTD_ANON_30, documentation='\n        The type of detector used to capture the image.\n        The Detector ID can be used as a reference within the Channel element in the Image element.\n        The values stored in Detector represent the fixed values,\n        variable values modified during the acquisition go in DetectorSettings\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2144, 2))
+Namespace.addCategoryObject('elementBinding', Detector.name().localName(), Detector)
+
+FilterSet = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSet'), CTD_ANON_31, documentation='Filter set manufacturer specification', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2242, 2))
+Namespace.addCategoryObject('elementBinding', FilterSet.name().localName(), FilterSet)
+
+Filter = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Filter'), CTD_ANON_32, documentation="\n        A filter is either an excitation or emission filters.\n        There should be one filter element specified per wavelength in the image.\n        The channel number associated with a filter set is specified in Channel.\n        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.\n        It may also contain a Type attribute which may be set to\n        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',\n        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.\n        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2274, 2))
+Namespace.addCategoryObject('elementBinding', Filter.name().localName(), Filter)
+
+Dichroic = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dichroic'), CTD_ANON_33, documentation='The dichromatic beamsplitter or dichroic mirror used for this filter combination.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2391, 2))
+Namespace.addCategoryObject('elementBinding', Dichroic.name().localName(), Dichroic)
+
+DichroicRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), CTD_ANON_34, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2))
+Namespace.addCategoryObject('elementBinding', DichroicRef.name().localName(), DichroicRef)
+
+LightSourceGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup'), LightSource, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2454, 2))
+Namespace.addCategoryObject('elementBinding', LightSourceGroup.name().localName(), LightSourceGroup)
+
+Pump = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pump'), CTD_ANON_35, documentation="\n        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2778, 2))
+Namespace.addCategoryObject('elementBinding', Pump.name().localName(), Pump)
+
+ImageRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2))
+Namespace.addCategoryObject('elementBinding', ImageRef.name().localName(), ImageRef)
+
+MicrobeamManipulationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef'), CTD_ANON_37, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2867, 2))
+Namespace.addCategoryObject('elementBinding', MicrobeamManipulationRef.name().localName(), MicrobeamManipulationRef)
+
+ExperimentRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef'), CTD_ANON_38, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2876, 2))
+Namespace.addCategoryObject('elementBinding', ExperimentRef.name().localName(), ExperimentRef)
+
+ChannelRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ChannelRef'), CTD_ANON_39, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2885, 2))
+Namespace.addCategoryObject('elementBinding', ChannelRef.name().localName(), ChannelRef)
+
+ProjectRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ProjectRef'), CTD_ANON_40, documentation='\n        There may be one or more of these in a Dataset.\n        This empty element has a required Project ID attribute that refers to Projects defined within the OME element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2894, 2))
+Namespace.addCategoryObject('elementBinding', ProjectRef.name().localName(), ProjectRef)
+
+ExperimenterRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2))
+Namespace.addCategoryObject('elementBinding', ExperimenterRef.name().localName(), ExperimenterRef)
+
+ExperimenterGroupRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2))
+Namespace.addCategoryObject('elementBinding', ExperimenterGroupRef.name().localName(), ExperimenterGroupRef)
+
+InstrumentRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef'), CTD_ANON_43, documentation='\n        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2935, 2))
+Namespace.addCategoryObject('elementBinding', InstrumentRef.name().localName(), InstrumentRef)
+
+DatasetRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef'), CTD_ANON_44, documentation='\n        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.\n        One or more DatasetRef elements may be listed within the Image element to specify what Datasets\n        the Image belongs to.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2949, 2))
+Namespace.addCategoryObject('elementBinding', DatasetRef.name().localName(), DatasetRef)
+
+FolderRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FolderRef'), CTD_ANON_45, documentation='\n        The FolderRef element refers to a Folder by specifying the Folder ID attribute.\n        One or more FolderRef elements may be listed within the Folder element to specify what Folders\n        the Folder contains. This tree hierarchy must be acyclic.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2965, 2))
+Namespace.addCategoryObject('elementBinding', FolderRef.name().localName(), FolderRef)
+
+FilterSetRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef'), CTD_ANON_46, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2981, 2))
+Namespace.addCategoryObject('elementBinding', FilterSetRef.name().localName(), FilterSetRef)
+
+LightSourceSettings = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), CTD_ANON_47, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2))
+Namespace.addCategoryObject('elementBinding', LightSourceSettings.name().localName(), LightSourceSettings)
+
+DetectorSettings = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings'), CTD_ANON_48, documentation='\n        This holds the setting applied to a detector as well as a\n        reference to the detector.\n        The ID is the detector used in this case.\n        The values stored in DetectorSettings represent the variable values,\n        fixed values not modified during the acquisition go in Detector.\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3040, 2))
+Namespace.addCategoryObject('elementBinding', DetectorSettings.name().localName(), DetectorSettings)
+
+ObjectiveSettings = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings'), CTD_ANON_49, documentation='\n        This holds the setting applied to an objective as well as a\n        reference to the objective.\n        The ID is the objective used in this case.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3129, 2))
+Namespace.addCategoryObject('elementBinding', ObjectiveSettings.name().localName(), ObjectiveSettings)
+
+BinData = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2))
+Namespace.addCategoryObject('elementBinding', BinData.name().localName(), BinData)
+
+AnnotationRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2))
+Namespace.addCategoryObject('elementBinding', AnnotationRef.name().localName(), AnnotationRef)
+
+ROI = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROI'), CTD_ANON_52, documentation="\n        A four dimensional 'Region of Interest'.\n        If they are not used, and the Image has more than one plane,\n        the entire set of planes is assumed to be included in the ROI.\n        Multiple ROIs may be specified.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3746, 2))
+Namespace.addCategoryObject('elementBinding', ROI.name().localName(), ROI)
+
+ShapeGroup = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup'), Shape, abstract=pyxb.binding.datatypes.boolean(1), location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3795, 2))
+Namespace.addCategoryObject('elementBinding', ShapeGroup.name().localName(), ShapeGroup)
+
+ROIRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2))
+Namespace.addCategoryObject('elementBinding', ROIRef.name().localName(), ROIRef)
+
+Plate = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plate'), CTD_ANON_54, documentation='\n        This element identifies microtiter plates within a screen.\n        A plate can belong to more than one screen.\n        The Screen(s) that a plate belongs to are specified by the ScreenRef element.\n        The Plate ID and Name attributes are required.\n        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.\n        i.e. The top-left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4300, 2))
+Namespace.addCategoryObject('elementBinding', Plate.name().localName(), Plate)
+
+Reagent = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Reagent'), CTD_ANON_55, documentation='\n        Reagent is used to describe a chemical or some other physical experimental parameter.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4498, 2))
+Namespace.addCategoryObject('elementBinding', Reagent.name().localName(), Reagent)
+
+ReagentRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef'), CTD_ANON_56, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4544, 2))
+Namespace.addCategoryObject('elementBinding', ReagentRef.name().localName(), ReagentRef)
+
+Screen = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Screen'), CTD_ANON_57, documentation="\n        The Screen element is a grouping for Plates.\n        The required attribute is the Screen's Name and ID - both must be unique within the document.\n        The Screen element may contain an ExternalRef attribute that refers to an external database.\n        A description of the screen may be specified in the Description element.\n        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.\n        Plates contain one or more ScreenRef elements to specify what screens they belong to.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4560, 2))
+Namespace.addCategoryObject('elementBinding', Screen.name().localName(), Screen)
+
+PlateAcquisition = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition'), CTD_ANON_59, documentation='\n        PlateAcquisition is used to describe a single acquisition run for a plate.\n        This object is used to record the set of images acquired in a single\n        acquisition run. The Images for this run are linked to PlateAcquisition\n        through WellSample.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4660, 2))
+Namespace.addCategoryObject('elementBinding', PlateAcquisition.name().localName(), PlateAcquisition)
+
+Well = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Well'), CTD_ANON_60, documentation='\n        A Well is a component of the Well/Plate/Screen construct to describe screening applications.\n        A Well has a number of WellSample elements that link to the Images collected in this well.\n        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.\n        The origin for the row and column identifiers is the top left corner of the plate starting at zero.\n        i.e The top left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4726, 2))
+Namespace.addCategoryObject('elementBinding', Well.name().localName(), Well)
+
+WellSample = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSample'), CTD_ANON_61, documentation='\n        WellSample is an individual image that has been captured within a Well.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4810, 2))
+Namespace.addCategoryObject('elementBinding', WellSample.name().localName(), WellSample)
+
+WellSampleRef = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef'), CTD_ANON_62, documentation='\n        The WellSampleRef element is a reference to a WellSample element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4883, 2))
+Namespace.addCategoryObject('elementBinding', WellSampleRef.name().localName(), WellSampleRef)
+
+Laser = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Laser'), CTD_ANON_63, documentation='\n        Laser types are specified using two attributes - the Type and the LaserMedium.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2497, 2))
+Namespace.addCategoryObject('elementBinding', Laser.name().localName(), Laser)
+
+Arc = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Arc'), CTD_ANON_64, documentation='\n        The Arc element is used to describe various kinds of Arc lamps - Hg, Xe, HgXe.\n        The Power of the Arc is now stored in the LightSource.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2658, 2))
+Namespace.addCategoryObject('elementBinding', Arc.name().localName(), Arc)
+
+Filament = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Filament'), CTD_ANON_65, documentation='\n        The Filament element is used to describe various kinds of filament bulbs such as Incadescent or Halogen.\n        The Power of the Filament is now stored in the LightSource.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2688, 2))
+Namespace.addCategoryObject('elementBinding', Filament.name().localName(), Filament)
+
+LightEmittingDiode = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightEmittingDiode'), CTD_ANON_66, documentation="\n        The LightEmittingDiode element is used to describe\n        various kinds of LED lamps.\n\n        As the LightEmittingDiode is inside a LightSource it already has\n        available the values from ManufacturerSpec\n        (Manufacturer, Model, SerialNumber, LotNumber)\n        And the values from LightSource which includes Power in milliwatts\n\n        We have looked at extending this element but have had a problem\n        producing a generic solution.\n\n        Possible attributes talked about adding include:\n        Power in lumens - but this is complicated by multi-channel\n        devices like CoolLED where each channel's power is different\n        Wavelength Range - not a simple value so would require\n        multiple attributes or a child element\n        Angle of Projection - this would be further affected by the\n        optics used for filtering the naked LED or that combine\n        power from multiple devices\n\n        These values are further affected if you over-drive the LED\n        resulting in a more complex system\n\n        Another issue is that LED's may not be used directly for\n        illumination but as drivers for secondary emissions from doped\n        fiber optics. This would require the fiber optics to be modeled.\n\n        Thanks to Paul Goodwin of Applied Precision of information about\n        this topic.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2717, 2))
+Namespace.addCategoryObject('elementBinding', LightEmittingDiode.name().localName(), LightEmittingDiode)
+
+GenericExcitationSource = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'GenericExcitationSource'), CTD_ANON_67, documentation='\n        The GenericExcitationSource element is used to represent\n        a source as a collection of key/value pairs, stored\n        in a Map. The other lightsource objects should\n        always be used in preference to this if possible.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2758, 2))
+Namespace.addCategoryObject('elementBinding', GenericExcitationSource.name().localName(), GenericExcitationSource)
+
+ListAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation'), CTD_ANON_68, documentation='\n        This annotation is a grouping object. It uses the sequence of\n        annotation refs from the base Annotation to form the list.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3594, 2))
+Namespace.addCategoryObject('elementBinding', ListAnnotation.name().localName(), ListAnnotation)
+
+MapAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation'), CTD_ANON_69, documentation='\n        An map annotation. The contents of this is a list of key/value pairs.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3727, 2))
+Namespace.addCategoryObject('elementBinding', MapAnnotation.name().localName(), MapAnnotation)
+
+Rectangle = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Rectangle'), CTD_ANON_70, documentation='\n        A simple rectangle object. If rotation is required apply a\n        transformation at the Shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3965, 2))
+Namespace.addCategoryObject('elementBinding', Rectangle.name().localName(), Rectangle)
+
+Mask = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Mask'), CTD_ANON_71, documentation='\n        The Mask ROI shape is a link to a BinData object that is\n        a BIT mask drawn on top of the image as an ROI. It is applied\n        at the same scale, pixel to pixel, as the Image the ROI is\n        applied to, unless a transform is applied at the shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4009, 2))
+Namespace.addCategoryObject('elementBinding', Mask.name().localName(), Mask)
+
+Point = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Point'), CTD_ANON_72, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4058, 2))
+Namespace.addCategoryObject('elementBinding', Point.name().localName(), Point)
+
+Ellipse = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Ellipse'), CTD_ANON_73, documentation='\n        A simple ellipse object. If rotation is required apply a\n        transformation at the Shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4084, 2))
+Namespace.addCategoryObject('elementBinding', Ellipse.name().localName(), Ellipse)
+
+Line = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Line'), CTD_ANON_74, documentation="\n        A straight line defined by it's end points.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4128, 2))
+Namespace.addCategoryObject('elementBinding', Line.name().localName(), Line)
+
+Polyline = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Polyline'), CTD_ANON_75, documentation='\n        The Polyline defines open shapes formed of straight\n        lines. Note: Polyline uses counterclockwise winding (this is the\n        default OpenGL behavior)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4169, 2))
+Namespace.addCategoryObject('elementBinding', Polyline.name().localName(), Polyline)
+
+Polygon = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Polygon'), CTD_ANON_76, documentation='\n        The Polygon defines closed shapes formed of straight\n        lines. Note: Polygon uses counterclockwise winding (this is the\n        default OpenGL behavior)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4195, 2))
+Namespace.addCategoryObject('elementBinding', Polygon.name().localName(), Polygon)
+
+Label = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Label'), CTD_ANON_77, documentation='\n        The text label. Any transformation should be applied at the\n        shape level.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4219, 2))
+Namespace.addCategoryObject('elementBinding', Label.name().localName(), Label)
+
+FileAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation'), CTD_ANON_78, documentation='\n        A file object annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3554, 2))
+Namespace.addCategoryObject('elementBinding', FileAnnotation.name().localName(), FileAnnotation)
+
+XMLAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation'), CTD_ANON_79, documentation='\n        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3571, 2))
+Namespace.addCategoryObject('elementBinding', XMLAnnotation.name().localName(), XMLAnnotation)
+
+CommentAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation'), CTD_ANON_80, documentation='\n        A simple comment annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3608, 2))
+Namespace.addCategoryObject('elementBinding', CommentAnnotation.name().localName(), CommentAnnotation)
+
+BooleanAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation'), CTD_ANON_81, documentation='\n        A simple boolean annotation of type xsd:boolean\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3659, 2))
+Namespace.addCategoryObject('elementBinding', BooleanAnnotation.name().localName(), BooleanAnnotation)
+
+TimestampAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation'), CTD_ANON_82, documentation='\n        A date/time annotation of type xsd:dateTime\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3676, 2))
+Namespace.addCategoryObject('elementBinding', TimestampAnnotation.name().localName(), TimestampAnnotation)
+
+TagAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation'), CTD_ANON_83, documentation='\n        A tag annotation (represents a tag or a tagset)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3693, 2))
+Namespace.addCategoryObject('elementBinding', TagAnnotation.name().localName(), TagAnnotation)
+
+TermAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation'), CTD_ANON_84, documentation='\n        A ontology term annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3710, 2))
+Namespace.addCategoryObject('elementBinding', TermAnnotation.name().localName(), TermAnnotation)
+
+LongAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation'), CTD_ANON_85, documentation='\n        A simple numerical annotation of type xsd:long\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3625, 2))
+Namespace.addCategoryObject('elementBinding', LongAnnotation.name().localName(), LongAnnotation)
+
+DoubleAnnotation = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation'), CTD_ANON_86, documentation='\n        A simple numerical annotation of type xsd:double\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3642, 2))
+Namespace.addCategoryObject('elementBinding', DoubleAnnotation.name().localName(), DoubleAnnotation)
+
+
+
+Map._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'M'), CTD_ANON, scope=Map, documentation=' This is a key/value pair used to build up a Mapping. The\n          Element and Attribute name are kept to single letters to minimize the\n          length at the expense of readability as they are likely to occur many\n          times. ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 6)))
+
+def _BuildAutomaton ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton
+    del _BuildAutomaton
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 6))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(Map._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'M')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1563, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+Map._Automaton = _BuildAutomaton()
+
+
+
+
+CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), FilterRef, scope=CTD_ANON_, documentation='\n              The Filters placed in the Excitation light path.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 8)))
+
+CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), FilterRef, scope=CTD_ANON_, documentation='\n              The Filters placed in the Emission light path.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8)))
+
+CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), CTD_ANON_34, scope=CTD_ANON_, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2)))
+
+CTD_ANON_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_ ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_
+    del _BuildAutomaton_
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2426, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2435, 8))
+    counters.add(cc_3)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2418, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2426, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2427, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2435, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    st_3._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_._Automaton = _BuildAutomaton_()
+
+
+
+
+CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'RightsHolder'), STD_ANON_23, scope=CTD_ANON_2, documentation=' The rights holder for this data. [plain-text multi-line string]\n            e.g. "Copyright (C) 2002 - 2016 Open Microscopy Environment"\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 8)))
+
+CTD_ANON_2._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'RightsHeld'), STD_ANON_24, scope=CTD_ANON_2, documentation='\n              The rights held by the rights holder. [plain-text multi-line string]\n              e.g. "All rights reserved" or "Creative Commons Attribution 3.0 Unported License"\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8)))
+
+def _BuildAutomaton_2 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_2
+    del _BuildAutomaton_2
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'RightsHolder')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2803, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_2._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'RightsHeld')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2815, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_2._Automaton = _BuildAutomaton_2()
+
+
+
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation'), CTD_ANON_78, scope=CTD_ANON_3, documentation='\n        A file object annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3554, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation'), CTD_ANON_79, scope=CTD_ANON_3, documentation='\n        An general xml annotation. The contents of this is not processed as OME XML but should still be well-formed XML.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3571, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation'), CTD_ANON_68, scope=CTD_ANON_3, documentation='\n        This annotation is a grouping object. It uses the sequence of\n        annotation refs from the base Annotation to form the list.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3594, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation'), CTD_ANON_80, scope=CTD_ANON_3, documentation='\n        A simple comment annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3608, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation'), CTD_ANON_85, scope=CTD_ANON_3, documentation='\n        A simple numerical annotation of type xsd:long\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3625, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation'), CTD_ANON_86, scope=CTD_ANON_3, documentation='\n        A simple numerical annotation of type xsd:double\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3642, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation'), CTD_ANON_81, scope=CTD_ANON_3, documentation='\n        A simple boolean annotation of type xsd:boolean\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3659, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation'), CTD_ANON_82, scope=CTD_ANON_3, documentation='\n        A date/time annotation of type xsd:dateTime\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3676, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation'), CTD_ANON_83, scope=CTD_ANON_3, documentation='\n        A tag annotation (represents a tag or a tagset)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3693, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation'), CTD_ANON_84, scope=CTD_ANON_3, documentation='\n        A ontology term annotation\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3710, 2)))
+
+CTD_ANON_3._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation'), CTD_ANON_69, scope=CTD_ANON_3, documentation='\n        An map annotation. The contents of this is a list of key/value pairs.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3727, 2)))
+
+def _BuildAutomaton_3 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_3
+    del _BuildAutomaton_3
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3420, 6))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'XMLAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3421, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FileAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3422, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ListAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3423, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LongAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3424, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DoubleAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3425, 8))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'CommentAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3426, 8))
+    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_5)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BooleanAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3427, 8))
+    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_6)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TimestampAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3428, 8))
+    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_7)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TagAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3429, 8))
+    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_8)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TermAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3430, 8))
+    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_9)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_3._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MapAnnotation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3431, 8))
+    st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_10)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_4._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_5._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_6._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_7._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_8._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_9._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_10._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_3._Automaton = _BuildAutomaton_3()
+
+
+
+
+def _BuildAutomaton_4 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_4
+    del _BuildAutomaton_4
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3585, 18))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.WildcardUse(pyxb.binding.content.Wildcard(process_contents=pyxb.binding.content.Wildcard.PC_lax, namespace_constraint=pyxb.binding.content.Wildcard.NC_any), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3585, 18))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_4._Automaton = _BuildAutomaton_4()
+
+
+
+
+CTD_ANON_5._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup'), Shape, abstract=pyxb.binding.datatypes.boolean(1), scope=CTD_ANON_5, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3795, 2)))
+
+def _BuildAutomaton_5 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_5
+    del _BuildAutomaton_5
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    states = []
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_5._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ShapeGroup')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3762, 16))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+         ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_5._Automaton = _BuildAutomaton_5()
+
+
+
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinaryOnly'), CTD_ANON_7, scope=CTD_ANON_6, documentation=' Pointer to an external metadata file. If this\n              element is present, then no other metadata may be present in this\n              file, i.e. this file is a place-holder. ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 79, 10)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Image'), CTD_ANON_17, scope=CTD_ANON_6, documentation="\n        This element describes the actual image and its meta-data.\n        The elements that are references (ending in Ref or Settings) refer to\n        elements defined outside of the Image element. Ref elements are simple\n        links, while Settings elements are links with additional values.\n\n        If any of the required Image attributes or elements are missing, its\n        guaranteed to be an invalid document. The required attributes and\n        elements are ID and Pixels.\n\n        ExperimenterRef is required for all Images with well formed LSIDs.\n        ImageType is a vendor-specific designation of the type of image this is.\n        Examples of ImageType include 'STK', 'SoftWorx', etc.\n        The Name attributes are in all cases the name of the element\n        instance. In this case, the name of the image, not necessarily the filename.\n        Physical size of pixels are microns[\xb5m].\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 209, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Instrument'), CTD_ANON_21, scope=CTD_ANON_6, documentation="\n        This element describes the instrument used to capture the Image.\n        It is primarily a container for manufacturer's model and catalog\n        numbers for the Microscope, LightSource, Detector, Objective and\n        Filters components.\n        The Objective element contains the additional elements LensNA and Magnification.\n        The Filters element can be composed either of separate excitation,\n        emission filters and a dichroic mirror or a single filter set.\n        Within the Image itself, a reference is made to this one Filter element.\n        There may be multiple light sources, detectors, objectives and filters on a microscope.\n        Each of these has their own ID attribute, which can be referred to from Channel.\n        It is understood that the light path configuration can be different\n        for each channel, but cannot be different for each timepoint or\n        each plane of an XYZ stack.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 979, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Project'), CTD_ANON_22, scope=CTD_ANON_6, documentation='\n        The Project ID is required.\n        Datasets can be grouped into projects using a many-to-many relationship.\n        A Dataset may belong to one or more Projects by including one or more ProjectRef elements which refer to Project IDs.\n        Projects do not directly contain images - only by virtue of containing datasets, which themselves contain images.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1101, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup'), CTD_ANON_23, scope=CTD_ANON_6, documentation='\n        The ExperimenterGroupID is required.\n        Information should ideally be specified for at least one Leader as a contact for the group.\n        The Leaders are themselves Experimenters.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1142, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dataset'), CTD_ANON_25, scope=CTD_ANON_6, documentation='\n        An element specifying a collection of images that are always processed together.\n        Images can belong to more than one Dataset, and a Dataset may contain more than one Image.\n        Images contain one or more DatasetRef elements to specify what datasets they belong to.\n        Once a Dataset has been processed in any way, its collection of images cannot be altered.\n        The ExperimenterRef and ExperimenterGroupRef elements specify the person and group this Dataset belongs to.\n        Projects may contain one or more Datasets, and Datasets may belong to one or more Projects.\n        This relationship is specified by listing DatasetRef elements within the Project element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1201, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experiment'), CTD_ANON_26, scope=CTD_ANON_6, documentation="\n        This element describes the type of experiment.  The required Type attribute must contain one or more entries from the following list:\n        FP FRET Time-lapse 4-D+ Screen Immunocytochemistry FISH Electrophysiology  Ion-Imaging Colocalization PGI/Documentation\n        FRAP Photoablation Optical-Trapping Photoactivation Fluorescence-Lifetime Spectral-Imaging Other\n        FP refers to fluorescent proteins, PGI/Documentation is not a 'data' image.\n        The optional Description element may contain free text to further describe the experiment.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1251, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Experimenter'), CTD_ANON_27, scope=CTD_ANON_6, documentation='\n        This element describes a person who performed an imaging experiment.\n        This person may also be a user of the OME system, in which case the UserName element contains their login name.\n        Experimenters may belong to one or more groups which are specified using one or more ExperimenterGroupRef elements.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1320, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Folder'), CTD_ANON_28, scope=CTD_ANON_6, documentation='\n        An element specifying a possibly heterogeneous collection of data.\n        Folders may contain Folders so that data may be organized within a tree of Folders.\n        Data may be in multiple Folders but a Folder may not be in more than one other Folder.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1377, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Rights'), CTD_ANON_2, scope=CTD_ANON_6, documentation='\n        The rights holder of this data and the rights held.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2794, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations'), CTD_ANON_3, scope=CTD_ANON_6, documentation='\n        An unordered collection of annotation attached to objects in the OME data model.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3413, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROI'), CTD_ANON_52, scope=CTD_ANON_6, documentation="\n        A four dimensional 'Region of Interest'.\n        If they are not used, and the Image has more than one plane,\n        the entire set of planes is assumed to be included in the ROI.\n        Multiple ROIs may be specified.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3746, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plate'), CTD_ANON_54, scope=CTD_ANON_6, documentation='\n        This element identifies microtiter plates within a screen.\n        A plate can belong to more than one screen.\n        The Screen(s) that a plate belongs to are specified by the ScreenRef element.\n        The Plate ID and Name attributes are required.\n        The Wells in a plate are numbers from the top-left corner in a grid starting at zero.\n        i.e. The top-left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4300, 2)))
+
+CTD_ANON_6._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Screen'), CTD_ANON_57, scope=CTD_ANON_6, documentation="\n        The Screen element is a grouping for Plates.\n        The required attribute is the Screen's Name and ID - both must be unique within the document.\n        The Screen element may contain an ExternalRef attribute that refers to an external database.\n        A description of the screen may be specified in the Description element.\n        Screens may contain overlapping sets of Plates i.e.      Screens and Plates have a many-to-many relationship.\n        Plates contain one or more ScreenRef elements to specify what screens they belong to.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4560, 2)))
+
+def _BuildAutomaton_6 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_6
+    del _BuildAutomaton_6
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 61, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 65, 12))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 66, 12))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 67, 12))
+    counters.add(cc_3)
+    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 68, 12))
+    counters.add(cc_4)
+    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 69, 12))
+    counters.add(cc_5)
+    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 70, 12))
+    counters.add(cc_6)
+    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 71, 12))
+    counters.add(cc_7)
+    cc_8 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 72, 12))
+    counters.add(cc_8)
+    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 73, 12))
+    counters.add(cc_9)
+    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 74, 12))
+    counters.add(cc_10)
+    cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 75, 12))
+    counters.add(cc_11)
+    cc_12 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 76, 12))
+    counters.add(cc_12)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Rights')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 61, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Project')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 65, 12))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Dataset')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 66, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Folder')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 67, 12))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_4, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Experiment')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 68, 12))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_5, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Plate')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 69, 12))
+    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_5)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_6, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Screen')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 70, 12))
+    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_6)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_7, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Experimenter')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 71, 12))
+    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_7)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_8, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroup')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 72, 12))
+    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_8)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_9, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Instrument')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 73, 12))
+    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_9)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_10, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Image')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 74, 12))
+    st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_10)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_11, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'StructuredAnnotations')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 75, 12))
+    st_11 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_11)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_12, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROI')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 76, 12))
+    st_12 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_12)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_6._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinaryOnly')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 79, 10))
+    st_13 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_13)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_13, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_4, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    st_4._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_5, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    st_5._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_6, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    st_6._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_7, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_7, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_7, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_7, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_7, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_7, False) ]))
+    st_7._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_8, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_8, False) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_8, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_8, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_8, False) ]))
+    st_8._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_9, True) ]))
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_9, False) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_9, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_9, False) ]))
+    st_9._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_10, True) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_10, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_10, False) ]))
+    st_10._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_11, True) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_11, False) ]))
+    st_11._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_12, True) ]))
+    st_12._set_transitionSet(transitions)
+    transitions = []
+    st_13._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_6._Automaton = _BuildAutomaton_6()
+
+
+
+
+CTD_ANON_8._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'HashSHA1'), Hex40, scope=CTD_ANON_8, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 496, 10)))
+
+CTD_ANON_8._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_8, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_7 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_7
+    del _BuildAutomaton_7
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 488, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 498, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_8._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'HashSHA1')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 496, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_8._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 498, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_8._Automaton = _BuildAutomaton_7()
+
+
+
+
+CTD_ANON_9._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'UUID'), CTD_ANON_10, scope=CTD_ANON_9, documentation='\n              This must be used when the IFDs are located in another file.\n              Note: It is permissible for this to be self referential.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8)))
+
+def _BuildAutomaton_8 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_8
+    del _BuildAutomaton_8
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_9._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'UUID')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 801, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_9._Automaton = _BuildAutomaton_8()
+
+
+
+
+CTD_ANON_13._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Map'), Map, scope=CTD_ANON_13, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8)))
+
+def _BuildAutomaton_9 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_9
+    del _BuildAutomaton_9
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_13._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Map')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1051, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_13._Automaton = _BuildAutomaton_9()
+
+
+
+
+CTD_ANON_16._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'External'), CTD_ANON_15, scope=CTD_ANON_16, documentation='Describes a file location.  Can optionally specify a portion of a file using Offset and a ReadLength.\n      If Offset and ReadLength are specified in conjuction with Compression, then they point into the uncompressed file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3288, 2)))
+
+CTD_ANON_16._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, scope=CTD_ANON_16, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2)))
+
+def _BuildAutomaton_10 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_10
+    del _BuildAutomaton_10
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    states = []
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_16._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'External')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3369, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_16._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3370, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_16._Automaton = _BuildAutomaton_10()
+
+
+
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AcquisitionDate'), pyxb.binding.datatypes.dateTime, scope=CTD_ANON_17, documentation="\n              The acquisition date of the Image.\n              The element contains an xsd:dateTime string based on the ISO 8601 format (i.e. 1988-04-07T18:39:09.359)\n\n              YYYY-MM-DDTHH:mm:SS.sssZ\n              Y - Year\n              M - Month\n              D - Day\n              H - Hour\n              m - minutes\n              S - Seconds\n              s - sub-seconds (optional)\n              Z - Zone (optional) +HH:mm or -HH:mm or Z for UTC\n\n              Note: xsd:dataTime supports a very wide date range with unlimited precision. The full date range\n              and precision are not typically supported by platform- and language-specific libraries.\n              Where the supported time precision is less than the precision used by the xsd:dateTime\n              timestamp there will be loss of precision; this will typically occur via direct truncation\n              or (less commonly) rounding.\n\n              The year value can be large and/or negative. Any value covering the current or last century\n              should be correctly processed, but some systems cannot process earlier dates.\n\n              The sub-second value is defined as an unlimited number of digits after the decimal point.\n              In Java a minimum of millisecond precision is guaranteed.\n              In C++ microsecond precision is guaranteed, with nanosecond precision being available on\n              some platforms.\n\n              Time zones are supported, eg '2013-10-24T11:52:33+01:00' for Paris, but in most cases it will\n              be converted to UTC when the timestamp is written.\n            ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON, scope=CTD_ANON_17, documentation='\n              A description for the image. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pixels'), CTD_ANON_18, scope=CTD_ANON_17, documentation="\n        Pixels is going to be removed in the future, but it is still required.\n\n        This is just notice that the contents of Pixels will be\n        moved up to Image in a future release. This is because there\n        has only been 1 Pixels object in each Image for some time.\n        The concept of multiple Pixels sets for one Image failed to\n        take off. It is therefore redundant.\n\n        The Image will be unreadable if any of the required Pixel attributes are missing.\n\n        The Pixels themselves can be stored within the OME-XML compressed by plane, and encoded\n        in Base64.\n        Or the Pixels may be stored in TIFF format.\n\n        The Pixels element should contain a list of BinData or TiffData, each containing a\n        single plane of pixels. These Pixels elements, when read in document order,\n        must produce a 5-D pixel array of the size specified in this element, and in the\n        dimension order specified by 'DimensionOrder'.\n\n        All of the values in the Pixels object when present should match the same value\n        stored in any associated TIFF format (e.g. SizeX should be the same). Where there\n        is a mismatch our readers will take the value from the TIFF structure as overriding\n        the value in the OME-XML. This is simply a pragmatic decision as it increases the\n        likelihood of reading data from a slightly incorrect file.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 307, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'StageLabel'), CTD_ANON_11, scope=CTD_ANON_17, documentation="\n        The StageLabel is used to specify a name and position for a stage position in the microscope's reference frame.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 871, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment'), CTD_ANON_13, scope=CTD_ANON_17, documentation='\n        This describes the environment that the biological sample was in\n        during the experiment.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1041, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef'), CTD_ANON_37, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2867, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef'), CTD_ANON_38, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2876, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_17, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, scope=CTD_ANON_17, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef'), CTD_ANON_43, scope=CTD_ANON_17, documentation='\n        This empty element can be used (via the required Instrument ID attribute) to refer to an Instrument defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2935, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings'), CTD_ANON_49, scope=CTD_ANON_17, documentation='\n        This holds the setting applied to an objective as well as a\n        reference to the objective.\n        The ID is the objective used in this case.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3129, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_17, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_17._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, scope=CTD_ANON_17, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2)))
+
+def _BuildAutomaton_11 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_11
+    del _BuildAutomaton_11
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 267, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 280, 8))
+    counters.add(cc_3)
+    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 281, 8))
+    counters.add(cc_4)
+    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 282, 8))
+    counters.add(cc_5)
+    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 283, 8))
+    counters.add(cc_6)
+    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 284, 8))
+    counters.add(cc_7)
+    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 285, 8))
+    counters.add(cc_8)
+    cc_9 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 287, 8))
+    counters.add(cc_9)
+    cc_10 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 292, 8))
+    counters.add(cc_10)
+    cc_11 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 297, 8))
+    counters.add(cc_11)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AcquisitionDate')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 232, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 267, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 268, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimentRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 280, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 281, 8))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'InstrumentRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 282, 8))
+    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_5)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ObjectiveSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 283, 8))
+    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_6)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImagingEnvironment')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 284, 8))
+    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_7)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'StageLabel')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 285, 8))
+    st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_8)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Pixels')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 286, 8))
+    st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_9)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_9, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROIRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 287, 8))
+    st_10 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_10)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_10, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 292, 8))
+    st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_11)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_11, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_17._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 297, 8))
+    st_12 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_12)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_4, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    st_4._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_5, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    st_5._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_6, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    st_6._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_7, True) ]))
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_7, False) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_7, False) ]))
+    st_7._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_8, [
+        fac.UpdateInstruction(cc_8, True) ]))
+    transitions.append(fac.Transition(st_9, [
+        fac.UpdateInstruction(cc_8, False) ]))
+    st_8._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_10, [
+         ]))
+    transitions.append(fac.Transition(st_11, [
+         ]))
+    transitions.append(fac.Transition(st_12, [
+         ]))
+    st_9._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_10, [
+        fac.UpdateInstruction(cc_9, True) ]))
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_9, False) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_9, False) ]))
+    st_10._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_11, [
+        fac.UpdateInstruction(cc_10, True) ]))
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_10, False) ]))
+    st_11._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_12, [
+        fac.UpdateInstruction(cc_11, True) ]))
+    st_12._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_17._Automaton = _BuildAutomaton_11()
+
+
+
+
+CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Plane'), CTD_ANON_8, scope=CTD_ANON_18, documentation='\n        The Plane object holds microscope stage and image timing data\n        for a given channel/z-section/timepoint.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 478, 2)))
+
+CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Channel'), CTD_ANON_19, scope=CTD_ANON_18, documentation="\n        There must be one per channel in the Image, even for a single-plane image.\n        And information about how each of them was acquired is stored in the various optional *Ref elements.  Each Logical Channel is composed of one or more\n        ChannelComponents.  For example, an entire spectrum in an FTIR experiment may be stored in a single Logical Channel with each discrete wavenumber of the spectrum\n        constituting a ChannelComponent of the FTIR Logical Channel.  An RGB image where the Red, Green and Blue components do not reflect discrete probes but are\n        instead the output of a color camera would be treated similarly - one Logical channel with three ChannelComponents in this case.\n        The total number of ChannelComponents for a set of pixels must equal SizeC.\n        The IlluminationType attribute is a string enumeration which may be set to 'Transmitted', 'Epifluorescence', 'Oblique', or 'NonLinear'.\n        The user interface logic for labeling a given channel for the user should use the first existing attribute in the following sequence:\n        Name -> Fluor -> EmissionWavelength -> ChannelComponent/Index.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 592, 2)))
+
+CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly'), pyxb.binding.datatypes.anyType, scope=CTD_ANON_18, documentation='\n        This place holder means there is on pixel data in this file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 784, 2)))
+
+CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TiffData'), CTD_ANON_9, scope=CTD_ANON_18, documentation='\n        This described the location of the pixel data in a tiff file.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 792, 2)))
+
+CTD_ANON_18._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, scope=CTD_ANON_18, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2)))
+
+def _BuildAutomaton_12 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_12
+    del _BuildAutomaton_12
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 339, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 349, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Channel')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 339, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 345, 10))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TiffData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 346, 10))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MetadataOnly')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 347, 10))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_18._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Plane')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 349, 8))
+    st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+         ]))
+    transitions.append(fac.Transition(st_4, [
+         ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+         ]))
+    transitions.append(fac.Transition(st_4, [
+         ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+         ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_4._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_18._Automaton = _BuildAutomaton_12()
+
+
+
+
+CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightPath'), CTD_ANON_, scope=CTD_ANON_19, documentation='A description of the light path', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2411, 2)))
+
+CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef'), CTD_ANON_46, scope=CTD_ANON_19, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2981, 2)))
+
+CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), CTD_ANON_47, scope=CTD_ANON_19, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2)))
+
+CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings'), CTD_ANON_48, scope=CTD_ANON_19, documentation='\n        This holds the setting applied to a detector as well as a\n        reference to the detector.\n        The ID is the detector used in this case.\n        The values stored in DetectorSettings represent the variable values,\n        fixed values not modified during the acquisition go in Detector.\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3040, 2)))
+
+CTD_ANON_19._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_19, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_13 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_13
+    del _BuildAutomaton_13
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 609, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 610, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 611, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 612, 8))
+    counters.add(cc_3)
+    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 617, 8))
+    counters.add(cc_4)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 609, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DetectorSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 610, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FilterSetRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 611, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 612, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_4, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_19._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightPath')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 617, 8))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_4, True) ]))
+    st_4._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_19._Automaton = _BuildAutomaton_13()
+
+
+
+
+CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_5, scope=CTD_ANON_20, documentation='\n              A description for the Microbeam Manipulation. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8)))
+
+CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_20, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))
+
+CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings'), CTD_ANON_47, scope=CTD_ANON_20, documentation='', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3006, 2)))
+
+CTD_ANON_20._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, scope=CTD_ANON_20, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2)))
+
+def _BuildAutomaton_14 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_14
+    del _BuildAutomaton_14
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 949, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 931, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROIRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 943, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 948, 8))
+    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_20._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightSourceSettings')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 949, 8))
+    st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+         ]))
+    transitions.append(fac.Transition(st_2, [
+         ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+         ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_3._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_20._Automaton = _BuildAutomaton_14()
+
+
+
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Microscope'), CTD_ANON_12, scope=CTD_ANON_21, documentation="The microscope's manufacturer specification.", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1016, 2)))
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Objective'), CTD_ANON_29, scope=CTD_ANON_21, documentation="\n        A description of the microscope's objective lens.\n        Required elements include the lens numerical aperture,\n        and the magnification, both of which a floating\n        point (real) numbers.\n        The values are those that are fixed for a particular\n        objective: either because it has been manufactured to\n        this specification or the value has been measured on\n        this particular objective.\n        Correction: This is the type of correction coating applied to this lens.\n        Immersion: This is the types of immersion medium the lens is designed to\n        work with. It is not the same as 'Medium' in ObjectiveRef (a\n        single type) as here Immersion can have compound values like 'Multi'.\n        LensNA: The numerical aperture of the lens (as a float)\n        NominalMagnification: The specified magnification e.g. x10\n        CalibratedMagnification: The measured magnification e.g. x10.3\n        WorkingDistance: WorkingDistance of the lens.\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2024, 2)))
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Detector'), CTD_ANON_30, scope=CTD_ANON_21, documentation='\n        The type of detector used to capture the image.\n        The Detector ID can be used as a reference within the Channel element in the Image element.\n        The values stored in Detector represent the fixed values,\n        variable values modified during the acquisition go in DetectorSettings\n\n        Each attribute now has an indication of what type of detector\n        it applies to. This is preparatory work for cleaning up and\n        possibly splitting this object into sub-types.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2144, 2)))
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FilterSet'), CTD_ANON_31, scope=CTD_ANON_21, documentation='Filter set manufacturer specification', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2242, 2)))
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Filter'), CTD_ANON_32, scope=CTD_ANON_21, documentation="\n        A filter is either an excitation or emission filters.\n        There should be one filter element specified per wavelength in the image.\n        The channel number associated with a filter set is specified in Channel.\n        It is based on the FilterSpec type, so has the required attributes Manufacturer, Model, and LotNumber.\n        It may also contain a Type attribute which may be set to\n        'LongPass', 'ShortPass', 'BandPass', 'MultiPass',\n        'Dichroic', 'NeutralDensity', 'Tuneable' or 'Other'.\n        It can be associated with an optional FilterWheel - Note: this is not the same as a FilterSet\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2274, 2)))
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Dichroic'), CTD_ANON_33, scope=CTD_ANON_21, documentation='The dichromatic beamsplitter or dichroic mirror used for this filter combination.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2391, 2)))
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup'), LightSource, abstract=pyxb.binding.datatypes.boolean(1), scope=CTD_ANON_21, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2454, 2)))
+
+CTD_ANON_21._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_21, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_15 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_15
+    del _BuildAutomaton_15
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1000, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1001, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1002, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1003, 8))
+    counters.add(cc_3)
+    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1004, 8))
+    counters.add(cc_4)
+    cc_5 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1005, 8))
+    counters.add(cc_5)
+    cc_6 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1006, 8))
+    counters.add(cc_6)
+    cc_7 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1007, 8))
+    counters.add(cc_7)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Microscope')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1000, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'LightSourceGroup')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1001, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Detector')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1002, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Objective')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1003, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_4, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FilterSet')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1004, 8))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_5, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Filter')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1005, 8))
+    st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_5)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_6, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Dichroic')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1006, 8))
+    st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_6)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_7, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_21._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1007, 8))
+    st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_7)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_4, True) ]))
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_4, False) ]))
+    st_4._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_5, [
+        fac.UpdateInstruction(cc_5, True) ]))
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_5, False) ]))
+    st_5._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_6, [
+        fac.UpdateInstruction(cc_6, True) ]))
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_6, False) ]))
+    st_6._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_7, [
+        fac.UpdateInstruction(cc_7, True) ]))
+    st_7._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_21._Automaton = _BuildAutomaton_15()
+
+
+
+
+CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_8, scope=CTD_ANON_22, documentation='\n              A description for the project. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 8)))
+
+CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_22, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))
+
+CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, scope=CTD_ANON_22, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2)))
+
+CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef'), CTD_ANON_44, scope=CTD_ANON_22, documentation='\n        The DatasetRef element refers to a Dataset by specifying the Dataset ID attribute.\n        One or more DatasetRef elements may be listed within the Image element to specify what Datasets\n        the Image belongs to.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2949, 2)))
+
+CTD_ANON_22._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_22, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_16 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_16
+    del _BuildAutomaton_16
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1125, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1126, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1127, 8))
+    counters.add(cc_3)
+    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1132, 8))
+    counters.add(cc_4)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1113, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1125, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1126, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DatasetRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1127, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_4, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_22._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1132, 8))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_4, True) ]))
+    st_4._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_22._Automaton = _BuildAutomaton_16()
+
+
+
+
+CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_9, scope=CTD_ANON_23, documentation='\n              A description for the group. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 8)))
+
+CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Leader'), CTD_ANON_24, scope=CTD_ANON_23, documentation='\n        Contact information for a ExperimenterGroup leader specified using a reference\n        to an Experimenter element defined elsewhere in the document.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1185, 2)))
+
+CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_23, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))
+
+CTD_ANON_23._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_23, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_17 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_17
+    del _BuildAutomaton_17
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1165, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1170, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1171, 8))
+    counters.add(cc_3)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1153, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1165, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Leader')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1170, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_23._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1171, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    st_3._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_23._Automaton = _BuildAutomaton_17()
+
+
+
+
+CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_10, scope=CTD_ANON_25, documentation='\n              A description for the dataset. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 8)))
+
+CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, scope=CTD_ANON_25, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2)))
+
+CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_25, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))
+
+CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef'), CTD_ANON_42, scope=CTD_ANON_25, documentation='This empty element has a reference (the ExperimenterGroup ID attribute) to a ExperimenterGroup defined within OME.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2923, 2)))
+
+CTD_ANON_25._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_25, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_18 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_18
+    del _BuildAutomaton_18
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1228, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1229, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1230, 8))
+    counters.add(cc_3)
+    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1235, 8))
+    counters.add(cc_4)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1216, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1228, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterGroupRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1229, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImageRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1230, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_4, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_25._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1235, 8))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_4, True) ]))
+    st_4._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_25._Automaton = _BuildAutomaton_18()
+
+
+
+
+CTD_ANON_26._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation'), CTD_ANON_20, scope=CTD_ANON_26, documentation='\n        Defines a microbeam operation type and the region of the image it was applied to.\n        The LightSourceRef element is a reference to a LightSource specified in the Instrument element which was used for a technique other than illumination for\n        the purpose of imaging. For example, a laser used for photobleaching.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 920, 2)))
+
+CTD_ANON_26._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_11, scope=CTD_ANON_26, documentation='\n              A description for the experiment. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 8)))
+
+CTD_ANON_26._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef'), CTD_ANON_41, scope=CTD_ANON_26, documentation='\n        This empty element has a required Experimenter ID and an optional DocumentID attribute which refers to one of the Experimenters defined within OME.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2909, 2)))
+
+def _BuildAutomaton_19 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_19
+    del _BuildAutomaton_19
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1276, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1283, 8))
+    counters.add(cc_2)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1264, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExperimenterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1276, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_26._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'MicrobeamManipulation')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1283, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_26._Automaton = _BuildAutomaton_19()
+
+
+
+
+CTD_ANON_27._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_27, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_20 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_20
+    del _BuildAutomaton_20
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1331, 8))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_27._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1331, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_27._Automaton = _BuildAutomaton_20()
+
+
+
+
+CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_13, scope=CTD_ANON_28, documentation='\n              A description for the folder. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 8)))
+
+CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, scope=CTD_ANON_28, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2)))
+
+CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FolderRef'), CTD_ANON_45, scope=CTD_ANON_28, documentation='\n        The FolderRef element refers to a Folder by specifying the Folder ID attribute.\n        One or more FolderRef elements may be listed within the Folder element to specify what Folders\n        the Folder contains. This tree hierarchy must be acyclic.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2965, 2)))
+
+CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_28, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_28._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ROIRef'), CTD_ANON_53, scope=CTD_ANON_28, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4247, 2)))
+
+def _BuildAutomaton_21 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_21
+    del _BuildAutomaton_21
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1400, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1401, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1406, 8))
+    counters.add(cc_3)
+    cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1411, 8))
+    counters.add(cc_4)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1388, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FolderRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1400, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImageRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1401, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ROIRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1406, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_4, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_28._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 1411, 8))
+    st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_4)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_3, False) ]))
+    st_3._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_4, [
+        fac.UpdateInstruction(cc_4, True) ]))
+    st_4._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_28._Automaton = _BuildAutomaton_21()
+
+
+
+
+CTD_ANON_29._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_29, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_22 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_22
+    del _BuildAutomaton_22
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2050, 12))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_29._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2050, 12))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_29._Automaton = _BuildAutomaton_22()
+
+
+
+
+CTD_ANON_30._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_30, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_23 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_23
+    del _BuildAutomaton_23
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2162, 12))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_30._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2162, 12))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_30._Automaton = _BuildAutomaton_23()
+
+
+
+
+CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef'), FilterRef, scope=CTD_ANON_31, documentation='\n                  The Filters placed in the Excitation light path.\n                ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12)))
+
+CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef'), FilterRef, scope=CTD_ANON_31, documentation='\n                  The Filters placed in the Emission light path.\n                ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12)))
+
+CTD_ANON_31._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef'), CTD_ANON_34, scope=CTD_ANON_31, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2443, 2)))
+
+def _BuildAutomaton_24 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_24
+    del _BuildAutomaton_24
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2259, 12))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12))
+    counters.add(cc_2)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ExcitationFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2251, 12))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'DichroicRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2259, 12))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_31._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'EmissionFilterRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2260, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_31._Automaton = _BuildAutomaton_24()
+
+
+
+
+CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange'), CTD_ANON_14, scope=CTD_ANON_32, documentation='\n        This records the range of wavelengths that are transmitted by the filter. It also records the maximum amount of light transmitted.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2325, 2)))
+
+CTD_ANON_32._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_32, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_25 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_25
+    del _BuildAutomaton_25
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2292, 12))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2293, 12))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'TransmittanceRange')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2292, 12))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_32._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2293, 12))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_32._Automaton = _BuildAutomaton_25()
+
+
+
+
+CTD_ANON_33._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_33, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_26 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_26
+    del _BuildAutomaton_26
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2400, 12))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_33._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2400, 12))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_33._Automaton = _BuildAutomaton_26()
+
+
+
+
+LightSource._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=LightSource, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+def _BuildAutomaton_27 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_27
+    del _BuildAutomaton_27
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(LightSource._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+LightSource._Automaton = _BuildAutomaton_27()
+
+
+
+
+Annotation._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=Annotation, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+Annotation._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_28, scope=Annotation, documentation='\n            A description for the annotation. [plain-text multi-line string]\n          ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6)))
+
+def _BuildAutomaton_28 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_28
+    del _BuildAutomaton_28
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(Annotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(Annotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+Annotation._Automaton = _BuildAutomaton_28()
+
+
+
+
+CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_52, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Union'), CTD_ANON_5, scope=CTD_ANON_52, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3759, 10)))
+
+CTD_ANON_52._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_29, scope=CTD_ANON_52, documentation='\n              A description for the ROI. [plain-text multi-line string]\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8)))
+
+def _BuildAutomaton_29 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_29
+    del _BuildAutomaton_29
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3767, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Union')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3759, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3767, 8))
+    st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_52._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3772, 8))
+    st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+         ]))
+    transitions.append(fac.Transition(st_2, [
+         ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_52._Automaton = _BuildAutomaton_29()
+
+
+
+
+Shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=Shape, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+Shape._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Transform'), AffineTransform, scope=Shape, documentation='\n            This is a matrix used to transform the shape.\n            The element has 6 xsd:float attributes. If the element\n            is present then all 6 values must be included.\n          ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6)))
+
+def _BuildAutomaton_30 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_30
+    del _BuildAutomaton_30
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(Shape._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(Shape._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+Shape._Automaton = _BuildAutomaton_30()
+
+
+
+
+CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_54, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_33, scope=CTD_ANON_54, documentation='\n              A description for the plate.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 8)))
+
+CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition'), CTD_ANON_59, scope=CTD_ANON_54, documentation='\n        PlateAcquisition is used to describe a single acquisition run for a plate.\n        This object is used to record the set of images acquired in a single\n        acquisition run. The Images for this run are linked to PlateAcquisition\n        through WellSample.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4660, 2)))
+
+CTD_ANON_54._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Well'), CTD_ANON_60, scope=CTD_ANON_54, documentation='\n        A Well is a component of the Well/Plate/Screen construct to describe screening applications.\n        A Well has a number of WellSample elements that link to the Images collected in this well.\n        The ReagentRef links any Reagents that were used in this Well. A well is part of only one Plate.\n        The origin for the row and column identifiers is the top left corner of the plate starting at zero.\n        i.e The top left well of a plate is index (0,0)\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4726, 2)))
+
+def _BuildAutomaton_31 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_31
+    del _BuildAutomaton_31
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4326, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4327, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4332, 8))
+    counters.add(cc_3)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4314, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Well')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4326, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4327, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_54._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'PlateAcquisition')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4332, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    st_3._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_54._Automaton = _BuildAutomaton_31()
+
+
+
+
+CTD_ANON_55._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_55, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_55._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_34, scope=CTD_ANON_55, documentation='\n              A long description for the reagent.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 8)))
+
+def _BuildAutomaton_32 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_32
+    del _BuildAutomaton_32
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4519, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_55._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4507, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_55._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4519, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_55._Automaton = _BuildAutomaton_32()
+
+
+
+
+CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_57, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Reagent'), CTD_ANON_55, scope=CTD_ANON_57, documentation='\n        Reagent is used to describe a chemical or some other physical experimental parameter.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4498, 2)))
+
+CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_35, scope=CTD_ANON_57, documentation='\n              A description for the screen.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 8)))
+
+CTD_ANON_57._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PlateRef'), CTD_ANON_58, scope=CTD_ANON_57, documentation='\n              The PlateRef element is a reference to a Plate element.\n              Screen elements may have one or more PlateRef elements to define the plates that are part of the screen.\n              Plates may belong to more than one screen.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8)))
+
+def _BuildAutomaton_33 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_33
+    del _BuildAutomaton_33
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4586, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8))
+    counters.add(cc_2)
+    cc_3 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4604, 8))
+    counters.add(cc_3)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4574, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Reagent')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4586, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'PlateRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4587, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_3, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_57._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4604, 8))
+    st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_3)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_2, False) ]))
+    st_2._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_3, [
+        fac.UpdateInstruction(cc_3, True) ]))
+    st_3._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_57._Automaton = _BuildAutomaton_33()
+
+
+
+
+CTD_ANON_59._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_59, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_59._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Description'), STD_ANON_36, scope=CTD_ANON_59, documentation='\n              A description for the PlateAcquisition.\n            ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 8)))
+
+CTD_ANON_59._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef'), CTD_ANON_62, scope=CTD_ANON_59, documentation='\n        The WellSampleRef element is a reference to a WellSample element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4883, 2)))
+
+def _BuildAutomaton_34 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_34
+    del _BuildAutomaton_34
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4684, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4685, 8))
+    counters.add(cc_2)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4672, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'WellSampleRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4684, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_59._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4685, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_59._Automaton = _BuildAutomaton_34()
+
+
+
+
+CTD_ANON_60._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef'), CTD_ANON_51, scope=CTD_ANON_60, documentation='\n        The AnnotationRef element is a reference to an element derived\n        from the CommonAnnotation element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3435, 2)))
+
+CTD_ANON_60._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef'), CTD_ANON_56, scope=CTD_ANON_60, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4544, 2)))
+
+CTD_ANON_60._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'WellSample'), CTD_ANON_61, scope=CTD_ANON_60, documentation='\n        WellSample is an individual image that has been captured within a Well.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4810, 2)))
+
+def _BuildAutomaton_35 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_35
+    del _BuildAutomaton_35
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4739, 8))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4744, 8))
+    counters.add(cc_1)
+    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4745, 8))
+    counters.add(cc_2)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'WellSample')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4739, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ReagentRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4744, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_2, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_60._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4745, 8))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_2, True) ]))
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_60._Automaton = _BuildAutomaton_35()
+
+
+
+
+CTD_ANON_61._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ImageRef'), CTD_ANON_36, scope=CTD_ANON_61, documentation='\n        The ImageRef element is a reference to an Image element.\n      ', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2844, 2)))
+
+def _BuildAutomaton_36 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_36
+    del _BuildAutomaton_36
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4819, 8))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_61._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'ImageRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4819, 8))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_61._Automaton = _BuildAutomaton_36()
+
+
+
+
+CTD_ANON_63._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Pump'), CTD_ANON_35, scope=CTD_ANON_63, documentation="\n        The Pump element is a reference to a LightSource.  It is used within the Laser element to specify the light source for the laser's pump (if any).\n      ", location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2778, 2)))
+
+def _BuildAutomaton_37 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_37
+    del _BuildAutomaton_37
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2508, 12))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_63._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_63._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Pump')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2508, 12))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_63._Automaton = _BuildAutomaton_37()
+
+
+
+
+def _BuildAutomaton_38 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_38
+    del _BuildAutomaton_38
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_64._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_64._Automaton = _BuildAutomaton_38()
+
+
+
+
+def _BuildAutomaton_39 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_39
+    del _BuildAutomaton_39
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_65._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_65._Automaton = _BuildAutomaton_39()
+
+
+
+
+def _BuildAutomaton_40 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_40
+    del _BuildAutomaton_40
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    counters.add(cc_0)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_66._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    st_0._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_66._Automaton = _BuildAutomaton_40()
+
+
+
+
+CTD_ANON_67._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Map'), Map, scope=CTD_ANON_67, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12)))
+
+def _BuildAutomaton_41 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_41
+    del _BuildAutomaton_41
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2468, 10))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_67._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Map')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 2772, 12))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_67._Automaton = _BuildAutomaton_41()
+
+
+
+
+def _BuildAutomaton_42 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_42
+    del _BuildAutomaton_42
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(BasicAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(BasicAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+BasicAnnotation._Automaton = _BuildAutomaton_42()
+
+
+
+
+def _BuildAutomaton_43 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_43
+    del _BuildAutomaton_43
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(TextAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(TextAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+TextAnnotation._Automaton = _BuildAutomaton_43()
+
+
+
+
+def _BuildAutomaton_44 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_44
+    del _BuildAutomaton_44
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(TypeAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(TypeAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+TypeAnnotation._Automaton = _BuildAutomaton_44()
+
+
+
+
+def _BuildAutomaton_45 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_45
+    del _BuildAutomaton_45
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_68._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_68._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_68._Automaton = _BuildAutomaton_45()
+
+
+
+
+CTD_ANON_69._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), Map, scope=CTD_ANON_69, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3738, 12)))
+
+def _BuildAutomaton_46 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_46
+    del _BuildAutomaton_46
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_69._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3738, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_69._Automaton = _BuildAutomaton_46()
+
+
+
+
+def _BuildAutomaton_47 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_47
+    del _BuildAutomaton_47
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_70._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_70._Automaton = _BuildAutomaton_47()
+
+
+
+
+CTD_ANON_71._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinData'), CTD_ANON_50, scope=CTD_ANON_71, documentation='The contents of this element are base64-encoded.  These are not CDATA sections, just a base64 stream.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3320, 2)))
+
+def _BuildAutomaton_48 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_48
+    del _BuildAutomaton_48
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_71._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinData')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 4023, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_71._Automaton = _BuildAutomaton_48()
+
+
+
+
+def _BuildAutomaton_49 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_49
+    del _BuildAutomaton_49
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_72._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_72._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_72._Automaton = _BuildAutomaton_49()
+
+
+
+
+def _BuildAutomaton_50 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_50
+    del _BuildAutomaton_50
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_73._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_73._Automaton = _BuildAutomaton_50()
+
+
+
+
+def _BuildAutomaton_51 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_51
+    del _BuildAutomaton_51
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_74._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_74._Automaton = _BuildAutomaton_51()
+
+
+
+
+def _BuildAutomaton_52 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_52
+    del _BuildAutomaton_52
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_75._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_75._Automaton = _BuildAutomaton_52()
+
+
+
+
+def _BuildAutomaton_53 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_53
+    del _BuildAutomaton_53
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_76._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_76._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_76._Automaton = _BuildAutomaton_53()
+
+
+
+
+def _BuildAutomaton_54 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_54
+    del _BuildAutomaton_54
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Transform')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3806, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_77._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3815, 6))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+CTD_ANON_77._Automaton = _BuildAutomaton_54()
+
+
+
+
+def _BuildAutomaton_55 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_55
+    del _BuildAutomaton_55
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_0, False))
+    symbol = pyxb.binding.content.ElementUse(NumericAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = set()
+    final_update.add(fac.UpdateInstruction(cc_1, False))
+    symbol = pyxb.binding.content.ElementUse(NumericAnnotation._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    st_1._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, True, containing_state=None)
+NumericAnnotation._Automaton = _BuildAutomaton_55()
+
+
+
+
+CTD_ANON_78._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile'), CTD_ANON_16, scope=CTD_ANON_78, documentation='Describes a binary file.', location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3362, 2)))
+
+def _BuildAutomaton_56 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_56
+    del _BuildAutomaton_56
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_78._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'BinaryFile')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3565, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_78._Automaton = _BuildAutomaton_56()
+
+
+
+
+CTD_ANON_79._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), CTD_ANON_4, scope=CTD_ANON_79, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3582, 12)))
+
+def _BuildAutomaton_57 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_57
+    del _BuildAutomaton_57
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_79._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3582, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_79._Automaton = _BuildAutomaton_57()
+
+
+
+
+CTD_ANON_80._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.string, scope=CTD_ANON_80, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3619, 12)))
+
+def _BuildAutomaton_58 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_58
+    del _BuildAutomaton_58
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_80._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3619, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_80._Automaton = _BuildAutomaton_58()
+
+
+
+
+CTD_ANON_81._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.boolean, scope=CTD_ANON_81, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3670, 12)))
+
+def _BuildAutomaton_59 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_59
+    del _BuildAutomaton_59
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_81._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3670, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_81._Automaton = _BuildAutomaton_59()
+
+
+
+
+CTD_ANON_82._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.dateTime, scope=CTD_ANON_82, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3687, 12)))
+
+def _BuildAutomaton_60 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_60
+    del _BuildAutomaton_60
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_82._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3687, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_82._Automaton = _BuildAutomaton_60()
+
+
+
+
+CTD_ANON_83._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.string, scope=CTD_ANON_83, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3704, 12)))
+
+def _BuildAutomaton_61 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_61
+    del _BuildAutomaton_61
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_83._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3704, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_83._Automaton = _BuildAutomaton_61()
+
+
+
+
+CTD_ANON_84._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.string, scope=CTD_ANON_84, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3721, 12)))
+
+def _BuildAutomaton_62 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_62
+    del _BuildAutomaton_62
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_84._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3721, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_84._Automaton = _BuildAutomaton_62()
+
+
+
+
+CTD_ANON_85._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.long, scope=CTD_ANON_85, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3636, 12)))
+
+def _BuildAutomaton_63 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_63
+    del _BuildAutomaton_63
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_85._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3636, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_85._Automaton = _BuildAutomaton_63()
+
+
+
+
+CTD_ANON_86._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Value'), pyxb.binding.datatypes.double, scope=CTD_ANON_86, location=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3653, 12)))
+
+def _BuildAutomaton_64 ():
+    # Remove this helper function from the namespace after it is invoked
+    global _BuildAutomaton_64
+    del _BuildAutomaton_64
+    import pyxb.utils.fac as fac
+
+    counters = set()
+    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    counters.add(cc_0)
+    cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    counters.add(cc_1)
+    states = []
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Description')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3460, 6))
+    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_0)
+    final_update = None
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'AnnotationRef')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3473, 8))
+    st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_1)
+    final_update = set()
+    symbol = pyxb.binding.content.ElementUse(CTD_ANON_86._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Value')), pyxb.utils.utility.Location('https://www.openmicroscopy.org/Schemas/OME/2016-06/ome.xsd', 3653, 12))
+    st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
+    states.append(st_2)
+    transitions = []
+    transitions.append(fac.Transition(st_0, [
+        fac.UpdateInstruction(cc_0, True) ]))
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_0, False) ]))
+    st_0._set_transitionSet(transitions)
+    transitions = []
+    transitions.append(fac.Transition(st_1, [
+        fac.UpdateInstruction(cc_1, True) ]))
+    transitions.append(fac.Transition(st_2, [
+        fac.UpdateInstruction(cc_1, False) ]))
+    st_1._set_transitionSet(transitions)
+    transitions = []
+    st_2._set_transitionSet(transitions)
+    return fac.Automaton(states, counters, False, containing_state=None)
+CTD_ANON_86._Automaton = _BuildAutomaton_64()
+
+
+Laser._setSubstitutionGroup(LightSourceGroup)
+
+Arc._setSubstitutionGroup(LightSourceGroup)
+
+Filament._setSubstitutionGroup(LightSourceGroup)
+
+LightEmittingDiode._setSubstitutionGroup(LightSourceGroup)
+
+GenericExcitationSource._setSubstitutionGroup(LightSourceGroup)
+
+Rectangle._setSubstitutionGroup(ShapeGroup)
+
+Mask._setSubstitutionGroup(ShapeGroup)
+
+Point._setSubstitutionGroup(ShapeGroup)
+
+Ellipse._setSubstitutionGroup(ShapeGroup)
+
+Line._setSubstitutionGroup(ShapeGroup)
+
+Polyline._setSubstitutionGroup(ShapeGroup)
+
+Polygon._setSubstitutionGroup(ShapeGroup)
+
+Label._setSubstitutionGroup(ShapeGroup)
diff --git a/format_conversion/tiff_to_vtk.py b/format_conversion/tiff_to_vtk.py
new file mode 100644
index 0000000..71216b2
--- /dev/null
+++ b/format_conversion/tiff_to_vtk.py
@@ -0,0 +1,120 @@
+"""
+Convert to VTK. Use pvti files for final assembly.
+"""
+
+import os
+import logging
+import math
+from argparse import ArgumentParser
+from functools import partial
+import multiprocessing as mp
+import vtk
+import utility
+import extract_zeiss_metadata
+
+
+def do_conversion(file_attributes, working_directory):
+    
+    reader = vtk.vtkTIFFReader()
+    reader.SetFileName(file_attributes["FileName"])
+    reader.Update()
+    
+    image_data = reader.GetOutput()
+    image_data.SetExtent(file_attributes["Extents"])
+    image_data.SetSpacing(file_attributes["PhysicalSize"])
+    
+    out_path = working_directory + "/" + os.path.splitext(os.path.basename(file_attributes["FileName"]))[0] + ".vti"
+    writer = vtk.vtkXMLImageDataWriter()
+    writer.SetInputData(image_data)
+    writer.SetFileName(out_path)
+    writer.Write()
+
+def convert_to_vti(input_folder, metadata_file, tile_dimensions, downsample_dimensions):
+    
+    extract_zeiss_metadata.extract_metadata(metadata_file, os.getcwd() + "temp_metadata.xml")
+    image_metadata = extract_zeiss_metadata.get_metadata_as_class(os.getcwd() + "temp_metadata.xml")
+    
+    num_x = int(math.floor(image_metadata.Image[0].Pixels.SizeX/tile_dimensions[0]))+1
+    num_y = int(math.floor(image_metadata.Image[0].Pixels.SizeY/tile_dimensions[1]))+1
+    size_x = int(math.floor(tile_dimensions[0]/downsample_dimensions[0]))+1
+    size_y = int(math.floor(tile_dimensions[1]/downsample_dimensions[1]))+1
+    size_z = int(math.floor(image_metadata.Image[0].Pixels.SizeZ/downsample_dimensions[2]))
+    physical_x = float(image_metadata.Image[0].Pixels.PhysicalSizeX)*float(downsample_dimensions[0])
+    physical_y = float(image_metadata.Image[0].Pixels.PhysicalSizeY)*float(downsample_dimensions[1])
+    physical_z = float(image_metadata.Image[0].Pixels.PhysicalSizeZ)*float(downsample_dimensions[2])
+    
+    # Grab the file base name. Assume the input folder only has the tiff files we want to convert
+    path_base_name = ""
+    for eachFile in os.listdir(input_folder):
+        if eachFile.endswith(".tiff"):
+            loc_start_index = eachFile.find("_tile")
+            if loc_start_index>-1:
+                path_base_name = input_folder + "/" + eachFile[:loc_start_index]
+                break
+            
+    file_attribute_collection = []
+    for jdx in range(num_y):
+        for idx in range(num_x):
+            global_index = idx + jdx*num_x
+            file_name = path_base_name + "_tile_X" + str(idx) + "_Y" + str(jdx) + "_ID_" + str(global_index)+"_pixels_only_downsampled.tiff"
+            min_ext_x = idx*size_x
+            min_ext_y = jdx*size_y
+            max_ext_x = (idx+1)*size_x-1
+            max_ext_y = (jdx+1)*size_y-1
+            min_ext_z = 0
+            max_ext_z = size_z-1
+            if idx == num_x - 1:
+                max_ext_x = int(math.floor(image_metadata.Image[0].Pixels.SizeX/downsample_dimensions[0]))+2
+            if jdx == num_y - 1:
+                max_ext_y = int(math.floor(image_metadata.Image[0].Pixels.SizeY/downsample_dimensions[1]))+2
+            extents = [min_ext_x, max_ext_x, min_ext_y, max_ext_y, min_ext_z, max_ext_z]
+            file_attributes = {}
+            file_attributes["PhysicalSize"]= (physical_x, physical_y, physical_z)
+            file_attributes["Extents"]= extents
+            file_attributes["FileName"]= file_name
+            file_attribute_collection.append(file_attributes)
+            
+    # Make a partial function for multiple arg mapping
+    working_directory = os.getcwd() + "/VTK_Files/"
+    if not os.path.exists(working_directory):
+        os.makedirs(working_directory)
+    partial_extract_pixel_values_only = partial(do_conversion, working_directory=working_directory)
+     
+    # Limit to max 6 cpus
+    num_available_cpus = mp.cpu_count()
+    if num_available_cpus > 6:
+        num_available_cpus = 6
+        
+    # Distribute across processes - Be conservative with available CPUs
+    run_cpus = int(math.floor(num_available_cpus/2))
+    if run_cpus == 0:
+        run_cpus = 1
+    #pool = mp.Pool(processes = run_cpus)
+    pool = mp.Pool(processes = 1)
+    pool.map(partial_extract_pixel_values_only, file_attribute_collection)
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "zeiss_to_tiff"
+    utility.do_setup(tool_name)
+    logger1 = logging.getLogger('tiff_to_vtk.'+tool_name)
+    
+    # Suppress XML Parse warnings
+    pyxb_logger = logging.getLogger('pyxb')
+    pyxb_logger.setLevel(logging.CRITICAL)
+    
+    parser = ArgumentParser()
+    parser.add_argument("-i", "--input_folder", type=str, help='Folder with tiffs to be converted.')
+    parser.add_argument("-m", "--metadatafile", type=str, help='File with image metadata.')
+    parser.add_argument("-tx", "--tile_x", type=int, help='X Tile size.')
+    parser.add_argument("-ty", "--tile_y", type=int, help='Y Tile Size.')
+    parser.add_argument("-dx", "--downsample_x", type=int, help='X Downsample Factor.', default=1)
+    parser.add_argument("-dy", "--downsample_y", type=int, help='Y Downsample Factor.', default=1)
+    parser.add_argument("-dz", "--downsample_z", type=int, help='Y Downsample Factor.', default=1)
+    args = parser.parse_args()
+    
+    logger1.info('Start Converting Images to VTI at: ' + args.input_folder)
+    convert_to_vti(args.input_folder, args.metadatafile, (args.tile_x, args.tile_y), 
+                   (args.downsample_x, args.downsample_y, args.downsample_z))
+    logger1.info('Completed Converting')
\ No newline at end of file
diff --git a/format_conversion/zeiss_to_tiff.py b/format_conversion/zeiss_to_tiff.py
new file mode 100644
index 0000000..7fa0451
--- /dev/null
+++ b/format_conversion/zeiss_to_tiff.py
@@ -0,0 +1,97 @@
+"""
+Conversion of IMS/LSM/CZI files to OME and then Generic TIFFs
+"""
+
+import os
+import logging
+import math
+from argparse import ArgumentParser
+from functools import partial
+import multiprocessing as mp
+import skimage.external.tifffile
+import utility
+import extract_zeiss_metadata
+import bftools_wrapper
+
+def extract_pixel_values_only(input_file, working_directory, channel=0, significant_bits=8):
+
+    im = skimage.external.tifffile.imread(input_file)
+    pixel_vals_only = im[0, :, 0, channel, :, :] # Strip excess data
+    out_path = working_directory + "/" + os.path.splitext(os.path.basename(input_file))[0] + "_pixels_only.tiff"
+    
+    if significant_bits==8:
+        skimage.external.tifffile.imsave(out_path, skimage.img_as_ubyte(pixel_vals_only))
+    elif significant_bits==16:
+        skimage.external.tifffile.imsave(out_path, skimage.img_as_uint(pixel_vals_only))
+    else:
+        # Let skiimage decide
+        skimage.external.tifffile.imsave(out_path, pixel_vals_only)
+        
+def do_conversion(input_file, output_file, channel = 0, series = 0):
+#     
+#     # Get the image metadata
+    extract_zeiss_metadata.extract_metadata(input_file, os.getcwd() + "temp_metadata.xml")
+    image_metadata = extract_zeiss_metadata.get_metadata_as_class(os.getcwd() + "temp_metadata.xml")
+#     
+#     # Choose the tile size
+    tile_x = 1024
+    tile_y = 1024
+    
+    # Black box JVM conversion via CLI. Be skeptical of outputs, 
+    # at least the Z-physical size is silently lost!!!
+    bftools_wrapper.convert(input_file, output_file, tile_x, tile_y, channel, series)
+    
+    # Make versions with just XYZ pixel values for easier use in scikit-image/VTK etc. 
+    # DANGER, now all physical size is lost. Only trust physical sizes
+    # in the standalone xml metadata file, obtained (and validated) using `extract_zeiss_metadata()`.
+    
+    # Collect the file names
+    file_names = []
+    for eachFile in os.listdir(output_file):
+        if eachFile.endswith(".tiff"):
+            file_names.append(output_file + "/" + eachFile)
+
+    # Make a partial function for multiple arg mapping
+    working_directory = output_file + "/Pixel_Values_Only/"
+    if not os.path.exists(working_directory):
+        os.makedirs(working_directory)
+        
+    significant_bits = int(image_metadata.Image[0].Pixels.SignificantBits)
+    partial_extract_pixel_values_only = partial(extract_pixel_values_only, 
+                                                working_directory=working_directory, 
+                                                channel=channel,
+                                                significant_bits=significant_bits)
+     
+    # Limit to max 6 cpus
+    num_available_cpus = mp.cpu_count()
+    if num_available_cpus > 6:
+        num_available_cpus = 6
+        
+    # Distribute across processes - Be conservative with available CPUs
+    run_cpus = int(math.floor(num_available_cpus/2))
+    if run_cpus == 0:
+        run_cpus = 1
+    run_cpus = 1
+    #pool = mp.Pool(processes = run_cpus)
+    pool = mp.Pool(processes = 1)
+    pool.map(partial_extract_pixel_values_only, file_names)
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "zeiss_to_tiff"
+    utility.do_setup(tool_name)
+    logger1 = logging.getLogger('format_conversion.'+tool_name)
+    
+    # Suppress XML Parse warnings
+    pyxb_logger = logging.getLogger('pyxb')
+    pyxb_logger.setLevel(logging.CRITICAL)
+    
+    parser = ArgumentParser()
+    parser.add_argument("-i", "--input_file", type=str, help='Input file in a ZEISS format.')
+    parser.add_argument("-o", "--output_folder", type=str, help='Output Tiff Location.')
+    args = parser.parse_args()
+    
+    logger1.info('Start Converting Image at: ' + args.input_file)
+    do_conversion(args.input_file, args.output_folder, channel = 1, series = 0)
+    logger1.info('Completed Processing')
\ No newline at end of file
diff --git a/image/__init__.py b/image/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/image/downsample_tiffs.py b/image/downsample_tiffs.py
new file mode 100644
index 0000000..ec6a200
--- /dev/null
+++ b/image/downsample_tiffs.py
@@ -0,0 +1,75 @@
+"""
+Downsample the tiffs for easier postprocessing
+"""
+
+import os
+import logging
+import math
+from argparse import ArgumentParser
+from functools import partial
+import multiprocessing as mp
+import skimage.external.tifffile
+import skimage.transform
+from skimage import exposure
+import utility
+
+def do_downsample(input_file, working_directory, downsample_ratios):
+    
+    im = skimage.external.tifffile.imread(input_file)
+    downsampled = skimage.transform.downscale_local_mean(im, downsample_ratios)
+    out_path = working_directory + "/" + os.path.splitext(os.path.basename(input_file))[0] + "_downsampled.tiff"
+    scaled_image = exposure.rescale_intensity(downsampled, out_range=(0.0, 1.0))
+    skimage.external.tifffile.imsave(out_path, skimage.img_as_ubyte(scaled_image))
+    
+def downsample_tiffs(input_folder, downsample_ratios, channel = 0, series = 0):
+    
+    file_names = []
+    dir_name = os.path.dirname(input_folder)
+    for eachFile in os.listdir(input_folder):
+        if eachFile.endswith(".tiff"):
+            file_names.append(dir_name + "/" + eachFile)
+    
+    # Make a partial function for multiple arg mapping
+    working_directory = os.getcwd() + "/Downsampled_X"+str(downsample_ratios[2]) + "_Y"+str(downsample_ratios[1])
+    working_directory += "_Z"+str(downsample_ratios[0]) + "/"
+    if not os.path.exists(working_directory):
+        os.makedirs(working_directory)
+    partial_extract_pixel_values_only = partial(do_downsample, 
+                                                working_directory=working_directory, 
+                                                downsample_ratios=downsample_ratios)
+     
+    # Limit to max 6 cpus
+    num_available_cpus = mp.cpu_count()
+    if num_available_cpus > 6:
+        num_available_cpus = 6
+        
+    # Distribute across processes - Be conservative with available CPUs
+    run_cpus = int(math.floor(num_available_cpus/2))
+    if run_cpus == 0:
+        run_cpus = 1
+    #pool = mp.Pool(processes = run_cpus)
+    pool = mp.Pool(processes = 3)
+    pool.map(partial_extract_pixel_values_only, file_names)
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "zeiss_to_tiff"
+    utility.do_setup(tool_name)
+    logger1 = logging.getLogger('downsample_tiffs.'+tool_name)
+    
+    # Suppress XML Parse warnings
+    pyxb_logger = logging.getLogger('pyxb')
+    pyxb_logger.setLevel(logging.CRITICAL)
+    
+    parser = ArgumentParser()
+    parser.add_argument("-i", "--input_folder", type=str, help='Folder with tiffs to be downsampled.')
+    parser.add_argument("-x", "--x_reduction", type=int, help='Factor reduction in x.', default=1)
+    parser.add_argument("-y", "--y_reduction", type=int, help='Factor reduction in y.', default=1)
+    parser.add_argument("-z", "--z_reduction", type=int, help='Factor reduction in z.', default=1)
+    args = parser.parse_args()
+    
+    logger1.info('Start Downsampling Images at: ' + args.input_folder)
+    downsample_ratios = (args.z_reduction, args.y_reduction, args.x_reduction)
+    downsample_tiffs(args.input_folder, downsample_ratios)
+    logger1.info('Completed Downsampling')
\ No newline at end of file
diff --git a/image/processing.py b/image/processing.py
new file mode 100644
index 0000000..4052ffb
--- /dev/null
+++ b/image/processing.py
@@ -0,0 +1,135 @@
+import itk
+
+def default_image_type():
+    return itk.Image[itk.UC, 3]
+
+def image_type_2d():
+    return itk.Image[itk.UC, 2]
+
+def read_image(path, image_type):
+    
+    """
+    Read the image from file
+    """
+    
+    reader = itk.ImageFileReader[image_type].New()
+    reader.SetFileName(path)
+    reader.Update()
+    return reader
+
+def write_image(path, image_type, image_container):
+    
+    """
+    Write the image to file
+    """
+    
+    writer = itk.ImageFileWriter[image_type].New()
+    writer.SetInput(image_container.GetOutput())
+    writer.SetFileName(path)
+    writer.Update()
+    
+def convert_vtk(image_container, image_type):
+    
+    itk_vtk_converter = itk.ImageToVTKImageFilter[image_type].New()
+    itk_vtk_converter.SetInput(image_container.GetOutput())
+    itk_vtk_converter.Update()
+    return itk_vtk_converter
+
+def merge_tiles(image_containers, image_type, num_x):
+    
+    tiler = itk.TileImageFilter[image_type,image_type].New()
+    layout = [num_x, num_x, 0]
+    tiler.SetLayout(layout)
+    for idx, eachContainer in enumerate(image_containers):
+        tiler.SetInput(idx, eachContainer.GetOutput())
+        
+    tiler.Update()
+    return tiler
+
+def median_filter(image_container, image_type, radius):
+    
+    median_filter = itk.MedianImageFilter[image_type, image_type].New()
+    median_filter.SetInput(image_container.GetOutput())
+    median_filter.SetRadius(radius)
+    median_filter.Update()
+    
+    return median_filter
+    
+def correct_spacing(image_container, image_type, z_spacing):
+    
+    correct = itk.ChangeInformationImageFilter[image_type].New()
+    correct.SetInput(image_container.GetOutput())
+    spacing = image_container.GetOutput().GetSpacing()
+    spacing[2] = z_spacing
+    correct.SetOutputSpacing(spacing)
+    correct.ChangeSpacingOn()
+    correct.Update()
+    
+    return correct
+
+def sum_projection(image_container, image_type):
+    output_type = itk.Image[itk.UC, 2]
+    
+    sum_projection = itk.SumProjectionImageFilter[image_type, output_type].New()
+    sum_projection.SetInput(image_container.GetOutput())
+    
+    sum_projection.Update()
+    return sum_projection
+
+def shrink_image(image_type, image_container, factors = [2,2,2]):
+    
+    """
+    Reduce the size of the image in each dimension by the specified factors
+    """
+    
+    shrink = itk.ShrinkImageFilter[image_type, image_type].New()
+    shrink.SetInput(image_container.GetOutput())
+    shrink.SetShrinkFactor(0, factors[0])
+    shrink.SetShrinkFactor(1, factors[1])
+    shrink.SetShrinkFactor(2, factors[2])
+    shrink.Update()
+    return shrink
+
+def get_roi(image_type, image_container, start = [0,0,0], size = [200, 200, 10]):
+    
+    """
+    Select a region of interest in the image
+    """
+    
+    roi = itk.RegionOfInterestImageFilter[image_type, image_type].New()
+    roi.SetInput(image_container.GetOutput())
+
+    region = itk.ImageRegion[3]()
+    region.SetIndex(start)
+    region.SetSize(size)
+
+    roi.SetRegionOfInterest(region)
+    roi.Update()
+    return roi
+
+def threshold_image(image_type, image_container, lower = 195, upper = 200):
+    
+    """
+    Do a binary thresholding
+    """
+    
+    threshold = itk.BinaryThresholdImageFilter[image_type,image_type].New()
+    threshold.SetInput(image_container.GetOutput())
+    threshold.SetLowerThreshold(lower)
+    threshold.SetUpperThreshold(upper)
+    threshold.Update()
+    return threshold
+    
+def get_intensity_histogram(image_type, image_container):
+    
+    """
+    Write an intensity histogram
+    """
+    
+    histogram = itk.ImageToHistogramFilter[image_type].New()
+    histogram.SetInput(image_container.GetOutput())
+    histogram.Update()
+    
+    for idx in range(histogram.GetOutput().GetSize()[0]):
+        print "Hist Intensity: ", idx, " Frequency: ", histogram.GetOutput().GetFrequency(idx)
+    
\ No newline at end of file
diff --git a/image/processing/__init__.py b/image/processing/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/image/processing/conversion/__init__.py b/image/processing/conversion/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/image/processing/median.py b/image/processing/median.py
new file mode 100644
index 0000000..0a42856
--- /dev/null
+++ b/image/processing/median.py
@@ -0,0 +1,30 @@
+"""
+Median filter on chosen image
+"""
+
+import logging
+from code.image.tools import it_wrapper
+import code.image.settings
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "median"
+    work_dir, image_data = code.image.settings.do_setup(tool_name)
+    logger1 = logging.getLogger('processing.'+tool_name)
+
+    output_path = work_dir+"/median"
+    
+    logger1.info('Start Filtering Image at: ' + work_dir)
+    image_type = it_wrapper.default_image_type()
+    
+    input_path = work_dir + "/convert/itk_tile_0_2_6.tiff"
+    logger1.info("Reading the image: " +input_path + " into ITK")
+    reader = it_wrapper.read_image(input_path, image_type)
+    correct = it_wrapper.correct_spacing(reader, image_type, image_data["VoxelSizeZ"])
+            
+    logger1.info('Doing Median Filter')
+    median_filter = it_wrapper.median_filter(correct, image_type, 1)
+    
+    logger1.info('Writing TIFF Stack')
+    it_wrapper.write_image(output_path+"/itk_tile_0_2_6.tiff", image_type, median_filter)
\ No newline at end of file
diff --git a/image/processing/projection.py b/image/processing/projection.py
new file mode 100644
index 0000000..48fdd2f
--- /dev/null
+++ b/image/processing/projection.py
@@ -0,0 +1,36 @@
+"""
+SUM projection of tiled images
+"""
+
+import logging
+from code.image.tools import it_wrapper
+import code.image.settings
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "projection"
+    work_dir, image_data = code.image.settings.do_setup(tool_name)
+    logger1 = logging.getLogger('processing.'+tool_name)
+
+    output_path = work_dir+"/projection"
+    
+    logger1.info('Start Projecting Image at: ' + work_dir)
+    image_type = it_wrapper.default_image_type()
+    
+    num_tiles_y = 3
+    num_tiles_x = 3
+    for jdx in range(num_tiles_y):
+        for idx in range(num_tiles_x):
+            label = str(idx) + "_" + str(jdx) +"_"+ str(idx+ num_tiles_x*jdx)
+            input_path = work_dir + "/convert/itk_tile_" + label + ".tiff"
+            logger1.info("Reading the image: " +input_path + " into ITK")
+            reader = it_wrapper.read_image(input_path, image_type)
+            correct = it_wrapper.correct_spacing(reader, image_type, image_data["VoxelSizeZ"])
+            
+            logger1.info('Doing SUM projection')
+            project = it_wrapper.sum_projection(correct, image_type)
+    
+            output_image_type = it_wrapper.image_type_2d()
+            logger1.info('Writing TIFF Stack')
+            it_wrapper.write_image(output_path+"/sum_tile_" + label + ".tiff", output_image_type, project)
\ No newline at end of file
diff --git a/image/processing/reduce.py b/image/processing/reduce.py
new file mode 100644
index 0000000..d59c164
--- /dev/null
+++ b/image/processing/reduce.py
@@ -0,0 +1,30 @@
+"""
+Median filter on chosen image
+"""
+
+import logging
+from code.image.tools import it_wrapper
+import code.image.settings
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "reduce"
+    work_dir, image_data = code.image.settings.do_setup(tool_name)
+    logger1 = logging.getLogger('processing.'+tool_name)
+
+    output_path = work_dir+"/reduce"
+    
+    logger1.info('Start Reducing Image at: ' + work_dir)
+    image_type = it_wrapper.default_image_type()
+    
+    input_path = work_dir + "/median/itk_tile_0_2_6.tiff"
+    logger1.info("Reading the image: " +input_path + " into ITK")
+    reader = it_wrapper.read_image(input_path, image_type)
+    correct = it_wrapper.correct_spacing(reader, image_type, image_data["VoxelSizeZ"])
+            
+    logger1.info('Doing Reduction')
+    im_reduce = it_wrapper.shrink_image(image_type, correct, [2,2,1])
+    
+    logger1.info('Writing TIFF Stack')
+    it_wrapper.write_image(output_path+"/itk_tile_0_2_6.tiff", image_type, im_reduce)
\ No newline at end of file
diff --git a/image/processing/show.py b/image/processing/show.py
new file mode 100644
index 0000000..d92fce5
--- /dev/null
+++ b/image/processing/show.py
@@ -0,0 +1,17 @@
+"""
+Show a tiff using vtk
+"""
+
+import code.image.settings
+from code.image.tools import simple_render
+from code.image.tools import it_wrapper
+
+work_dir, input_data = code.image.settings.do_setup("show")
+input_path = work_dir + "/threshold/itk_tile_0_2_6.tiff"
+
+image_type = it_wrapper.default_image_type()
+reader = it_wrapper.read_image(input_path, image_type)
+correct = it_wrapper.correct_spacing(reader, image_type, input_data["VoxelSizeZ"])
+converter = it_wrapper.convert_vtk(reader, image_type)
+    
+simple_render.render_image(converter, threshold = 1.0)
\ No newline at end of file
diff --git a/image/processing/threshold.py b/image/processing/threshold.py
new file mode 100644
index 0000000..266afc2
--- /dev/null
+++ b/image/processing/threshold.py
@@ -0,0 +1,30 @@
+"""
+Threshold on chosen image
+"""
+
+import logging
+from code.image.tools import it_wrapper
+import code.image.settings
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "threshold"
+    work_dir, image_data = code.image.settings.do_setup(tool_name)
+    logger1 = logging.getLogger('processing.'+tool_name)
+
+    output_path = work_dir+"/threshold"
+    
+    logger1.info('Start Thresholding Image at: ' + work_dir)
+    image_type = it_wrapper.default_image_type()
+    
+    input_path = work_dir + "/reduce/itk_tile_0_2_6.tiff"
+    logger1.info("Reading the image: " +input_path + " into ITK")
+    reader = it_wrapper.read_image(input_path, image_type)
+    correct = it_wrapper.correct_spacing(reader, image_type, image_data["VoxelSizeZ"])
+            
+    logger1.info('Doing Thresholding')
+    threshold = it_wrapper.threshold_image(image_type, correct, lower = 20, upper = 255)
+    
+    logger1.info('Writing TIFF Stack')
+    it_wrapper.write_image(output_path+"/itk_tile_0_2_6.tiff", image_type, threshold)
\ No newline at end of file
diff --git a/image/processing/tile.py b/image/processing/tile.py
new file mode 100644
index 0000000..d3f15c0
--- /dev/null
+++ b/image/processing/tile.py
@@ -0,0 +1,39 @@
+"""
+Merging of tiled images
+"""
+
+import logging
+from code.image.tools import it_wrapper
+import code.image.settings
+
+if __name__ == "__main__":
+    
+    # Do setup
+    tool_name = "tile"
+    work_dir, image_data = code.image.settings.do_setup(tool_name)
+    logger1 = logging.getLogger('processing.'+tool_name)
+
+    output_path = work_dir+"/projection"
+    
+    logger1.info('Start Merging Images at: ' + work_dir)
+    image_type = it_wrapper.default_image_type()
+    
+    num_tiles_y = 3
+    num_tiles_x = 3
+    container = []
+    for jdx in range(num_tiles_y):
+        for idx in range(num_tiles_x):
+            
+            label = str(idx) + "_" + str(jdx) +"_"+ str(idx+ num_tiles_x*jdx)
+            input_path = work_dir + "/projection/sum_tile_" + label + ".tiff"
+            logger1.info("Reading the image: " +input_path + " into ITK")
+            reader = it_wrapper.read_image(input_path, image_type)
+            correct = it_wrapper.correct_spacing(reader, image_type, image_data["VoxelSizeZ"])
+            container.append(correct)
+    
+    logger1.info('Merging Tiles')    
+    merged = it_wrapper.merge_tiles(container, image_type, num_tiles_x)
+      
+    output_image_type = it_wrapper.default_image_type()
+    logger1.info('Writing TIFF Stack')
+    it_wrapper.write_image(output_path+"/sum_merge.tiff", output_image_type, merged)
\ No newline at end of file
diff --git a/image/surface.py b/image/surface.py
new file mode 100644
index 0000000..a0caf3f
--- /dev/null
+++ b/image/surface.py
@@ -0,0 +1,171 @@
+import vtk
+from vmtk import pypes
+
+class Surface2d():
+    
+    def __init__(self, input_path):
+        self.input_path = input_path
+        self.surface = None
+        self.boundaries = None
+    
+    def generate(self, target_reduction = 0.9994, num_subdivisions = 3, resize_factors = None, clipping_factor = 0.0):
+        
+        # Convert to VTI
+        myArguments = 'vmtkimagereader -ifile ' + self.input_path
+        my_pype = pypes.PypeRun(myArguments)
+        
+        vtk_image = my_pype.GetScriptObject('vmtkimagereader','0').Image
+        
+        # Size the image if needed
+        if resize_factors is not None:
+            reduction_filter = vtk.vtkImageResize()
+            reduction_filter.SetInput(vtk_image)
+            reduction_filter.SetMagnificationFactors(resize_factors[0], resize_factors[1], resize_factors[2])
+            reduction_filter.SetResizeMethodToMagnificationFactors()
+            reduction_filter.Update()
+        
+        # Threshold
+        threshold = vtk.vtkThreshold()
+        if resize_factors is not None:
+            threshold.SetInputConnection(reduction_filter.GetOutputPort())
+        else:
+            threshold.SetInput(vtk_image)
+        threshold.ThresholdByUpper(1.0)
+        threshold.Update()
+        
+        # Convert to polydata
+        surface = vtk.vtkGeometryFilter()
+        surface.SetInputConnection(threshold.GetOutputPort())
+        surface.Update()
+        
+        # Triangulate
+        triangle = vtk.vtkTriangleFilter()
+        triangle.SetInputConnection(surface.GetOutputPort())
+        triangle.Update()
+    
+        # Decimate
+        decimate = vtk.vtkDecimatePro()
+        decimate.SetInputConnection(triangle.GetOutputPort())
+        decimate.SetTargetReduction(target_reduction)
+        decimate.SetFeatureAngle(15.0)
+        decimate.Update()
+        
+        # Do loop subdivision
+        su = vtk.vtkLinearSubdivisionFilter()
+        su.SetInputConnection(decimate.GetOutputPort())
+        su.SetNumberOfSubdivisions(num_subdivisions)
+        su.Update()
+        
+        # Clip the boundaries, recommended to ensure straight inlets and outlets
+        if clipping_factor > 0.0:
+            bounds = su.GetOutput().GetBounds()
+            
+            width = bounds[1] - bounds[0]
+            height = bounds[3] - bounds[2]
+            print bounds[2], bounds[3], height
+            
+            p1 = vtk.vtkPlane()
+            p1.SetOrigin(bounds[0] + clipping_factor*width, 0.0, 0)
+            p1.SetNormal(1, 0, 0)
+            
+            p2 = vtk.vtkPlane()
+            p2.SetOrigin(0.0, bounds[2] + clipping_factor*height, 0)
+            p2.SetNormal(0, 1, 0)
+            
+            p3 = vtk.vtkPlane()
+            p3.SetOrigin(bounds[1] - clipping_factor*width, 0.0, 0)
+            p3.SetNormal(-1, 0, 0)
+        
+            p4 = vtk.vtkPlane()
+            p4.SetOrigin(0.0, bounds[3] - clipping_factor*height, 0)
+            p4.SetNormal(0, -1, 0)        
+        
+            c1 = vtk.vtkClipPolyData()
+            c1.SetInputConnection(su.GetOutputPort())
+            c1.SetClipFunction(p1)
+            c1.SetValue(0.0)
+            
+            c2 = vtk.vtkClipPolyData()
+            c2.SetInputConnection(c1.GetOutputPort())
+            c2.SetClipFunction(p2)
+            c2.SetValue(0.0)
+# 
+            c3 = vtk.vtkClipPolyData()
+            c3.SetInputConnection(c2.GetOutputPort())
+            c3.SetClipFunction(p3)
+            c3.SetValue(0.0)
+             
+            c4 = vtk.vtkClipPolyData()
+            c4.SetInputConnection(c3.GetOutputPort())
+            c4.SetClipFunction(p4)
+            c4.SetValue(0.0)
+            
+            su = vtk.vtkGeometryFilter()
+            su.SetInputConnection(c4.GetOutputPort())
+            su.Update()
+        
+        feature_edges = vtk.vtkFeatureEdges()
+        feature_edges.SetInputConnection(su.GetOutputPort())  
+        feature_edges.Update()   
+        
+        clean = vtk.vtkCleanPolyData()
+        clean.SetInputConnection(feature_edges.GetOutputPort())
+        clean.Update()
+         
+        triangle2 = vtk.vtkTriangleFilter()
+        triangle2.SetInputConnection(clean.GetOutputPort())
+        triangle2.Update()
+        
+        self.surface = su.GetOutput()
+        self.boundaries = triangle2.GetOutput()
+        return su.GetOutput(), triangle2.GetOutput()
+    
+    def write(self, output_directory):
+        
+        surface_writer = vtk.vtkXMLPolyDataWriter()
+        surface_writer.SetFileName(output_directory + "/surface.vtp")
+        surface_writer.SetInput(self.surface)
+        surface_writer.Write() 
+        
+        surface_writer.SetFileName(output_directory + "/boundaries.vtp")
+        surface_writer.SetInput(self.boundaries)
+        surface_writer.Write() 
+        
+class Surface3d():
+    
+    def __init__(self):
+        pass
+    
+    def generate(self, input_path, output_directory, part_name):
+        
+        input_path = work_dir + "/vtk_image/itk_tile_0_2_6.vti"
+        
+        reader = vtk.vtkXMLImageDataReader()
+        reader.SetFileName(input_path)
+        reader.Update()
+         
+        pad_filter = vtk.vtkImageConstantPad()
+        pad_filter.SetInputConnection(reader.GetOutputPort())
+        pad_filter.SetConstant(0)
+        pad_filter.SetOutputWholeExtent(reader.GetOutput().GetExtent()[0]-5, 
+                                        reader.GetOutput().GetExtent()[1]+5, 
+                                        reader.GetOutput().GetExtent()[2]-5, 
+                                        reader.GetOutput().GetExtent()[3]+5, 
+                                        reader.GetOutput().GetExtent()[4]-5, 
+                                        reader.GetOutput().GetExtent()[5]+5)
+        pad_filter.Update()
+         
+        writer = vtk.vtkXMLImageDataWriter()
+        writer.SetFileName(work_dir + "/surface/itk_tile_0_2_6_pad.vti")
+        writer.SetInputConnection(pad_filter.GetOutputPort())
+        writer.Update()    
+        
+        
+        myArguments = 'vmtklevelsetsegmentation -ifile ' + work_dir + "/surface/itk_tile_0_2_6_pad.vti" + ' -ofile ' + output_path+"/itk_tile_0_2_6_ls.vti"
+     
+        myPype = pypes.PypeRun(myArguments)
+         
+        myArguments = 'vmtkmarchingcubes -ifile ' + output_path+"/itk_tile_0_2_6_ls.vti" + ' -ofile ' + output_path+"/itk_tile_0_2_6_model.vtp"
+     
+        myPype = pypes.PypeRun(myArguments)
+        
\ No newline at end of file
diff --git a/process_russ_format.py b/process_russ_format.py
new file mode 100644
index 0000000..0cd349e
--- /dev/null
+++ b/process_russ_format.py
@@ -0,0 +1,44 @@
+"""
+Reader for the MATLAB vessel network format provided by Russel Bates (russell.bates@new.ox.ac.uk)
+"""
+
+from argparse import ArgumentParser
+import scipy.io
+import numpy as np
+
+def compare(x, y):
+    
+    return (x[0] == y[0]) and (x[1] == y[1]) and (x[2] == y[2])
+
+def convert_to_vtk(mat): 
+    
+    """
+    Convert the format to VTK
+    """
+    
+    nodes = []
+    edges = []
+    
+    for idx, eachConnectedComponent in enumerate(mat["Vessels"][0]):
+        adjacency = eachConnectedComponent['Adj']
+        branches  = eachConnectedComponent['Branch'][0][0][0]
+        if idx ==0:
+            for kdx, eachBranch in enumerate(branches):
+                if kdx <200:
+                    for jdx, eachPoint in enumerate(eachBranch['Points'][0][0]):
+                        nodes.append(np.array(eachPoint))
+                        
+    for idx, eachEntry in enumerate(nodes):
+        for jdx, eachOtherEntry in enumerate(nodes):
+            if idx!=jdx:
+                if compare(eachEntry, eachOtherEntry):
+                    print eachEntry, eachOtherEntry, idx, jdx
+                    break
+        
+            #nodes.append(eachBranch['Points'][0][0][0])
+            #print eachBranch['Points'][0][0][0]
+            #adjacency_indices = adjacency[0][0].nonzero()
+            #print adjacency_indices[0]
+
+mat = scipy.io.loadmat('/home/grogan/Vessels.mat', struct_as_record=True)
+convert_to_vtk(mat)
\ No newline at end of file
diff --git a/utility.py b/utility.py
new file mode 100644
index 0000000..45837cf
--- /dev/null
+++ b/utility.py
@@ -0,0 +1,36 @@
+"""
+Utilities for logging, parallel execution
+"""
+
+import os
+import logging
+
+def do_setup(tool_name = None):
+    
+    out_directory = os.getcwd() + "/Stack3D_Logging/"
+    if not os.path.exists(out_directory):
+        os.makedirs(out_directory)
+    if tool_name is not None:
+        filename = out_directory + tool_name + ".log"
+    else:
+        filename = out_directory + "/root.log"
+        
+    logging.basicConfig(level=logging.DEBUG,
+                format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
+                datefmt='%m-%d %H:%M',
+                filename=filename,
+                filemode='w')
+    
+    console = logging.StreamHandler()
+    console.setLevel(logging.INFO)
+    
+    # set a format which is simpler for console use
+    formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
+    
+    # tell the handler to use this format
+    console.setFormatter(formatter)
+    
+    # add the handler to the root logger
+    logging.getLogger('').addHandler(console)
+        
+        
\ No newline at end of file
diff --git a/viewing/__init__.py b/viewing/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/viewing/mp_color_map.py b/viewing/mp_color_map.py
new file mode 100644
index 0000000..9e18dda
--- /dev/null
+++ b/viewing/mp_color_map.py
@@ -0,0 +1,534 @@
+import vtk
+
+
+def get_disc_ctf():
+    
+    ctf = vtk.vtkColorTransferFunction()
+    
+    disc_colors = [[0.498039215803,0.78823530674,0.498039215803],
+    [0.504821223137,0.785328732519,0.507189542873],
+    [0.511603230472,0.782422158297,0.516339869943],
+    [0.518385237806,0.779515584076,0.525490197013],
+    [0.52516724514,0.776609009855,0.534640524083],
+    [0.531949252475,0.773702435634,0.543790851154],
+    [0.538731259809,0.770795861412,0.552941178224],
+    [0.545513267143,0.767889287191,0.562091505294],
+    [0.552295274477,0.76498271297,0.571241832364],
+    [0.559077281812,0.762076138749,0.580392159434],
+    [0.565859289146,0.759169564528,0.589542486504],
+    [0.57264129648,0.756262990306,0.598692813574],
+    [0.579423303814,0.753356416085,0.607843140644],
+    [0.586205311149,0.750449841864,0.616993467714],
+    [0.592987318483,0.747543267643,0.626143794784],
+    [0.599769325817,0.744636693422,0.635294121854],
+    [0.606551333152,0.7417301192,0.644444448925],
+    [0.613333340486,0.738823544979,0.653594775995],
+    [0.62011534782,0.735916970758,0.662745103065],
+    [0.626897355154,0.733010396537,0.671895430135],
+    [0.633679362489,0.730103822315,0.681045757205],
+    [0.640461369823,0.727197248094,0.690196084275],
+    [0.647243377157,0.724290673873,0.699346411345],
+    [0.654025384492,0.721384099652,0.708496738415],
+    [0.660807391826,0.718477525431,0.717647065485],
+    [0.66758939916,0.715570951209,0.726797392555],
+    [0.674371406494,0.712664376988,0.735947719625],
+    [0.681153413829,0.709757802767,0.745098046695],
+    [0.687935421163,0.706851228546,0.754248373766],
+    [0.694717428497,0.703944654324,0.763398700836],
+    [0.701499435832,0.701038080103,0.772549027906],
+    [0.708281443166,0.698131505882,0.781699354976],
+    [0.7150634505,0.695224931661,0.790849682046],
+    [0.721845457834,0.69231835744,0.800000009116],
+    [0.728627465169,0.689411783218,0.809150336186],
+    [0.735409472503,0.686505208997,0.818300663256],
+    [0.742191479837,0.683598634776,0.827450990326],
+    [0.748973486704,0.68346022648,0.826574404801],
+    [0.75575549322,0.685397942627,0.818177634828],
+    [0.762537499736,0.687335658775,0.809780864856],
+    [0.769319506253,0.689273374922,0.801384094883],
+    [0.776101512769,0.69121109107,0.792987324911],
+    [0.782883519285,0.693148807217,0.784590554939],
+    [0.789665525801,0.695086523365,0.776193784966],
+    [0.796447532317,0.697024239512,0.767797014994],
+    [0.803229538833,0.69896195566,0.759400245021],
+    [0.81001154535,0.700899671807,0.751003475049],
+    [0.816793551866,0.702837387954,0.742606705077],
+    [0.823575558382,0.704775104102,0.734209935104],
+    [0.830357564898,0.706712820249,0.725813165132],
+    [0.837139571414,0.708650536397,0.717416395159],
+    [0.84392157793,0.710588252544,0.709019625187],
+    [0.850703584447,0.712525968692,0.700622855215],
+    [0.857485590963,0.714463684839,0.692226085242],
+    [0.864267597479,0.716401400987,0.68382931527],
+    [0.871049603995,0.718339117134,0.675432545297],
+    [0.877831610511,0.720276833282,0.667035775325],
+    [0.884613617028,0.722214549429,0.658639005352],
+    [0.891395623544,0.724152265577,0.65024223538],
+    [0.89817763006,0.726089981724,0.641845465408],
+    [0.904959636576,0.728027697872,0.633448695435],
+    [0.911741643092,0.729965414019,0.625051925463],
+    [0.918523649608,0.731903130167,0.61665515549],
+    [0.925305656125,0.733840846314,0.608258385518],
+    [0.932087662641,0.735778562462,0.599861615546],
+    [0.938869669157,0.737716278609,0.591464845573],
+    [0.945651675673,0.739653994757,0.583068075601],
+    [0.952433682189,0.741591710904,0.574671305628],
+    [0.959215688705,0.743529427052,0.566274535656],
+    [0.965997695222,0.745467143199,0.557877765684],
+    [0.972779701738,0.747404859347,0.549480995711],
+    [0.979561708254,0.749342575494,0.541084225739],
+    [0.98634371477,0.751280291641,0.532687455766],
+    [0.992187620612,0.75391004927,0.525782419653],
+    [0.992402922406,0.760692055786,0.527827786698],
+    [0.9926182242,0.767474062303,0.529873153743],
+    [0.992833525994,0.774256068819,0.531918520787],
+    [0.993048827788,0.781038075335,0.533963887832],
+    [0.993264129583,0.787820081851,0.536009254876],
+    [0.993479431377,0.794602088367,0.538054621921],
+    [0.993694733171,0.801384094883,0.540099988965],
+    [0.993910034965,0.8081661014,0.54214535601],
+    [0.994125336759,0.814948107916,0.544190723055],
+    [0.994340638553,0.821730114432,0.546236090099],
+    [0.994555940348,0.828512120948,0.548281457144],
+    [0.994771242142,0.835294127464,0.550326824188],
+    [0.994986543936,0.84207613398,0.552372191233],
+    [0.99520184573,0.848858140497,0.554417558277],
+    [0.995417147524,0.855640147013,0.556462925322],
+    [0.995632449318,0.862422153529,0.558508292366],
+    [0.995847751113,0.869204160045,0.560553659411],
+    [0.996063052907,0.875986166561,0.562599026456],
+    [0.996278354701,0.882768173078,0.5646443935],
+    [0.996493656495,0.889550179594,0.566689760545],
+    [0.996708958289,0.89633218611,0.568735127589],
+    [0.996924260083,0.903114192626,0.570780494634],
+    [0.997139561878,0.909896199142,0.572825861678],
+    [0.997354863672,0.916678205658,0.574871228723],
+    [0.997570165466,0.923460212175,0.576916595768],
+    [0.99778546726,0.930242218691,0.578961962812],
+    [0.998000769054,0.937024225207,0.581007329857],
+    [0.998216070848,0.943806231723,0.583052696901],
+    [0.998431372643,0.950588238239,0.585098063946],
+    [0.998646674437,0.957370244755,0.58714343099],
+    [0.998861976231,0.964152251272,0.589188798035],
+    [0.999077278025,0.970934257788,0.591234165079],
+    [0.999292579819,0.977716264304,0.593279532124],
+    [0.999507881613,0.98449827082,0.595324899169],
+    [0.999723183408,0.991280277336,0.597370266213],
+    [0.999938485202,0.998062283853,0.599415633258],
+    [0.984698193038,0.988696655222,0.601768574294],
+    [0.963275663292,0.972871972533,0.604244544927],
+    [0.941853133545,0.957047289844,0.60672051556],
+    [0.920430603799,0.941222607154,0.609196486193],
+    [0.899008074052,0.925397924465,0.611672456825],
+    [0.877585544306,0.909573241776,0.614148427458],
+    [0.856163014559,0.893748559087,0.616624398091],
+    [0.834740484813,0.877923876398,0.619100368724],
+    [0.813317955066,0.862099193709,0.621576339357],
+    [0.79189542532,0.846274511019,0.62405230999],
+    [0.770472895573,0.83044982833,0.626528280623],
+    [0.749050365827,0.814625145641,0.629004251256],
+    [0.72762783608,0.798800462952,0.631480221889],
+    [0.706205306334,0.782975780263,0.633956192521],
+    [0.684782776587,0.767151097573,0.636432163154],
+    [0.663360246841,0.751326414884,0.638908133787],
+    [0.641937717094,0.735501732195,0.64138410442],
+    [0.620515187348,0.719677049506,0.643860075053],
+    [0.599092657601,0.703852366817,0.646336045686],
+    [0.577670127855,0.688027684128,0.648812016319],
+    [0.556247598108,0.672203001438,0.651287986952],
+    [0.534825068362,0.656378318749,0.653763957585],
+    [0.513402538615,0.64055363606,0.656239928217],
+    [0.491980008869,0.624728953371,0.65871589885],
+    [0.470557479122,0.608904270682,0.661191869483],
+    [0.449134949376,0.593079587992,0.663667840116],
+    [0.427712419629,0.577254905303,0.666143810749],
+    [0.406289889883,0.561430222614,0.668619781382],
+    [0.384867360136,0.545605539925,0.671095752015],
+    [0.36344483039,0.529780857236,0.673571722648],
+    [0.342022300643,0.513956174547,0.676047693281],
+    [0.320599770897,0.498131491857,0.678523663914],
+    [0.29917724115,0.482306809168,0.680999634546],
+    [0.277754711404,0.466482126479,0.683475605179],
+    [0.256332181657,0.45065744379,0.685951575812],
+    [0.234909651911,0.434832761101,0.688427546445],
+    [0.225267206746,0.420269131785,0.688688984104],
+    [0.245074973036,0.408858135901,0.683414089329],
+    [0.264882739327,0.397447140018,0.678139194554],
+    [0.284690505617,0.386036144135,0.672864299779],
+    [0.304498271907,0.374625148252,0.667589405004],
+    [0.324306038197,0.363214152368,0.662314510229],
+    [0.344113804488,0.351803156485,0.657039615453],
+    [0.363921570778,0.340392160602,0.651764720678],
+    [0.383729337068,0.328981164719,0.646489825903],
+    [0.403537103358,0.317570168835,0.641214931128],
+    [0.423344869649,0.306159172952,0.635940036353],
+    [0.443152635939,0.294748177069,0.630665141578],
+    [0.462960402229,0.283337181186,0.625390246803],
+    [0.48276816852,0.271926185302,0.620115352028],
+    [0.50257593481,0.260515189419,0.614840457252],
+    [0.5223837011,0.249104193536,0.609565562477],
+    [0.54219146739,0.237693197653,0.604290667702],
+    [0.561999233681,0.226282201769,0.599015772927],
+    [0.581806999971,0.214871205886,0.593740878152],
+    [0.601614766261,0.203460210003,0.588465983377],
+    [0.621422532551,0.19204921412,0.583191088602],
+    [0.641230298842,0.180638218236,0.577916193827],
+    [0.661038065132,0.169227222353,0.572641299051],
+    [0.680845831422,0.15781622647,0.567366404276],
+    [0.700653597713,0.146405230587,0.562091509501],
+    [0.720461364003,0.134994234703,0.556816614726],
+    [0.740269130293,0.12358323882,0.551541719951],
+    [0.760076896583,0.112172242937,0.546266825176],
+    [0.779884662874,0.100761247054,0.540991930401],
+    [0.799692429164,0.0893502511705,0.535717035625],
+    [0.819500195454,0.0779392552872,0.53044214085],
+    [0.839307961744,0.066528259404,0.525167246075],
+    [0.859115728035,0.0551172635208,0.5198923513],
+    [0.878923494325,0.0437062676375,0.514617456525],
+    [0.898731260615,0.0322952717543,0.50934256175],
+    [0.918539026906,0.020884275871,0.504067666975],
+    [0.938346793196,0.00947327998777,0.4987927722],
+    [0.936655136417,0.0160553639755,0.488442906737],
+    [0.93138024246,0.0256362946083,0.477247212827],
+    [0.926105348503,0.0352172252412,0.466051518917],
+    [0.920830454546,0.044798155874,0.454855825007],
+    [0.915555560589,0.0543790865069,0.443660131097],
+    [0.910280666632,0.0639600171397,0.432464437187],
+    [0.905005772675,0.0735409477726,0.421268743277],
+    [0.899730878718,0.0831218784054,0.410073049366],
+    [0.894455984761,0.0927028090383,0.398877355456],
+    [0.889181090804,0.102283739671,0.387681661546],
+    [0.883906196847,0.111864670304,0.376485967636],
+    [0.87863130289,0.121445600937,0.365290273726],
+    [0.873356408933,0.13102653157,0.354094579816],
+    [0.868081514976,0.140607462203,0.342898885906],
+    [0.862806621019,0.150188392835,0.331703191996],
+    [0.857531727062,0.159769323468,0.320507498085],
+    [0.852256833105,0.169350254101,0.309311804175],
+    [0.846981939148,0.178931184734,0.298116110265],
+    [0.84170704519,0.188512115367,0.286920416355],
+    [0.836432151233,0.198093046,0.275724722445],
+    [0.831157257276,0.207673976632,0.264529028535],
+    [0.825882363319,0.217254907265,0.253333334625],
+    [0.820607469362,0.226835837898,0.242137640715],
+    [0.815332575405,0.236416768531,0.230941946805],
+    [0.810057681448,0.245997699164,0.219746252894],
+    [0.804782787491,0.255578629797,0.208550558984],
+    [0.799507893534,0.26515956043,0.197354865074],
+    [0.794232999577,0.274740491062,0.186159171164],
+    [0.78895810562,0.284321421695,0.174963477254],
+    [0.783683211663,0.293902352328,0.163767783344],
+    [0.778408317706,0.303483282961,0.152572089434],
+    [0.773133423749,0.313064213594,0.141376395524],
+    [0.767858529792,0.322645144227,0.130180701613],
+    [0.762583635835,0.33222607486,0.118985007703],
+    [0.757308741878,0.341807005492,0.107789313793],
+    [0.752033847921,0.351387936125,0.0965936198831],
+    [0.744913509663,0.357370250716,0.09384083257],
+    [0.735332579005,0.358554410584,0.102345254053],
+    [0.725751648347,0.359738570452,0.110849675536],
+    [0.716170717688,0.36092273032,0.119354097019],
+    [0.70658978703,0.362106890188,0.127858518502],
+    [0.697008856371,0.363291050055,0.136362939985],
+    [0.687427925713,0.364475209923,0.144867361468],
+    [0.677846995055,0.365659369791,0.153371782951],
+    [0.668266064396,0.366843529659,0.161876204435],
+    [0.658685133738,0.368027689527,0.170380625918],
+    [0.649104203079,0.369211849395,0.178885047401],
+    [0.639523272421,0.370396009263,0.187389468884],
+    [0.629942341762,0.371580169131,0.195893890367],
+    [0.620361411104,0.372764328999,0.20439831185],
+    [0.610780480446,0.373948488867,0.212902733333],
+    [0.601199549787,0.375132648734,0.221407154816],
+    [0.591618619129,0.376316808602,0.229911576299],
+    [0.58203768847,0.37750096847,0.238415997782],
+    [0.572456757812,0.378685128338,0.246920419265],
+    [0.562875827154,0.379869288206,0.255424840748],
+    [0.553294896495,0.381053448074,0.263929262231],
+    [0.543713965837,0.382237607942,0.272433683714],
+    [0.534133035178,0.38342176781,0.280938105198],
+    [0.52455210452,0.384605927678,0.289442526681],
+    [0.514971173861,0.385790087546,0.297946948164],
+    [0.505390243203,0.386974247414,0.306451369647],
+    [0.495809312545,0.388158407281,0.31495579113],
+    [0.486228381886,0.389342567149,0.323460212613],
+    [0.476647451228,0.390526727017,0.331964634096],
+    [0.467066520569,0.391710886885,0.340469055579],
+    [0.457485589911,0.392895046753,0.348973477062],
+    [0.447904659253,0.394079206621,0.357477898545],
+    [0.438323728594,0.395263366489,0.365982320028],
+    [0.428742797936,0.396447526357,0.374486741511],
+    [0.419161867277,0.397631686225,0.382991162994],
+    [0.409580936619,0.398815846093,0.391495584477],
+    ];
+    
+    for idx, eachColor in enumerate(disc_colors):
+        ctf.AddRGBPoint(float(idx)/255.0,disc_colors[idx][0], disc_colors[idx][1],disc_colors[idx][2])
+        
+    return ctf
+
+def get_ctf():
+
+    ctf = vtk.vtkColorTransferFunction()
+    
+    viridis_colors = [ [0.0267004, 0.004874, 0.329415],
+          [0.0268510, 0.009605, 0.335427],
+          [0.0269944, 0.014625, 0.341379],
+          [0.0271305, 0.019942, 0.347269],
+          [0.0272594, 0.025563, 0.353093],
+          [0.0273809, 0.031497, 0.358853],
+          [0.0274952, 0.037752, 0.364543],
+          [0.0276022, 0.044167, 0.370164],
+          [0.0277018, 0.050344, 0.375715],
+          [0.0277941, 0.056324, 0.381191],
+          [0.0278791, 0.062145, 0.386592],
+          [0.0279566, 0.067836, 0.391917],
+          [0.0280267, 0.073417, 0.397163],
+          [0.0280894, 0.078907, 0.402329],
+          [0.0281446, 0.084320, 0.407414],
+          [0.0281924, 0.089666, 0.412415],
+          [0.0282327, 0.094955, 0.417331],
+          [0.0282656, 0.100196, 0.422160],
+          [0.0282910, 0.105393, 0.426902],
+          [0.0283091, 0.110553, 0.431554],
+          [0.0283197, 0.115680, 0.436115],
+          [0.0283229, 0.120777, 0.440584],
+          [0.0283187, 0.125848, 0.444960],
+          [0.0283072, 0.130895, 0.449241],
+          [0.0282884, 0.135920, 0.453427],
+          [0.0282623, 0.140926, 0.457517],
+          [0.0282290, 0.145912, 0.461510],
+          [0.0281887, 0.150881, 0.465405],
+          [0.0281412, 0.155834, 0.469201],
+          [0.0280868, 0.160771, 0.472899],
+          [0.0280255, 0.165693, 0.476498],
+          [0.0279574, 0.170599, 0.479997],
+          [0.0278826, 0.175490, 0.483397],
+          [0.0278012, 0.180367, 0.486697],
+          [0.0277134, 0.185228, 0.489898],
+          [0.0276194, 0.190074, 0.493001],
+          [0.0275191, 0.194905, 0.496005],
+          [0.0274128, 0.199721, 0.498911],
+          [0.0273006, 0.204520, 0.501721],
+          [0.0271828, 0.209303, 0.504434],
+          [0.0270595, 0.214069, 0.507052],
+          [0.0269308, 0.218818, 0.509577],
+          [0.0267968, 0.223549, 0.512008],
+          [0.0266580, 0.228262, 0.514349],
+          [0.0265145, 0.232956, 0.516599],
+          [0.0263663, 0.237631, 0.518762],
+          [0.0262138, 0.242286, 0.520837],
+          [0.0260571, 0.246922, 0.522828],
+          [0.0258965, 0.251537, 0.524736],
+          [0.0257322, 0.256130, 0.526563],
+          [0.0255645, 0.260703, 0.528312],
+          [0.0253935, 0.265254, 0.529983],
+          [0.0252194, 0.269783, 0.531579],
+          [0.0250425, 0.274290, 0.533103],
+          [0.0248629, 0.278775, 0.534556],
+          [0.0246811, 0.283237, 0.535941],
+          [0.0244972, 0.287675, 0.537260],
+          [0.0243113, 0.292092, 0.538516],
+          [0.0241237, 0.296485, 0.539709],
+          [0.0239346, 0.300855, 0.540844],
+          [0.0237441, 0.305202, 0.541921],
+          [0.0235526, 0.309527, 0.542944],
+          [0.0233603, 0.313828, 0.543914],
+          [0.0231674, 0.318106, 0.544834],
+          [0.0229739, 0.322361, 0.545706],
+          [0.0227802, 0.326594, 0.546532],
+          [0.0225863, 0.330805, 0.547314],
+          [0.0223925, 0.334994, 0.548053],
+          [0.0221989, 0.339161, 0.548752],
+          [0.0220057, 0.343307, 0.549413],
+          [0.0218130, 0.347432, 0.550038],
+          [0.0216210, 0.351535, 0.550627],
+          [0.0214298, 0.355619, 0.551184],
+          [0.0212395, 0.359683, 0.551710],
+          [0.0210503, 0.363727, 0.552206],
+          [0.0208623, 0.367752, 0.552675],
+          [0.0206756, 0.371758, 0.553117],
+          [0.0204903, 0.375746, 0.553533],
+          [0.0203063, 0.379716, 0.553925],
+          [0.0201239, 0.383670, 0.554294],
+          [0.0199430, 0.387607, 0.554642],
+          [0.0197636, 0.391528, 0.554969],
+          [0.0195860, 0.395433, 0.555276],
+          [0.0194100, 0.399323, 0.555565],
+          [0.0192357, 0.403199, 0.555836],
+          [0.0190631, 0.407061, 0.556089],
+          [0.0188923, 0.410910, 0.556326],
+          [0.0187231, 0.414746, 0.556547],
+          [0.0185556, 0.418570, 0.556753],
+          [0.0183898, 0.422383, 0.556944],
+          [0.0182256, 0.426184, 0.557120],
+          [0.0180629, 0.429975, 0.557282],
+          [0.0179019, 0.433756, 0.557430],
+          [0.0177423, 0.437527, 0.557565],
+          [0.0175841, 0.441290, 0.557685],
+          [0.0174274, 0.445044, 0.557792],
+          [0.0172719, 0.448791, 0.557885],
+          [0.0171176, 0.452530, 0.557965],
+          [0.0169646, 0.456262, 0.558030],
+          [0.0168126, 0.459988, 0.558082],
+          [0.0166617, 0.463708, 0.558119],
+          [0.0165117, 0.467423, 0.558141],
+          [0.0163625, 0.471133, 0.558148],
+          [0.0162142, 0.474838, 0.558140],
+          [0.0160665, 0.478540, 0.558115],
+          [0.0159194, 0.482237, 0.558073],
+          [0.0157729, 0.485932, 0.558013],
+          [0.0156270, 0.489624, 0.557936],
+          [0.0154815, 0.493313, 0.557840],
+          [0.0153364, 0.497000, 0.557724],
+          [0.0151918, 0.500685, 0.557587],
+          [0.0150476, 0.504369, 0.557430],
+          [0.0149039, 0.508051, 0.557250],
+          [0.0147607, 0.511733, 0.557049],
+          [0.0146180, 0.515413, 0.556823],
+          [0.0144759, 0.519093, 0.556572],
+          [0.0143343, 0.522773, 0.556295],
+          [0.0141935, 0.526453, 0.555991],
+          [0.0140536, 0.530132, 0.555659],
+          [0.0139147, 0.533812, 0.555298],
+          [0.0137770, 0.537492, 0.554906],
+          [0.0136408, 0.541173, 0.554483],
+          [0.0135066, 0.544853, 0.554029],
+          [0.0133743, 0.548535, 0.553541],
+          [0.0132444, 0.552216, 0.553018],
+          [0.0131172, 0.555899, 0.552459],
+          [0.0129933, 0.559582, 0.551864],
+          [0.0128729, 0.563265, 0.551229],
+          [0.0127568, 0.566949, 0.550556],
+          [0.0126453, 0.570633, 0.549841],
+          [0.0125394, 0.574318, 0.549086],
+          [0.0124395, 0.578002, 0.548287],
+          [0.0123463, 0.581687, 0.547445],
+          [0.0122606, 0.585371, 0.546557],
+          [0.0121831, 0.589055, 0.545623],
+          [0.0121148, 0.592739, 0.544641],
+          [0.0120565, 0.596422, 0.543611],
+          [0.0120092, 0.600104, 0.542530],
+          [0.0119738, 0.603785, 0.541400],
+          [0.0119512, 0.607464, 0.540218],
+          [0.0119423, 0.611141, 0.538982],
+          [0.0119483, 0.614817, 0.537692],
+          [0.0119699, 0.618490, 0.536347],
+          [0.0120081, 0.622161, 0.534946],
+          [0.0120638, 0.625828, 0.533488],
+          [0.0121380, 0.629492, 0.531973],
+          [0.0122312, 0.633153, 0.530398],
+          [0.0123444, 0.636809, 0.528763],
+          [0.0124780, 0.640461, 0.527068],
+          [0.0126326, 0.644107, 0.525311],
+          [0.0128087, 0.647749, 0.523491],
+          [0.0130067, 0.651384, 0.521608],
+          [0.0132268, 0.655014, 0.519661],
+          [0.0134692, 0.658636, 0.517649],
+          [0.0137339, 0.662252, 0.515571],
+          [0.0140210, 0.665859, 0.513427],
+          [0.0143303, 0.669459, 0.511215],
+          [0.0146616, 0.673050, 0.508936],
+          [0.0150148, 0.676631, 0.506589],
+          [0.0153894, 0.680203, 0.504172],
+          [0.0157851, 0.683765, 0.501686],
+          [0.0162016, 0.687316, 0.499129],
+          [0.0166383, 0.690856, 0.496502],
+          [0.0170948, 0.694384, 0.493803],
+          [0.0175707, 0.697900, 0.491033],
+          [0.0180653, 0.701402, 0.488189],
+          [0.0185783, 0.704891, 0.485273],
+          [0.0191090, 0.708366, 0.482284],
+          [0.0196571, 0.711827, 0.479221],
+          [0.0202219, 0.715272, 0.476084],
+          [0.0208030, 0.718701, 0.472873],
+          [0.0214000, 0.722114, 0.469588],
+          [0.0220124, 0.725509, 0.466226],
+          [0.0226397, 0.728888, 0.462789],
+          [0.0232815, 0.732247, 0.459277],
+          [0.0239374, 0.735588, 0.455688],
+          [0.0246070, 0.738910, 0.452024],
+          [0.0252899, 0.742211, 0.448284],
+          [0.0259857, 0.745492, 0.444467],
+          [0.0266941, 0.748751, 0.440573],
+          [0.0274149, 0.751988, 0.436601],
+          [0.0281477, 0.755203, 0.432552],
+          [0.0288921, 0.758394, 0.428426],
+          [0.0296479, 0.761561, 0.424223],
+          [0.0304148, 0.764704, 0.419943],
+          [0.0311925, 0.767822, 0.415586],
+          [0.0319809, 0.770914, 0.411152],
+          [0.0327796, 0.773980, 0.406640],
+          [0.0335885, 0.777018, 0.402049],
+          [0.0344074, 0.780029, 0.397381],
+          [0.0352360, 0.783011, 0.392636],
+          [0.0360741, 0.785964, 0.387814],
+          [0.0369214, 0.788888, 0.382914],
+          [0.0377779, 0.791781, 0.377939],
+          [0.0386433, 0.794644, 0.372886],
+          [0.0395174, 0.797475, 0.367757],
+          [0.0404001, 0.800275, 0.362552],
+          [0.0412913, 0.803041, 0.357269],
+          [0.0421908, 0.805774, 0.351910],
+          [0.0430983, 0.808473, 0.346476],
+          [0.0440137, 0.811138, 0.340967],
+          [0.0449368, 0.813768, 0.335384],
+          [0.0458674, 0.816363, 0.329727],
+          [0.0468053, 0.818921, 0.323998],
+          [0.0477504, 0.821444, 0.318195],
+          [0.0487026, 0.823929, 0.312321],
+          [0.0496615, 0.826376, 0.306377],
+          [0.0506271, 0.828786, 0.300362],
+          [0.0515992, 0.831158, 0.294279],
+          [0.0525776, 0.833491, 0.288127],
+          [0.0535621, 0.835785, 0.281908],
+          [0.0545524, 0.838039, 0.275626],
+          [0.0555484, 0.840254, 0.269281],
+          [0.0565498, 0.842430, 0.262877],
+          [0.0575563, 0.844566, 0.256415],
+          [0.0585678, 0.846661, 0.249897],
+          [0.0595839, 0.848717, 0.243329],
+          [0.0606045, 0.850733, 0.236712],
+          [0.0616293, 0.852709, 0.230052],
+          [0.0626579, 0.854645, 0.223353],
+          [0.0636902, 0.856542, 0.216620],
+          [0.0647257, 0.858400, 0.209861],
+          [0.0657642, 0.860219, 0.203082],
+          [0.0668054, 0.861999, 0.196293],
+          [0.0678489, 0.863742, 0.189503],
+          [0.0688944, 0.865448, 0.182725],
+          [0.0699415, 0.867117, 0.175971],
+          [0.0709898, 0.868751, 0.169257],
+          [0.0720391, 0.870350, 0.162603],
+          [0.0730889, 0.871916, 0.156029],
+          [0.0741388, 0.873449, 0.149561],
+          [0.0751884, 0.874951, 0.143228],
+          [0.0762373, 0.876424, 0.137064],
+          [0.0772852, 0.877868, 0.131109],
+          [0.0783315, 0.879285, 0.125405],
+          [0.0793760, 0.880678, 0.120005],
+          [0.0804182, 0.882046, 0.114965],
+          [0.0814576, 0.883393, 0.110347],
+          [0.0824940, 0.884720, 0.106217],
+          [0.0835270, 0.886029, 0.102646],
+          [0.0845561, 0.887322, 0.099702],
+          [0.0855810, 0.888601, 0.097452],
+          [0.0866013, 0.889868, 0.095953],
+          [0.0876168, 0.891125, 0.095250],
+          [0.0886271, 0.892374, 0.095374],
+          [0.0896320, 0.893616, 0.096335],
+          [0.0906311, 0.894855, 0.098125],
+          [0.0916242, 0.896091, 0.100717],
+          [0.0926106, 0.897330, 0.104071],
+          [0.0935904, 0.898570, 0.108131],
+          [0.0945636, 0.899815, 0.112838],
+          [0.0955300, 0.901065, 0.118128],
+          [0.0964894, 0.902323, 0.123941],
+          [0.0974417, 0.903590, 0.130215],
+          [0.0983868, 0.904867, 0.136897],
+          [0.0993248, 0.906157, 0.143936]]
+        
+    for idx, eachColor in enumerate(viridis_colors):
+        ctf.AddRGBPoint(float(idx)/255.0,viridis_colors[idx][0], viridis_colors[idx][1],viridis_colors[idx][2])
+        
+    return ctf
\ No newline at end of file
diff --git a/viewing/simple_render.py b/viewing/simple_render.py
new file mode 100644
index 0000000..7691ad3
--- /dev/null
+++ b/viewing/simple_render.py
@@ -0,0 +1,309 @@
+"""
+Rendering of 3D TIFF stacks with VTK
+"""
+
+import os
+from argparse import ArgumentParser
+import vtk
+import mp_color_map
+
+def get_ox_map():
+    
+    files = ["/home/grogan/oxygen_solution_loc_0.vti",
+             "/home/grogan/oxygen_solution_loc_1.vti",
+             "/home/grogan/oxygen_solution_loc_2.vti",
+             "/home/grogan/oxygen_solution_loc_3.vti"]
+    offsets = [(0.0,0.0), (40.0, 0.0), (40.0, 40.0), (0.0, 40.0)]
+    
+    ox_actors = []
+    for idx, eachFile in enumerate(files):
+        reader = vtk.vtkXMLImageDataReader()
+        reader.SetFileName(eachFile)
+        reader.Update()
+        reader.GetOutput().GetPointData().SetScalars(reader.GetOutput().GetPointData().GetArray("oxygen"))
+         
+        plane = vtk.vtkPlane()
+        plane.SetOrigin(0.0, 0, 3)
+        plane.SetNormal(0, 0, 1)
+         
+        cutter = vtk.vtkCutter()
+        cutter.SetInputData(reader.GetOutput())
+        cutter.SetCutFunction(plane)
+        cutter.GenerateCutScalarsOn()
+        cutter.Update()
+        
+        trans = vtk.vtkTransform()
+        trans.Scale(42.375, 42.375, 42.375)
+        transf = vtk.vtkTransformFilter()
+        transf.SetInputData(cutter.GetOutput())
+        transf.SetTransform(trans)
+        transf.Update()
+        
+        trans1 = vtk.vtkTransform()
+        trans1.Translate(42.375*offsets[idx][0], 42.375*offsets[idx][1], 0.0)
+        transf2 = vtk.vtkTransformFilter()
+        transf2.SetInputData(transf.GetOutput())
+        transf2.SetTransform(trans1)
+        transf2.Update()
+        
+        warp = vtk.vtkWarpScalar()
+        warp.SetInputData(transf2.GetOutput())
+        warp.SetScaleFactor(0.15*42.375)
+        warp.Update()
+        
+        scaled_ctf = vtk.vtkColorTransferFunction()
+        scalar_range = [0, 0]
+        warp.GetOutput().GetPointData().GetArray("oxygen").GetRange(scalar_range)
+        for idx in range(256):
+            color = [0, 0, 0]
+            mp_color_map.get_ctf().GetColor(float(idx)/255.0, color)
+            scaled_ctf.AddRGBPoint(scalar_range[0] + float(idx)*(scalar_range[1]-scalar_range[0])/255.0, 
+                                   color[0], color[1], color[2])
+         
+        ox_mapper = vtk.vtkPolyDataMapper()
+        ox_mapper.SetInputData(warp.GetOutput())
+        ox_mapper.ScalarVisibilityOn()
+        ox_mapper.SetLookupTable(scaled_ctf)
+        ox_mapper.SelectColorArray("oxygen")
+        ox_mapper.SetScalarModeToUsePointFieldData()
+        ox_mapper.SetColorModeToMapScalars()
+        
+        #ox_mapper.ScalarVisibilityOn()
+        ox_actor = vtk.vtkActor()
+        ox_actor.SetMapper(ox_mapper)
+        ox_actor.GetProperty().SetColor(0.0, 1.0, 0.0)
+        ox_actor.GetProperty().SetOpacity(0.5)
+        ox_actors.append(ox_actor)
+
+    scale_bar = vtk.vtkScalarBarActor()
+    scale_bar.SetLookupTable(scaled_ctf);
+    #scale_bar.SetTitle("Oxygen Tension (mmHg)");
+    scale_bar.SetOrientationToVertical();
+    scale_bar.GetPositionCoordinate().SetCoordinateSystemToNormalizedViewport();
+    scale_bar.GetPositionCoordinate().SetValue(0.23, 0.27);
+    scale_bar.SetWidth(0.08);
+    scale_bar.SetHeight(0.6);
+    #scale_bar.SetAnnotationTextScalingOff()
+    #scale_bar.UnconstrainedFontSizeOn()
+    scale_bar.GetTitleTextProperty().ItalicOff();
+    scale_bar.GetLabelTextProperty().ItalicOff();
+    scale_bar.GetTitleTextProperty().BoldOff();
+    scale_bar.GetLabelTextProperty().BoldOff();
+    scale_bar.GetTitleTextProperty().ShadowOff();
+    scale_bar.GetLabelTextProperty().ShadowOff();
+    scale_bar.SetLabelFormat("%.2g");
+    scale_bar.GetTitleTextProperty().SetFontSize(15)
+    scale_bar.GetLabelTextProperty().SetFontSize(15)
+    scale_bar.GetTitleTextProperty().SetColor(1.0, 1.0, 1.0);
+    scale_bar.GetLabelTextProperty().SetColor(1.0, 1.0, 1.0);
+    
+    return ox_actors, scale_bar
+
+def add_cells():
+    
+    cell_files = ["/scratch/jgrogan/TBME_16_Work/Simulations/BioHigh_15x/Bio3d_1/results_from_time_0/results_20.vtu",
+                  "/scratch/jgrogan/TBME_16_Work/Simulations/BioHigh_15x/Bio3d_1/results_from_time_0/results_100.vtu",
+                  "/scratch/jgrogan/TBME_16_Work/Simulations/BioHigh_15x/Bio3d_1/results_from_time_0/results_150.vtu"]
+    
+    cell_actors = []
+    
+    for eachFile in cell_files:
+        reader = vtk.vtkXMLUnstructuredGridReader()
+        reader.SetFileName(eachFile)
+        reader.Update()
+        
+        spheres = vtk.vtkSphereSource()
+        spheres.SetRadius(0.6)
+        spheres.SetPhiResolution(8)
+        spheres.SetThetaResolution(8)
+        
+        glyph = vtk.vtkGlyph3D()
+        glyph.SetInputData(reader.GetOutput());
+        glyph.SetSourceConnection(spheres.GetOutputPort());
+        glyph.ClampingOff();
+        glyph.SetScaleModeToScaleByScalar();
+        glyph.SetScaleFactor(0.8);
+        glyph.Update();
+        
+        trans = vtk.vtkTransform()
+        trans.Scale(42.375, 42.375, 42.375)
+        transf = vtk.vtkTransformFilter()
+        transf.SetInputData(glyph.GetOutput())
+        transf.SetTransform(trans)
+        transf.Update()
+        
+        scaled_ctf = vtk.vtkColorTransferFunction()
+        scalar_range = [0, 0]
+        reader.GetOutput().GetPointData().GetArray("Cell types").GetRange(scalar_range)
+        for idx in range(256):
+            color = [0, 0, 0]
+            mp_color_map.get_disc_ctf().GetColor(float(idx)/255.0, color)
+            scaled_ctf.AddRGBPoint(scalar_range[0] + float(idx)*(scalar_range[1]-scalar_range[0])/255.0, 
+                                   color[0], color[1], color[2])
+    
+        mapper = vtk.vtkPolyDataMapper();
+        mapper.SetInputData(transf.GetOutput());
+        mapper.SetLookupTable(scaled_ctf);
+        mapper.ScalarVisibilityOn();
+        mapper.SelectColorArray("Cell types");
+        mapper.SetScalarModeToUsePointFieldData();
+        mapper.SetColorModeToMapScalars();
+    
+        actor = vtk.vtkActor();
+        actor.SetMapper(mapper);
+        actor.GetProperty().SetOpacity(0.8);
+
+        cell_actors.append(actor)
+    return cell_actors
+
+#         if(!this->mDataLabel.empty() and this->mShowScaleBar)
+#         {
+#             this->mpScaleBar->SetLookupTable(p_scaled_ctf);
+#             this->mpScaleBar->SetTitle(this->mDataLabel.c_str());
+#             pRenderer->AddActor(this->mpScaleBar);
+#         }
+
+def render_image(image_path, threshold = 20.0):
+    
+    """
+    Render the 3D stack with VTK
+    """
+    
+    input_files = []
+    for eachFile in os.listdir(image_path):
+        if eachFile.endswith(".vti"):
+            input_files.append(image_path + "/"+eachFile)
+    
+    renderer = vtk.vtkRenderer()
+    renderer.SetBackground(20.0/255.0,30.0/255.0,48.0/255.0);
+    renderer.SetBackground2(36.0/255.0,59.0/255.0,85.0/255.0);
+    
+    for eachImage in input_files:
+        reader= vtk.vtkXMLImageDataReader()
+        reader.SetFileName(eachImage)
+        reader.Update()
+    
+        volume_mapper = vtk.vtkVolumeRayCastMapper()
+        volume_mapper.SetInputData(reader.GetOutput())
+        composite_function = vtk.vtkVolumeRayCastCompositeFunction()
+        volume_mapper.SetVolumeRayCastFunction(composite_function)
+        
+        color_transfer_func = vtk.vtkColorTransferFunction()
+        color_transfer_func.AddRGBPoint(0, 0.0, 1.0, 0.0 )
+        color_transfer_func.AddRGBPoint(threshold-1, 0.0, 1.0, 0.0 )
+        color_transfer_func.AddRGBPoint(threshold, 1.0, 0.0, 0.0 )
+        color_transfer_func.AddRGBPoint(255.0, 1.0, 0.0, 0.0 )
+        
+        opacity_transfer_func = vtk.vtkPiecewiseFunction()
+        opacity_transfer_func.AddPoint(0, 0.0 )
+        opacity_transfer_func.AddPoint(threshold-1.0, 0.0 )
+        #opacity_transfer_func.AddPoint(threshold, 1.0 )
+        opacity_transfer_func.AddPoint(255.0, 0.1 )
+        
+        volume_properties = vtk.vtkVolumeProperty()
+        volume_properties.SetColor( color_transfer_func )
+        volume_properties.SetScalarOpacity( opacity_transfer_func )
+        
+        volume = vtk.vtkVolume()
+        volume.SetMapper(volume_mapper)
+        volume.SetProperty(volume_properties)
+        renderer.AddVolume(volume)
+    
+#     textActor = vtk.vtkTextActor()
+#     textActor.SetTextScaleModeToNone()
+#     textActor.SetDisplayPosition(200, 300)
+#     textActor.SetInput("Oxygen Tension (mmHg)")
+#     tprop = textActor.GetTextProperty()
+#     tprop.SetFontSize(10)
+#     tprop.SetFontFamilyToArial()
+#     tprop.SetJustificationToCentered()
+#     tprop.BoldOff()
+#     tprop.ItalicOff()
+#     tprop.ShadowOff()
+#     tprop.SetColor(1, 1, 1)
+#     #renderer.AddActor2D(textActor)
+    
+    renderer.ResetCamera()
+    render_window = vtk.vtkRenderWindow()
+    window_interactor = vtk.vtkRenderWindowInteractor()
+    
+    render_window.AddRenderer(renderer)
+    window_interactor.SetRenderWindow(render_window)
+    
+    render_window.SetSize(170, 177)
+    render_window.Render()
+    ox_actors, scale_bar_actor = get_ox_map()
+    #renderer.AddActor(scale_bar_actor)
+    render_window.Render()
+    
+    renderer.GetActiveCamera().Elevation(-33.0)
+    renderer.GetActiveCamera().Zoom(1.0)
+    position = list(renderer.GetActiveCamera().GetFocalPoint())
+    #position[0] = position[0] - 750
+    #position[1] = position[1] - 105
+    renderer.GetActiveCamera().SetFocalPoint(position)
+    renderer.ResetCameraClippingRange()
+    render_window.Render()
+    
+    window_to_image_filter = vtk.vtkWindowToImageFilter()
+    window_to_image_filter.SetInput(render_window)
+    writer = vtk.vtkTIFFWriter()
+    extension = ".tiff"
+    writer.SetInputConnection(window_to_image_filter.GetOutputPort())
+    writer.SetFileName("vtk_animation_0"+extension)
+    writer.Write()
+     
+     
+    num_samples = 1
+    for idx in range(num_samples):
+         
+        if idx==0:
+            for eachActor in ox_actors:
+                renderer.AddActor(eachActor)
+         
+        renderer.GetActiveCamera().OrthogonalizeViewUp()
+        #time.sleep(0.02)
+        
+        #renderer.GetActiveCamera().Dolly(1.002))
+        render_window.Render()
+        window_to_image_filter.Modified()
+        writer.SetFileName("vtk_animation_"+str(idx+1)+extension)
+        writer.Write()
+     
+    renderer.RemoveActor(ox_actors[0])
+    render_window.Render()
+    window_to_image_filter.Modified()
+    writer.SetFileName("vtk_animation_"+str(num_samples+1)+extension)
+    writer.Write()
+    
+    cell_actors = add_cells()
+    renderer.AddActor(cell_actors[0])
+    render_window.Render()
+    window_to_image_filter.Modified()
+    writer.SetFileName("vtk_animation_"+str(num_samples+2)+extension)
+    writer.Write()
+    renderer.RemoveActor(cell_actors[0])
+    
+    renderer.AddActor(cell_actors[1])
+    render_window.Render()
+    window_to_image_filter.Modified()
+    writer.SetFileName("vtk_animation_"+str(num_samples+3)+extension)
+    writer.Write()
+    renderer.RemoveActor(cell_actors[1])
+    
+    renderer.AddActor(cell_actors[2])
+    render_window.Render()
+    window_to_image_filter.Modified()
+    writer.SetFileName("vtk_animation_"+str(num_samples+4)+extension)
+    writer.Write()
+     
+    window_interactor.Start()
+    
+if __name__ == "__main__":
+    
+
+    parser = ArgumentParser()
+    parser.add_argument("-i", "--input_file", type=str, help='vtk input file')
+    args = parser.parse_args()
+    
+    render_image(args.input_file)
\ No newline at end of file