python-openturns 1.2-2 / usr / share / pyshared / openturns / graph.py

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


"""
Graphical output.
"""


from sys import version_info
if 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('_graph', [dirname(__file__)])
        except ImportError:
            import _graph
            return _graph
        if fp is not None:
            try:
                _mod = imp.load_module('_graph', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _graph = swig_import_helper()
    del swig_import_helper
else:
    import _graph
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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):
        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(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class SwigPyIterator(_object):
    """Proxy of C++ swig::SwigPyIterator class"""
    __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__ = _graph.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _graph.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _graph.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _graph.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _graph.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _graph.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _graph.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _graph.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _graph.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _graph.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graph.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _graph.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _graph.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graph.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graph.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _graph.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _graph.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator_swigregister = _graph.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

GCC_VERSION = _graph.GCC_VERSION
class TestFailed:
  """
  TestFailed is used to raise an uniform exception in tests
  """
  __type = "TestFailed"
  def __init__(self,reason=""):
    self.reason = reason
  def type(self):
    return TestFailed.__type
  def what(self):
    return self.reason
  def __str__(self):
    return TestFailed.__type + ": " + self.reason
  def __lshift__(self,ch):
    self.reason += ch
    return self

import openturns.common
import openturns.wrapper
import openturns.typ
class DrawableImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::DrawableImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DrawableImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DrawableImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.DrawableImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getClassName(self)

    def __repr__(self):
        """__repr__(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(DrawableImplementation self, OT::String const & offset="") -> OT::String
        __str__(DrawableImplementation self) -> OT::String
        """
        return _graph.DrawableImplementation___str__(self, offset)

    def __eq__(self, *args):
        """__eq__(DrawableImplementation self, DrawableImplementation other) -> OT::Bool"""
        return _graph.DrawableImplementation___eq__(self, *args)

    def getPointCode(self, *args):
        """getPointCode(DrawableImplementation self, OT::String const & key) -> OT::UnsignedLong"""
        return _graph.DrawableImplementation_getPointCode(self, *args)

    def IsValidColorCode(*args):
        """IsValidColorCode(OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementation_IsValidColorCode(*args)

    if _newclass:IsValidColorCode = staticmethod(IsValidColorCode)
    __swig_getmethods__["IsValidColorCode"] = lambda x: IsValidColorCode
    def IsValidColorName(*args):
        """IsValidColorName(OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementation_IsValidColorName(*args)

    if _newclass:IsValidColorName = staticmethod(IsValidColorName)
    __swig_getmethods__["IsValidColorName"] = lambda x: IsValidColorName
    def IsValidColor(*args):
        """IsValidColor(OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementation_IsValidColor(*args)

    if _newclass:IsValidColor = staticmethod(IsValidColor)
    __swig_getmethods__["IsValidColor"] = lambda x: IsValidColor
    def IsValidLineStyle(*args):
        """IsValidLineStyle(OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementation_IsValidLineStyle(*args)

    if _newclass:IsValidLineStyle = staticmethod(IsValidLineStyle)
    __swig_getmethods__["IsValidLineStyle"] = lambda x: IsValidLineStyle
    def IsValidPointStyle(*args):
        """IsValidPointStyle(OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementation_IsValidPointStyle(*args)

    if _newclass:IsValidPointStyle = staticmethod(IsValidPointStyle)
    __swig_getmethods__["IsValidPointStyle"] = lambda x: IsValidPointStyle
    def IsValidFillStyle(*args):
        """IsValidFillStyle(OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementation_IsValidFillStyle(*args)

    if _newclass:IsValidFillStyle = staticmethod(IsValidFillStyle)
    __swig_getmethods__["IsValidFillStyle"] = lambda x: IsValidFillStyle
    def IsValidPattern(*args):
        """IsValidPattern(OT::String const & pattern) -> OT::Bool"""
        return _graph.DrawableImplementation_IsValidPattern(*args)

    if _newclass:IsValidPattern = staticmethod(IsValidPattern)
    __swig_getmethods__["IsValidPattern"] = lambda x: IsValidPattern
    def getLegendName(self):
        """getLegendName(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getLegendName(self)

    def setLegendName(self, *args):
        """setLegendName(DrawableImplementation self, OT::String const & legendName)"""
        return _graph.DrawableImplementation_setLegendName(self, *args)

    def getLegend(self):
        """getLegend(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getLegend(self)

    def setLegend(self, *args):
        """setLegend(DrawableImplementation self, OT::String const & legend)"""
        return _graph.DrawableImplementation_setLegend(self, *args)

    def getData(self):
        """getData(DrawableImplementation self) -> NumericalSample"""
        return _graph.DrawableImplementation_getData(self)

    def getLineStyle(self):
        """getLineStyle(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getLineStyle(self)

    def setLineStyle(self, *args):
        """setLineStyle(DrawableImplementation self, OT::String const & lineStyle)"""
        return _graph.DrawableImplementation_setLineStyle(self, *args)

    def getColor(self):
        """getColor(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getColor(self)

    def getColorCode(self):
        """getColorCode(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getColorCode(self)

    def setColor(self, *args):
        """setColor(DrawableImplementation self, OT::String const & color)"""
        return _graph.DrawableImplementation_setColor(self, *args)

    def getEdgeColor(self):
        """getEdgeColor(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getEdgeColor(self)

    def getPointStyle(self):
        """getPointStyle(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getPointStyle(self)

    def setPointStyle(self, *args):
        """setPointStyle(DrawableImplementation self, OT::String const & pointStyle)"""
        return _graph.DrawableImplementation_setPointStyle(self, *args)

    def getFillStyle(self):
        """getFillStyle(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getFillStyle(self)

    def setFillStyle(self, *args):
        """setFillStyle(DrawableImplementation self, OT::String const & fillStyle)"""
        return _graph.DrawableImplementation_setFillStyle(self, *args)

    def getLineWidth(self):
        """getLineWidth(DrawableImplementation self) -> OT::UnsignedLong"""
        return _graph.DrawableImplementation_getLineWidth(self)

    def setLineWidth(self, *args):
        """setLineWidth(DrawableImplementation self, OT::UnsignedLong const lineWidth)"""
        return _graph.DrawableImplementation_setLineWidth(self, *args)

    def getPattern(self):
        """getPattern(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_getPattern(self)

    def setPattern(self, *args):
        """setPattern(DrawableImplementation self, OT::String const style)"""
        return _graph.DrawableImplementation_setPattern(self, *args)

    def setShowPoints(self, *args):
        """setShowPoints(DrawableImplementation self, OT::Bool const showPoints)"""
        return _graph.DrawableImplementation_setShowPoints(self, *args)

    def getShowPoints(self):
        """getShowPoints(DrawableImplementation self) -> OT::Bool"""
        return _graph.DrawableImplementation_getShowPoints(self)

    def getCenter(self):
        """getCenter(DrawableImplementation self) -> NumericalPoint"""
        return _graph.DrawableImplementation_getCenter(self)

    def setCenter(self, *args):
        """setCenter(DrawableImplementation self, NumericalPoint center)"""
        return _graph.DrawableImplementation_setCenter(self, *args)

    def getRadius(self):
        """getRadius(DrawableImplementation self) -> OT::NumericalScalar"""
        return _graph.DrawableImplementation_getRadius(self)

    def setRadius(self, *args):
        """setRadius(DrawableImplementation self, OT::NumericalScalar const radius)"""
        return _graph.DrawableImplementation_setRadius(self, *args)

    def getLabels(self):
        """getLabels(DrawableImplementation self) -> Description"""
        return _graph.DrawableImplementation_getLabels(self)

    def setLabels(self, *args):
        """setLabels(DrawableImplementation self, Description labels)"""
        return _graph.DrawableImplementation_setLabels(self, *args)

    def getPalette(self):
        """getPalette(DrawableImplementation self) -> Description"""
        return _graph.DrawableImplementation_getPalette(self)

    def setPalette(self, *args):
        """setPalette(DrawableImplementation self, Description palette)"""
        return _graph.DrawableImplementation_setPalette(self, *args)

    def getOrigin(self):
        """getOrigin(DrawableImplementation self) -> OT::NumericalScalar"""
        return _graph.DrawableImplementation_getOrigin(self)

    def setOrigin(self, *args):
        """setOrigin(DrawableImplementation self, OT::NumericalScalar const origin)"""
        return _graph.DrawableImplementation_setOrigin(self, *args)

    def getX(self):
        """getX(DrawableImplementation self) -> NumericalSample"""
        return _graph.DrawableImplementation_getX(self)

    def setX(self, *args):
        """setX(DrawableImplementation self, NumericalSample x)"""
        return _graph.DrawableImplementation_setX(self, *args)

    def getY(self):
        """getY(DrawableImplementation self) -> NumericalSample"""
        return _graph.DrawableImplementation_getY(self)

    def setY(self, *args):
        """setY(DrawableImplementation self, NumericalSample y)"""
        return _graph.DrawableImplementation_setY(self, *args)

    def getLevels(self):
        """getLevels(DrawableImplementation self) -> NumericalPoint"""
        return _graph.DrawableImplementation_getLevels(self)

    def setLevels(self, *args):
        """setLevels(DrawableImplementation self, NumericalPoint levels)"""
        return _graph.DrawableImplementation_setLevels(self, *args)

    def getDrawLabels(self):
        """getDrawLabels(DrawableImplementation self) -> OT::Bool"""
        return _graph.DrawableImplementation_getDrawLabels(self)

    def setDrawLabels(self, *args):
        """setDrawLabels(DrawableImplementation self, OT::Bool const & drawLabels)"""
        return _graph.DrawableImplementation_setDrawLabels(self, *args)

    def getBoundingBox(self):
        """getBoundingBox(DrawableImplementation self) -> NumericalPoint"""
        return _graph.DrawableImplementation_getBoundingBox(self)

    def draw(self):
        """draw(DrawableImplementation self) -> OT::String"""
        return _graph.DrawableImplementation_draw(self)

    def clean(self):
        """clean(DrawableImplementation self)"""
        return _graph.DrawableImplementation_clean(self)

    def GetValidColors():
        """GetValidColors() -> Description"""
        return _graph.DrawableImplementation_GetValidColors()

    if _newclass:GetValidColors = staticmethod(GetValidColors)
    __swig_getmethods__["GetValidColors"] = lambda x: GetValidColors
    def GetValidLineStyles():
        """GetValidLineStyles() -> Description"""
        return _graph.DrawableImplementation_GetValidLineStyles()

    if _newclass:GetValidLineStyles = staticmethod(GetValidLineStyles)
    __swig_getmethods__["GetValidLineStyles"] = lambda x: GetValidLineStyles
    def GetValidFillStyles():
        """GetValidFillStyles() -> Description"""
        return _graph.DrawableImplementation_GetValidFillStyles()

    if _newclass:GetValidFillStyles = staticmethod(GetValidFillStyles)
    __swig_getmethods__["GetValidFillStyles"] = lambda x: GetValidFillStyles
    def GetValidPointStyles():
        """GetValidPointStyles() -> Description"""
        return _graph.DrawableImplementation_GetValidPointStyles()

    if _newclass:GetValidPointStyles = staticmethod(GetValidPointStyles)
    __swig_getmethods__["GetValidPointStyles"] = lambda x: GetValidPointStyles
    def ConvertFromName(*args):
        """ConvertFromName(OT::String const & name) -> OT::String"""
        return _graph.DrawableImplementation_ConvertFromName(*args)

    if _newclass:ConvertFromName = staticmethod(ConvertFromName)
    __swig_getmethods__["ConvertFromName"] = lambda x: ConvertFromName
    def ConvertFromRGB(*args):
        """
        ConvertFromRGB(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue) -> OT::String
        ConvertFromRGB(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue) -> OT::String
        """
        return _graph.DrawableImplementation_ConvertFromRGB(*args)

    if _newclass:ConvertFromRGB = staticmethod(ConvertFromRGB)
    __swig_getmethods__["ConvertFromRGB"] = lambda x: ConvertFromRGB
    def ConvertFromRGBA(*args):
        """
        ConvertFromRGBA(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue, 
            OT::UnsignedLong const alpha) -> OT::String
        ConvertFromRGBA(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue, 
            OT::NumericalScalar const alpha) -> OT::String
        """
        return _graph.DrawableImplementation_ConvertFromRGBA(*args)

    if _newclass:ConvertFromRGBA = staticmethod(ConvertFromRGBA)
    __swig_getmethods__["ConvertFromRGBA"] = lambda x: ConvertFromRGBA
    def ConvertFromHSVIntoRGB(*args):
        """ConvertFromHSVIntoRGB(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> NumericalPoint"""
        return _graph.DrawableImplementation_ConvertFromHSVIntoRGB(*args)

    if _newclass:ConvertFromHSVIntoRGB = staticmethod(ConvertFromHSVIntoRGB)
    __swig_getmethods__["ConvertFromHSVIntoRGB"] = lambda x: ConvertFromHSVIntoRGB
    def ConvertFromHSV(*args):
        """ConvertFromHSV(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> OT::String"""
        return _graph.DrawableImplementation_ConvertFromHSV(*args)

    if _newclass:ConvertFromHSV = staticmethod(ConvertFromHSV)
    __swig_getmethods__["ConvertFromHSV"] = lambda x: ConvertFromHSV
    def ConvertFromHSVA(*args):
        """
        ConvertFromHSVA(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value, 
            OT::NumericalScalar const alpha) -> OT::String
        """
        return _graph.DrawableImplementation_ConvertFromHSVA(*args)

    if _newclass:ConvertFromHSVA = staticmethod(ConvertFromHSVA)
    __swig_getmethods__["ConvertFromHSVA"] = lambda x: ConvertFromHSVA
    def BuildDefaultPalette(*args):
        """BuildDefaultPalette(OT::UnsignedLong const size) -> Description"""
        return _graph.DrawableImplementation_BuildDefaultPalette(*args)

    if _newclass:BuildDefaultPalette = staticmethod(BuildDefaultPalette)
    __swig_getmethods__["BuildDefaultPalette"] = lambda x: BuildDefaultPalette
    def __init__(self, *args): 
        """
        __init__(OT::DrawableImplementation self, NumericalSample data, OT::String const & legend="") -> DrawableImplementation
        __init__(OT::DrawableImplementation self, NumericalSample data) -> DrawableImplementation
        __init__(OT::DrawableImplementation self, DrawableImplementation other) -> DrawableImplementation
        """
        this = _graph.new_DrawableImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_DrawableImplementation
    __del__ = lambda self : None;
DrawableImplementation_swigregister = _graph.DrawableImplementation_swigregister
DrawableImplementation_swigregister(DrawableImplementation)

def DrawableImplementation_GetClassName():
  """DrawableImplementation_GetClassName() -> OT::String"""
  return _graph.DrawableImplementation_GetClassName()

def DrawableImplementation_IsValidColorCode(*args):
  """DrawableImplementation_IsValidColorCode(OT::String const & key) -> OT::Bool"""
  return _graph.DrawableImplementation_IsValidColorCode(*args)

def DrawableImplementation_IsValidColorName(*args):
  """DrawableImplementation_IsValidColorName(OT::String const & key) -> OT::Bool"""
  return _graph.DrawableImplementation_IsValidColorName(*args)

def DrawableImplementation_IsValidColor(*args):
  """DrawableImplementation_IsValidColor(OT::String const & key) -> OT::Bool"""
  return _graph.DrawableImplementation_IsValidColor(*args)

def DrawableImplementation_IsValidLineStyle(*args):
  """DrawableImplementation_IsValidLineStyle(OT::String const & key) -> OT::Bool"""
  return _graph.DrawableImplementation_IsValidLineStyle(*args)

def DrawableImplementation_IsValidPointStyle(*args):
  """DrawableImplementation_IsValidPointStyle(OT::String const & key) -> OT::Bool"""
  return _graph.DrawableImplementation_IsValidPointStyle(*args)

def DrawableImplementation_IsValidFillStyle(*args):
  """DrawableImplementation_IsValidFillStyle(OT::String const & key) -> OT::Bool"""
  return _graph.DrawableImplementation_IsValidFillStyle(*args)

def DrawableImplementation_IsValidPattern(*args):
  """DrawableImplementation_IsValidPattern(OT::String const & pattern) -> OT::Bool"""
  return _graph.DrawableImplementation_IsValidPattern(*args)

def DrawableImplementation_GetValidColors():
  """DrawableImplementation_GetValidColors() -> Description"""
  return _graph.DrawableImplementation_GetValidColors()

def DrawableImplementation_GetValidLineStyles():
  """DrawableImplementation_GetValidLineStyles() -> Description"""
  return _graph.DrawableImplementation_GetValidLineStyles()

def DrawableImplementation_GetValidFillStyles():
  """DrawableImplementation_GetValidFillStyles() -> Description"""
  return _graph.DrawableImplementation_GetValidFillStyles()

def DrawableImplementation_GetValidPointStyles():
  """DrawableImplementation_GetValidPointStyles() -> Description"""
  return _graph.DrawableImplementation_GetValidPointStyles()

def DrawableImplementation_ConvertFromName(*args):
  """DrawableImplementation_ConvertFromName(OT::String const & name) -> OT::String"""
  return _graph.DrawableImplementation_ConvertFromName(*args)

def DrawableImplementation_ConvertFromRGB(*args):
  """
    ConvertFromRGB(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue) -> OT::String
    DrawableImplementation_ConvertFromRGB(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue) -> OT::String
    """
  return _graph.DrawableImplementation_ConvertFromRGB(*args)

def DrawableImplementation_ConvertFromRGBA(*args):
  """
    ConvertFromRGBA(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue, 
        OT::UnsignedLong const alpha) -> OT::String
    DrawableImplementation_ConvertFromRGBA(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue, 
        OT::NumericalScalar const alpha) -> OT::String
    """
  return _graph.DrawableImplementation_ConvertFromRGBA(*args)

def DrawableImplementation_ConvertFromHSVIntoRGB(*args):
  """DrawableImplementation_ConvertFromHSVIntoRGB(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> NumericalPoint"""
  return _graph.DrawableImplementation_ConvertFromHSVIntoRGB(*args)

def DrawableImplementation_ConvertFromHSV(*args):
  """DrawableImplementation_ConvertFromHSV(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> OT::String"""
  return _graph.DrawableImplementation_ConvertFromHSV(*args)

def DrawableImplementation_ConvertFromHSVA(*args):
  """
    DrawableImplementation_ConvertFromHSVA(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value, 
        OT::NumericalScalar const alpha) -> OT::String
    """
  return _graph.DrawableImplementation_ConvertFromHSVA(*args)

def DrawableImplementation_BuildDefaultPalette(*args):
  """DrawableImplementation_BuildDefaultPalette(OT::UnsignedLong const size) -> Description"""
  return _graph.DrawableImplementation_BuildDefaultPalette(*args)

class DrawableImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::DrawableImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DrawableImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DrawableImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::DrawableImplementation)> self) -> DrawableImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::DrawableImplementation)> self, DrawableImplementationPointer impl) -> DrawableImplementationTypedInterfaceObject
        """
        this = _graph.new_DrawableImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(DrawableImplementationTypedInterfaceObject self) -> DrawableImplementationPointer
        getImplementation(DrawableImplementationTypedInterfaceObject self) -> DrawableImplementationPointer
        """
        return _graph.DrawableImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(DrawableImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _graph.DrawableImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(DrawableImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _graph.DrawableImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(DrawableImplementationTypedInterfaceObject self, DrawableImplementationTypedInterfaceObject other)"""
        return _graph.DrawableImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(DrawableImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _graph.DrawableImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(DrawableImplementationTypedInterfaceObject self) -> OT::String"""
        return _graph.DrawableImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(DrawableImplementationTypedInterfaceObject self, DrawableImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _graph.DrawableImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _graph.delete_DrawableImplementationTypedInterfaceObject
    __del__ = lambda self : None;
DrawableImplementationTypedInterfaceObject_swigregister = _graph.DrawableImplementationTypedInterfaceObject_swigregister
DrawableImplementationTypedInterfaceObject_swigregister(DrawableImplementationTypedInterfaceObject)

class DrawableCollection(_object):
    """Proxy of C++ OT::Collection<(OT::Drawable)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DrawableCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DrawableCollection, name)
    __swig_destroy__ = _graph.delete_DrawableCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(DrawableCollection self)"""
        return _graph.DrawableCollection_clear(self)

    def __len__(self):
        """__len__(DrawableCollection self) -> OT::UnsignedLong"""
        return _graph.DrawableCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(DrawableCollection self, DrawableCollection rhs) -> OT::Bool"""
        return _graph.DrawableCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(DrawableCollection self, Drawable val) -> OT::Bool"""
        return _graph.DrawableCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(DrawableCollection self, OT::UnsignedLong const i) -> Drawable"""
        return _graph.DrawableCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(DrawableCollection self, OT::UnsignedLong const i, Drawable val)"""
        return _graph.DrawableCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(DrawableCollection self, OT::UnsignedLong const i)"""
        return _graph.DrawableCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(DrawableCollection self, OT::UnsignedLong const i) -> Drawable
        at(DrawableCollection self, OT::UnsignedLong const i) -> Drawable
        """
        return _graph.DrawableCollection_at(self, *args)

    def add(self, *args):
        """
        add(DrawableCollection self, Drawable elt)
        add(DrawableCollection self, DrawableCollection coll)
        """
        return _graph.DrawableCollection_add(self, *args)

    def getSize(self):
        """getSize(DrawableCollection self) -> OT::UnsignedLong"""
        return _graph.DrawableCollection_getSize(self)

    def resize(self, *args):
        """resize(DrawableCollection self, OT::UnsignedLong const newSize)"""
        return _graph.DrawableCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(DrawableCollection self) -> OT::Bool"""
        return _graph.DrawableCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(DrawableCollection self) -> OT::String"""
        return _graph.DrawableCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(DrawableCollection self, OT::String const & offset="") -> OT::String
        __str__(DrawableCollection self) -> OT::String
        """
        return _graph.DrawableCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::Drawable)> self) -> DrawableCollection
        __init__(OT::Collection<(OT::Drawable)> self, OT::UnsignedLong const size) -> DrawableCollection
        __init__(OT::Collection<(OT::Drawable)> self, OT::UnsignedLong const size, Drawable value) -> DrawableCollection
        __init__(OT::Collection<(OT::Drawable)> self, PyObject * pyObj) -> DrawableCollection
        __init__(OT::Collection<(OT::Drawable)> self, DrawableCollection other) -> DrawableCollection
        """
        this = _graph.new_DrawableCollection(*args)
        try: self.this.append(this)
        except: self.this = this
DrawableCollection_swigregister = _graph.DrawableCollection_swigregister
DrawableCollection_swigregister(DrawableCollection)

class Drawable(DrawableImplementationTypedInterfaceObject):
    """Proxy of C++ OT::Drawable class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Drawable, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Drawable, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Drawable_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Drawable self) -> OT::String"""
        return _graph.Drawable_getClassName(self)

    def __repr__(self):
        """__repr__(Drawable self) -> OT::String"""
        return _graph.Drawable___repr__(self)

    def getBoundingBox(self):
        """getBoundingBox(Drawable self) -> NumericalPoint"""
        return _graph.Drawable_getBoundingBox(self)

    def getLegendName(self):
        """getLegendName(Drawable self) -> OT::String"""
        return _graph.Drawable_getLegendName(self)

    def setLegendName(self, *args):
        """setLegendName(Drawable self, OT::String const & legendName)"""
        return _graph.Drawable_setLegendName(self, *args)

    def getLegend(self):
        """getLegend(Drawable self) -> OT::String"""
        return _graph.Drawable_getLegend(self)

    def setLegend(self, *args):
        """setLegend(Drawable self, OT::String const & legend)"""
        return _graph.Drawable_setLegend(self, *args)

    def getLineStyle(self):
        """getLineStyle(Drawable self) -> OT::String"""
        return _graph.Drawable_getLineStyle(self)

    def setLineStyle(self, *args):
        """setLineStyle(Drawable self, OT::String const & lineStyle)"""
        return _graph.Drawable_setLineStyle(self, *args)

    def getPointStyle(self):
        """getPointStyle(Drawable self) -> OT::String"""
        return _graph.Drawable_getPointStyle(self)

    def setPointStyle(self, *args):
        """setPointStyle(Drawable self, OT::String const & pointStyle)"""
        return _graph.Drawable_setPointStyle(self, *args)

    def getFillStyle(self):
        """getFillStyle(Drawable self) -> OT::String"""
        return _graph.Drawable_getFillStyle(self)

    def setFillStyle(self, *args):
        """setFillStyle(Drawable self, OT::String const & fillStyle)"""
        return _graph.Drawable_setFillStyle(self, *args)

    def getLineWidth(self):
        """getLineWidth(Drawable self) -> OT::UnsignedLong"""
        return _graph.Drawable_getLineWidth(self)

    def setLineWidth(self, *args):
        """setLineWidth(Drawable self, OT::UnsignedLong const lineWidth)"""
        return _graph.Drawable_setLineWidth(self, *args)

    def getColor(self):
        """getColor(Drawable self) -> OT::String"""
        return _graph.Drawable_getColor(self)

    def getColorCode(self):
        """getColorCode(Drawable self) -> OT::String"""
        return _graph.Drawable_getColorCode(self)

    def setColor(self, *args):
        """setColor(Drawable self, OT::String const & color)"""
        return _graph.Drawable_setColor(self, *args)

    def getEdgeColor(self):
        """getEdgeColor(Drawable self) -> OT::String"""
        return _graph.Drawable_getEdgeColor(self)

    def getPattern(self):
        """getPattern(Drawable self) -> OT::String"""
        return _graph.Drawable_getPattern(self)

    def setPattern(self, *args):
        """setPattern(Drawable self, OT::String const style)"""
        return _graph.Drawable_setPattern(self, *args)

    def getCenter(self):
        """getCenter(Drawable self) -> NumericalPoint"""
        return _graph.Drawable_getCenter(self)

    def setCenter(self, *args):
        """setCenter(Drawable self, NumericalPoint center)"""
        return _graph.Drawable_setCenter(self, *args)

    def getRadius(self):
        """getRadius(Drawable self) -> OT::NumericalScalar"""
        return _graph.Drawable_getRadius(self)

    def setRadius(self, *args):
        """setRadius(Drawable self, OT::NumericalScalar const radius)"""
        return _graph.Drawable_setRadius(self, *args)

    def getLabels(self):
        """getLabels(Drawable self) -> Description"""
        return _graph.Drawable_getLabels(self)

    def setLabels(self, *args):
        """setLabels(Drawable self, Description labels)"""
        return _graph.Drawable_setLabels(self, *args)

    def getPalette(self):
        """getPalette(Drawable self) -> Description"""
        return _graph.Drawable_getPalette(self)

    def setPalette(self, *args):
        """setPalette(Drawable self, Description palette)"""
        return _graph.Drawable_setPalette(self, *args)

    def getOrigin(self):
        """getOrigin(Drawable self) -> OT::NumericalScalar"""
        return _graph.Drawable_getOrigin(self)

    def setOrigin(self, *args):
        """setOrigin(Drawable self, OT::NumericalScalar const origin)"""
        return _graph.Drawable_setOrigin(self, *args)

    def getX(self):
        """getX(Drawable self) -> NumericalSample"""
        return _graph.Drawable_getX(self)

    def setX(self, *args):
        """setX(Drawable self, NumericalSample x)"""
        return _graph.Drawable_setX(self, *args)

    def getY(self):
        """getY(Drawable self) -> NumericalSample"""
        return _graph.Drawable_getY(self)

    def setY(self, *args):
        """setY(Drawable self, NumericalSample y)"""
        return _graph.Drawable_setY(self, *args)

    def getLevels(self):
        """getLevels(Drawable self) -> NumericalPoint"""
        return _graph.Drawable_getLevels(self)

    def setLevels(self, *args):
        """setLevels(Drawable self, NumericalPoint levels)"""
        return _graph.Drawable_setLevels(self, *args)

    def getDrawLabels(self):
        """getDrawLabels(Drawable self) -> OT::Bool"""
        return _graph.Drawable_getDrawLabels(self)

    def setDrawLabels(self, *args):
        """setDrawLabels(Drawable self, OT::Bool const & drawLabels)"""
        return _graph.Drawable_setDrawLabels(self, *args)

    def getData(self):
        """getData(Drawable self) -> NumericalSample"""
        return _graph.Drawable_getData(self)

    def draw(self):
        """draw(Drawable self) -> OT::String"""
        return _graph.Drawable_draw(self)

    def getPointCode(self, *args):
        """getPointCode(Drawable self, OT::String const key) -> OT::UnsignedLong"""
        return _graph.Drawable_getPointCode(self, *args)

    def clean(self):
        """clean(Drawable self)"""
        return _graph.Drawable_clean(self)

    def GetValidColors():
        """GetValidColors() -> Description"""
        return _graph.Drawable_GetValidColors()

    if _newclass:GetValidColors = staticmethod(GetValidColors)
    __swig_getmethods__["GetValidColors"] = lambda x: GetValidColors
    def GetValidLineStyles():
        """GetValidLineStyles() -> Description"""
        return _graph.Drawable_GetValidLineStyles()

    if _newclass:GetValidLineStyles = staticmethod(GetValidLineStyles)
    __swig_getmethods__["GetValidLineStyles"] = lambda x: GetValidLineStyles
    def GetValidFillStyles():
        """GetValidFillStyles() -> Description"""
        return _graph.Drawable_GetValidFillStyles()

    if _newclass:GetValidFillStyles = staticmethod(GetValidFillStyles)
    __swig_getmethods__["GetValidFillStyles"] = lambda x: GetValidFillStyles
    def GetValidPointStyles():
        """GetValidPointStyles() -> Description"""
        return _graph.Drawable_GetValidPointStyles()

    if _newclass:GetValidPointStyles = staticmethod(GetValidPointStyles)
    __swig_getmethods__["GetValidPointStyles"] = lambda x: GetValidPointStyles
    def ConvertFromName(*args):
        """ConvertFromName(OT::String const & name) -> OT::String"""
        return _graph.Drawable_ConvertFromName(*args)

    if _newclass:ConvertFromName = staticmethod(ConvertFromName)
    __swig_getmethods__["ConvertFromName"] = lambda x: ConvertFromName
    def ConvertFromRGB(*args):
        """
        ConvertFromRGB(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue) -> OT::String
        ConvertFromRGB(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue) -> OT::String
        """
        return _graph.Drawable_ConvertFromRGB(*args)

    if _newclass:ConvertFromRGB = staticmethod(ConvertFromRGB)
    __swig_getmethods__["ConvertFromRGB"] = lambda x: ConvertFromRGB
    def ConvertFromRGBA(*args):
        """
        ConvertFromRGBA(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue, 
            OT::UnsignedLong const alpha) -> OT::String
        ConvertFromRGBA(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue, 
            OT::NumericalScalar const alpha) -> OT::String
        """
        return _graph.Drawable_ConvertFromRGBA(*args)

    if _newclass:ConvertFromRGBA = staticmethod(ConvertFromRGBA)
    __swig_getmethods__["ConvertFromRGBA"] = lambda x: ConvertFromRGBA
    def ConvertFromHSVIntoRGB(*args):
        """ConvertFromHSVIntoRGB(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> NumericalPoint"""
        return _graph.Drawable_ConvertFromHSVIntoRGB(*args)

    if _newclass:ConvertFromHSVIntoRGB = staticmethod(ConvertFromHSVIntoRGB)
    __swig_getmethods__["ConvertFromHSVIntoRGB"] = lambda x: ConvertFromHSVIntoRGB
    def ConvertFromHSV(*args):
        """ConvertFromHSV(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> OT::String"""
        return _graph.Drawable_ConvertFromHSV(*args)

    if _newclass:ConvertFromHSV = staticmethod(ConvertFromHSV)
    __swig_getmethods__["ConvertFromHSV"] = lambda x: ConvertFromHSV
    def ConvertFromHSVA(*args):
        """
        ConvertFromHSVA(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value, 
            OT::NumericalScalar const alpha) -> OT::String
        """
        return _graph.Drawable_ConvertFromHSVA(*args)

    if _newclass:ConvertFromHSVA = staticmethod(ConvertFromHSVA)
    __swig_getmethods__["ConvertFromHSVA"] = lambda x: ConvertFromHSVA
    def BuildDefaultPalette(*args):
        """BuildDefaultPalette(OT::UnsignedLong const size) -> Description"""
        return _graph.Drawable_BuildDefaultPalette(*args)

    if _newclass:BuildDefaultPalette = staticmethod(BuildDefaultPalette)
    __swig_getmethods__["BuildDefaultPalette"] = lambda x: BuildDefaultPalette
    def __init__(self, *args): 
        """
        __init__(OT::Drawable self) -> Drawable
        __init__(OT::Drawable self, DrawableImplementation implementation) -> Drawable
        __init__(OT::Drawable self, Drawable other) -> Drawable
        __init__(OT::Drawable self, PyObject * pyObj) -> Drawable
        """
        this = _graph.new_Drawable(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Drawable
    __del__ = lambda self : None;
Drawable_swigregister = _graph.Drawable_swigregister
Drawable_swigregister(Drawable)

def Drawable_GetClassName():
  """Drawable_GetClassName() -> OT::String"""
  return _graph.Drawable_GetClassName()

def Drawable_GetValidColors():
  """Drawable_GetValidColors() -> Description"""
  return _graph.Drawable_GetValidColors()

def Drawable_GetValidLineStyles():
  """Drawable_GetValidLineStyles() -> Description"""
  return _graph.Drawable_GetValidLineStyles()

def Drawable_GetValidFillStyles():
  """Drawable_GetValidFillStyles() -> Description"""
  return _graph.Drawable_GetValidFillStyles()

def Drawable_GetValidPointStyles():
  """Drawable_GetValidPointStyles() -> Description"""
  return _graph.Drawable_GetValidPointStyles()

def Drawable_ConvertFromName(*args):
  """Drawable_ConvertFromName(OT::String const & name) -> OT::String"""
  return _graph.Drawable_ConvertFromName(*args)

def Drawable_ConvertFromRGB(*args):
  """
    ConvertFromRGB(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue) -> OT::String
    Drawable_ConvertFromRGB(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue) -> OT::String
    """
  return _graph.Drawable_ConvertFromRGB(*args)

def Drawable_ConvertFromRGBA(*args):
  """
    ConvertFromRGBA(OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue, 
        OT::UnsignedLong const alpha) -> OT::String
    Drawable_ConvertFromRGBA(OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue, 
        OT::NumericalScalar const alpha) -> OT::String
    """
  return _graph.Drawable_ConvertFromRGBA(*args)

def Drawable_ConvertFromHSVIntoRGB(*args):
  """Drawable_ConvertFromHSVIntoRGB(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> NumericalPoint"""
  return _graph.Drawable_ConvertFromHSVIntoRGB(*args)

def Drawable_ConvertFromHSV(*args):
  """Drawable_ConvertFromHSV(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> OT::String"""
  return _graph.Drawable_ConvertFromHSV(*args)

def Drawable_ConvertFromHSVA(*args):
  """
    Drawable_ConvertFromHSVA(OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value, 
        OT::NumericalScalar const alpha) -> OT::String
    """
  return _graph.Drawable_ConvertFromHSVA(*args)

def Drawable_BuildDefaultPalette(*args):
  """Drawable_BuildDefaultPalette(OT::UnsignedLong const size) -> Description"""
  return _graph.Drawable_BuildDefaultPalette(*args)

class GraphImplementation(openturns.common.PersistentObject):
    """Proxy of C++ OT::GraphImplementation class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphImplementation, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.PersistentObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GraphImplementation, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.GraphImplementation_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getClassName(self)

    __swig_setmethods__["ValidLegendPositions"] = _graph.GraphImplementation_ValidLegendPositions_set
    __swig_getmethods__["ValidLegendPositions"] = _graph.GraphImplementation_ValidLegendPositions_get
    if _newclass:ValidLegendPositions = _swig_property(_graph.GraphImplementation_ValidLegendPositions_get, _graph.GraphImplementation_ValidLegendPositions_set)
    __swig_setmethods__["IsFirstInitialization"] = _graph.GraphImplementation_IsFirstInitialization_set
    __swig_getmethods__["IsFirstInitialization"] = _graph.GraphImplementation_IsFirstInitialization_get
    if _newclass:IsFirstInitialization = _swig_property(_graph.GraphImplementation_IsFirstInitialization_get, _graph.GraphImplementation_IsFirstInitialization_set)
    ALL = _graph.GraphImplementation_ALL
    PNG = _graph.GraphImplementation_PNG
    EPS = _graph.GraphImplementation_EPS
    FIG = _graph.GraphImplementation_FIG
    PDF = _graph.GraphImplementation_PDF
    NONE = _graph.GraphImplementation_NONE
    LOGX = _graph.GraphImplementation_LOGX
    LOGY = _graph.GraphImplementation_LOGY
    LOGXY = _graph.GraphImplementation_LOGXY
    def __repr__(self):
        """__repr__(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation___repr__(self)

    def add(self, *args):
        """
        add(GraphImplementation self, Drawable aDrawable)
        add(GraphImplementation self, DrawableCollection drawableCollection)
        add(GraphImplementation self, GraphImplementation graphImplementation)
        """
        return _graph.GraphImplementation_add(self, *args)

    def erase(self, *args):
        """erase(GraphImplementation self, OT::UnsignedLong const i)"""
        return _graph.GraphImplementation_erase(self, *args)

    def getDrawables(self):
        """getDrawables(GraphImplementation self) -> DrawableCollection"""
        return _graph.GraphImplementation_getDrawables(self)

    def setDrawables(self, *args):
        """setDrawables(GraphImplementation self, DrawableCollection drawableCollection)"""
        return _graph.GraphImplementation_setDrawables(self, *args)

    def getDrawable(self, *args):
        """getDrawable(GraphImplementation self, OT::UnsignedLong const index) -> Drawable"""
        return _graph.GraphImplementation_getDrawable(self, *args)

    def setDrawable(self, *args):
        """setDrawable(GraphImplementation self, Drawable drawable, OT::UnsignedLong const index)"""
        return _graph.GraphImplementation_setDrawable(self, *args)

    def getColors(self):
        """getColors(GraphImplementation self) -> Description"""
        return _graph.GraphImplementation_getColors(self)

    def setColors(self, *args):
        """setColors(GraphImplementation self, Description colors)"""
        return _graph.GraphImplementation_setColors(self, *args)

    def getLegends(self):
        """getLegends(GraphImplementation self) -> Description"""
        return _graph.GraphImplementation_getLegends(self)

    def setLegends(self, *args):
        """setLegends(GraphImplementation self, Description legends)"""
        return _graph.GraphImplementation_setLegends(self, *args)

    def setAxes(self, *args):
        """setAxes(GraphImplementation self, OT::Bool const showAxes)"""
        return _graph.GraphImplementation_setAxes(self, *args)

    def getAxes(self):
        """getAxes(GraphImplementation self) -> OT::Bool"""
        return _graph.GraphImplementation_getAxes(self)

    def setLogScale(self, *args):
        """setLogScale(GraphImplementation self, OT::GraphImplementation::LogScale const logScale)"""
        return _graph.GraphImplementation_setLogScale(self, *args)

    def getLogScale(self):
        """getLogScale(GraphImplementation self) -> OT::GraphImplementation::LogScale"""
        return _graph.GraphImplementation_getLogScale(self)

    def setGrid(self, *args):
        """setGrid(GraphImplementation self, OT::Bool const showGrid)"""
        return _graph.GraphImplementation_setGrid(self, *args)

    def getGrid(self):
        """getGrid(GraphImplementation self) -> OT::Bool"""
        return _graph.GraphImplementation_getGrid(self)

    def setGridColor(self, *args):
        """setGridColor(GraphImplementation self, OT::String const & color)"""
        return _graph.GraphImplementation_setGridColor(self, *args)

    def getGridColor(self):
        """getGridColor(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getGridColor(self)

    def getXTitle(self):
        """getXTitle(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getXTitle(self)

    def setXTitle(self, *args):
        """setXTitle(GraphImplementation self, OT::String const & title)"""
        return _graph.GraphImplementation_setXTitle(self, *args)

    def getYTitle(self):
        """getYTitle(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getYTitle(self)

    def setYTitle(self, *args):
        """setYTitle(GraphImplementation self, OT::String const & title)"""
        return _graph.GraphImplementation_setYTitle(self, *args)

    def getTitle(self):
        """getTitle(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getTitle(self)

    def setTitle(self, *args):
        """setTitle(GraphImplementation self, OT::String const & title)"""
        return _graph.GraphImplementation_setTitle(self, *args)

    def getPath(self):
        """getPath(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getPath(self)

    def getFileName(self):
        """getFileName(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getFileName(self)

    def draw(self, *args):
        """
        draw(GraphImplementation self, OT::String const & path, OT::String const & file, OT::NumericalScalar const width, 
            OT::NumericalScalar const height, OT::GraphImplementation::Format const format=ALL)
        draw(GraphImplementation self, OT::String const & path, OT::String const & file, OT::NumericalScalar const width, 
            OT::NumericalScalar const height)
        draw(GraphImplementation self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"), 
            OT::NumericalScalar const height=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultHeight"), 
            OT::GraphImplementation::Format const format=ALL)
        draw(GraphImplementation self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"), 
            OT::NumericalScalar const height=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultHeight"))
        draw(GraphImplementation self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"))
        draw(GraphImplementation self, OT::String const & file)
        """
        return _graph.GraphImplementation_draw(self, *args)

    def getRCommand(self):
        """getRCommand(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getRCommand(self)

    def clean(self):
        """clean(GraphImplementation self)"""
        return _graph.GraphImplementation_clean(self)

    def getBitmap(self):
        """getBitmap(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getBitmap(self)

    def getPostscript(self):
        """getPostscript(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getPostscript(self)

    def getPDF(self):
        """getPDF(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getPDF(self)

    def getVectorial(self):
        """getVectorial(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getVectorial(self)

    def getBoundingBox(self):
        """getBoundingBox(GraphImplementation self) -> NumericalPoint"""
        return _graph.GraphImplementation_getBoundingBox(self)

    def setBoundingBox(self, *args):
        """
        setBoundingBox(GraphImplementation self, NumericalPoint boundingBox)
        setBoundingBox(GraphImplementation self, Interval boundingBox)
        """
        return _graph.GraphImplementation_setBoundingBox(self, *args)

    def getAutomaticBoundingBox(self):
        """getAutomaticBoundingBox(GraphImplementation self) -> OT::Bool"""
        return _graph.GraphImplementation_getAutomaticBoundingBox(self)

    def setAutomaticBoundingBox(self, *args):
        """setAutomaticBoundingBox(GraphImplementation self, OT::Bool const automaticBoundingBox)"""
        return _graph.GraphImplementation_setAutomaticBoundingBox(self, *args)

    def getLegendPosition(self):
        """getLegendPosition(GraphImplementation self) -> OT::String"""
        return _graph.GraphImplementation_getLegendPosition(self)

    def setLegendPosition(self, *args):
        """setLegendPosition(GraphImplementation self, OT::String const & position)"""
        return _graph.GraphImplementation_setLegendPosition(self, *args)

    def getLegendFontSize(self):
        """getLegendFontSize(GraphImplementation self) -> OT::NumericalScalar"""
        return _graph.GraphImplementation_getLegendFontSize(self)

    def setLegendFontSize(self, *args):
        """setLegendFontSize(GraphImplementation self, OT::NumericalScalar const legendFontSize)"""
        return _graph.GraphImplementation_setLegendFontSize(self, *args)

    def isValidLegendPosition(self, *args):
        """isValidLegendPosition(GraphImplementation self, OT::String const & position) -> OT::Bool"""
        return _graph.GraphImplementation_isValidLegendPosition(self, *args)

    def initializeValidLegendPositions():
        """initializeValidLegendPositions()"""
        return _graph.GraphImplementation_initializeValidLegendPositions()

    if _newclass:initializeValidLegendPositions = staticmethod(initializeValidLegendPositions)
    __swig_getmethods__["initializeValidLegendPositions"] = lambda x: initializeValidLegendPositions
    def GetValidLegendPositions():
        """GetValidLegendPositions() -> Description"""
        return _graph.GraphImplementation_GetValidLegendPositions()

    if _newclass:GetValidLegendPositions = staticmethod(GetValidLegendPositions)
    __swig_getmethods__["GetValidLegendPositions"] = lambda x: GetValidLegendPositions
    def __init__(self, *args): 
        """
        __init__(OT::GraphImplementation self, OT::String const & title="") -> GraphImplementation
        __init__(OT::GraphImplementation self) -> GraphImplementation
        __init__(OT::GraphImplementation self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes, 
            OT::String const & legendPosition="", OT::NumericalScalar const legendFontSize=OT::ResourceMap::GetAsNumericalScalar("GraphImplementation-DefaultLegendFontSize"), 
            OT::GraphImplementation::LogScale const logScale=NONE) -> GraphImplementation
        __init__(OT::GraphImplementation self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes, 
            OT::String const & legendPosition="", OT::NumericalScalar const legendFontSize=OT::ResourceMap::GetAsNumericalScalar("GraphImplementation-DefaultLegendFontSize")) -> GraphImplementation
        __init__(OT::GraphImplementation self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes, 
            OT::String const & legendPosition="") -> GraphImplementation
        __init__(OT::GraphImplementation self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes) -> GraphImplementation
        __init__(OT::GraphImplementation self, GraphImplementation other) -> GraphImplementation
        """
        this = _graph.new_GraphImplementation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_GraphImplementation
    __del__ = lambda self : None;
GraphImplementation_swigregister = _graph.GraphImplementation_swigregister
GraphImplementation_swigregister(GraphImplementation)

def GraphImplementation_GetClassName():
  """GraphImplementation_GetClassName() -> OT::String"""
  return _graph.GraphImplementation_GetClassName()
cvar = _graph.cvar

def GraphImplementation_initializeValidLegendPositions():
  """GraphImplementation_initializeValidLegendPositions()"""
  return _graph.GraphImplementation_initializeValidLegendPositions()

def GraphImplementation_GetValidLegendPositions():
  """GraphImplementation_GetValidLegendPositions() -> Description"""
  return _graph.GraphImplementation_GetValidLegendPositions()

class GraphImplementationTypedInterfaceObject(openturns.common.InterfaceObject):
    """Proxy of C++ OT::TypedInterfaceObject<(OT::GraphImplementation)> class"""
    __swig_setmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphImplementationTypedInterfaceObject, name, value)
    __swig_getmethods__ = {}
    for _s in [openturns.common.InterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GraphImplementationTypedInterfaceObject, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(OT::TypedInterfaceObject<(OT::GraphImplementation)> self) -> GraphImplementationTypedInterfaceObject
        __init__(OT::TypedInterfaceObject<(OT::GraphImplementation)> self, GraphImplementationPointer impl) -> GraphImplementationTypedInterfaceObject
        """
        this = _graph.new_GraphImplementationTypedInterfaceObject(*args)
        try: self.this.append(this)
        except: self.this = this
    def getImplementation(self, *args):
        """
        getImplementation(GraphImplementationTypedInterfaceObject self) -> GraphImplementationPointer
        getImplementation(GraphImplementationTypedInterfaceObject self) -> GraphImplementationPointer
        """
        return _graph.GraphImplementationTypedInterfaceObject_getImplementation(self, *args)

    def getImplementationAsPersistentObject(self):
        """getImplementationAsPersistentObject(GraphImplementationTypedInterfaceObject self) -> PersistentObjectPointer"""
        return _graph.GraphImplementationTypedInterfaceObject_getImplementationAsPersistentObject(self)

    def setImplementationAsPersistentObject(self, *args):
        """setImplementationAsPersistentObject(GraphImplementationTypedInterfaceObject self, PersistentObjectPointer obj)"""
        return _graph.GraphImplementationTypedInterfaceObject_setImplementationAsPersistentObject(self, *args)

    def swap(self, *args):
        """swap(GraphImplementationTypedInterfaceObject self, GraphImplementationTypedInterfaceObject other)"""
        return _graph.GraphImplementationTypedInterfaceObject_swap(self, *args)

    def setName(self, *args):
        """setName(GraphImplementationTypedInterfaceObject self, OT::String const & name)"""
        return _graph.GraphImplementationTypedInterfaceObject_setName(self, *args)

    def getName(self):
        """getName(GraphImplementationTypedInterfaceObject self) -> OT::String"""
        return _graph.GraphImplementationTypedInterfaceObject_getName(self)

    def __eq__(self, *args):
        """__eq__(GraphImplementationTypedInterfaceObject self, GraphImplementationTypedInterfaceObject other) -> OT::Bool"""
        return _graph.GraphImplementationTypedInterfaceObject___eq__(self, *args)

    __swig_destroy__ = _graph.delete_GraphImplementationTypedInterfaceObject
    __del__ = lambda self : None;
GraphImplementationTypedInterfaceObject_swigregister = _graph.GraphImplementationTypedInterfaceObject_swigregister
GraphImplementationTypedInterfaceObject_swigregister(GraphImplementationTypedInterfaceObject)

class GraphCollection(_object):
    """Proxy of C++ OT::Collection<(OT::Graph)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GraphCollection, name)
    __swig_destroy__ = _graph.delete_GraphCollection
    __del__ = lambda self : None;
    def clear(self):
        """clear(GraphCollection self)"""
        return _graph.GraphCollection_clear(self)

    def __len__(self):
        """__len__(GraphCollection self) -> OT::UnsignedLong"""
        return _graph.GraphCollection___len__(self)

    def __eq__(self, *args):
        """__eq__(GraphCollection self, GraphCollection rhs) -> OT::Bool"""
        return _graph.GraphCollection___eq__(self, *args)

    def __contains__(self, *args):
        """__contains__(GraphCollection self, Graph val) -> OT::Bool"""
        return _graph.GraphCollection___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(GraphCollection self, OT::UnsignedLong const i) -> Graph"""
        return _graph.GraphCollection___getitem__(self, *args)

    def __setitem__(self, *args):
        """__setitem__(GraphCollection self, OT::UnsignedLong const i, Graph val)"""
        return _graph.GraphCollection___setitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(GraphCollection self, OT::UnsignedLong const i)"""
        return _graph.GraphCollection___delitem__(self, *args)

    def at(self, *args):
        """
        at(GraphCollection self, OT::UnsignedLong const i) -> Graph
        at(GraphCollection self, OT::UnsignedLong const i) -> Graph
        """
        return _graph.GraphCollection_at(self, *args)

    def add(self, *args):
        """
        add(GraphCollection self, Graph elt)
        add(GraphCollection self, GraphCollection coll)
        """
        return _graph.GraphCollection_add(self, *args)

    def getSize(self):
        """getSize(GraphCollection self) -> OT::UnsignedLong"""
        return _graph.GraphCollection_getSize(self)

    def resize(self, *args):
        """resize(GraphCollection self, OT::UnsignedLong const newSize)"""
        return _graph.GraphCollection_resize(self, *args)

    def isEmpty(self):
        """isEmpty(GraphCollection self) -> OT::Bool"""
        return _graph.GraphCollection_isEmpty(self)

    def __repr__(self):
        """__repr__(GraphCollection self) -> OT::String"""
        return _graph.GraphCollection___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(GraphCollection self, OT::String const & offset="") -> OT::String
        __str__(GraphCollection self) -> OT::String
        """
        return _graph.GraphCollection___str__(self, offset)

    def __init__(self, *args): 
        """
        __init__(OT::Collection<(OT::Graph)> self) -> GraphCollection
        __init__(OT::Collection<(OT::Graph)> self, OT::UnsignedLong const size) -> GraphCollection
        __init__(OT::Collection<(OT::Graph)> self, OT::UnsignedLong const size, Graph value) -> GraphCollection
        __init__(OT::Collection<(OT::Graph)> self, PyObject * pyObj) -> GraphCollection
        __init__(OT::Collection<(OT::Graph)> self, GraphCollection other) -> GraphCollection
        """
        this = _graph.new_GraphCollection(*args)
        try: self.this.append(this)
        except: self.this = this
GraphCollection_swigregister = _graph.GraphCollection_swigregister
GraphCollection_swigregister(GraphCollection)

class Graph(GraphImplementationTypedInterfaceObject):
    """Proxy of C++ OT::Graph class"""
    __swig_setmethods__ = {}
    for _s in [GraphImplementationTypedInterfaceObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Graph, name, value)
    __swig_getmethods__ = {}
    for _s in [GraphImplementationTypedInterfaceObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Graph, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Graph_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Graph self) -> OT::String"""
        return _graph.Graph_getClassName(self)

    def __repr__(self):
        """__repr__(Graph self) -> OT::String"""
        return _graph.Graph___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(Graph self, OT::String const & offset="") -> OT::String
        __str__(Graph self) -> OT::String
        """
        return _graph.Graph___str__(self, offset)

    def add(self, *args):
        """
        add(Graph self, Drawable aDrawable)
        add(Graph self, DrawableCollection drawableCollection)
        add(Graph self, Graph graph)
        """
        return _graph.Graph_add(self, *args)

    def erase(self, *args):
        """erase(Graph self, OT::UnsignedLong const i)"""
        return _graph.Graph_erase(self, *args)

    def getDrawables(self):
        """getDrawables(Graph self) -> DrawableCollection"""
        return _graph.Graph_getDrawables(self)

    def setDrawables(self, *args):
        """setDrawables(Graph self, DrawableCollection drawableCollection)"""
        return _graph.Graph_setDrawables(self, *args)

    def getDrawable(self, *args):
        """getDrawable(Graph self, OT::UnsignedLong const index) -> Drawable"""
        return _graph.Graph_getDrawable(self, *args)

    def setDrawable(self, *args):
        """setDrawable(Graph self, Drawable drawable, OT::UnsignedLong const index)"""
        return _graph.Graph_setDrawable(self, *args)

    def getColors(self):
        """getColors(Graph self) -> Description"""
        return _graph.Graph_getColors(self)

    def setColors(self, *args):
        """setColors(Graph self, Description colors)"""
        return _graph.Graph_setColors(self, *args)

    def getLegends(self):
        """getLegends(Graph self) -> Description"""
        return _graph.Graph_getLegends(self)

    def setLegends(self, *args):
        """setLegends(Graph self, Description legends)"""
        return _graph.Graph_setLegends(self, *args)

    def setAxes(self, *args):
        """setAxes(Graph self, OT::Bool const showAxes)"""
        return _graph.Graph_setAxes(self, *args)

    def getAxes(self):
        """getAxes(Graph self) -> OT::Bool"""
        return _graph.Graph_getAxes(self)

    def setLogScale(self, *args):
        """setLogScale(Graph self, OT::Graph::LogScale const logScale)"""
        return _graph.Graph_setLogScale(self, *args)

    def getLogScale(self):
        """getLogScale(Graph self) -> OT::Graph::LogScale"""
        return _graph.Graph_getLogScale(self)

    def setGrid(self, *args):
        """setGrid(Graph self, OT::Bool const showGrid)"""
        return _graph.Graph_setGrid(self, *args)

    def getGrid(self):
        """getGrid(Graph self) -> OT::Bool"""
        return _graph.Graph_getGrid(self)

    def setGridColor(self, *args):
        """setGridColor(Graph self, OT::String const & color)"""
        return _graph.Graph_setGridColor(self, *args)

    def getGridColor(self):
        """getGridColor(Graph self) -> OT::String"""
        return _graph.Graph_getGridColor(self)

    def getXTitle(self):
        """getXTitle(Graph self) -> OT::String"""
        return _graph.Graph_getXTitle(self)

    def setXTitle(self, *args):
        """setXTitle(Graph self, OT::String const & title)"""
        return _graph.Graph_setXTitle(self, *args)

    def getYTitle(self):
        """getYTitle(Graph self) -> OT::String"""
        return _graph.Graph_getYTitle(self)

    def setYTitle(self, *args):
        """setYTitle(Graph self, OT::String const & title)"""
        return _graph.Graph_setYTitle(self, *args)

    def getTitle(self):
        """getTitle(Graph self) -> OT::String"""
        return _graph.Graph_getTitle(self)

    def setTitle(self, *args):
        """setTitle(Graph self, OT::String const & title)"""
        return _graph.Graph_setTitle(self, *args)

    def getPath(self):
        """getPath(Graph self) -> OT::String"""
        return _graph.Graph_getPath(self)

    def getFileName(self):
        """getFileName(Graph self) -> OT::String"""
        return _graph.Graph_getFileName(self)

    def draw(self, *args):
        """
        draw(Graph self, OT::String const & path, OT::String const & file, OT::NumericalScalar const width, 
            OT::NumericalScalar const height, OT::Graph::Format const format=ALL)
        draw(Graph self, OT::String const & path, OT::String const & file, OT::NumericalScalar const width, 
            OT::NumericalScalar const height)
        draw(Graph self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"), 
            OT::NumericalScalar const height=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultHeight"), 
            OT::Graph::Format const format=ALL)
        draw(Graph self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"), 
            OT::NumericalScalar const height=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultHeight"))
        draw(Graph self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"))
        draw(Graph self, OT::String const & file)
        """
        return _graph.Graph_draw(self, *args)

    def getRCommand(self):
        """getRCommand(Graph self) -> OT::String"""
        return _graph.Graph_getRCommand(self)

    def clean(self):
        """clean(Graph self)"""
        return _graph.Graph_clean(self)

    def getBitmap(self):
        """getBitmap(Graph self) -> OT::String"""
        return _graph.Graph_getBitmap(self)

    def getPostscript(self):
        """getPostscript(Graph self) -> OT::String"""
        return _graph.Graph_getPostscript(self)

    def getVectorial(self):
        """getVectorial(Graph self) -> OT::String"""
        return _graph.Graph_getVectorial(self)

    def getBoundingBox(self):
        """getBoundingBox(Graph self) -> NumericalPoint"""
        return _graph.Graph_getBoundingBox(self)

    def setBoundingBox(self, *args):
        """
        setBoundingBox(Graph self, NumericalPoint boundingBox)
        setBoundingBox(Graph self, Interval boundingBox)
        """
        return _graph.Graph_setBoundingBox(self, *args)

    def getAutomaticBoundingBox(self):
        """getAutomaticBoundingBox(Graph self) -> OT::Bool"""
        return _graph.Graph_getAutomaticBoundingBox(self)

    def setAutomaticBoundingBox(self, *args):
        """setAutomaticBoundingBox(Graph self, OT::Bool const automaticBoundingBox)"""
        return _graph.Graph_setAutomaticBoundingBox(self, *args)

    def getLegendPosition(self):
        """getLegendPosition(Graph self) -> OT::String"""
        return _graph.Graph_getLegendPosition(self)

    def setLegendPosition(self, *args):
        """setLegendPosition(Graph self, OT::String const & position)"""
        return _graph.Graph_setLegendPosition(self, *args)

    def getLegendFontSize(self):
        """getLegendFontSize(Graph self) -> OT::NumericalScalar"""
        return _graph.Graph_getLegendFontSize(self)

    def setLegendFontSize(self, *args):
        """setLegendFontSize(Graph self, OT::NumericalScalar const legendFontSize)"""
        return _graph.Graph_setLegendFontSize(self, *args)

    def isValidLegendPosition(self, *args):
        """isValidLegendPosition(Graph self, OT::String const & position) -> OT::Bool"""
        return _graph.Graph_isValidLegendPosition(self, *args)

    def initializeValidLegendPositions(self):
        """initializeValidLegendPositions(Graph self)"""
        return _graph.Graph_initializeValidLegendPositions(self)

    def getValidLegendPositions(self):
        """getValidLegendPositions(Graph self) -> Description"""
        return _graph.Graph_getValidLegendPositions(self)

    def GetValidLegendPositions():
        """GetValidLegendPositions() -> Description"""
        return _graph.Graph_GetValidLegendPositions()

    if _newclass:GetValidLegendPositions = staticmethod(GetValidLegendPositions)
    __swig_getmethods__["GetValidLegendPositions"] = lambda x: GetValidLegendPositions
    def __init__(self, *args): 
        """
        __init__(OT::Graph self, OT::String const & title="") -> Graph
        __init__(OT::Graph self) -> Graph
        __init__(OT::Graph self, GraphImplementation implementation) -> Graph
        __init__(OT::Graph self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes, 
            OT::String const & legendPosition="", OT::NumericalScalar const legendFontSize=OT::ResourceMap::GetAsNumericalScalar("GraphImplementation-DefaultLegendFontSize"), 
            OT::Graph::LogScale const logScale=NONE) -> Graph
        __init__(OT::Graph self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes, 
            OT::String const & legendPosition="", OT::NumericalScalar const legendFontSize=OT::ResourceMap::GetAsNumericalScalar("GraphImplementation-DefaultLegendFontSize")) -> Graph
        __init__(OT::Graph self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes, 
            OT::String const & legendPosition="") -> Graph
        __init__(OT::Graph self, OT::String const & title, OT::String const & xTitle, OT::String const & yTitle, OT::Bool const showAxes) -> Graph
        __init__(OT::Graph self, Graph other) -> Graph
        __init__(OT::Graph self, PyObject * pyObj) -> Graph
        """
        this = _graph.new_Graph(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Graph
    __del__ = lambda self : None;
Graph_swigregister = _graph.Graph_swigregister
Graph_swigregister(Graph)

def Graph_GetClassName():
  """Graph_GetClassName() -> OT::String"""
  return _graph.Graph_GetClassName()

def Graph_GetValidLegendPositions():
  """Graph_GetValidLegendPositions() -> Description"""
  return _graph.Graph_GetValidLegendPositions()

class BarPlot(DrawableImplementation):
    """Proxy of C++ OT::BarPlot class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BarPlot, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BarPlot, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.BarPlot_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(BarPlot self) -> OT::String"""
        return _graph.BarPlot_getClassName(self)

    def __repr__(self):
        """__repr__(BarPlot self) -> OT::String"""
        return _graph.BarPlot___repr__(self)

    def getOrigin(self):
        """getOrigin(BarPlot self) -> OT::NumericalScalar"""
        return _graph.BarPlot_getOrigin(self)

    def setOrigin(self, *args):
        """setOrigin(BarPlot self, OT::NumericalScalar const origin)"""
        return _graph.BarPlot_setOrigin(self, *args)

    def getBoundingBox(self):
        """getBoundingBox(BarPlot self) -> NumericalPoint"""
        return _graph.BarPlot_getBoundingBox(self)

    def draw(self):
        """draw(BarPlot self) -> OT::String"""
        return _graph.BarPlot_draw(self)

    def __init__(self, *args): 
        """
        __init__(OT::BarPlot self, NumericalSample data, OT::NumericalScalar const origin, OT::String const & legend="") -> BarPlot
        __init__(OT::BarPlot self, NumericalSample data, OT::NumericalScalar const origin) -> BarPlot
        __init__(OT::BarPlot self, NumericalSample data, OT::NumericalScalar const origin, OT::String const & color, 
            OT::String const & fillStyle, OT::String const & lineStyle, OT::UnsignedLong const lineWidth, 
            OT::String const & legend="") -> BarPlot
        __init__(OT::BarPlot self, NumericalSample data, OT::NumericalScalar const origin, OT::String const & color, 
            OT::String const & fillStyle, OT::String const & lineStyle, OT::UnsignedLong const lineWidth) -> BarPlot
        __init__(OT::BarPlot self, NumericalSample data, OT::NumericalScalar const origin, OT::String const & color, 
            OT::String const & fillStyle, OT::String const & lineStyle, OT::String const & legend="") -> BarPlot
        __init__(OT::BarPlot self, NumericalSample data, OT::NumericalScalar const origin, OT::String const & color, 
            OT::String const & fillStyle, OT::String const & lineStyle) -> BarPlot
        __init__(OT::BarPlot self, BarPlot other) -> BarPlot
        """
        this = _graph.new_BarPlot(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_BarPlot
    __del__ = lambda self : None;
BarPlot_swigregister = _graph.BarPlot_swigregister
BarPlot_swigregister(BarPlot)

def BarPlot_GetClassName():
  """BarPlot_GetClassName() -> OT::String"""
  return _graph.BarPlot_GetClassName()

class Cloud(DrawableImplementation):
    """Proxy of C++ OT::Cloud class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cloud, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cloud, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Cloud_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Cloud self) -> OT::String"""
        return _graph.Cloud_getClassName(self)

    def __repr__(self):
        """__repr__(Cloud self) -> OT::String"""
        return _graph.Cloud___repr__(self)

    def draw(self):
        """draw(Cloud self) -> OT::String"""
        return _graph.Cloud_draw(self)

    def __init__(self, *args): 
        """
        __init__(OT::Cloud self, NumericalSample data, OT::String const & legend="") -> Cloud
        __init__(OT::Cloud self, NumericalSample data) -> Cloud
        __init__(OT::Cloud self, NumericalComplexCollection data, OT::String const & legend="") -> Cloud
        __init__(OT::Cloud self, NumericalComplexCollection data) -> Cloud
        __init__(OT::Cloud self, NumericalSample dataX, NumericalSample dataY, OT::String const & legend="") -> Cloud
        __init__(OT::Cloud self, NumericalSample dataX, NumericalSample dataY) -> Cloud
        __init__(OT::Cloud self, NumericalSample data, OT::String const & color, OT::String const & pointStyle, OT::String const & legend="") -> Cloud
        __init__(OT::Cloud self, NumericalSample data, OT::String const & color, OT::String const & pointStyle) -> Cloud
        __init__(OT::Cloud self, Cloud other) -> Cloud
        """
        this = _graph.new_Cloud(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Cloud
    __del__ = lambda self : None;
Cloud_swigregister = _graph.Cloud_swigregister
Cloud_swigregister(Cloud)

def Cloud_GetClassName():
  """Cloud_GetClassName() -> OT::String"""
  return _graph.Cloud_GetClassName()

class Contour(DrawableImplementation):
    """Proxy of C++ OT::Contour class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Contour, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Contour, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Contour_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Contour self) -> OT::String"""
        return _graph.Contour_getClassName(self)

    def __repr__(self):
        """__repr__(Contour self) -> OT::String"""
        return _graph.Contour___repr__(self)

    def getX(self):
        """getX(Contour self) -> NumericalSample"""
        return _graph.Contour_getX(self)

    def setX(self, *args):
        """setX(Contour self, NumericalSample x)"""
        return _graph.Contour_setX(self, *args)

    def getY(self):
        """getY(Contour self) -> NumericalSample"""
        return _graph.Contour_getY(self)

    def setY(self, *args):
        """setY(Contour self, NumericalSample y)"""
        return _graph.Contour_setY(self, *args)

    def getLevels(self):
        """getLevels(Contour self) -> NumericalPoint"""
        return _graph.Contour_getLevels(self)

    def setLevels(self, *args):
        """setLevels(Contour self, NumericalPoint levels)"""
        return _graph.Contour_setLevels(self, *args)

    def getLabels(self):
        """getLabels(Contour self) -> Description"""
        return _graph.Contour_getLabels(self)

    def setLabels(self, *args):
        """setLabels(Contour self, Description labels)"""
        return _graph.Contour_setLabels(self, *args)

    def getDrawLabels(self):
        """getDrawLabels(Contour self) -> OT::Bool"""
        return _graph.Contour_getDrawLabels(self)

    def setDrawLabels(self, *args):
        """setDrawLabels(Contour self, OT::Bool const & drawLabels)"""
        return _graph.Contour_setDrawLabels(self, *args)

    def getBoundingBox(self):
        """getBoundingBox(Contour self) -> NumericalPoint"""
        return _graph.Contour_getBoundingBox(self)

    def draw(self):
        """draw(Contour self) -> OT::String"""
        return _graph.Contour_draw(self)

    def buildDefaultLevels(self, *args):
        """
        buildDefaultLevels(Contour self, OT::UnsignedLong const number=OT::ResourceMap::GetAsUnsignedLong( "Contour-DefaultLevelsNumber" ))
        buildDefaultLevels(Contour self)
        """
        return _graph.Contour_buildDefaultLevels(self, *args)

    def buildDefaultLabels(self):
        """buildDefaultLabels(Contour self)"""
        return _graph.Contour_buildDefaultLabels(self)

    def clean(self):
        """clean(Contour self)"""
        return _graph.Contour_clean(self)

    def __init__(self, *args): 
        """
        __init__(OT::Contour self, OT::UnsignedLong const dimX, OT::UnsignedLong const dimY, NumericalSample data, OT::String const & legend="") -> Contour
        __init__(OT::Contour self, OT::UnsignedLong const dimX, OT::UnsignedLong const dimY, NumericalSample data) -> Contour
        __init__(OT::Contour self, NumericalSample x, NumericalSample y, NumericalSample data, NumericalPoint levels, 
            Description labels, OT::Bool const drawLabels=True, OT::String const & legend="") -> Contour
        __init__(OT::Contour self, NumericalSample x, NumericalSample y, NumericalSample data, NumericalPoint levels, 
            Description labels, OT::Bool const drawLabels=True) -> Contour
        __init__(OT::Contour self, NumericalSample x, NumericalSample y, NumericalSample data, NumericalPoint levels, 
            Description labels) -> Contour
        __init__(OT::Contour self, Contour other) -> Contour
        """
        this = _graph.new_Contour(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Contour
    __del__ = lambda self : None;
Contour_swigregister = _graph.Contour_swigregister
Contour_swigregister(Contour)

def Contour_GetClassName():
  """Contour_GetClassName() -> OT::String"""
  return _graph.Contour_GetClassName()

class Curve(DrawableImplementation):
    """Proxy of C++ OT::Curve class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Curve, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Curve, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Curve_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Curve self) -> OT::String"""
        return _graph.Curve_getClassName(self)

    def __repr__(self):
        """__repr__(Curve self) -> OT::String"""
        return _graph.Curve___repr__(self)

    def draw(self):
        """draw(Curve self) -> OT::String"""
        return _graph.Curve_draw(self)

    def setShowPoints(self, *args):
        """setShowPoints(Curve self, OT::Bool const showPoints)"""
        return _graph.Curve_setShowPoints(self, *args)

    def getShowPoints(self):
        """getShowPoints(Curve self) -> OT::Bool"""
        return _graph.Curve_getShowPoints(self)

    def __init__(self, *args): 
        """
        __init__(OT::Curve self, OT::String const & legend="") -> Curve
        __init__(OT::Curve self) -> Curve
        __init__(OT::Curve self, NumericalSample data, OT::String const & legend="") -> Curve
        __init__(OT::Curve self, NumericalSample data) -> Curve
        __init__(OT::Curve self, NumericalSample dataX, NumericalSample dataY, OT::String const & legend="") -> Curve
        __init__(OT::Curve self, NumericalSample dataX, NumericalSample dataY) -> Curve
        __init__(OT::Curve self, NumericalSample data, OT::String const & color, OT::String const & lineStyle, OT::UnsignedLong const lineWidth=1, 
            OT::String const & legend="") -> Curve
        __init__(OT::Curve self, NumericalSample data, OT::String const & color, OT::String const & lineStyle, OT::UnsignedLong const lineWidth=1) -> Curve
        __init__(OT::Curve self, NumericalSample data, OT::String const & color, OT::String const & lineStyle) -> Curve
        __init__(OT::Curve self, Curve other) -> Curve
        """
        this = _graph.new_Curve(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Curve
    __del__ = lambda self : None;
Curve_swigregister = _graph.Curve_swigregister
Curve_swigregister(Curve)

def Curve_GetClassName():
  """Curve_GetClassName() -> OT::String"""
  return _graph.Curve_GetClassName()

class Pairs(DrawableImplementation):
    """Proxy of C++ OT::Pairs class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pairs, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pairs, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Pairs_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Pairs self) -> OT::String"""
        return _graph.Pairs_getClassName(self)

    def __repr__(self):
        """__repr__(Pairs self) -> OT::String"""
        return _graph.Pairs___repr__(self)

    def getData(self):
        """getData(Pairs self) -> NumericalSample"""
        return _graph.Pairs_getData(self)

    def getLabels(self):
        """getLabels(Pairs self) -> Description"""
        return _graph.Pairs_getLabels(self)

    def setLabels(self, *args):
        """setLabels(Pairs self, Description labels)"""
        return _graph.Pairs_setLabels(self, *args)

    def getTitle(self):
        """getTitle(Pairs self) -> OT::String"""
        return _graph.Pairs_getTitle(self)

    def setTitle(self, *args):
        """setTitle(Pairs self, OT::String const & title)"""
        return _graph.Pairs_setTitle(self, *args)

    def draw(self):
        """draw(Pairs self) -> OT::String"""
        return _graph.Pairs_draw(self)

    def buildDefaultLabels(self):
        """buildDefaultLabels(Pairs self)"""
        return _graph.Pairs_buildDefaultLabels(self)

    def clean(self):
        """clean(Pairs self)"""
        return _graph.Pairs_clean(self)

    def __init__(self, *args): 
        """
        __init__(OT::Pairs self, NumericalSample data, OT::String const & title="") -> Pairs
        __init__(OT::Pairs self, NumericalSample data) -> Pairs
        __init__(OT::Pairs self, NumericalSample data, OT::String const & title, Description labels, OT::String const color, 
            OT::String const PointStyle) -> Pairs
        __init__(OT::Pairs self, Pairs other) -> Pairs
        """
        this = _graph.new_Pairs(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Pairs
    __del__ = lambda self : None;
Pairs_swigregister = _graph.Pairs_swigregister
Pairs_swigregister(Pairs)

def Pairs_GetClassName():
  """Pairs_GetClassName() -> OT::String"""
  return _graph.Pairs_GetClassName()

class Pie(DrawableImplementation):
    """Proxy of C++ OT::Pie class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pie, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Pie, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Pie_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Pie self) -> OT::String"""
        return _graph.Pie_getClassName(self)

    def __repr__(self):
        """__repr__(Pie self) -> OT::String"""
        return _graph.Pie___repr__(self)

    def getCenter(self):
        """getCenter(Pie self) -> NumericalPoint"""
        return _graph.Pie_getCenter(self)

    def setCenter(self, *args):
        """setCenter(Pie self, NumericalPoint center)"""
        return _graph.Pie_setCenter(self, *args)

    def getRadius(self):
        """getRadius(Pie self) -> OT::NumericalScalar"""
        return _graph.Pie_getRadius(self)

    def setRadius(self, *args):
        """setRadius(Pie self, OT::NumericalScalar const radius)"""
        return _graph.Pie_setRadius(self, *args)

    def getLabels(self):
        """getLabels(Pie self) -> Description"""
        return _graph.Pie_getLabels(self)

    def setLabels(self, *args):
        """setLabels(Pie self, Description labels)"""
        return _graph.Pie_setLabels(self, *args)

    def getPalette(self):
        """getPalette(Pie self) -> Description"""
        return _graph.Pie_getPalette(self)

    def setPalette(self, *args):
        """setPalette(Pie self, Description palette)"""
        return _graph.Pie_setPalette(self, *args)

    def getBoundingBox(self):
        """getBoundingBox(Pie self) -> NumericalPoint"""
        return _graph.Pie_getBoundingBox(self)

    def draw(self):
        """draw(Pie self) -> OT::String"""
        return _graph.Pie_draw(self)

    def buildDefaultPalette(self):
        """buildDefaultPalette(Pie self)"""
        return _graph.Pie_buildDefaultPalette(self)

    def buildDefaultLabels(self):
        """buildDefaultLabels(Pie self)"""
        return _graph.Pie_buildDefaultLabels(self)

    def IsValidColorPalette(*args):
        """IsValidColorPalette(Description palette) -> OT::Bool"""
        return _graph.Pie_IsValidColorPalette(*args)

    if _newclass:IsValidColorPalette = staticmethod(IsValidColorPalette)
    __swig_getmethods__["IsValidColorPalette"] = lambda x: IsValidColorPalette
    def __init__(self, *args): 
        """
        __init__(OT::Pie self, NumericalPoint data) -> Pie
        __init__(OT::Pie self, NumericalSample data) -> Pie
        __init__(OT::Pie self, NumericalPoint data, Description labels) -> Pie
        __init__(OT::Pie self, NumericalPoint data, Description labels, NumericalPoint center, OT::NumericalScalar const & radius, 
            Description palette) -> Pie
        __init__(OT::Pie self, NumericalSample data, Description labels, NumericalPoint center, OT::NumericalScalar const & radius, 
            Description palette) -> Pie
        __init__(OT::Pie self, Pie other) -> Pie
        """
        this = _graph.new_Pie(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Pie
    __del__ = lambda self : None;
Pie_swigregister = _graph.Pie_swigregister
Pie_swigregister(Pie)

def Pie_GetClassName():
  """Pie_GetClassName() -> OT::String"""
  return _graph.Pie_GetClassName()

def Pie_IsValidColorPalette(*args):
  """Pie_IsValidColorPalette(Description palette) -> OT::Bool"""
  return _graph.Pie_IsValidColorPalette(*args)

class Polygon(DrawableImplementation):
    """Proxy of C++ OT::Polygon class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Polygon, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Polygon, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Polygon_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Polygon self) -> OT::String"""
        return _graph.Polygon_getClassName(self)

    def __repr__(self):
        """__repr__(Polygon self) -> OT::String"""
        return _graph.Polygon___repr__(self)

    def draw(self):
        """draw(Polygon self) -> OT::String"""
        return _graph.Polygon_draw(self)

    def setEdgeColor(self, *args):
        """setEdgeColor(Polygon self, OT::String const & edgeColor)"""
        return _graph.Polygon_setEdgeColor(self, *args)

    def getEdgeColor(self):
        """getEdgeColor(Polygon self) -> OT::String"""
        return _graph.Polygon_getEdgeColor(self)

    def __init__(self, *args): 
        """
        __init__(OT::Polygon self, OT::String const & legend="") -> Polygon
        __init__(OT::Polygon self) -> Polygon
        __init__(OT::Polygon self, NumericalSample data, OT::String const & legend="") -> Polygon
        __init__(OT::Polygon self, NumericalSample data) -> Polygon
        __init__(OT::Polygon self, NumericalSample dataX, NumericalSample dataY, OT::String const & legend="") -> Polygon
        __init__(OT::Polygon self, NumericalSample dataX, NumericalSample dataY) -> Polygon
        __init__(OT::Polygon self, NumericalSample data, OT::String const & color, OT::String const & edgeColor, OT::String const & legend="") -> Polygon
        __init__(OT::Polygon self, NumericalSample data, OT::String const & color, OT::String const & edgeColor) -> Polygon
        __init__(OT::Polygon self, Polygon other) -> Polygon
        """
        this = _graph.new_Polygon(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Polygon
    __del__ = lambda self : None;
Polygon_swigregister = _graph.Polygon_swigregister
Polygon_swigregister(Polygon)

def Polygon_GetClassName():
  """Polygon_GetClassName() -> OT::String"""
  return _graph.Polygon_GetClassName()

class Staircase(DrawableImplementation):
    """Proxy of C++ OT::Staircase class"""
    __swig_setmethods__ = {}
    for _s in [DrawableImplementation]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Staircase, name, value)
    __swig_getmethods__ = {}
    for _s in [DrawableImplementation]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Staircase, name)
    def GetClassName():
        """GetClassName() -> OT::String"""
        return _graph.Staircase_GetClassName()

    if _newclass:GetClassName = staticmethod(GetClassName)
    __swig_getmethods__["GetClassName"] = lambda x: GetClassName
    def getClassName(self):
        """getClassName(Staircase self) -> OT::String"""
        return _graph.Staircase_getClassName(self)

    def __repr__(self):
        """__repr__(Staircase self) -> OT::String"""
        return _graph.Staircase___repr__(self)

    def draw(self):
        """draw(Staircase self) -> OT::String"""
        return _graph.Staircase_draw(self)

    def getPattern(self):
        """getPattern(Staircase self) -> OT::String"""
        return _graph.Staircase_getPattern(self)

    def setPattern(self, *args):
        """setPattern(Staircase self, OT::String const style)"""
        return _graph.Staircase_setPattern(self, *args)

    def __init__(self, *args): 
        """
        __init__(OT::Staircase self) -> Staircase
        __init__(OT::Staircase self, NumericalSample data, OT::String const & legend="") -> Staircase
        __init__(OT::Staircase self, NumericalSample data) -> Staircase
        __init__(OT::Staircase self, NumericalSample data, OT::String const & color, OT::String const & lineStyle, OT::UnsignedLong const lineWidth, 
            OT::String const & pattern, OT::String const & legend="") -> Staircase
        __init__(OT::Staircase self, NumericalSample data, OT::String const & color, OT::String const & lineStyle, OT::UnsignedLong const lineWidth, 
            OT::String const & pattern) -> Staircase
        __init__(OT::Staircase self, NumericalSample data, OT::String const & color, OT::String const & lineStyle, OT::String const & pattern, 
            OT::String const & legend="") -> Staircase
        __init__(OT::Staircase self, NumericalSample data, OT::String const & color, OT::String const & lineStyle, OT::String const & pattern) -> Staircase
        __init__(OT::Staircase self, Staircase other) -> Staircase
        """
        this = _graph.new_Staircase(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_Staircase
    __del__ = lambda self : None;
Staircase_swigregister = _graph.Staircase_swigregister
Staircase_swigregister(Staircase)

def Staircase_GetClassName():
  """Staircase_GetClassName() -> OT::String"""
  return _graph.Staircase_GetClassName()

class DrawableImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::DrawableImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DrawableImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DrawableImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _graph.DrawableImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _graph.DrawableImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_graph.DrawableImplementationPointer_ptr__get, _graph.DrawableImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::DrawableImplementation)> self) -> DrawableImplementationPointer
        __init__(OT::Pointer<(OT::DrawableImplementation)> self, DrawableImplementation ptr) -> DrawableImplementationPointer
        """
        this = _graph.new_DrawableImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_DrawableImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(DrawableImplementationPointer self)"""
        return _graph.DrawableImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(DrawableImplementationPointer self) -> DrawableImplementation
        __ref__(DrawableImplementationPointer self) -> DrawableImplementation
        """
        return _graph.DrawableImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(DrawableImplementationPointer self) -> DrawableImplementation"""
        return _graph.DrawableImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(DrawableImplementationPointer self) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _graph.DrawableImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(DrawableImplementationPointer self) -> DrawableImplementation"""
        return _graph.DrawableImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(DrawableImplementationPointer self) -> OT::Pointer< OT::DrawableImplementation >::pointer_type const &"""
        return _graph.DrawableImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(DrawableImplementationPointer self) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_unique(self)

    def use_count(self):
        """use_count(DrawableImplementationPointer self) -> OT::UnsignedLong"""
        return _graph.DrawableImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(DrawableImplementationPointer self, DrawableImplementationPointer other)"""
        return _graph.DrawableImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getClassName(self)

    def __repr__(self):
        """__repr__(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer___repr__(self)

    def __str__(self, offset=""):
        """
        __str__(DrawableImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(DrawableImplementationPointer self) -> OT::String
        """
        return _graph.DrawableImplementationPointer___str__(self, offset)

    def __eq__(self, *args):
        """__eq__(DrawableImplementationPointer self, DrawableImplementation other) -> OT::Bool"""
        return _graph.DrawableImplementationPointer___eq__(self, *args)

    def getPointCode(self, *args):
        """getPointCode(DrawableImplementationPointer self, OT::String const & key) -> OT::UnsignedLong"""
        return _graph.DrawableImplementationPointer_getPointCode(self, *args)

    def IsValidColorCode(self, *args):
        """IsValidColorCode(DrawableImplementationPointer self, OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_IsValidColorCode(self, *args)

    def IsValidColorName(self, *args):
        """IsValidColorName(DrawableImplementationPointer self, OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_IsValidColorName(self, *args)

    def IsValidColor(self, *args):
        """IsValidColor(DrawableImplementationPointer self, OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_IsValidColor(self, *args)

    def IsValidLineStyle(self, *args):
        """IsValidLineStyle(DrawableImplementationPointer self, OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_IsValidLineStyle(self, *args)

    def IsValidPointStyle(self, *args):
        """IsValidPointStyle(DrawableImplementationPointer self, OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_IsValidPointStyle(self, *args)

    def IsValidFillStyle(self, *args):
        """IsValidFillStyle(DrawableImplementationPointer self, OT::String const & key) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_IsValidFillStyle(self, *args)

    def IsValidPattern(self, *args):
        """IsValidPattern(DrawableImplementationPointer self, OT::String const & pattern) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_IsValidPattern(self, *args)

    def getLegendName(self):
        """getLegendName(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getLegendName(self)

    def setLegendName(self, *args):
        """setLegendName(DrawableImplementationPointer self, OT::String const & legendName)"""
        return _graph.DrawableImplementationPointer_setLegendName(self, *args)

    def getLegend(self):
        """getLegend(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getLegend(self)

    def setLegend(self, *args):
        """setLegend(DrawableImplementationPointer self, OT::String const & legend)"""
        return _graph.DrawableImplementationPointer_setLegend(self, *args)

    def getData(self):
        """getData(DrawableImplementationPointer self) -> NumericalSample"""
        return _graph.DrawableImplementationPointer_getData(self)

    def getLineStyle(self):
        """getLineStyle(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getLineStyle(self)

    def setLineStyle(self, *args):
        """setLineStyle(DrawableImplementationPointer self, OT::String const & lineStyle)"""
        return _graph.DrawableImplementationPointer_setLineStyle(self, *args)

    def getColor(self):
        """getColor(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getColor(self)

    def getColorCode(self):
        """getColorCode(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getColorCode(self)

    def setColor(self, *args):
        """setColor(DrawableImplementationPointer self, OT::String const & color)"""
        return _graph.DrawableImplementationPointer_setColor(self, *args)

    def getEdgeColor(self):
        """getEdgeColor(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getEdgeColor(self)

    def getPointStyle(self):
        """getPointStyle(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getPointStyle(self)

    def setPointStyle(self, *args):
        """setPointStyle(DrawableImplementationPointer self, OT::String const & pointStyle)"""
        return _graph.DrawableImplementationPointer_setPointStyle(self, *args)

    def getFillStyle(self):
        """getFillStyle(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getFillStyle(self)

    def setFillStyle(self, *args):
        """setFillStyle(DrawableImplementationPointer self, OT::String const & fillStyle)"""
        return _graph.DrawableImplementationPointer_setFillStyle(self, *args)

    def getLineWidth(self):
        """getLineWidth(DrawableImplementationPointer self) -> OT::UnsignedLong"""
        return _graph.DrawableImplementationPointer_getLineWidth(self)

    def setLineWidth(self, *args):
        """setLineWidth(DrawableImplementationPointer self, OT::UnsignedLong const lineWidth)"""
        return _graph.DrawableImplementationPointer_setLineWidth(self, *args)

    def getPattern(self):
        """getPattern(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getPattern(self)

    def setPattern(self, *args):
        """setPattern(DrawableImplementationPointer self, OT::String const style)"""
        return _graph.DrawableImplementationPointer_setPattern(self, *args)

    def setShowPoints(self, *args):
        """setShowPoints(DrawableImplementationPointer self, OT::Bool const showPoints)"""
        return _graph.DrawableImplementationPointer_setShowPoints(self, *args)

    def getShowPoints(self):
        """getShowPoints(DrawableImplementationPointer self) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_getShowPoints(self)

    def getCenter(self):
        """getCenter(DrawableImplementationPointer self) -> NumericalPoint"""
        return _graph.DrawableImplementationPointer_getCenter(self)

    def setCenter(self, *args):
        """setCenter(DrawableImplementationPointer self, NumericalPoint center)"""
        return _graph.DrawableImplementationPointer_setCenter(self, *args)

    def getRadius(self):
        """getRadius(DrawableImplementationPointer self) -> OT::NumericalScalar"""
        return _graph.DrawableImplementationPointer_getRadius(self)

    def setRadius(self, *args):
        """setRadius(DrawableImplementationPointer self, OT::NumericalScalar const radius)"""
        return _graph.DrawableImplementationPointer_setRadius(self, *args)

    def getLabels(self):
        """getLabels(DrawableImplementationPointer self) -> Description"""
        return _graph.DrawableImplementationPointer_getLabels(self)

    def setLabels(self, *args):
        """setLabels(DrawableImplementationPointer self, Description labels)"""
        return _graph.DrawableImplementationPointer_setLabels(self, *args)

    def getPalette(self):
        """getPalette(DrawableImplementationPointer self) -> Description"""
        return _graph.DrawableImplementationPointer_getPalette(self)

    def setPalette(self, *args):
        """setPalette(DrawableImplementationPointer self, Description palette)"""
        return _graph.DrawableImplementationPointer_setPalette(self, *args)

    def getOrigin(self):
        """getOrigin(DrawableImplementationPointer self) -> OT::NumericalScalar"""
        return _graph.DrawableImplementationPointer_getOrigin(self)

    def setOrigin(self, *args):
        """setOrigin(DrawableImplementationPointer self, OT::NumericalScalar const origin)"""
        return _graph.DrawableImplementationPointer_setOrigin(self, *args)

    def getX(self):
        """getX(DrawableImplementationPointer self) -> NumericalSample"""
        return _graph.DrawableImplementationPointer_getX(self)

    def setX(self, *args):
        """setX(DrawableImplementationPointer self, NumericalSample x)"""
        return _graph.DrawableImplementationPointer_setX(self, *args)

    def getY(self):
        """getY(DrawableImplementationPointer self) -> NumericalSample"""
        return _graph.DrawableImplementationPointer_getY(self)

    def setY(self, *args):
        """setY(DrawableImplementationPointer self, NumericalSample y)"""
        return _graph.DrawableImplementationPointer_setY(self, *args)

    def getLevels(self):
        """getLevels(DrawableImplementationPointer self) -> NumericalPoint"""
        return _graph.DrawableImplementationPointer_getLevels(self)

    def setLevels(self, *args):
        """setLevels(DrawableImplementationPointer self, NumericalPoint levels)"""
        return _graph.DrawableImplementationPointer_setLevels(self, *args)

    def getDrawLabels(self):
        """getDrawLabels(DrawableImplementationPointer self) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_getDrawLabels(self)

    def setDrawLabels(self, *args):
        """setDrawLabels(DrawableImplementationPointer self, OT::Bool const & drawLabels)"""
        return _graph.DrawableImplementationPointer_setDrawLabels(self, *args)

    def getBoundingBox(self):
        """getBoundingBox(DrawableImplementationPointer self) -> NumericalPoint"""
        return _graph.DrawableImplementationPointer_getBoundingBox(self)

    def draw(self):
        """draw(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_draw(self)

    def clean(self):
        """clean(DrawableImplementationPointer self)"""
        return _graph.DrawableImplementationPointer_clean(self)

    def GetValidColors(self):
        """GetValidColors(DrawableImplementationPointer self) -> Description"""
        return _graph.DrawableImplementationPointer_GetValidColors(self)

    def GetValidLineStyles(self):
        """GetValidLineStyles(DrawableImplementationPointer self) -> Description"""
        return _graph.DrawableImplementationPointer_GetValidLineStyles(self)

    def GetValidFillStyles(self):
        """GetValidFillStyles(DrawableImplementationPointer self) -> Description"""
        return _graph.DrawableImplementationPointer_GetValidFillStyles(self)

    def GetValidPointStyles(self):
        """GetValidPointStyles(DrawableImplementationPointer self) -> Description"""
        return _graph.DrawableImplementationPointer_GetValidPointStyles(self)

    def ConvertFromName(self, *args):
        """ConvertFromName(DrawableImplementationPointer self, OT::String const & name) -> OT::String"""
        return _graph.DrawableImplementationPointer_ConvertFromName(self, *args)

    def ConvertFromRGB(self, *args):
        """
        ConvertFromRGB(DrawableImplementationPointer self, OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue) -> OT::String
        ConvertFromRGB(DrawableImplementationPointer self, OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue) -> OT::String
        """
        return _graph.DrawableImplementationPointer_ConvertFromRGB(self, *args)

    def ConvertFromRGBA(self, *args):
        """
        ConvertFromRGBA(DrawableImplementationPointer self, OT::UnsignedLong const red, OT::UnsignedLong const green, OT::UnsignedLong const blue, 
            OT::UnsignedLong const alpha) -> OT::String
        ConvertFromRGBA(DrawableImplementationPointer self, OT::NumericalScalar const red, OT::NumericalScalar const green, OT::NumericalScalar const blue, 
            OT::NumericalScalar const alpha) -> OT::String
        """
        return _graph.DrawableImplementationPointer_ConvertFromRGBA(self, *args)

    def ConvertFromHSVIntoRGB(self, *args):
        """ConvertFromHSVIntoRGB(DrawableImplementationPointer self, OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> NumericalPoint"""
        return _graph.DrawableImplementationPointer_ConvertFromHSVIntoRGB(self, *args)

    def ConvertFromHSV(self, *args):
        """ConvertFromHSV(DrawableImplementationPointer self, OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value) -> OT::String"""
        return _graph.DrawableImplementationPointer_ConvertFromHSV(self, *args)

    def ConvertFromHSVA(self, *args):
        """
        ConvertFromHSVA(DrawableImplementationPointer self, OT::NumericalScalar const hue, OT::NumericalScalar const saturation, OT::NumericalScalar const value, 
            OT::NumericalScalar const alpha) -> OT::String
        """
        return _graph.DrawableImplementationPointer_ConvertFromHSVA(self, *args)

    def BuildDefaultPalette(self, *args):
        """BuildDefaultPalette(DrawableImplementationPointer self, OT::UnsignedLong const size) -> Description"""
        return _graph.DrawableImplementationPointer_BuildDefaultPalette(self, *args)

    def Is(self, *args):
        """Is(DrawableImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_Is(self, *args)

    def getId(self):
        """getId(DrawableImplementationPointer self) -> OT::Id"""
        return _graph.DrawableImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(DrawableImplementationPointer self, OT::Id id)"""
        return _graph.DrawableImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(DrawableImplementationPointer self) -> OT::Id"""
        return _graph.DrawableImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(DrawableImplementationPointer self, OT::Bool visible)"""
        return _graph.DrawableImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(DrawableImplementationPointer self) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(DrawableImplementationPointer self) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(DrawableImplementationPointer self) -> OT::Bool"""
        return _graph.DrawableImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(DrawableImplementationPointer self) -> OT::String"""
        return _graph.DrawableImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(DrawableImplementationPointer self, OT::String const & name)"""
        return _graph.DrawableImplementationPointer_setName(self, *args)

DrawableImplementationPointer_swigregister = _graph.DrawableImplementationPointer_swigregister
DrawableImplementationPointer_swigregister(DrawableImplementationPointer)

class GraphImplementationPointer(_object):
    """Proxy of C++ OT::Pointer<(OT::GraphImplementation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GraphImplementationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GraphImplementationPointer, name)
    __swig_setmethods__["ptr_"] = _graph.GraphImplementationPointer_ptr__set
    __swig_getmethods__["ptr_"] = _graph.GraphImplementationPointer_ptr__get
    if _newclass:ptr_ = _swig_property(_graph.GraphImplementationPointer_ptr__get, _graph.GraphImplementationPointer_ptr__set)
    def __init__(self, *args): 
        """
        __init__(OT::Pointer<(OT::GraphImplementation)> self) -> GraphImplementationPointer
        __init__(OT::Pointer<(OT::GraphImplementation)> self, GraphImplementation ptr) -> GraphImplementationPointer
        """
        this = _graph.new_GraphImplementationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _graph.delete_GraphImplementationPointer
    __del__ = lambda self : None;
    def reset(self):
        """reset(GraphImplementationPointer self)"""
        return _graph.GraphImplementationPointer_reset(self)

    def __ref__(self, *args):
        """
        __ref__(GraphImplementationPointer self) -> GraphImplementation
        __ref__(GraphImplementationPointer self) -> GraphImplementation
        """
        return _graph.GraphImplementationPointer___ref__(self, *args)

    def __deref__(self):
        """__deref__(GraphImplementationPointer self) -> GraphImplementation"""
        return _graph.GraphImplementationPointer___deref__(self)

    def isNull(self):
        """isNull(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_isNull(self)

    def __nonzero__(self):
        return _graph.GraphImplementationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def get(self):
        """get(GraphImplementationPointer self) -> GraphImplementation"""
        return _graph.GraphImplementationPointer_get(self)

    def getImplementation(self):
        """getImplementation(GraphImplementationPointer self) -> OT::Pointer< OT::GraphImplementation >::pointer_type const &"""
        return _graph.GraphImplementationPointer_getImplementation(self)

    def unique(self):
        """unique(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_unique(self)

    def use_count(self):
        """use_count(GraphImplementationPointer self) -> OT::UnsignedLong"""
        return _graph.GraphImplementationPointer_use_count(self)

    def swap(self, *args):
        """swap(GraphImplementationPointer self, GraphImplementationPointer other)"""
        return _graph.GraphImplementationPointer_swap(self, *args)

    def GetClassName(self):
        """GetClassName(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_GetClassName(self)

    def getClassName(self):
        """getClassName(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getClassName(self)

    __swig_setmethods__["ValidLegendPositions"] = _graph.GraphImplementationPointer_ValidLegendPositions_set
    __swig_getmethods__["ValidLegendPositions"] = _graph.GraphImplementationPointer_ValidLegendPositions_get
    if _newclass:ValidLegendPositions = _swig_property(_graph.GraphImplementationPointer_ValidLegendPositions_get, _graph.GraphImplementationPointer_ValidLegendPositions_set)
    __swig_setmethods__["IsFirstInitialization"] = _graph.GraphImplementationPointer_IsFirstInitialization_set
    __swig_getmethods__["IsFirstInitialization"] = _graph.GraphImplementationPointer_IsFirstInitialization_get
    if _newclass:IsFirstInitialization = _swig_property(_graph.GraphImplementationPointer_IsFirstInitialization_get, _graph.GraphImplementationPointer_IsFirstInitialization_set)
    def __repr__(self):
        """__repr__(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer___repr__(self)

    def add(self, *args):
        """
        add(GraphImplementationPointer self, Drawable aDrawable)
        add(GraphImplementationPointer self, DrawableCollection drawableCollection)
        add(GraphImplementationPointer self, GraphImplementation graphImplementation)
        """
        return _graph.GraphImplementationPointer_add(self, *args)

    def erase(self, *args):
        """erase(GraphImplementationPointer self, OT::UnsignedLong const i)"""
        return _graph.GraphImplementationPointer_erase(self, *args)

    def getDrawables(self):
        """getDrawables(GraphImplementationPointer self) -> DrawableCollection"""
        return _graph.GraphImplementationPointer_getDrawables(self)

    def setDrawables(self, *args):
        """setDrawables(GraphImplementationPointer self, DrawableCollection drawableCollection)"""
        return _graph.GraphImplementationPointer_setDrawables(self, *args)

    def getDrawable(self, *args):
        """getDrawable(GraphImplementationPointer self, OT::UnsignedLong const index) -> Drawable"""
        return _graph.GraphImplementationPointer_getDrawable(self, *args)

    def setDrawable(self, *args):
        """setDrawable(GraphImplementationPointer self, Drawable drawable, OT::UnsignedLong const index)"""
        return _graph.GraphImplementationPointer_setDrawable(self, *args)

    def getColors(self):
        """getColors(GraphImplementationPointer self) -> Description"""
        return _graph.GraphImplementationPointer_getColors(self)

    def setColors(self, *args):
        """setColors(GraphImplementationPointer self, Description colors)"""
        return _graph.GraphImplementationPointer_setColors(self, *args)

    def getLegends(self):
        """getLegends(GraphImplementationPointer self) -> Description"""
        return _graph.GraphImplementationPointer_getLegends(self)

    def setLegends(self, *args):
        """setLegends(GraphImplementationPointer self, Description legends)"""
        return _graph.GraphImplementationPointer_setLegends(self, *args)

    def setAxes(self, *args):
        """setAxes(GraphImplementationPointer self, OT::Bool const showAxes)"""
        return _graph.GraphImplementationPointer_setAxes(self, *args)

    def getAxes(self):
        """getAxes(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_getAxes(self)

    def setLogScale(self, *args):
        """setLogScale(GraphImplementationPointer self, OT::GraphImplementation::LogScale const logScale)"""
        return _graph.GraphImplementationPointer_setLogScale(self, *args)

    def getLogScale(self):
        """getLogScale(GraphImplementationPointer self) -> OT::GraphImplementation::LogScale"""
        return _graph.GraphImplementationPointer_getLogScale(self)

    def setGrid(self, *args):
        """setGrid(GraphImplementationPointer self, OT::Bool const showGrid)"""
        return _graph.GraphImplementationPointer_setGrid(self, *args)

    def getGrid(self):
        """getGrid(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_getGrid(self)

    def setGridColor(self, *args):
        """setGridColor(GraphImplementationPointer self, OT::String const & color)"""
        return _graph.GraphImplementationPointer_setGridColor(self, *args)

    def getGridColor(self):
        """getGridColor(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getGridColor(self)

    def getXTitle(self):
        """getXTitle(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getXTitle(self)

    def setXTitle(self, *args):
        """setXTitle(GraphImplementationPointer self, OT::String const & title)"""
        return _graph.GraphImplementationPointer_setXTitle(self, *args)

    def getYTitle(self):
        """getYTitle(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getYTitle(self)

    def setYTitle(self, *args):
        """setYTitle(GraphImplementationPointer self, OT::String const & title)"""
        return _graph.GraphImplementationPointer_setYTitle(self, *args)

    def getTitle(self):
        """getTitle(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getTitle(self)

    def setTitle(self, *args):
        """setTitle(GraphImplementationPointer self, OT::String const & title)"""
        return _graph.GraphImplementationPointer_setTitle(self, *args)

    def getPath(self):
        """getPath(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getPath(self)

    def getFileName(self):
        """getFileName(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getFileName(self)

    def draw(self, *args):
        """
        draw(GraphImplementationPointer self, OT::String const & path, OT::String const & file, OT::NumericalScalar const width, 
            OT::NumericalScalar const height, OT::GraphImplementation::Format const format=ALL)
        draw(GraphImplementationPointer self, OT::String const & path, OT::String const & file, OT::NumericalScalar const width, 
            OT::NumericalScalar const height)
        draw(GraphImplementationPointer self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"), 
            OT::NumericalScalar const height=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultHeight"), 
            OT::GraphImplementation::Format const format=ALL)
        draw(GraphImplementationPointer self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"), 
            OT::NumericalScalar const height=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultHeight"))
        draw(GraphImplementationPointer self, OT::String const & file, OT::NumericalScalar const width=OT::ResourceMap::GetAsUnsignedLong("GraphImplementation-DefaultWidth"))
        draw(GraphImplementationPointer self, OT::String const & file)
        """
        return _graph.GraphImplementationPointer_draw(self, *args)

    def getRCommand(self):
        """getRCommand(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getRCommand(self)

    def clean(self):
        """clean(GraphImplementationPointer self)"""
        return _graph.GraphImplementationPointer_clean(self)

    def getBitmap(self):
        """getBitmap(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getBitmap(self)

    def getPostscript(self):
        """getPostscript(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getPostscript(self)

    def getPDF(self):
        """getPDF(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getPDF(self)

    def getVectorial(self):
        """getVectorial(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getVectorial(self)

    def getBoundingBox(self):
        """getBoundingBox(GraphImplementationPointer self) -> NumericalPoint"""
        return _graph.GraphImplementationPointer_getBoundingBox(self)

    def setBoundingBox(self, *args):
        """
        setBoundingBox(GraphImplementationPointer self, NumericalPoint boundingBox)
        setBoundingBox(GraphImplementationPointer self, Interval boundingBox)
        """
        return _graph.GraphImplementationPointer_setBoundingBox(self, *args)

    def getAutomaticBoundingBox(self):
        """getAutomaticBoundingBox(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_getAutomaticBoundingBox(self)

    def setAutomaticBoundingBox(self, *args):
        """setAutomaticBoundingBox(GraphImplementationPointer self, OT::Bool const automaticBoundingBox)"""
        return _graph.GraphImplementationPointer_setAutomaticBoundingBox(self, *args)

    def getLegendPosition(self):
        """getLegendPosition(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getLegendPosition(self)

    def setLegendPosition(self, *args):
        """setLegendPosition(GraphImplementationPointer self, OT::String const & position)"""
        return _graph.GraphImplementationPointer_setLegendPosition(self, *args)

    def getLegendFontSize(self):
        """getLegendFontSize(GraphImplementationPointer self) -> OT::NumericalScalar"""
        return _graph.GraphImplementationPointer_getLegendFontSize(self)

    def setLegendFontSize(self, *args):
        """setLegendFontSize(GraphImplementationPointer self, OT::NumericalScalar const legendFontSize)"""
        return _graph.GraphImplementationPointer_setLegendFontSize(self, *args)

    def isValidLegendPosition(self, *args):
        """isValidLegendPosition(GraphImplementationPointer self, OT::String const & position) -> OT::Bool"""
        return _graph.GraphImplementationPointer_isValidLegendPosition(self, *args)

    def initializeValidLegendPositions(self):
        """initializeValidLegendPositions(GraphImplementationPointer self)"""
        return _graph.GraphImplementationPointer_initializeValidLegendPositions(self)

    def GetValidLegendPositions(self):
        """GetValidLegendPositions(GraphImplementationPointer self) -> Description"""
        return _graph.GraphImplementationPointer_GetValidLegendPositions(self)

    def __eq__(self, *args):
        """__eq__(GraphImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _graph.GraphImplementationPointer___eq__(self, *args)

    def Is(self, *args):
        """Is(GraphImplementationPointer self, PersistentObject other) -> OT::Bool"""
        return _graph.GraphImplementationPointer_Is(self, *args)

    def __str__(self, offset=""):
        """
        __str__(GraphImplementationPointer self, OT::String const & offset="") -> OT::String
        __str__(GraphImplementationPointer self) -> OT::String
        """
        return _graph.GraphImplementationPointer___str__(self, offset)

    def getId(self):
        """getId(GraphImplementationPointer self) -> OT::Id"""
        return _graph.GraphImplementationPointer_getId(self)

    def setShadowedId(self, *args):
        """setShadowedId(GraphImplementationPointer self, OT::Id id)"""
        return _graph.GraphImplementationPointer_setShadowedId(self, *args)

    def getShadowedId(self):
        """getShadowedId(GraphImplementationPointer self) -> OT::Id"""
        return _graph.GraphImplementationPointer_getShadowedId(self)

    def setVisibility(self, *args):
        """setVisibility(GraphImplementationPointer self, OT::Bool visible)"""
        return _graph.GraphImplementationPointer_setVisibility(self, *args)

    def getVisibility(self):
        """getVisibility(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_getVisibility(self)

    def hasName(self):
        """hasName(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_hasName(self)

    def hasVisibleName(self):
        """hasVisibleName(GraphImplementationPointer self) -> OT::Bool"""
        return _graph.GraphImplementationPointer_hasVisibleName(self)

    def getName(self):
        """getName(GraphImplementationPointer self) -> OT::String"""
        return _graph.GraphImplementationPointer_getName(self)

    def setName(self, *args):
        """setName(GraphImplementationPointer self, OT::String const & name)"""
        return _graph.GraphImplementationPointer_setName(self, *args)

GraphImplementationPointer_swigregister = _graph.GraphImplementationPointer_swigregister
GraphImplementationPointer_swigregister(GraphImplementationPointer)

# This file is compatible with both classic and new-style classes.