display/__init__.py

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





from sys import version_info
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('_IMP_display', [dirname(__file__)])
        except ImportError:
            import _IMP_display
            return _IMP_display
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_display', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_display = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_display
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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class IMP_DISPLAY_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_DISPLAY_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_DISPLAY_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_DISPLAY_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_display.delete_IMP_DISPLAY_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_DISPLAY_SwigPyIterator self) -> PyObject *"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_DISPLAY_SwigPyIterator self, size_t n=1) -> IMP_DISPLAY_SwigPyIterator
        incr(IMP_DISPLAY_SwigPyIterator self) -> IMP_DISPLAY_SwigPyIterator
        """
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_DISPLAY_SwigPyIterator self, size_t n=1) -> IMP_DISPLAY_SwigPyIterator
        decr(IMP_DISPLAY_SwigPyIterator self) -> IMP_DISPLAY_SwigPyIterator
        """
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_DISPLAY_SwigPyIterator self, IMP_DISPLAY_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_DISPLAY_SwigPyIterator self, IMP_DISPLAY_SwigPyIterator x) -> bool"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_DISPLAY_SwigPyIterator self) -> IMP_DISPLAY_SwigPyIterator"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_DISPLAY_SwigPyIterator self) -> PyObject *"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_DISPLAY_SwigPyIterator self) -> PyObject *"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_DISPLAY_SwigPyIterator self) -> PyObject *"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_DISPLAY_SwigPyIterator self, ptrdiff_t n) -> IMP_DISPLAY_SwigPyIterator"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_DISPLAY_SwigPyIterator self, IMP_DISPLAY_SwigPyIterator x) -> bool"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_DISPLAY_SwigPyIterator self, IMP_DISPLAY_SwigPyIterator x) -> bool"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_DISPLAY_SwigPyIterator self, ptrdiff_t n) -> IMP_DISPLAY_SwigPyIterator"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_DISPLAY_SwigPyIterator self, ptrdiff_t n) -> IMP_DISPLAY_SwigPyIterator"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_DISPLAY_SwigPyIterator self, ptrdiff_t n) -> IMP_DISPLAY_SwigPyIterator"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_DISPLAY_SwigPyIterator self, ptrdiff_t n) -> IMP_DISPLAY_SwigPyIterator
        __sub__(IMP_DISPLAY_SwigPyIterator self, IMP_DISPLAY_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_display.IMP_DISPLAY_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_DISPLAY_SwigPyIterator_swigregister = _IMP_display.IMP_DISPLAY_SwigPyIterator_swigregister
IMP_DISPLAY_SwigPyIterator_swigregister(IMP_DISPLAY_SwigPyIterator)

_value_types=[]
_object_types=[]
_raii_types=[]
_plural_types=[]

IMP_DEBUG = _IMP_display.IMP_DEBUG
IMP_RELEASE = _IMP_display.IMP_RELEASE
IMP_SILENT = _IMP_display.IMP_SILENT
IMP_PROGRESS = _IMP_display.IMP_PROGRESS
IMP_TERSE = _IMP_display.IMP_TERSE
IMP_VERBOSE = _IMP_display.IMP_VERBOSE
IMP_MEMORY = _IMP_display.IMP_MEMORY
IMP_NONE = _IMP_display.IMP_NONE
IMP_USAGE = _IMP_display.IMP_USAGE
IMP_INTERNAL = _IMP_display.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_display.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_display.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_display.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_display.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_display.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_display.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_display.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_display.IMPBASE_SHOW_WARNINGS
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        
        
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

DEFAULT_CHECK = _IMP_display.DEFAULT_CHECK
NONE = _IMP_display.NONE
USAGE = _IMP_display.USAGE
USAGE_AND_INTERNAL = _IMP_display.USAGE_AND_INTERNAL

def set_check_level(*args):
  """set_check_level(IMP::base::CheckLevel tf)"""
  return _IMP_display.set_check_level(*args)

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_display.get_check_level()
class _ostream(_object):
    """Proxy of C++ std::ostream class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ostream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ostream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *args):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_display._ostream_write(self, *args)

_ostream_swigregister = _IMP_display._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_display.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_display.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_display.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_display.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_display.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_display.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_display.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_display.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_display.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_display.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_display.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_display.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_display.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_display.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_display.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_display.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_display.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_display.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_display.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_display.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_display.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_display.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_display.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_display.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_display.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_display.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_display.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_display.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_display.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_display.IMPDISPLAY_SHOW_WARNINGS
_object_types.append("Writer")


def _object_cast_to_Writer(*args):
  """_object_cast_to_Writer(Object o) -> Writer"""
  return _IMP_display._object_cast_to_Writer(*args)
_object_types.append("TextWriter")


def _object_cast_to_TextWriter(*args):
  """_object_cast_to_TextWriter(Object o) -> TextWriter"""
  return _IMP_display._object_cast_to_TextWriter(*args)
_object_types.append("Geometry")


def _object_cast_to_Geometry(*args):
  """_object_cast_to_Geometry(Object o) -> Geometry"""
  return _IMP_display._object_cast_to_Geometry(*args)
_object_types.append("SingletonGeometry")


def _object_cast_to_SingletonGeometry(*args):
  """_object_cast_to_SingletonGeometry(Object o) -> SingletonGeometry"""
  return _IMP_display._object_cast_to_SingletonGeometry(*args)
_object_types.append("PairGeometry")


def _object_cast_to_PairGeometry(*args):
  """_object_cast_to_PairGeometry(Object o) -> PairGeometry"""
  return _IMP_display._object_cast_to_PairGeometry(*args)
_object_types.append("SingletonsGeometry")


def _object_cast_to_SingletonsGeometry(*args):
  """_object_cast_to_SingletonsGeometry(Object o) -> SingletonsGeometry"""
  return _IMP_display._object_cast_to_SingletonsGeometry(*args)
_object_types.append("PairsGeometry")


def _object_cast_to_PairsGeometry(*args):
  """_object_cast_to_PairsGeometry(Object o) -> PairsGeometry"""
  return _IMP_display._object_cast_to_PairsGeometry(*args)
_object_types.append("ChimeraWriter")


def _object_cast_to_ChimeraWriter(*args):
  """_object_cast_to_ChimeraWriter(Object o) -> ChimeraWriter"""
  return _IMP_display._object_cast_to_ChimeraWriter(*args)
_object_types.append("PymolWriter")


def _object_cast_to_PymolWriter(*args):
  """_object_cast_to_PymolWriter(Object o) -> PymolWriter"""
  return _IMP_display._object_cast_to_PymolWriter(*args)
_object_types.append("SphereGeometry")


def _object_cast_to_SphereGeometry(*args):
  """_object_cast_to_SphereGeometry(Object o) -> SphereGeometry"""
  return _IMP_display._object_cast_to_SphereGeometry(*args)
_object_types.append("CylinderGeometry")


def _object_cast_to_CylinderGeometry(*args):
  """_object_cast_to_CylinderGeometry(Object o) -> CylinderGeometry"""
  return _IMP_display._object_cast_to_CylinderGeometry(*args)
_object_types.append("EllipsoidGeometry")


def _object_cast_to_EllipsoidGeometry(*args):
  """_object_cast_to_EllipsoidGeometry(Object o) -> EllipsoidGeometry"""
  return _IMP_display._object_cast_to_EllipsoidGeometry(*args)
_object_types.append("PointGeometry")


def _object_cast_to_PointGeometry(*args):
  """_object_cast_to_PointGeometry(Object o) -> PointGeometry"""
  return _IMP_display._object_cast_to_PointGeometry(*args)
_object_types.append("SegmentGeometry")


def _object_cast_to_SegmentGeometry(*args):
  """_object_cast_to_SegmentGeometry(Object o) -> SegmentGeometry"""
  return _IMP_display._object_cast_to_SegmentGeometry(*args)
_object_types.append("PolygonGeometry")


def _object_cast_to_PolygonGeometry(*args):
  """_object_cast_to_PolygonGeometry(Object o) -> PolygonGeometry"""
  return _IMP_display._object_cast_to_PolygonGeometry(*args)
_object_types.append("ReferenceFrameGeometry")


def _object_cast_to_ReferenceFrameGeometry(*args):
  """_object_cast_to_ReferenceFrameGeometry(Object o) -> ReferenceFrameGeometry"""
  return _IMP_display._object_cast_to_ReferenceFrameGeometry(*args)
_object_types.append("BoundingBoxGeometry")


def _object_cast_to_BoundingBoxGeometry(*args):
  """_object_cast_to_BoundingBoxGeometry(Object o) -> BoundingBoxGeometry"""
  return _IMP_display._object_cast_to_BoundingBoxGeometry(*args)
_object_types.append("LabelGeometry")


def _object_cast_to_LabelGeometry(*args):
  """_object_cast_to_LabelGeometry(Object o) -> LabelGeometry"""
  return _IMP_display._object_cast_to_LabelGeometry(*args)
_object_types.append("RestraintGeometry")


def _object_cast_to_RestraintGeometry(*args):
  """_object_cast_to_RestraintGeometry(Object o) -> RestraintGeometry"""
  return _IMP_display._object_cast_to_RestraintGeometry(*args)
_object_types.append("RestraintSetGeometry")


def _object_cast_to_RestraintSetGeometry(*args):
  """_object_cast_to_RestraintSetGeometry(Object o) -> RestraintSetGeometry"""
  return _IMP_display._object_cast_to_RestraintSetGeometry(*args)
_object_types.append("GeometrySet")


def _object_cast_to_GeometrySet(*args):
  """_object_cast_to_GeometrySet(Object o) -> GeometrySet"""
  return _IMP_display._object_cast_to_GeometrySet(*args)
def Coloreds(l=[]):
    return [Colored(x) for x in l]
_plural_types.append("Coloreds")

_value_types.append("Colored")

Colors=list
_plural_types.append("Colors")
_value_types.append("Color")

WriterAdaptors=list
_plural_types.append("WriterAdaptors")
_value_types.append("WriterAdaptor")

_object_types.append("FilterGeometry")


def _object_cast_to_FilterGeometry(*args):
  """_object_cast_to_FilterGeometry(Object o) -> FilterGeometry"""
  return _IMP_display._object_cast_to_FilterGeometry(*args)
_object_types.append("WriteOptimizerState")


def _object_cast_to_WriteOptimizerState(*args):
  """_object_cast_to_WriteOptimizerState(Object o) -> WriteOptimizerState"""
  return _IMP_display._object_cast_to_WriteOptimizerState(*args)
_object_types.append("TriangleGeometry")


def _object_cast_to_TriangleGeometry(*args):
  """_object_cast_to_TriangleGeometry(Object o) -> TriangleGeometry"""
  return _IMP_display._object_cast_to_TriangleGeometry(*args)
_object_types.append("SurfaceMeshGeometry")


def _object_cast_to_SurfaceMeshGeometry(*args):
  """_object_cast_to_SurfaceMeshGeometry(Object o) -> SurfaceMeshGeometry"""
  return _IMP_display._object_cast_to_SurfaceMeshGeometry(*args)
_object_types.append("PlaneGeometry")


def _object_cast_to_PlaneGeometry(*args):
  """_object_cast_to_PlaneGeometry(Object o) -> PlaneGeometry"""
  return _IMP_display._object_cast_to_PlaneGeometry(*args)
_object_types.append("IsosurfaceGeometry")


def _object_cast_to_IsosurfaceGeometry(*args):
  """_object_cast_to_IsosurfaceGeometry(Object o) -> IsosurfaceGeometry"""
  return _IMP_display._object_cast_to_IsosurfaceGeometry(*args)
_object_types.append("SkinSurfaceGeometry")


def _object_cast_to_SkinSurfaceGeometry(*args):
  """_object_cast_to_SkinSurfaceGeometry(Object o) -> SkinSurfaceGeometry"""
  return _IMP_display._object_cast_to_SkinSurfaceGeometry(*args)
class Color(IMP.base._Value):
    """Proxy of C++ IMP::display::Color class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Color, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Color, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::Color self) -> Color
        __init__(IMP::display::Color self, double r, double g, double b) -> Color
        """
        this = _IMP_display.new_Color(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_display.delete_Color
    __del__ = lambda self : None;
    def get_red(self):
        """get_red(Color self) -> double"""
        return _IMP_display.Color_get_red(self)

    def get_green(self):
        """get_green(Color self) -> double"""
        return _IMP_display.Color_get_green(self)

    def get_blue(self):
        """get_blue(Color self) -> double"""
        return _IMP_display.Color_get_blue(self)

    def show(self, *args):
        """
        show(Color self, _ostream out, std::string delim)
        show(Color self, _ostream out=std::cout)
        show(Color self)
        """
        return _IMP_display.Color_show(self, *args)

    def __eq__(self, *args):
        """__eq__(Color self, Color o) -> bool"""
        return _IMP_display.Color___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(Color self, Color o) -> bool"""
        return _IMP_display.Color___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(Color self, Color o) -> bool"""
        return _IMP_display.Color___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(Color self, Color o) -> bool"""
        return _IMP_display.Color___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(Color self, Color o) -> bool"""
        return _IMP_display.Color___ge__(self, *args)

    def __le__(self, *args):
        """__le__(Color self, Color o) -> bool"""
        return _IMP_display.Color___le__(self, *args)

    def __str__(self):
        """__str__(Color self) -> std::string"""
        return _IMP_display.Color___str__(self)

    def __repr__(self):
        """__repr__(Color self) -> std::string"""
        return _IMP_display.Color___repr__(self)

Color_swigregister = _IMP_display.Color_swigregister
Color_swigregister(Color)


def get_display_color(*args):
  """get_display_color(unsigned int i) -> Color"""
  return _IMP_display.get_display_color(*args)

def get_interpolated_rgb(*args):
  """get_interpolated_rgb(Color a, Color b, double f) -> Color"""
  return _IMP_display.get_interpolated_rgb(*args)

def get_linear_color_map_value(*args):
  """get_linear_color_map_value(double min, double max, double value) -> double"""
  return _IMP_display.get_linear_color_map_value(*args)

def get_jet_color(*args):
  """get_jet_color(double f) -> Color"""
  return _IMP_display.get_jet_color(*args)

def get_hot_color(*args):
  """get_hot_color(double f) -> Color"""
  return _IMP_display.get_hot_color(*args)

def get_rgb_color(*args):
  """get_rgb_color(double f) -> Color"""
  return _IMP_display.get_rgb_color(*args)

def get_grey_color(*args):
  """get_grey_color(double f) -> Color"""
  return _IMP_display.get_grey_color(*args)

def get_gnuplot_color(*args):
  """get_gnuplot_color(double f) -> Color"""
  return _IMP_display.get_gnuplot_color(*args)
class Geometry(IMP.base.Object):
    """Proxy of C++ IMP::display::Geometry class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Geometry, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Geometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::Geometry self, std::string name) -> Geometry
        __init__(IMP::display::Geometry self, Color c, std::string name) -> Geometry
        """
        if self.__class__ == Geometry:
            _self = None
        else:
            _self = self
        this = _IMP_display.new_Geometry(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Geometry:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_color(self):
        """get_color(Geometry self) -> Color"""
        return _IMP_display.Geometry_get_color(self)

    def get_has_color(self):
        """get_has_color(Geometry self) -> bool"""
        return _IMP_display.Geometry_get_has_color(self)

    def set_has_color(self, *args):
        """set_has_color(Geometry self, bool tf)"""
        return _IMP_display.Geometry_set_has_color(self, *args)

    def set_color(self, *args):
        """set_color(Geometry self, Color c)"""
        return _IMP_display.Geometry_set_color(self, *args)

    def get_components(self):
        """get_components(Geometry self) -> IMP::display::Geometries"""
        return _IMP_display.Geometry_get_components(self)

    __swig_destroy__ = _IMP_display.delete_Geometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Geometry self) -> std::string"""
        return _IMP_display.Geometry___str__(self)

    def __repr__(self):
        """__repr__(Geometry self) -> std::string"""
        return _IMP_display.Geometry___repr__(self)

    def get_from(o):
       return _object_cast_to_Geometry(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::display" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Geometry(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_display.disown_Geometry(self)
        return weakref_proxy(self)
Geometry_swigregister = _IMP_display.Geometry_swigregister
Geometry_swigregister(Geometry)

class GeometrySet(Geometry):
    """Proxy of C++ IMP::display::GeometrySet class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeometrySet, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GeometrySet, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::GeometrySet self, IMP::display::Geometries const & v) -> GeometrySet
        __init__(IMP::display::GeometrySet self, IMP::display::Geometries const & v, Color c) -> GeometrySet
        __init__(IMP::display::GeometrySet self, IMP::display::Geometries const & v, std::string const n) -> GeometrySet
        __init__(IMP::display::GeometrySet self, IMP::display::Geometries const & v, Color c, std::string n) -> GeometrySet
        """
        this = _IMP_display.new_GeometrySet(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(GeometrySet self) -> IMP::display::Geometries"""
        return _IMP_display.GeometrySet_get_geometry(self)

    def get_version_info(self):
        """get_version_info(GeometrySet self) -> VersionInfo"""
        return _IMP_display.GeometrySet_get_version_info(self)

    def __str__(self):
        """__str__(GeometrySet self) -> std::string"""
        return _IMP_display.GeometrySet___str__(self)

    def __repr__(self):
        """__repr__(GeometrySet self) -> std::string"""
        return _IMP_display.GeometrySet___repr__(self)

    def get_from(o):
       return _object_cast_to_GeometrySet(o)
    get_from = staticmethod(get_from)

GeometrySet_swigregister = _IMP_display.GeometrySet_swigregister
GeometrySet_swigregister(GeometrySet)

class SphereGeometry(Geometry):
    """Proxy of C++ IMP::display::SphereGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SphereGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SphereGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::SphereGeometry self, Sphere3D v) -> SphereGeometry
        __init__(IMP::display::SphereGeometry self, Sphere3D v, Color c) -> SphereGeometry
        __init__(IMP::display::SphereGeometry self, Sphere3D v, std::string const n) -> SphereGeometry
        __init__(IMP::display::SphereGeometry self, Sphere3D v, Color c, std::string n) -> SphereGeometry
        """
        this = _IMP_display.new_SphereGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(SphereGeometry self) -> Sphere3D"""
        return _IMP_display.SphereGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(SphereGeometry self, Sphere3D v)"""
        return _IMP_display.SphereGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(SphereGeometry self) -> VersionInfo"""
        return _IMP_display.SphereGeometry_get_version_info(self)

    def __str__(self):
        """__str__(SphereGeometry self) -> std::string"""
        return _IMP_display.SphereGeometry___str__(self)

    def __repr__(self):
        """__repr__(SphereGeometry self) -> std::string"""
        return _IMP_display.SphereGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_SphereGeometry(o)
    get_from = staticmethod(get_from)

SphereGeometry_swigregister = _IMP_display.SphereGeometry_swigregister
SphereGeometry_swigregister(SphereGeometry)

class CylinderGeometry(Geometry):
    """Proxy of C++ IMP::display::CylinderGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CylinderGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CylinderGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::CylinderGeometry self, Cylinder3D v) -> CylinderGeometry
        __init__(IMP::display::CylinderGeometry self, Cylinder3D v, Color c) -> CylinderGeometry
        __init__(IMP::display::CylinderGeometry self, Cylinder3D v, std::string const n) -> CylinderGeometry
        __init__(IMP::display::CylinderGeometry self, Cylinder3D v, Color c, std::string n) -> CylinderGeometry
        """
        this = _IMP_display.new_CylinderGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(CylinderGeometry self) -> Cylinder3D"""
        return _IMP_display.CylinderGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(CylinderGeometry self, Cylinder3D v)"""
        return _IMP_display.CylinderGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(CylinderGeometry self) -> VersionInfo"""
        return _IMP_display.CylinderGeometry_get_version_info(self)

    def __str__(self):
        """__str__(CylinderGeometry self) -> std::string"""
        return _IMP_display.CylinderGeometry___str__(self)

    def __repr__(self):
        """__repr__(CylinderGeometry self) -> std::string"""
        return _IMP_display.CylinderGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_CylinderGeometry(o)
    get_from = staticmethod(get_from)

CylinderGeometry_swigregister = _IMP_display.CylinderGeometry_swigregister
CylinderGeometry_swigregister(CylinderGeometry)

class EllipsoidGeometry(Geometry):
    """Proxy of C++ IMP::display::EllipsoidGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EllipsoidGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EllipsoidGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::EllipsoidGeometry self, Ellipsoid3D v) -> EllipsoidGeometry
        __init__(IMP::display::EllipsoidGeometry self, Ellipsoid3D v, Color c) -> EllipsoidGeometry
        __init__(IMP::display::EllipsoidGeometry self, Ellipsoid3D v, std::string const n) -> EllipsoidGeometry
        __init__(IMP::display::EllipsoidGeometry self, Ellipsoid3D v, Color c, std::string n) -> EllipsoidGeometry
        """
        this = _IMP_display.new_EllipsoidGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(EllipsoidGeometry self) -> Ellipsoid3D"""
        return _IMP_display.EllipsoidGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(EllipsoidGeometry self, Ellipsoid3D v)"""
        return _IMP_display.EllipsoidGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(EllipsoidGeometry self) -> VersionInfo"""
        return _IMP_display.EllipsoidGeometry_get_version_info(self)

    def __str__(self):
        """__str__(EllipsoidGeometry self) -> std::string"""
        return _IMP_display.EllipsoidGeometry___str__(self)

    def __repr__(self):
        """__repr__(EllipsoidGeometry self) -> std::string"""
        return _IMP_display.EllipsoidGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_EllipsoidGeometry(o)
    get_from = staticmethod(get_from)

EllipsoidGeometry_swigregister = _IMP_display.EllipsoidGeometry_swigregister
EllipsoidGeometry_swigregister(EllipsoidGeometry)

class PointGeometry(Geometry):
    """Proxy of C++ IMP::display::PointGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::PointGeometry self, Vector3D v) -> PointGeometry
        __init__(IMP::display::PointGeometry self, Vector3D v, Color c) -> PointGeometry
        __init__(IMP::display::PointGeometry self, Vector3D v, std::string const n) -> PointGeometry
        __init__(IMP::display::PointGeometry self, Vector3D v, Color c, std::string n) -> PointGeometry
        """
        this = _IMP_display.new_PointGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(PointGeometry self) -> Vector3D"""
        return _IMP_display.PointGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(PointGeometry self, Vector3D v)"""
        return _IMP_display.PointGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(PointGeometry self) -> VersionInfo"""
        return _IMP_display.PointGeometry_get_version_info(self)

    def __str__(self):
        """__str__(PointGeometry self) -> std::string"""
        return _IMP_display.PointGeometry___str__(self)

    def __repr__(self):
        """__repr__(PointGeometry self) -> std::string"""
        return _IMP_display.PointGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_PointGeometry(o)
    get_from = staticmethod(get_from)

PointGeometry_swigregister = _IMP_display.PointGeometry_swigregister
PointGeometry_swigregister(PointGeometry)

class SegmentGeometry(Geometry):
    """Proxy of C++ IMP::display::SegmentGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SegmentGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SegmentGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::SegmentGeometry self, Segment3D v) -> SegmentGeometry
        __init__(IMP::display::SegmentGeometry self, Segment3D v, Color c) -> SegmentGeometry
        __init__(IMP::display::SegmentGeometry self, Segment3D v, std::string const n) -> SegmentGeometry
        __init__(IMP::display::SegmentGeometry self, Segment3D v, Color c, std::string n) -> SegmentGeometry
        """
        this = _IMP_display.new_SegmentGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(SegmentGeometry self) -> Segment3D"""
        return _IMP_display.SegmentGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(SegmentGeometry self, Segment3D v)"""
        return _IMP_display.SegmentGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(SegmentGeometry self) -> VersionInfo"""
        return _IMP_display.SegmentGeometry_get_version_info(self)

    def __str__(self):
        """__str__(SegmentGeometry self) -> std::string"""
        return _IMP_display.SegmentGeometry___str__(self)

    def __repr__(self):
        """__repr__(SegmentGeometry self) -> std::string"""
        return _IMP_display.SegmentGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_SegmentGeometry(o)
    get_from = staticmethod(get_from)

SegmentGeometry_swigregister = _IMP_display.SegmentGeometry_swigregister
SegmentGeometry_swigregister(SegmentGeometry)

class PolygonGeometry(Geometry):
    """Proxy of C++ IMP::display::PolygonGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PolygonGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PolygonGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::PolygonGeometry self, IMP::algebra::Vector3Ds const & v) -> PolygonGeometry
        __init__(IMP::display::PolygonGeometry self, IMP::algebra::Vector3Ds const & v, Color c) -> PolygonGeometry
        __init__(IMP::display::PolygonGeometry self, IMP::algebra::Vector3Ds const & v, std::string const n) -> PolygonGeometry
        __init__(IMP::display::PolygonGeometry self, IMP::algebra::Vector3Ds const & v, Color c, std::string n) -> PolygonGeometry
        """
        this = _IMP_display.new_PolygonGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(PolygonGeometry self) -> IMP::algebra::Vector3Ds const &"""
        return _IMP_display.PolygonGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(PolygonGeometry self, IMP::algebra::Vector3Ds const & v)"""
        return _IMP_display.PolygonGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(PolygonGeometry self) -> VersionInfo"""
        return _IMP_display.PolygonGeometry_get_version_info(self)

    def __str__(self):
        """__str__(PolygonGeometry self) -> std::string"""
        return _IMP_display.PolygonGeometry___str__(self)

    def __repr__(self):
        """__repr__(PolygonGeometry self) -> std::string"""
        return _IMP_display.PolygonGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_PolygonGeometry(o)
    get_from = staticmethod(get_from)

PolygonGeometry_swigregister = _IMP_display.PolygonGeometry_swigregister
PolygonGeometry_swigregister(PolygonGeometry)

class TriangleGeometry(Geometry):
    """Proxy of C++ IMP::display::TriangleGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TriangleGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TriangleGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::TriangleGeometry self, Triangle3D v) -> TriangleGeometry
        __init__(IMP::display::TriangleGeometry self, Triangle3D v, Color c) -> TriangleGeometry
        __init__(IMP::display::TriangleGeometry self, Triangle3D v, std::string const n) -> TriangleGeometry
        __init__(IMP::display::TriangleGeometry self, Triangle3D v, Color c, std::string n) -> TriangleGeometry
        """
        this = _IMP_display.new_TriangleGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(TriangleGeometry self) -> Triangle3D"""
        return _IMP_display.TriangleGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(TriangleGeometry self, Triangle3D v)"""
        return _IMP_display.TriangleGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(TriangleGeometry self) -> VersionInfo"""
        return _IMP_display.TriangleGeometry_get_version_info(self)

    def __str__(self):
        """__str__(TriangleGeometry self) -> std::string"""
        return _IMP_display.TriangleGeometry___str__(self)

    def __repr__(self):
        """__repr__(TriangleGeometry self) -> std::string"""
        return _IMP_display.TriangleGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_TriangleGeometry(o)
    get_from = staticmethod(get_from)

TriangleGeometry_swigregister = _IMP_display.TriangleGeometry_swigregister
TriangleGeometry_swigregister(TriangleGeometry)

class BoundingBoxGeometry(Geometry):
    """Proxy of C++ IMP::display::BoundingBoxGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoundingBoxGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoundingBoxGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::BoundingBoxGeometry self, BoundingBox3D v) -> BoundingBoxGeometry
        __init__(IMP::display::BoundingBoxGeometry self, BoundingBox3D v, Color c) -> BoundingBoxGeometry
        __init__(IMP::display::BoundingBoxGeometry self, BoundingBox3D v, std::string const n) -> BoundingBoxGeometry
        __init__(IMP::display::BoundingBoxGeometry self, BoundingBox3D v, Color c, std::string n) -> BoundingBoxGeometry
        """
        this = _IMP_display.new_BoundingBoxGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(BoundingBoxGeometry self) -> BoundingBox3D"""
        return _IMP_display.BoundingBoxGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(BoundingBoxGeometry self, BoundingBox3D v)"""
        return _IMP_display.BoundingBoxGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(BoundingBoxGeometry self) -> VersionInfo"""
        return _IMP_display.BoundingBoxGeometry_get_version_info(self)

    def __str__(self):
        """__str__(BoundingBoxGeometry self) -> std::string"""
        return _IMP_display.BoundingBoxGeometry___str__(self)

    def __repr__(self):
        """__repr__(BoundingBoxGeometry self) -> std::string"""
        return _IMP_display.BoundingBoxGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_BoundingBoxGeometry(o)
    get_from = staticmethod(get_from)

BoundingBoxGeometry_swigregister = _IMP_display.BoundingBoxGeometry_swigregister
BoundingBoxGeometry_swigregister(BoundingBoxGeometry)

class ReferenceFrameGeometry(Geometry):
    """Proxy of C++ IMP::display::ReferenceFrameGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceFrameGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ReferenceFrameGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::ReferenceFrameGeometry self, ReferenceFrame3D v) -> ReferenceFrameGeometry
        __init__(IMP::display::ReferenceFrameGeometry self, ReferenceFrame3D v, Color c) -> ReferenceFrameGeometry
        __init__(IMP::display::ReferenceFrameGeometry self, ReferenceFrame3D v, std::string const n) -> ReferenceFrameGeometry
        __init__(IMP::display::ReferenceFrameGeometry self, ReferenceFrame3D v, Color c, std::string n) -> ReferenceFrameGeometry
        """
        this = _IMP_display.new_ReferenceFrameGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_geometry(self):
        """get_geometry(ReferenceFrameGeometry self) -> ReferenceFrame3D"""
        return _IMP_display.ReferenceFrameGeometry_get_geometry(self)

    def set_geometry(self, *args):
        """set_geometry(ReferenceFrameGeometry self, ReferenceFrame3D v)"""
        return _IMP_display.ReferenceFrameGeometry_set_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(ReferenceFrameGeometry self) -> VersionInfo"""
        return _IMP_display.ReferenceFrameGeometry_get_version_info(self)

    def __str__(self):
        """__str__(ReferenceFrameGeometry self) -> std::string"""
        return _IMP_display.ReferenceFrameGeometry___str__(self)

    def __repr__(self):
        """__repr__(ReferenceFrameGeometry self) -> std::string"""
        return _IMP_display.ReferenceFrameGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_ReferenceFrameGeometry(o)
    get_from = staticmethod(get_from)

ReferenceFrameGeometry_swigregister = _IMP_display.ReferenceFrameGeometry_swigregister
ReferenceFrameGeometry_swigregister(ReferenceFrameGeometry)


def create_geometry(*args):
  """
    create_geometry(Sphere3D t, std::string name="algebra::Sphere3D+%1%") -> SphereGeometry
    create_geometry(Sphere3D t) -> SphereGeometry
    create_geometry(Cylinder3D t, std::string name="algebra::Cylinder3D+%1%") -> CylinderGeometry
    create_geometry(Cylinder3D t) -> CylinderGeometry
    create_geometry(Ellipsoid3D t, std::string name="algebra::Ellipsoid3D+%1%") -> EllipsoidGeometry
    create_geometry(Ellipsoid3D t) -> EllipsoidGeometry
    create_geometry(Vector3D t, std::string name="algebra::Vector3D+%1%") -> PointGeometry
    create_geometry(Vector3D t) -> PointGeometry
    create_geometry(Segment3D t, std::string name="algebra::Segment3D+%1%") -> SegmentGeometry
    create_geometry(Segment3D t) -> SegmentGeometry
    create_geometry(IMP::algebra::Vector3Ds const & t, std::string name="algebra::Vector3Ds+%1%") -> PolygonGeometry
    create_geometry(IMP::algebra::Vector3Ds const & t) -> PolygonGeometry
    create_geometry(Triangle3D t, std::string name="algebra::Triangle3D+%1%") -> TriangleGeometry
    create_geometry(Triangle3D t) -> TriangleGeometry
    create_geometry(BoundingBox3D t, std::string name="algebra::BoundingBoxD<3>+%1%") -> BoundingBoxGeometry
    create_geometry(BoundingBox3D t) -> BoundingBoxGeometry
    create_geometry(ReferenceFrame3D t, std::string name="algebra::ReferenceFrame3D+%1%") -> ReferenceFrameGeometry
    create_geometry(ReferenceFrame3D t) -> ReferenceFrameGeometry
    """
  return _IMP_display.create_geometry(*args)
class LabelGeometry(Geometry):
    """Proxy of C++ IMP::display::LabelGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LabelGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LabelGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::LabelGeometry self, Sphere3D loc, std::string text) -> LabelGeometry
        __init__(IMP::display::LabelGeometry self, Vector3D loc, std::string text) -> LabelGeometry
        """
        this = _IMP_display.new_LabelGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_text(self):
        """get_text(LabelGeometry self) -> std::string"""
        return _IMP_display.LabelGeometry_get_text(self)

    def get_location(self):
        """get_location(LabelGeometry self) -> Sphere3D"""
        return _IMP_display.LabelGeometry_get_location(self)

    def get_version_info(self):
        """get_version_info(LabelGeometry self) -> VersionInfo"""
        return _IMP_display.LabelGeometry_get_version_info(self)

    def __str__(self):
        """__str__(LabelGeometry self) -> std::string"""
        return _IMP_display.LabelGeometry___str__(self)

    def __repr__(self):
        """__repr__(LabelGeometry self) -> std::string"""
        return _IMP_display.LabelGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_LabelGeometry(o)
    get_from = staticmethod(get_from)

LabelGeometry_swigregister = _IMP_display.LabelGeometry_swigregister
LabelGeometry_swigregister(LabelGeometry)

class SurfaceMeshGeometry(Geometry):
    """Proxy of C++ IMP::display::SurfaceMeshGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SurfaceMeshGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SurfaceMeshGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::SurfaceMeshGeometry self, IMP::algebra::Vector3Ds const & vertices, IMP::Ints const & faces) -> SurfaceMeshGeometry"""
        this = _IMP_display.new_SurfaceMeshGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_vertexes(self):
        """get_vertexes(SurfaceMeshGeometry self) -> IMP::algebra::Vector3Ds const &"""
        return _IMP_display.SurfaceMeshGeometry_get_vertexes(self)

    def get_faces(self):
        """get_faces(SurfaceMeshGeometry self) -> IMP::Ints const &"""
        return _IMP_display.SurfaceMeshGeometry_get_faces(self)

    def get_version_info(self):
        """get_version_info(SurfaceMeshGeometry self) -> VersionInfo"""
        return _IMP_display.SurfaceMeshGeometry_get_version_info(self)

    def __str__(self):
        """__str__(SurfaceMeshGeometry self) -> std::string"""
        return _IMP_display.SurfaceMeshGeometry___str__(self)

    def __repr__(self):
        """__repr__(SurfaceMeshGeometry self) -> std::string"""
        return _IMP_display.SurfaceMeshGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_SurfaceMeshGeometry(o)
    get_from = staticmethod(get_from)

SurfaceMeshGeometry_swigregister = _IMP_display.SurfaceMeshGeometry_swigregister
SurfaceMeshGeometry_swigregister(SurfaceMeshGeometry)

class PlaneGeometry(Geometry):
    """Proxy of C++ IMP::display::PlaneGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlaneGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PlaneGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::PlaneGeometry self, Plane3D loc, BoundingBox3D box) -> PlaneGeometry"""
        this = _IMP_display.new_PlaneGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(PlaneGeometry self) -> VersionInfo"""
        return _IMP_display.PlaneGeometry_get_version_info(self)

    def __str__(self):
        """__str__(PlaneGeometry self) -> std::string"""
        return _IMP_display.PlaneGeometry___str__(self)

    def __repr__(self):
        """__repr__(PlaneGeometry self) -> std::string"""
        return _IMP_display.PlaneGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_PlaneGeometry(o)
    get_from = staticmethod(get_from)

PlaneGeometry_swigregister = _IMP_display.PlaneGeometry_swigregister
PlaneGeometry_swigregister(PlaneGeometry)

class IsosurfaceGeometry(SurfaceMeshGeometry):
    """Proxy of C++ IMP::display::IsosurfaceGeometry class"""
    __swig_setmethods__ = {}
    for _s in [SurfaceMeshGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IsosurfaceGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [SurfaceMeshGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IsosurfaceGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::IsosurfaceGeometry self, IMP::algebra::GridD< 3,IMP::algebra::DenseGridStorageD< 3,double >,double,IMP::algebra::DefaultEmbeddingD< 3 > > const & grid, 
            double iso) -> IsosurfaceGeometry
        __init__(IMP::display::IsosurfaceGeometry self, IMP::algebra::GridD< 3,IMP::algebra::DenseGridStorageD< 3,float >,float,IMP::algebra::DefaultEmbeddingD< 3 > > const & grid, 
            double iso) -> IsosurfaceGeometry
        """
        this = _IMP_display.new_IsosurfaceGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(IsosurfaceGeometry self) -> std::string"""
        return _IMP_display.IsosurfaceGeometry___str__(self)

    def __repr__(self):
        """__repr__(IsosurfaceGeometry self) -> std::string"""
        return _IMP_display.IsosurfaceGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_IsosurfaceGeometry(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_display.delete_IsosurfaceGeometry
    __del__ = lambda self : None;
IsosurfaceGeometry_swigregister = _IMP_display.IsosurfaceGeometry_swigregister
IsosurfaceGeometry_swigregister(IsosurfaceGeometry)

class SkinSurfaceGeometry(SurfaceMeshGeometry):
    """Proxy of C++ IMP::display::SkinSurfaceGeometry class"""
    __swig_setmethods__ = {}
    for _s in [SurfaceMeshGeometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SkinSurfaceGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [SurfaceMeshGeometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SkinSurfaceGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::SkinSurfaceGeometry self, IMP::algebra::Sphere3Ds const & balls) -> SkinSurfaceGeometry"""
        this = _IMP_display.new_SkinSurfaceGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(SkinSurfaceGeometry self) -> std::string"""
        return _IMP_display.SkinSurfaceGeometry___str__(self)

    def __repr__(self):
        """__repr__(SkinSurfaceGeometry self) -> std::string"""
        return _IMP_display.SkinSurfaceGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_SkinSurfaceGeometry(o)
    get_from = staticmethod(get_from)

    __swig_destroy__ = _IMP_display.delete_SkinSurfaceGeometry
    __del__ = lambda self : None;
SkinSurfaceGeometry_swigregister = _IMP_display.SkinSurfaceGeometry_swigregister
SkinSurfaceGeometry_swigregister(SkinSurfaceGeometry)

class GeometryProcessor(_object):
    """Proxy of C++ IMP::display::GeometryProcessor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GeometryProcessor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GeometryProcessor, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::display::GeometryProcessor self) -> GeometryProcessor"""
        this = _IMP_display.new_GeometryProcessor()
        try: self.this.append(this)
        except: self.this = this
GeometryProcessor_swigregister = _IMP_display.GeometryProcessor_swigregister
GeometryProcessor_swigregister(GeometryProcessor)

class Writer(GeometryProcessor,IMP.base.Object):
    """Proxy of C++ IMP::display::Writer class"""
    __swig_setmethods__ = {}
    for _s in [GeometryProcessor,IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Writer, name, value)
    __swig_getmethods__ = {}
    for _s in [GeometryProcessor,IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Writer, name)
    def __init__(self, *args): 
        """__init__(IMP::display::Writer self, std::string name) -> Writer"""
        if self.__class__ == Writer:
            _self = None
        else:
            _self = self
        this = _IMP_display.new_Writer(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Writer:
            import IMP.base
            IMP.base._director_objects.register(self)



    __swig_destroy__ = _IMP_display.delete_Writer
    __del__ = lambda self : None;
    def set_frame(self, *args):
        """set_frame(Writer self, unsigned int i)"""
        return _IMP_display.Writer_set_frame(self, *args)

    def get_frame(self):
        """get_frame(Writer self) -> int"""
        return _IMP_display.Writer_get_frame(self)

    def add_geometry(self, *args):
        """
        add_geometry(Writer self, Geometry g)
        add_geometry(Writer self, IMP::display::Geometries const & g)
        """
        return _IMP_display.Writer_add_geometry(self, *args)

    def do_close(self):
        """do_close(Writer self)"""
        return _IMP_display.Writer_do_close(self)

    def do_open(self):
        """do_open(Writer self)"""
        return _IMP_display.Writer_do_open(self)

    def do_set_frame(self):
        """do_set_frame(Writer self)"""
        return _IMP_display.Writer_do_set_frame(self)

    def __str__(self):
        """__str__(Writer self) -> std::string"""
        return _IMP_display.Writer___str__(self)

    def __repr__(self):
        """__repr__(Writer self) -> std::string"""
        return _IMP_display.Writer___repr__(self)

    def get_from(o):
       return _object_cast_to_Writer(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::display" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_Writer(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_display.disown_Writer(self)
        return weakref_proxy(self)
    def handle_sphere(self, *args):
        """handle_sphere(Writer self, SphereGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_sphere(self, *args)

    def handle_cylinder(self, *args):
        """handle_cylinder(Writer self, CylinderGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_cylinder(self, *args)

    def handle_point(self, *args):
        """handle_point(Writer self, PointGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_point(self, *args)

    def handle_segment(self, *args):
        """handle_segment(Writer self, SegmentGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_segment(self, *args)

    def handle_polygon(self, *args):
        """handle_polygon(Writer self, PolygonGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_polygon(self, *args)

    def handle_triangle(self, *args):
        """handle_triangle(Writer self, TriangleGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_triangle(self, *args)

    def handle_surface_mesh(self, *args):
        """handle_surface_mesh(Writer self, SurfaceMeshGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_surface_mesh(self, *args)

    def handle_label(self, *args):
        """handle_label(Writer self, LabelGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_label(self, *args)

    def handle_ellipsoid(self, *args):
        """handle_ellipsoid(Writer self, EllipsoidGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_ellipsoid(self, *args)

    def handle_bounding_box(self, *args):
        """handle_bounding_box(Writer self, BoundingBoxGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_bounding_box(self, *args)

    def handle_anything(self, *args):
        """handle_anything(Writer self, Geometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_anything(self, *args)

Writer_swigregister = _IMP_display.Writer_swigregister
Writer_swigregister(Writer)

class TextWriter(Writer):
    """Proxy of C++ IMP::display::TextWriter class"""
    __swig_setmethods__ = {}
    for _s in [Writer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [Writer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TextWriter, name)
    def open(self):
        """open(TextWriter self)"""
        return _IMP_display.TextWriter_open(self)

    def get_stream(self):
        """get_stream(TextWriter self) -> _ostream"""
        return _IMP_display.TextWriter_get_stream(self)

    def do_set_frame(self):
        """do_set_frame(TextWriter self)"""
        return _IMP_display.TextWriter_do_set_frame(self)

    def __init__(self, *args): 
        """
        __init__(IMP::display::TextWriter self, TextOutput fn) -> TextWriter
        __init__(IMP::display::TextWriter self, std::string name) -> TextWriter
        """
        if self.__class__ == TextWriter:
            _self = None
        else:
            _self = self
        this = _IMP_display.new_TextWriter(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != TextWriter:
            import IMP.base
            IMP.base._director_objects.register(self)



    def get_current_file_name(self):
        """get_current_file_name(TextWriter self) -> std::string"""
        return _IMP_display.TextWriter_get_current_file_name(self)

    __swig_destroy__ = _IMP_display.delete_TextWriter
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TextWriter self) -> std::string"""
        return _IMP_display.TextWriter___str__(self)

    def __repr__(self):
        """__repr__(TextWriter self) -> std::string"""
        return _IMP_display.TextWriter___repr__(self)

    def get_from(o):
       return _object_cast_to_TextWriter(o)
    get_from = staticmethod(get_from)

    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::display" == "IMP":
          return VersionInfo("python", "0")
        else:
          return IMP.VersionInfo("python", "0")
    def get_from(o):
       return _object_cast_to_TextWriter(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_display.disown_TextWriter(self)
        return weakref_proxy(self)
    def handle_sphere(self, *args):
        """handle_sphere(TextWriter self, SphereGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_sphere(self, *args)

    def handle_cylinder(self, *args):
        """handle_cylinder(TextWriter self, CylinderGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_cylinder(self, *args)

    def handle_point(self, *args):
        """handle_point(TextWriter self, PointGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_point(self, *args)

    def handle_segment(self, *args):
        """handle_segment(TextWriter self, SegmentGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_segment(self, *args)

    def handle_polygon(self, *args):
        """handle_polygon(TextWriter self, PolygonGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_polygon(self, *args)

    def handle_triangle(self, *args):
        """handle_triangle(TextWriter self, TriangleGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_triangle(self, *args)

    def handle_surface_mesh(self, *args):
        """handle_surface_mesh(TextWriter self, SurfaceMeshGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_surface_mesh(self, *args)

    def handle_label(self, *args):
        """handle_label(TextWriter self, LabelGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_label(self, *args)

    def handle_ellipsoid(self, *args):
        """handle_ellipsoid(TextWriter self, EllipsoidGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_ellipsoid(self, *args)

    def handle_bounding_box(self, *args):
        """handle_bounding_box(TextWriter self, BoundingBoxGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_bounding_box(self, *args)

    def handle_anything(self, *args):
        """handle_anything(TextWriter self, Geometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_anything(self, *args)

    def do_close(self):
        """do_close(TextWriter self)"""
        return _IMP_display.TextWriter_do_close(self)

    def do_open(self):
        """do_open(TextWriter self)"""
        return _IMP_display.TextWriter_do_open(self)

TextWriter_swigregister = _IMP_display.TextWriter_swigregister
TextWriter_swigregister(TextWriter)


def create_writer(*args):
  """create_writer(std::string filename) -> Writer"""
  return _IMP_display.create_writer(*args)
class WriterAdaptor(IMP.base._InputAdaptor):
    """Proxy of C++ IMP::display::WriterAdaptor class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriterAdaptor, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base._InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WriterAdaptor, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::WriterAdaptor self, std::string name) -> WriterAdaptor
        __init__(IMP::display::WriterAdaptor self, Writer w) -> WriterAdaptor
        """
        this = _IMP_display.new_WriterAdaptor(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_writer(self):
        """get_writer(WriterAdaptor self) -> Writer"""
        return _IMP_display.WriterAdaptor_get_writer(self)

    def show(self, *args):
        """
        show(WriterAdaptor self, _ostream out=std::cout)
        show(WriterAdaptor self)
        """
        return _IMP_display.WriterAdaptor_show(self, *args)

    __swig_destroy__ = _IMP_display.delete_WriterAdaptor
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(WriterAdaptor self) -> std::string"""
        return _IMP_display.WriterAdaptor___str__(self)

    def __repr__(self):
        """__repr__(WriterAdaptor self) -> std::string"""
        return _IMP_display.WriterAdaptor___repr__(self)

WriterAdaptor_swigregister = _IMP_display.WriterAdaptor_swigregister
WriterAdaptor_swigregister(WriterAdaptor)

class ChimeraWriter(TextWriter):
    """Proxy of C++ IMP::display::ChimeraWriter class"""
    __swig_setmethods__ = {}
    for _s in [TextWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChimeraWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [TextWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChimeraWriter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::ChimeraWriter self, TextOutput of) -> ChimeraWriter
        __init__(IMP::display::ChimeraWriter self, std::string name) -> ChimeraWriter
        __init__(IMP::display::ChimeraWriter self, char const * name) -> ChimeraWriter
        """
        this = _IMP_display.new_ChimeraWriter(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(ChimeraWriter self) -> VersionInfo"""
        return _IMP_display.ChimeraWriter_get_version_info(self)

    def __str__(self):
        """__str__(ChimeraWriter self) -> std::string"""
        return _IMP_display.ChimeraWriter___str__(self)

    def __repr__(self):
        """__repr__(ChimeraWriter self) -> std::string"""
        return _IMP_display.ChimeraWriter___repr__(self)

    def get_from(o):
       return _object_cast_to_ChimeraWriter(o)
    get_from = staticmethod(get_from)

ChimeraWriter_swigregister = _IMP_display.ChimeraWriter_swigregister
ChimeraWriter_swigregister(ChimeraWriter)

class Colored(IMP.kernel.Decorator):
    """Proxy of C++ IMP::display::Colored class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Colored, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Colored, name)
    def set_color(self, *args):
        """set_color(Colored self, Color c)"""
        return _IMP_display.Colored_set_color(self, *args)

    def get_color(self):
        """get_color(Colored self) -> Color"""
        return _IMP_display.Colored_get_color(self)

    def get_color_keys():
        """get_color_keys() -> IMP::kernel::FloatKeys const &"""
        return _IMP_display.Colored_get_color_keys()

    if _newclass:get_color_keys = staticmethod(get_color_keys)
    __swig_getmethods__["get_color_keys"] = lambda x: get_color_keys
    def __init__(self, *args): 
        """
        __init__(IMP::display::Colored self) -> Colored
        __init__(IMP::display::Colored self, Model m, ::IMP::kernel::ParticleIndex id) -> Colored
        __init__(IMP::display::Colored self, _ParticleAdaptor d) -> Colored
        """
        this = _IMP_display.new_Colored(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> Colored"""
        return _IMP_display.Colored_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def get_is_setup(*args):
        """
        get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_display.Colored_get_is_setup(*args)

    if _newclass:get_is_setup = staticmethod(get_is_setup)
    __swig_getmethods__["get_is_setup"] = lambda x: get_is_setup
    def show(self, *args):
        """
        show(Colored self, _ostream out=std::cout)
        show(Colored self)
        """
        return _IMP_display.Colored_show(self, *args)

    def setup_particle(*args):
        """
        setup_particle(Model m, IMP::kernel::ParticleIndex pi, Color color) -> Colored
        setup_particle(_ParticleAdaptor decorator, Color color) -> Colored
        """
        return _IMP_display.Colored_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def add_attribute(self, *args):
        """
        add_attribute(Colored self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(Colored self, FloatKey a0, IMP::Float a1)
        add_attribute(Colored self, IntKey a0, IMP::Int a1)
        add_attribute(Colored self, StringKey a0, IMP::String a1)
        add_attribute(Colored self, ParticleIndexKey a0, Particle a1)
        add_attribute(Colored self, ObjectKey a0, Object a1)
        """
        return _IMP_display.Colored_add_attribute(self, *args)

    def get_value(self, *args):
        """
        get_value(Colored self, FloatKey a0) -> IMP::Float
        get_value(Colored self, IntKey a0) -> IMP::Int
        get_value(Colored self, StringKey a0) -> IMP::String
        get_value(Colored self, ParticleIndexKey a0) -> Particle
        get_value(Colored self, ObjectKey a0) -> Object
        """
        return _IMP_display.Colored_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(Colored self, FloatKey a0, IMP::Float a1)
        set_value(Colored self, IntKey a0, IMP::Int a1)
        set_value(Colored self, StringKey a0, IMP::String a1)
        set_value(Colored self, ParticleIndexKey a0, Particle a1)
        set_value(Colored self, ObjectKey a0, Object a1)
        """
        return _IMP_display.Colored_set_value(self, *args)

    def remove_attribute(self, *args):
        """
        remove_attribute(Colored self, FloatKey a0)
        remove_attribute(Colored self, IntKey a0)
        remove_attribute(Colored self, StringKey a0)
        remove_attribute(Colored self, ParticleIndexKey a0)
        remove_attribute(Colored self, ObjectKey a0)
        """
        return _IMP_display.Colored_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(Colored self, FloatKey a0) -> bool
        has_attribute(Colored self, IntKey a0) -> bool
        has_attribute(Colored self, StringKey a0) -> bool
        has_attribute(Colored self, ParticleIndexKey a0) -> bool
        has_attribute(Colored self, ObjectKey a0) -> bool
        """
        return _IMP_display.Colored_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(Colored self, FloatKey a0) -> double"""
        return _IMP_display.Colored_get_derivative(self, *args)

    def get_name(self):
        """get_name(Colored self) -> std::string"""
        return _IMP_display.Colored_get_name(self)

    def clear_caches(self):
        """clear_caches(Colored self)"""
        return _IMP_display.Colored_clear_caches(self)

    def set_name(self, *args):
        """set_name(Colored self, std::string a0)"""
        return _IMP_display.Colored_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Colored self, IMP::base::CheckLevel a0)"""
        return _IMP_display.Colored_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(Colored self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_display.Colored_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(Colored self, FloatKey a0, bool a1)"""
        return _IMP_display.Colored_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(Colored self, FloatKey a0) -> bool"""
        return _IMP_display.Colored_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(Colored self) -> IMP::base::CheckLevel"""
        return _IMP_display.Colored_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(Colored self, Colored o) -> bool
        __eq__(Colored self, Particle d) -> bool
        """
        return _IMP_display.Colored___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(Colored self, Colored o) -> bool
        __ne__(Colored self, Particle d) -> bool
        """
        return _IMP_display.Colored___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(Colored self, Colored o) -> bool
        __le__(Colored self, Particle d) -> bool
        """
        return _IMP_display.Colored___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(Colored self, Colored o) -> bool
        __lt__(Colored self, Particle d) -> bool
        """
        return _IMP_display.Colored___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(Colored self, Colored o) -> bool
        __ge__(Colored self, Particle d) -> bool
        """
        return _IMP_display.Colored___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(Colored self, Colored o) -> bool
        __gt__(Colored self, Particle d) -> bool
        """
        return _IMP_display.Colored___gt__(self, *args)

    def __str__(self):
        """__str__(Colored self) -> std::string"""
        return _IMP_display.Colored___str__(self)

    def __repr__(self):
        """__repr__(Colored self) -> std::string"""
        return _IMP_display.Colored___repr__(self)

    __swig_destroy__ = _IMP_display.delete_Colored
    __del__ = lambda self : None;
Colored_swigregister = _IMP_display.Colored_swigregister
Colored_swigregister(Colored)

def Colored_get_color_keys():
  """Colored_get_color_keys() -> IMP::kernel::FloatKeys const &"""
  return _IMP_display.Colored_get_color_keys()

def Colored_decorate_particle(*args):
  """Colored_decorate_particle(Particle p) -> Colored"""
  return _IMP_display.Colored_decorate_particle(*args)

def Colored_get_is_setup(*args):
  """
    get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
    Colored_get_is_setup(_ParticleAdaptor p) -> bool
    """
  return _IMP_display.Colored_get_is_setup(*args)

def Colored_setup_particle(*args):
  """
    setup_particle(Model m, IMP::kernel::ParticleIndex pi, Color color) -> Colored
    Colored_setup_particle(_ParticleAdaptor decorator, Color color) -> Colored
    """
  return _IMP_display.Colored_setup_particle(*args)


def __lshift__(*args):
  """__lshift__(_ostream out, Colored n) -> _ostream"""
  return _IMP_display.__lshift__(*args)
class FilterGeometry(GeometryProcessor,Geometry):
    """Proxy of C++ IMP::display::FilterGeometry class"""
    __swig_setmethods__ = {}
    for _s in [GeometryProcessor,Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilterGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [GeometryProcessor,Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilterGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::FilterGeometry self, Plane3D p) -> FilterGeometry"""
        this = _IMP_display.new_FilterGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_geometry(self, *args):
        """
        add_geometry(FilterGeometry self, Geometry g)
        add_geometry(FilterGeometry self, IMP::display::Geometries const & g)
        """
        return _IMP_display.FilterGeometry_add_geometry(self, *args)

    def get_version_info(self):
        """get_version_info(FilterGeometry self) -> VersionInfo"""
        return _IMP_display.FilterGeometry_get_version_info(self)

    def __str__(self):
        """__str__(FilterGeometry self) -> std::string"""
        return _IMP_display.FilterGeometry___str__(self)

    def __repr__(self):
        """__repr__(FilterGeometry self) -> std::string"""
        return _IMP_display.FilterGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_FilterGeometry(o)
    get_from = staticmethod(get_from)

FilterGeometry_swigregister = _IMP_display.FilterGeometry_swigregister
FilterGeometry_swigregister(FilterGeometry)

class WriteOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::display::WriteOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriteOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WriteOptimizerState, name)
    def __init__(self, *args): 
        """__init__(IMP::display::WriteOptimizerState self, Model m, WriterAdaptor w) -> WriteOptimizerState"""
        this = _IMP_display.new_WriteOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def write(self, *args):
        """write(WriteOptimizerState self, WriterAdaptor w)"""
        return _IMP_display.WriteOptimizerState_write(self, *args)

    def remove_geometry(self, *args):
        """remove_geometry(WriteOptimizerState self, Geometry d)"""
        return _IMP_display.WriteOptimizerState_remove_geometry(self, *args)

    def remove_geometries(self, *args):
        """remove_geometries(WriteOptimizerState self, IMP::display::Geometries const & d)"""
        return _IMP_display.WriteOptimizerState_remove_geometries(self, *args)

    def set_geometries(self, *args):
        """set_geometries(WriteOptimizerState self, IMP::display::Geometries const & ps)"""
        return _IMP_display.WriteOptimizerState_set_geometries(self, *args)

    def set_geometries_order(self, *args):
        """set_geometries_order(WriteOptimizerState self, IMP::display::Geometries const & objs)"""
        return _IMP_display.WriteOptimizerState_set_geometries_order(self, *args)

    def add_geometry(self, *args):
        """add_geometry(WriteOptimizerState self, Geometry obj) -> unsigned int"""
        return _IMP_display.WriteOptimizerState_add_geometry(self, *args)

    def add_geometries(self, *args):
        """add_geometries(WriteOptimizerState self, IMP::display::Geometries const & objs)"""
        return _IMP_display.WriteOptimizerState_add_geometries(self, *args)

    def clear_geometries(self):
        """clear_geometries(WriteOptimizerState self)"""
        return _IMP_display.WriteOptimizerState_clear_geometries(self)

    def get_number_of_geometries(self):
        """get_number_of_geometries(WriteOptimizerState self) -> unsigned int"""
        return _IMP_display.WriteOptimizerState_get_number_of_geometries(self)

    def get_has_geometries(self):
        """get_has_geometries(WriteOptimizerState self) -> bool"""
        return _IMP_display.WriteOptimizerState_get_has_geometries(self)

    def get_geometry(self, *args):
        """get_geometry(WriteOptimizerState self, unsigned int i) -> Geometry"""
        return _IMP_display.WriteOptimizerState_get_geometry(self, *args)

    def get_geometries(self):
        """get_geometries(WriteOptimizerState self) -> IMP::display::Geometries"""
        return _IMP_display.WriteOptimizerState_get_geometries(self)

    def reserve_geometries(self, *args):
        """reserve_geometries(WriteOptimizerState self, unsigned int sz)"""
        return _IMP_display.WriteOptimizerState_reserve_geometries(self, *args)

    def get_version_info(self):
        """get_version_info(WriteOptimizerState self) -> VersionInfo"""
        return _IMP_display.WriteOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(WriteOptimizerState self) -> std::string"""
        return _IMP_display.WriteOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(WriteOptimizerState self) -> std::string"""
        return _IMP_display.WriteOptimizerState___repr__(self)

    def get_from(o):
       return _object_cast_to_WriteOptimizerState(o)
    get_from = staticmethod(get_from)

WriteOptimizerState_swigregister = _IMP_display.WriteOptimizerState_swigregister
WriteOptimizerState_swigregister(WriteOptimizerState)

class SingletonGeometry(Geometry):
    """Proxy of C++ IMP::display::SingletonGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::SingletonGeometry self, Particle p) -> SingletonGeometry"""
        this = _IMP_display.new_SingletonGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_particle(self):
        """get_particle(SingletonGeometry self) -> Particle"""
        return _IMP_display.SingletonGeometry_get_particle(self)

    __swig_destroy__ = _IMP_display.delete_SingletonGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SingletonGeometry self) -> std::string"""
        return _IMP_display.SingletonGeometry___str__(self)

    def __repr__(self):
        """__repr__(SingletonGeometry self) -> std::string"""
        return _IMP_display.SingletonGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonGeometry(o)
    get_from = staticmethod(get_from)

SingletonGeometry_swigregister = _IMP_display.SingletonGeometry_swigregister
SingletonGeometry_swigregister(SingletonGeometry)

class SingletonsGeometry(Geometry):
    """Proxy of C++ IMP::display::SingletonsGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonsGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonsGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::SingletonsGeometry self, SingletonContainer pc, Color c) -> SingletonsGeometry
        __init__(IMP::display::SingletonsGeometry self, SingletonContainer pc) -> SingletonsGeometry
        """
        this = _IMP_display.new_SingletonsGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_container(self):
        """get_container(SingletonsGeometry self) -> SingletonContainer"""
        return _IMP_display.SingletonsGeometry_get_container(self)

    __swig_destroy__ = _IMP_display.delete_SingletonsGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SingletonsGeometry self) -> std::string"""
        return _IMP_display.SingletonsGeometry___str__(self)

    def __repr__(self):
        """__repr__(SingletonsGeometry self) -> std::string"""
        return _IMP_display.SingletonsGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_SingletonsGeometry(o)
    get_from = staticmethod(get_from)

SingletonsGeometry_swigregister = _IMP_display.SingletonsGeometry_swigregister
SingletonsGeometry_swigregister(SingletonsGeometry)

class PairGeometry(Geometry):
    """Proxy of C++ IMP::display::PairGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::PairGeometry self, IMP::kernel::ParticlePair const & pp) -> PairGeometry"""
        this = _IMP_display.new_PairGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_particle_pair(self):
        """get_particle_pair(PairGeometry self) -> IMP::kernel::ParticlePair"""
        return _IMP_display.PairGeometry_get_particle_pair(self)

    __swig_destroy__ = _IMP_display.delete_PairGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PairGeometry self) -> std::string"""
        return _IMP_display.PairGeometry___str__(self)

    def __repr__(self):
        """__repr__(PairGeometry self) -> std::string"""
        return _IMP_display.PairGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_PairGeometry(o)
    get_from = staticmethod(get_from)

PairGeometry_swigregister = _IMP_display.PairGeometry_swigregister
PairGeometry_swigregister(PairGeometry)

class PairsGeometry(Geometry):
    """Proxy of C++ IMP::display::PairsGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairsGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairsGeometry, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::PairsGeometry self, PairContainer pc, Color c) -> PairsGeometry
        __init__(IMP::display::PairsGeometry self, PairContainer pc) -> PairsGeometry
        """
        this = _IMP_display.new_PairsGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_container(self):
        """get_container(PairsGeometry self) -> PairContainer"""
        return _IMP_display.PairsGeometry_get_container(self)

    __swig_destroy__ = _IMP_display.delete_PairsGeometry
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(PairsGeometry self) -> std::string"""
        return _IMP_display.PairsGeometry___str__(self)

    def __repr__(self):
        """__repr__(PairsGeometry self) -> std::string"""
        return _IMP_display.PairsGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_PairsGeometry(o)
    get_from = staticmethod(get_from)

PairsGeometry_swigregister = _IMP_display.PairsGeometry_swigregister
PairsGeometry_swigregister(PairsGeometry)

class PymolWriter(TextWriter):
    """Proxy of C++ IMP::display::PymolWriter class"""
    __swig_setmethods__ = {}
    for _s in [TextWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PymolWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [TextWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PymolWriter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::display::PymolWriter self, TextOutput of) -> PymolWriter
        __init__(IMP::display::PymolWriter self, std::string name) -> PymolWriter
        __init__(IMP::display::PymolWriter self, char const * name) -> PymolWriter
        """
        this = _IMP_display.new_PymolWriter(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(PymolWriter self) -> VersionInfo"""
        return _IMP_display.PymolWriter_get_version_info(self)

    def __str__(self):
        """__str__(PymolWriter self) -> std::string"""
        return _IMP_display.PymolWriter___str__(self)

    def __repr__(self):
        """__repr__(PymolWriter self) -> std::string"""
        return _IMP_display.PymolWriter___repr__(self)

    def get_from(o):
       return _object_cast_to_PymolWriter(o)
    get_from = staticmethod(get_from)

PymolWriter_swigregister = _IMP_display.PymolWriter_swigregister
PymolWriter_swigregister(PymolWriter)

class RestraintGeometry(Geometry):
    """Proxy of C++ IMP::display::RestraintGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestraintGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestraintGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::RestraintGeometry self, Restraint p) -> RestraintGeometry"""
        this = _IMP_display.new_RestraintGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_restraint(self):
        """get_restraint(RestraintGeometry self) -> Restraint"""
        return _IMP_display.RestraintGeometry_get_restraint(self)

    def get_version_info(self):
        """get_version_info(RestraintGeometry self) -> VersionInfo"""
        return _IMP_display.RestraintGeometry_get_version_info(self)

    def __str__(self):
        """__str__(RestraintGeometry self) -> std::string"""
        return _IMP_display.RestraintGeometry___str__(self)

    def __repr__(self):
        """__repr__(RestraintGeometry self) -> std::string"""
        return _IMP_display.RestraintGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_RestraintGeometry(o)
    get_from = staticmethod(get_from)

RestraintGeometry_swigregister = _IMP_display.RestraintGeometry_swigregister
RestraintGeometry_swigregister(RestraintGeometry)

class RestraintSetGeometry(Geometry):
    """Proxy of C++ IMP::display::RestraintSetGeometry class"""
    __swig_setmethods__ = {}
    for _s in [Geometry]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RestraintSetGeometry, name, value)
    __swig_getmethods__ = {}
    for _s in [Geometry]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RestraintSetGeometry, name)
    def __init__(self, *args): 
        """__init__(IMP::display::RestraintSetGeometry self, RestraintSet p) -> RestraintSetGeometry"""
        this = _IMP_display.new_RestraintSetGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_restraint_set(self):
        """get_restraint_set(RestraintSetGeometry self) -> RestraintSet"""
        return _IMP_display.RestraintSetGeometry_get_restraint_set(self)

    def get_version_info(self):
        """get_version_info(RestraintSetGeometry self) -> VersionInfo"""
        return _IMP_display.RestraintSetGeometry_get_version_info(self)

    def __str__(self):
        """__str__(RestraintSetGeometry self) -> std::string"""
        return _IMP_display.RestraintSetGeometry___str__(self)

    def __repr__(self):
        """__repr__(RestraintSetGeometry self) -> std::string"""
        return _IMP_display.RestraintSetGeometry___repr__(self)

    def get_from(o):
       return _object_cast_to_RestraintSetGeometry(o)
    get_from = staticmethod(get_from)

RestraintSetGeometry_swigregister = _IMP_display.RestraintSetGeometry_swigregister
RestraintSetGeometry_swigregister(RestraintSetGeometry)

import _pivy
PivyWriter= _pivy.get_writer(Writer)
_object_types.append('PivyWriter')


def get_module_version():
  """get_module_version() -> std::string const"""
  return _IMP_display.get_module_version()

def get_example_path(*args):
  """get_example_path(std::string fname) -> std::string"""
  return _IMP_display.get_example_path(*args)

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_display.get_data_path(*args)
import _version_check
_version_check.check_version(get_module_version())

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