# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_py_interop_plot')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_py_interop_plot')
    _py_interop_plot = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_py_interop_plot', [dirname(__file__)])
        except ImportError:
            import _py_interop_plot
            return _py_interop_plot
        try:
            _mod = imp.load_module('_py_interop_plot', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _py_interop_plot = swig_import_helper()
    del swig_import_helper
else:
    import _py_interop_plot
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _py_interop_plot.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _py_interop_plot.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _py_interop_plot.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _py_interop_plot.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _py_interop_plot.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _py_interop_plot.SwigPyIterator_equal(self, x)

    def copy(self):
        return _py_interop_plot.SwigPyIterator_copy(self)

    def next(self):
        return _py_interop_plot.SwigPyIterator_next(self)

    def __next__(self):
        return _py_interop_plot.SwigPyIterator___next__(self)

    def previous(self):
        return _py_interop_plot.SwigPyIterator_previous(self)

    def advance(self, n):
        return _py_interop_plot.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _py_interop_plot.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _py_interop_plot.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _py_interop_plot.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _py_interop_plot.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _py_interop_plot.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _py_interop_plot.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _py_interop_plot.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import interop.py_interop_run
import interop.py_interop_metrics
import interop.py_interop_run_metrics
import interop.py_interop_comm
class invalid_filter_option(interop.py_interop_run.base_exception):
    __swig_setmethods__ = {}
    for _s in [interop.py_interop_run.base_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, invalid_filter_option, name, value)
    __swig_getmethods__ = {}
    for _s in [interop.py_interop_run.base_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, invalid_filter_option, name)
    __repr__ = _swig_repr

    def __init__(self, mesg):
        this = _py_interop_plot.new_invalid_filter_option(mesg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        return _py_interop_plot.invalid_filter_option___str__(self)
    __swig_destroy__ = _py_interop_plot.delete_invalid_filter_option
    __del__ = lambda self: None
invalid_filter_option_swigregister = _py_interop_plot.invalid_filter_option_swigregister
invalid_filter_option_swigregister(invalid_filter_option)

class axis(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, axis, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, axis, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _py_interop_plot.new_axis()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def set_range(self, vmin, vmax):
        return _py_interop_plot.axis_set_range(self, vmin, vmax)

    def set_label(self, label):
        return _py_interop_plot.axis_set_label(self, label)

    def clear(self):
        return _py_interop_plot.axis_clear(self)

    def label(self):
        return _py_interop_plot.axis_label(self)

    def min(self):
        return _py_interop_plot.axis_min(self)

    def max(self):
        return _py_interop_plot.axis_max(self)
    __swig_destroy__ = _py_interop_plot.delete_axis
    __del__ = lambda self: None
axis_swigregister = _py_interop_plot.axis_swigregister
axis_swigregister(axis)

class axes(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, axes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, axes, name)
    __repr__ = _swig_repr

    def set_range(self, xmin, xmax, ymin, ymax):
        return _py_interop_plot.axes_set_range(self, xmin, xmax, ymin, ymax)

    def set_xrange(self, vmin, vmax):
        return _py_interop_plot.axes_set_xrange(self, vmin, vmax)

    def set_yrange(self, vmin, vmax):
        return _py_interop_plot.axes_set_yrange(self, vmin, vmax)

    def set_xlabel(self, label):
        return _py_interop_plot.axes_set_xlabel(self, label)

    def set_ylabel(self, label):
        return _py_interop_plot.axes_set_ylabel(self, label)

    def set_xaxis(self, xaxes):
        return _py_interop_plot.axes_set_xaxis(self, xaxes)

    def set_yaxis(self, yaxes):
        return _py_interop_plot.axes_set_yaxis(self, yaxes)

    def clear(self):
        return _py_interop_plot.axes_clear(self)

    def xlabel(self):
        return _py_interop_plot.axes_xlabel(self)

    def ylabel(self):
        return _py_interop_plot.axes_ylabel(self)

    def x(self):
        return _py_interop_plot.axes_x(self)

    def y(self):
        return _py_interop_plot.axes_y(self)

    def __init__(self):
        this = _py_interop_plot.new_axes()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_axes
    __del__ = lambda self: None
axes_swigregister = _py_interop_plot.axes_swigregister
axes_swigregister(axes)

class filter_options(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, filter_options, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, filter_options, name)
    __repr__ = _swig_repr
    ALL_IDS = _py_interop_plot.filter_options_ALL_IDS
    ALL_CHANNELS = _py_interop_plot.filter_options_ALL_CHANNELS
    ALL_BASES = _py_interop_plot.filter_options_ALL_BASES

    def __init__(self, *args):
        this = _py_interop_plot.new_filter_options(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def reset(self):
        return _py_interop_plot.filter_options_reset(self)

    def validate(self, type, run_info, check_ignored=False):
        return _py_interop_plot.filter_options_validate(self, type, run_info, check_ignored)

    def all_channels(self, *args):
        return _py_interop_plot.filter_options_all_channels(self, *args)

    def all_bases(self, *args):
        return _py_interop_plot.filter_options_all_bases(self, *args)

    def all_reads(self):
        return _py_interop_plot.filter_options_all_reads(self)

    def all_cycles(self):
        return _py_interop_plot.filter_options_all_cycles(self)

    def all_lanes(self):
        return _py_interop_plot.filter_options_all_lanes(self)

    def all_tile_numbers(self):
        return _py_interop_plot.filter_options_all_tile_numbers(self)

    def all_swaths(self):
        return _py_interop_plot.filter_options_all_swaths(self)

    def all_sections(self):
        return _py_interop_plot.filter_options_all_sections(self)

    def is_specific_read(self, *args):
        return _py_interop_plot.filter_options_is_specific_read(self, *args)

    def is_specific_surface(self):
        return _py_interop_plot.filter_options_is_specific_surface(self)

    def valid_lane(self, lane):
        return _py_interop_plot.filter_options_valid_lane(self, lane)

    def valid_surface(self, surface):
        return _py_interop_plot.filter_options_valid_surface(self, surface)

    def valid_read(self, read):
        return _py_interop_plot.filter_options_valid_read(self, read)

    def valid_cycle(self, cycle):
        return _py_interop_plot.filter_options_valid_cycle(self, cycle)

    def valid_tile_number(self, tile_number):
        return _py_interop_plot.filter_options_valid_tile_number(self, tile_number)

    def valid_swath(self, swath):
        return _py_interop_plot.filter_options_valid_swath(self, swath)

    def valid_section(self, section):
        return _py_interop_plot.filter_options_valid_section(self, section)

    def valid_channel(self, channel):
        return _py_interop_plot.filter_options_valid_channel(self, channel)

    def valid_base(self, base):
        return _py_interop_plot.filter_options_valid_base(self, base)

    def tile_naming_method(self, naming_method):
        return _py_interop_plot.filter_options_tile_naming_method(self, naming_method)

    def swath(self, s):
        return _py_interop_plot.filter_options_swath(self, s)

    def section(self, s):
        return _py_interop_plot.filter_options_section(self, s)

    def tile_number(self, s):
        return _py_interop_plot.filter_options_tile_number(self, s)

    def lane(self, *args):
        return _py_interop_plot.filter_options_lane(self, *args)

    def channel(self, *args):
        return _py_interop_plot.filter_options_channel(self, *args)

    def dna_base(self, *args):
        return _py_interop_plot.filter_options_dna_base(self, *args)

    def read(self, *args):
        return _py_interop_plot.filter_options_read(self, *args)

    def cycle(self, *args):
        return _py_interop_plot.filter_options_cycle(self, *args)

    def surface(self, *args):
        return _py_interop_plot.filter_options_surface(self, *args)

    def cycle_description(self):
        return _py_interop_plot.filter_options_cycle_description(self)

    def lane_description(self):
        return _py_interop_plot.filter_options_lane_description(self)

    def channel_description(self, channels):
        return _py_interop_plot.filter_options_channel_description(self, channels)

    def base_description(self):
        return _py_interop_plot.filter_options_base_description(self)

    def surface_description(self):
        return _py_interop_plot.filter_options_surface_description(self)

    def read_description(self):
        return _py_interop_plot.filter_options_read_description(self)

    def naming_method(self):
        return _py_interop_plot.filter_options_naming_method(self)

    def supports_section(self, arg2, info):
        return _py_interop_plot.filter_options_supports_section(self, arg2, info)

    def supports_swath(self, arg2):
        return _py_interop_plot.filter_options_supports_swath(self, arg2)

    def supports_tile(self, arg2):
        return _py_interop_plot.filter_options_supports_tile(self, arg2)

    def supports_all_lanes(self, plot_type):
        return _py_interop_plot.filter_options_supports_all_lanes(self, plot_type)

    def supports_lane(self, plot_type):
        return _py_interop_plot.filter_options_supports_lane(self, plot_type)

    def supports_all_bases(self, plot_type):
        return _py_interop_plot.filter_options_supports_all_bases(self, plot_type)

    def supports_base(self, metric_type):
        return _py_interop_plot.filter_options_supports_base(self, metric_type)

    def supports_all_channels(self, plot_type):
        return _py_interop_plot.filter_options_supports_all_channels(self, plot_type)

    def supports_channel(self, metric_type):
        return _py_interop_plot.filter_options_supports_channel(self, metric_type)

    def supports_all_cycles(self, plot_type):
        return _py_interop_plot.filter_options_supports_all_cycles(self, plot_type)

    def supports_cycle(self, metric_type, plot_type):
        return _py_interop_plot.filter_options_supports_cycle(self, metric_type, plot_type)

    def supports_all_reads(self, plot_type):
        return _py_interop_plot.filter_options_supports_all_reads(self, plot_type)

    def supports_read(self, metric_type, plot_type):
        return _py_interop_plot.filter_options_supports_read(self, metric_type, plot_type)

    def supports_surface(self, metric_type, info):
        return _py_interop_plot.filter_options_supports_surface(self, metric_type, info)

    def subsample(self, *args):
        return _py_interop_plot.filter_options_subsample(self, *args)
    __swig_destroy__ = _py_interop_plot.delete_filter_options
    __del__ = lambda self: None
filter_options_swigregister = _py_interop_plot.filter_options_swigregister
filter_options_swigregister(filter_options)

class chart_data(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, chart_data, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, chart_data, name)
    __repr__ = _swig_repr

    def set_axes(self, xyaxes):
        return _py_interop_plot.chart_data_set_axes(self, xyaxes)

    def set_xaxis(self, xaxes):
        return _py_interop_plot.chart_data_set_xaxis(self, xaxes)

    def set_yaxis(self, yaxes):
        return _py_interop_plot.chart_data_set_yaxis(self, yaxes)

    def set_xlabel(self, label):
        return _py_interop_plot.chart_data_set_xlabel(self, label)

    def set_ylabel(self, label):
        return _py_interop_plot.chart_data_set_ylabel(self, label)

    def set_range(self, xmin, xmax, ymin, ymax):
        return _py_interop_plot.chart_data_set_range(self, xmin, xmax, ymin, ymax)

    def set_xrange(self, vmin, vmax):
        return _py_interop_plot.chart_data_set_xrange(self, vmin, vmax)

    def set_yrange(self, vmin, vmax):
        return _py_interop_plot.chart_data_set_yrange(self, vmin, vmax)

    def set_title(self, title):
        return _py_interop_plot.chart_data_set_title(self, title)

    def clear(self):
        return _py_interop_plot.chart_data_clear(self)

    def x_axis(self):
        return _py_interop_plot.chart_data_x_axis(self)

    def y_axis(self):
        return _py_interop_plot.chart_data_y_axis(self)

    def title(self):
        return _py_interop_plot.chart_data_title(self)

    def xyaxes(self):
        return _py_interop_plot.chart_data_xyaxes(self)

    def __init__(self):
        this = _py_interop_plot.new_chart_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_chart_data
    __del__ = lambda self: None
chart_data_swigregister = _py_interop_plot.chart_data_swigregister
chart_data_swigregister(chart_data)

class heatmap_data(chart_data):
    __swig_setmethods__ = {}
    for _s in [chart_data]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, heatmap_data, name, value)
    __swig_getmethods__ = {}
    for _s in [chart_data]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, heatmap_data, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _py_interop_plot.new_heatmap_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_heatmap_data
    __del__ = lambda self: None

    def at(self, *args):
        return _py_interop_plot.heatmap_data_at(self, *args)

    def row_count(self):
        return _py_interop_plot.heatmap_data_row_count(self)

    def column_count(self):
        return _py_interop_plot.heatmap_data_column_count(self)

    def length(self):
        return _py_interop_plot.heatmap_data_length(self)

    def empty(self):
        return _py_interop_plot.heatmap_data_empty(self)

    def set_buffer(self, *args):
        return _py_interop_plot.heatmap_data_set_buffer(self, *args)

    def resize(self, *args):
        return _py_interop_plot.heatmap_data_resize(self, *args)

    def clear(self):
        return _py_interop_plot.heatmap_data_clear(self)

    def index_of(self, row, col):
        return _py_interop_plot.heatmap_data_index_of(self, row, col)
heatmap_data_swigregister = _py_interop_plot.heatmap_data_swigregister
heatmap_data_swigregister(heatmap_data)

class flowcell_data(heatmap_data):
    __swig_setmethods__ = {}
    for _s in [heatmap_data]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, flowcell_data, name, value)
    __swig_getmethods__ = {}
    for _s in [heatmap_data]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, flowcell_data, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _py_interop_plot.new_flowcell_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_flowcell_data
    __del__ = lambda self: None

    def tile_at(self, index):
        return _py_interop_plot.flowcell_data_tile_at(self, index)

    def tile_id(self, lane_idx, loc):
        return _py_interop_plot.flowcell_data_tile_id(self, lane_idx, loc)

    def saxis(self):
        return _py_interop_plot.flowcell_data_saxis(self)

    def subtitle(self):
        return _py_interop_plot.flowcell_data_subtitle(self)

    def lane_count(self):
        return _py_interop_plot.flowcell_data_lane_count(self)

    def swath_count(self):
        return _py_interop_plot.flowcell_data_swath_count(self)

    def tile_count(self):
        return _py_interop_plot.flowcell_data_tile_count(self)

    def total_tile_count(self):
        return _py_interop_plot.flowcell_data_total_tile_count(self)

    def set_data(self, lane_idx, loc, tile_id, value):
        return _py_interop_plot.flowcell_data_set_data(self, lane_idx, loc, tile_id, value)

    def set_saxis(self, plot_axis):
        return _py_interop_plot.flowcell_data_set_saxis(self, plot_axis)

    def set_label(self, label):
        return _py_interop_plot.flowcell_data_set_label(self, label)

    def set_subtitle(self, subtitle):
        return _py_interop_plot.flowcell_data_set_subtitle(self, subtitle)

    def set_range(self, vmin, vmax):
        return _py_interop_plot.flowcell_data_set_range(self, vmin, vmax)

    def set_buffer(self, data_buffer, id_buffer, lanes, swaths, tiles):
        return _py_interop_plot.flowcell_data_set_buffer(self, data_buffer, id_buffer, lanes, swaths, tiles)

    def resize(self, lanes, swaths, tiles):
        return _py_interop_plot.flowcell_data_resize(self, lanes, swaths, tiles)

    def clear(self):
        return _py_interop_plot.flowcell_data_clear(self)
flowcell_data_swigregister = _py_interop_plot.flowcell_data_swigregister
flowcell_data_swigregister(flowcell_data)

class float_point(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, float_point, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, float_point, name)
    __repr__ = _swig_repr

    def __init__(self, x=0, y=0):
        this = _py_interop_plot.new_float_point(x, y)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def x(self):
        return _py_interop_plot.float_point_x(self)

    def y(self):
        return _py_interop_plot.float_point_y(self)

    def max_value(self):
        return _py_interop_plot.float_point_max_value(self)

    def min_value(self):
        return _py_interop_plot.float_point_min_value(self)

    def add(self, x, y):
        return _py_interop_plot.float_point_add(self, x, y)

    def set(self, x, y):
        return _py_interop_plot.float_point_set(self, x, y)
    __swig_destroy__ = _py_interop_plot.delete_float_point
    __del__ = lambda self: None
float_point_swigregister = _py_interop_plot.float_point_swigregister
float_point_swigregister(float_point)

class candle_stick_point(float_point):
    __swig_setmethods__ = {}
    for _s in [float_point]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, candle_stick_point, name, value)
    __swig_getmethods__ = {}
    for _s in [float_point]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, candle_stick_point, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _py_interop_plot.new_candle_stick_point(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def max_value(self):
        return _py_interop_plot.candle_stick_point_max_value(self)

    def min_value(self):
        return _py_interop_plot.candle_stick_point_min_value(self)

    def p25(self):
        return _py_interop_plot.candle_stick_point_p25(self)

    def p50(self):
        return _py_interop_plot.candle_stick_point_p50(self)

    def p75(self):
        return _py_interop_plot.candle_stick_point_p75(self)

    def lower(self):
        return _py_interop_plot.candle_stick_point_lower(self)

    def upper(self):
        return _py_interop_plot.candle_stick_point_upper(self)

    def outliers(self):
        return _py_interop_plot.candle_stick_point_outliers(self)

    def data_point_count(self):
        return _py_interop_plot.candle_stick_point_data_point_count(self)
    __swig_destroy__ = _py_interop_plot.delete_candle_stick_point
    __del__ = lambda self: None
candle_stick_point_swigregister = _py_interop_plot.candle_stick_point_swigregister
candle_stick_point_swigregister(candle_stick_point)

class bar_point(float_point):
    __swig_setmethods__ = {}
    for _s in [float_point]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, bar_point, name, value)
    __swig_getmethods__ = {}
    for _s in [float_point]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, bar_point, name)
    __repr__ = _swig_repr

    def __init__(self, x=0, height=0, width=0):
        this = _py_interop_plot.new_bar_point(x, height, width)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def set(self, x, height, width=1):
        return _py_interop_plot.bar_point_set(self, x, height, width)

    def width(self):
        return _py_interop_plot.bar_point_width(self)

    def min_value(self):
        return _py_interop_plot.bar_point_min_value(self)
    __swig_destroy__ = _py_interop_plot.delete_bar_point
    __del__ = lambda self: None
bar_point_swigregister = _py_interop_plot.bar_point_swigregister
bar_point_swigregister(bar_point)

class bar_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, bar_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, bar_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_plot.bar_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_plot.bar_vector___bool__(self)

    def __len__(self):
        return _py_interop_plot.bar_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_plot.bar_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_plot.bar_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_plot.bar_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_plot.bar_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_plot.bar_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_plot.bar_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_plot.bar_vector_pop(self)

    def append(self, x):
        return _py_interop_plot.bar_vector_append(self, x)

    def empty(self):
        return _py_interop_plot.bar_vector_empty(self)

    def size(self):
        return _py_interop_plot.bar_vector_size(self)

    def swap(self, v):
        return _py_interop_plot.bar_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_plot.bar_vector_rbegin(self)

    def rend(self):
        return _py_interop_plot.bar_vector_rend(self)

    def clear(self):
        return _py_interop_plot.bar_vector_clear(self)

    def get_allocator(self):
        return _py_interop_plot.bar_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_plot.bar_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_plot.bar_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_plot.new_bar_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_plot.bar_vector_push_back(self, x)

    def front(self):
        return _py_interop_plot.bar_vector_front(self)

    def back(self):
        return _py_interop_plot.bar_vector_back(self)

    def assign(self, n, x):
        return _py_interop_plot.bar_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_plot.bar_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_plot.bar_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_plot.bar_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_plot.bar_vector_capacity(self)
    __swig_destroy__ = _py_interop_plot.delete_bar_vector
    __del__ = lambda self: None
bar_vector_swigregister = _py_interop_plot.bar_vector_swigregister
bar_vector_swigregister(bar_vector)

class candle_stick_vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, candle_stick_vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, candle_stick_vector, name)
    __repr__ = _swig_repr
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _py_interop_plot.candle_stick_vector___nonzero__(self)

    def __bool__(self):
        return _py_interop_plot.candle_stick_vector___bool__(self)

    def __len__(self):
        return _py_interop_plot.candle_stick_vector___len__(self)

    def __getslice__(self, i, j):
        return _py_interop_plot.candle_stick_vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _py_interop_plot.candle_stick_vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _py_interop_plot.candle_stick_vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _py_interop_plot.candle_stick_vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _py_interop_plot.candle_stick_vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _py_interop_plot.candle_stick_vector___setitem__(self, *args)

    def pop(self):
        return _py_interop_plot.candle_stick_vector_pop(self)

    def append(self, x):
        return _py_interop_plot.candle_stick_vector_append(self, x)

    def empty(self):
        return _py_interop_plot.candle_stick_vector_empty(self)

    def size(self):
        return _py_interop_plot.candle_stick_vector_size(self)

    def swap(self, v):
        return _py_interop_plot.candle_stick_vector_swap(self, v)

    def rbegin(self):
        return _py_interop_plot.candle_stick_vector_rbegin(self)

    def rend(self):
        return _py_interop_plot.candle_stick_vector_rend(self)

    def clear(self):
        return _py_interop_plot.candle_stick_vector_clear(self)

    def get_allocator(self):
        return _py_interop_plot.candle_stick_vector_get_allocator(self)

    def pop_back(self):
        return _py_interop_plot.candle_stick_vector_pop_back(self)

    def erase(self, *args):
        return _py_interop_plot.candle_stick_vector_erase(self, *args)

    def __init__(self, *args):
        this = _py_interop_plot.new_candle_stick_vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _py_interop_plot.candle_stick_vector_push_back(self, x)

    def front(self):
        return _py_interop_plot.candle_stick_vector_front(self)

    def back(self):
        return _py_interop_plot.candle_stick_vector_back(self)

    def assign(self, n, x):
        return _py_interop_plot.candle_stick_vector_assign(self, n, x)

    def resize(self, *args):
        return _py_interop_plot.candle_stick_vector_resize(self, *args)

    def insert(self, *args):
        return _py_interop_plot.candle_stick_vector_insert(self, *args)

    def reserve(self, n):
        return _py_interop_plot.candle_stick_vector_reserve(self, n)

    def capacity(self):
        return _py_interop_plot.candle_stick_vector_capacity(self)
    __swig_destroy__ = _py_interop_plot.delete_candle_stick_vector
    __del__ = lambda self: None
candle_stick_vector_swigregister = _py_interop_plot.candle_stick_vector_swigregister
candle_stick_vector_swigregister(candle_stick_vector)

class candle_stick_collection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, candle_stick_collection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, candle_stick_collection, name)
    __repr__ = _swig_repr

    def at(self, index):
        return _py_interop_plot.candle_stick_collection_at(self, index)

    def size(self):
        return _py_interop_plot.candle_stick_collection_size(self)

    def assign(self, n, val):
        return _py_interop_plot.candle_stick_collection_assign(self, n, val)

    def resize(self, n):
        return _py_interop_plot.candle_stick_collection_resize(self, n)

    def push_back(self, point):
        return _py_interop_plot.candle_stick_collection_push_back(self, point)

    def __init__(self):
        this = _py_interop_plot.new_candle_stick_collection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_candle_stick_collection
    __del__ = lambda self: None
candle_stick_collection_swigregister = _py_interop_plot.candle_stick_collection_swigregister
candle_stick_collection_swigregister(candle_stick_collection)

class bar_collection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, bar_collection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, bar_collection, name)
    __repr__ = _swig_repr

    def at(self, index):
        return _py_interop_plot.bar_collection_at(self, index)

    def size(self):
        return _py_interop_plot.bar_collection_size(self)

    def assign(self, n, val):
        return _py_interop_plot.bar_collection_assign(self, n, val)

    def resize(self, n):
        return _py_interop_plot.bar_collection_resize(self, n)

    def push_back(self, point):
        return _py_interop_plot.bar_collection_push_back(self, point)

    def __init__(self):
        this = _py_interop_plot.new_bar_collection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_bar_collection
    __del__ = lambda self: None
bar_collection_swigregister = _py_interop_plot.bar_collection_swigregister
bar_collection_swigregister(bar_collection)

class candle_stick_series(candle_stick_collection):
    __swig_setmethods__ = {}
    for _s in [candle_stick_collection]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, candle_stick_series, name, value)
    __swig_getmethods__ = {}
    for _s in [candle_stick_collection]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, candle_stick_series, name)
    __repr__ = _swig_repr
    Candlestick = _py_interop_plot.candle_stick_series_Candlestick
    Line = _py_interop_plot.candle_stick_series_Line
    Bar = _py_interop_plot.candle_stick_series_Bar

    def __init__(self, *args):
        this = _py_interop_plot.new_candle_stick_series(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def title(self):
        return _py_interop_plot.candle_stick_series_title(self)

    def series_type(self):
        return _py_interop_plot.candle_stick_series_series_type(self)

    def options(self):
        return _py_interop_plot.candle_stick_series_options(self)

    def add_option(self, option):
        return _py_interop_plot.candle_stick_series_add_option(self, option)

    def color(self, *args):
        return _py_interop_plot.candle_stick_series_color(self, *args)
    __swig_destroy__ = _py_interop_plot.delete_candle_stick_series
    __del__ = lambda self: None
candle_stick_series_swigregister = _py_interop_plot.candle_stick_series_swigregister
candle_stick_series_swigregister(candle_stick_series)

class bar_series(bar_collection):
    __swig_setmethods__ = {}
    for _s in [bar_collection]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, bar_series, name, value)
    __swig_getmethods__ = {}
    for _s in [bar_collection]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, bar_series, name)
    __repr__ = _swig_repr
    Candlestick = _py_interop_plot.bar_series_Candlestick
    Line = _py_interop_plot.bar_series_Line
    Bar = _py_interop_plot.bar_series_Bar

    def __init__(self, *args):
        this = _py_interop_plot.new_bar_series(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def title(self):
        return _py_interop_plot.bar_series_title(self)

    def series_type(self):
        return _py_interop_plot.bar_series_series_type(self)

    def options(self):
        return _py_interop_plot.bar_series_options(self)

    def add_option(self, option):
        return _py_interop_plot.bar_series_add_option(self, option)

    def color(self, *args):
        return _py_interop_plot.bar_series_color(self, *args)
    __swig_destroy__ = _py_interop_plot.delete_bar_series
    __del__ = lambda self: None
bar_series_swigregister = _py_interop_plot.bar_series_swigregister
bar_series_swigregister(bar_series)

class candle_stick_plot_data(chart_data):
    __swig_setmethods__ = {}
    for _s in [chart_data]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, candle_stick_plot_data, name, value)
    __swig_getmethods__ = {}
    for _s in [chart_data]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, candle_stick_plot_data, name)
    __repr__ = _swig_repr

    def at(self, index):
        return _py_interop_plot.candle_stick_plot_data_at(self, index)

    def size(self):
        return _py_interop_plot.candle_stick_plot_data_size(self)

    def empty(self):
        return _py_interop_plot.candle_stick_plot_data_empty(self)

    def clear(self):
        return _py_interop_plot.candle_stick_plot_data_clear(self)

    def resize(self, n):
        return _py_interop_plot.candle_stick_plot_data_resize(self, n)

    def assign(self, n, val):
        return _py_interop_plot.candle_stick_plot_data_assign(self, n, val)

    def push_back(self, val):
        return _py_interop_plot.candle_stick_plot_data_push_back(self, val)

    def __init__(self):
        this = _py_interop_plot.new_candle_stick_plot_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_candle_stick_plot_data
    __del__ = lambda self: None
candle_stick_plot_data_swigregister = _py_interop_plot.candle_stick_plot_data_swigregister
candle_stick_plot_data_swigregister(candle_stick_plot_data)

class bar_plot_data(chart_data):
    __swig_setmethods__ = {}
    for _s in [chart_data]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, bar_plot_data, name, value)
    __swig_getmethods__ = {}
    for _s in [chart_data]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, bar_plot_data, name)
    __repr__ = _swig_repr

    def at(self, index):
        return _py_interop_plot.bar_plot_data_at(self, index)

    def size(self):
        return _py_interop_plot.bar_plot_data_size(self)

    def empty(self):
        return _py_interop_plot.bar_plot_data_empty(self)

    def clear(self):
        return _py_interop_plot.bar_plot_data_clear(self)

    def resize(self, n):
        return _py_interop_plot.bar_plot_data_resize(self, n)

    def assign(self, n, val):
        return _py_interop_plot.bar_plot_data_assign(self, n, val)

    def push_back(self, val):
        return _py_interop_plot.bar_plot_data_push_back(self, val)

    def __init__(self):
        this = _py_interop_plot.new_bar_plot_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _py_interop_plot.delete_bar_plot_data
    __del__ = lambda self: None
bar_plot_data_swigregister = _py_interop_plot.bar_plot_data_swigregister
bar_plot_data_swigregister(bar_plot_data)


def plot_by_cycle(*args):
    return _py_interop_plot.plot_by_cycle(*args)
plot_by_cycle = _py_interop_plot.plot_by_cycle

def list_by_cycle_metrics(types, ignore_accumulated=False):
    return _py_interop_plot.list_by_cycle_metrics(types, ignore_accumulated)
list_by_cycle_metrics = _py_interop_plot.list_by_cycle_metrics

def filter_by_cycle_metrics(types, ignore_accumulated=False):
    return _py_interop_plot.filter_by_cycle_metrics(types, ignore_accumulated)
filter_by_cycle_metrics = _py_interop_plot.filter_by_cycle_metrics

def plot_by_lane(*args):
    return _py_interop_plot.plot_by_lane(*args)
plot_by_lane = _py_interop_plot.plot_by_lane

def list_by_lane_metrics(types, ignore_pf=False):
    return _py_interop_plot.list_by_lane_metrics(types, ignore_pf)
list_by_lane_metrics = _py_interop_plot.list_by_lane_metrics

def filter_by_lane_metrics(types, ignore_pf=False):
    return _py_interop_plot.filter_by_lane_metrics(types, ignore_pf)
filter_by_lane_metrics = _py_interop_plot.filter_by_lane_metrics

def plot_qscore_histogram(metrics, options, data, boundary=0):
    return _py_interop_plot.plot_qscore_histogram(metrics, options, data, boundary)
plot_qscore_histogram = _py_interop_plot.plot_qscore_histogram

def plot_qscore_heatmap(metrics, options, data, buffer=None):
    return _py_interop_plot.plot_qscore_heatmap(metrics, options, data, buffer)
plot_qscore_heatmap = _py_interop_plot.plot_qscore_heatmap

def count_rows_for_heatmap(metrics):
    return _py_interop_plot.count_rows_for_heatmap(metrics)
count_rows_for_heatmap = _py_interop_plot.count_rows_for_heatmap

def count_columns_for_heatmap(metrics):
    return _py_interop_plot.count_columns_for_heatmap(metrics)
count_columns_for_heatmap = _py_interop_plot.count_columns_for_heatmap

def plot_flowcell_map(*args):
    return _py_interop_plot.plot_flowcell_map(*args)
plot_flowcell_map = _py_interop_plot.plot_flowcell_map

def plot_flowcell_map2(*args):
    return _py_interop_plot.plot_flowcell_map2(*args)
plot_flowcell_map2 = _py_interop_plot.plot_flowcell_map2

def list_flowcell_metrics(types, ignore_accumulated=False):
    return _py_interop_plot.list_flowcell_metrics(types, ignore_accumulated)
list_flowcell_metrics = _py_interop_plot.list_flowcell_metrics

def filter_flowcell_metrics(types, ignore_accumulated=False):
    return _py_interop_plot.filter_flowcell_metrics(types, ignore_accumulated)
filter_flowcell_metrics = _py_interop_plot.filter_flowcell_metrics

def calculate_flowcell_buffer_size(metrics, options):
    return _py_interop_plot.calculate_flowcell_buffer_size(metrics, options)
calculate_flowcell_buffer_size = _py_interop_plot.calculate_flowcell_buffer_size

def plot_sample_qc(metrics, lane, data):
    return _py_interop_plot.plot_sample_qc(metrics, lane, data)
plot_sample_qc = _py_interop_plot.plot_sample_qc

def list_plot_metrics(types):
    return _py_interop_plot.list_plot_metrics(types)
list_plot_metrics = _py_interop_plot.list_plot_metrics

def list_available_plot_metrics(metrics, types):
    return _py_interop_plot.list_available_plot_metrics(metrics, types)
list_available_plot_metrics = _py_interop_plot.list_available_plot_metrics
# This file is compatible with both classic and new-style classes.


