display/__init__.py

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

# This wrapper is part of IMP,
# Copyright 2007-2016 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import




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):
        object.__setattr__(self, 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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, x):
        """distance(IMP_DISPLAY_SwigPyIterator self, IMP_DISPLAY_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_distance(self, x)


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


    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, n):
        """advance(IMP_DISPLAY_SwigPyIterator self, ptrdiff_t n) -> IMP_DISPLAY_SwigPyIterator"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_advance(self, n)


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


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


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


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


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


    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_display.IMP_DEBUG_swigconstant(_IMP_display)
IMP_DEBUG = _IMP_display.IMP_DEBUG

_IMP_display.IMP_RELEASE_swigconstant(_IMP_display)
IMP_RELEASE = _IMP_display.IMP_RELEASE

_IMP_display.IMP_SILENT_swigconstant(_IMP_display)
IMP_SILENT = _IMP_display.IMP_SILENT

_IMP_display.IMP_PROGRESS_swigconstant(_IMP_display)
IMP_PROGRESS = _IMP_display.IMP_PROGRESS

_IMP_display.IMP_TERSE_swigconstant(_IMP_display)
IMP_TERSE = _IMP_display.IMP_TERSE

_IMP_display.IMP_VERBOSE_swigconstant(_IMP_display)
IMP_VERBOSE = _IMP_display.IMP_VERBOSE

_IMP_display.IMP_MEMORY_swigconstant(_IMP_display)
IMP_MEMORY = _IMP_display.IMP_MEMORY

_IMP_display.IMP_NONE_swigconstant(_IMP_display)
IMP_NONE = _IMP_display.IMP_NONE

_IMP_display.IMP_USAGE_swigconstant(_IMP_display)
IMP_USAGE = _IMP_display.IMP_USAGE

_IMP_display.IMP_INTERNAL_swigconstant(_IMP_display)
IMP_INTERNAL = _IMP_display.IMP_INTERNAL

_IMP_display.IMP_KERNEL_HAS_LOG4CXX_swigconstant(_IMP_display)
IMP_KERNEL_HAS_LOG4CXX = _IMP_display.IMP_KERNEL_HAS_LOG4CXX

_IMP_display.IMP_COMPILER_HAS_AUTO_swigconstant(_IMP_display)
IMP_COMPILER_HAS_AUTO = _IMP_display.IMP_COMPILER_HAS_AUTO

_IMP_display.IMP_COMPILER_HAS_DEBUG_VECTOR_swigconstant(_IMP_display)
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_display.IMP_COMPILER_HAS_DEBUG_VECTOR

_IMP_display.IMP_COMPILER_HAS_UNIQUE_PTR_swigconstant(_IMP_display)
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_display.IMP_COMPILER_HAS_UNIQUE_PTR

_IMP_display.IMP_KERNEL_HAS_BOOST_RANDOM_swigconstant(_IMP_display)
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_display.IMP_KERNEL_HAS_BOOST_RANDOM

_IMP_display.IMP_KERNEL_HAS_GPERFTOOLS_swigconstant(_IMP_display)
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_display.IMP_KERNEL_HAS_GPERFTOOLS

_IMP_display.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER_swigconstant(_IMP_display)
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_display.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

_IMP_display.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER_swigconstant(_IMP_display)
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_display.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

_IMP_display.IMPKERNEL_SHOW_WARNINGS_swigconstant(_IMP_display)
IMPKERNEL_SHOW_WARNINGS = _IMP_display.IMPKERNEL_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]
# Do in two steps so the references are kept until the end of the
# function (deleting references may trigger a fresh call to this method)
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

class _ostream(object):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def write(self, osa_buf):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_display._ostream_write(self, osa_buf)

_ostream_swigregister = _IMP_display._ostream_swigregister
_ostream_swigregister(_ostream)


_IMP_display.IMP_COMPILER_HAS_OVERRIDE_swigconstant(_IMP_display)
IMP_COMPILER_HAS_OVERRIDE = _IMP_display.IMP_COMPILER_HAS_OVERRIDE

_IMP_display.IMP_COMPILER_HAS_FINAL_swigconstant(_IMP_display)
IMP_COMPILER_HAS_FINAL = _IMP_display.IMP_COMPILER_HAS_FINAL

_IMP_display.IMP_HAS_NOEXCEPT_swigconstant(_IMP_display)
IMP_HAS_NOEXCEPT = _IMP_display.IMP_HAS_NOEXCEPT
import IMP

_IMP_display.IMP_CGAL_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_display)
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_display.IMP_CGAL_HAS_BOOST_FILESYSTEM

_IMP_display.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_display)
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_display.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS

_IMP_display.IMP_CGAL_HAS_BOOST_RANDOM_swigconstant(_IMP_display)
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_display.IMP_CGAL_HAS_BOOST_RANDOM

_IMP_display.IMP_CGAL_HAS_BOOST_SYSTEM_swigconstant(_IMP_display)
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_display.IMP_CGAL_HAS_BOOST_SYSTEM

_IMP_display.IMPCGAL_SHOW_WARNINGS_swigconstant(_IMP_display)
IMPCGAL_SHOW_WARNINGS = _IMP_display.IMPCGAL_SHOW_WARNINGS
import IMP.cgal

_IMP_display.IMP_ALGEBRA_HAS_IMP_CGAL_swigconstant(_IMP_display)
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_display.IMP_ALGEBRA_HAS_IMP_CGAL

_IMP_display.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_display)
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_display.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM

_IMP_display.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_display)
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_display.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS

_IMP_display.IMP_ALGEBRA_HAS_BOOST_RANDOM_swigconstant(_IMP_display)
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_display.IMP_ALGEBRA_HAS_BOOST_RANDOM

_IMP_display.IMP_ALGEBRA_HAS_BOOST_SYSTEM_swigconstant(_IMP_display)
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_display.IMP_ALGEBRA_HAS_BOOST_SYSTEM

_IMP_display.IMP_ALGEBRA_HAS_CGAL_swigconstant(_IMP_display)
IMP_ALGEBRA_HAS_CGAL = _IMP_display.IMP_ALGEBRA_HAS_CGAL

_IMP_display.IMP_ALGEBRA_HAS_ANN_swigconstant(_IMP_display)
IMP_ALGEBRA_HAS_ANN = _IMP_display.IMP_ALGEBRA_HAS_ANN

_IMP_display.IMPALGEBRA_SHOW_WARNINGS_swigconstant(_IMP_display)
IMPALGEBRA_SHOW_WARNINGS = _IMP_display.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra

_IMP_display.IMP_DISPLAY_HAS_IMP_CGAL_swigconstant(_IMP_display)
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_display.IMP_DISPLAY_HAS_IMP_CGAL

_IMP_display.IMP_DISPLAY_HAS_BOOST_FILESYSTEM_swigconstant(_IMP_display)
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_display.IMP_DISPLAY_HAS_BOOST_FILESYSTEM

_IMP_display.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS_swigconstant(_IMP_display)
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_display.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS

_IMP_display.IMP_DISPLAY_HAS_BOOST_RANDOM_swigconstant(_IMP_display)
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_display.IMP_DISPLAY_HAS_BOOST_RANDOM

_IMP_display.IMP_DISPLAY_HAS_BOOST_SYSTEM_swigconstant(_IMP_display)
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_display.IMP_DISPLAY_HAS_BOOST_SYSTEM

_IMP_display.IMP_DISPLAY_HAS_CGAL_swigconstant(_IMP_display)
IMP_DISPLAY_HAS_CGAL = _IMP_display.IMP_DISPLAY_HAS_CGAL

_IMP_display.IMPDISPLAY_SHOW_WARNINGS_swigconstant(_IMP_display)
IMPDISPLAY_SHOW_WARNINGS = _IMP_display.IMPDISPLAY_SHOW_WARNINGS

_object_types.append("Writer")


def _object_cast_to_Writer(o):
    """_object_cast_to_Writer(Object o) -> Writer"""
    return _IMP_display._object_cast_to_Writer(o)

_object_types.append("TextWriter")


def _object_cast_to_TextWriter(o):
    """_object_cast_to_TextWriter(Object o) -> TextWriter"""
    return _IMP_display._object_cast_to_TextWriter(o)

_object_types.append("Geometry")


def _object_cast_to_Geometry(o):
    """_object_cast_to_Geometry(Object o) -> Geometry"""
    return _IMP_display._object_cast_to_Geometry(o)

_object_types.append("SingletonGeometry")


def _object_cast_to_SingletonGeometry(o):
    """_object_cast_to_SingletonGeometry(Object o) -> SingletonGeometry"""
    return _IMP_display._object_cast_to_SingletonGeometry(o)

_object_types.append("PairGeometry")


def _object_cast_to_PairGeometry(o):
    """_object_cast_to_PairGeometry(Object o) -> PairGeometry"""
    return _IMP_display._object_cast_to_PairGeometry(o)

_object_types.append("SingletonsGeometry")


def _object_cast_to_SingletonsGeometry(o):
    """_object_cast_to_SingletonsGeometry(Object o) -> SingletonsGeometry"""
    return _IMP_display._object_cast_to_SingletonsGeometry(o)

_object_types.append("PairsGeometry")


def _object_cast_to_PairsGeometry(o):
    """_object_cast_to_PairsGeometry(Object o) -> PairsGeometry"""
    return _IMP_display._object_cast_to_PairsGeometry(o)

_object_types.append("PymolWriter")


def _object_cast_to_PymolWriter(o):
    """_object_cast_to_PymolWriter(Object o) -> PymolWriter"""
    return _IMP_display._object_cast_to_PymolWriter(o)

_object_types.append("SphereGeometry")


def _object_cast_to_SphereGeometry(o):
    """_object_cast_to_SphereGeometry(Object o) -> SphereGeometry"""
    return _IMP_display._object_cast_to_SphereGeometry(o)

_object_types.append("CylinderGeometry")


def _object_cast_to_CylinderGeometry(o):
    """_object_cast_to_CylinderGeometry(Object o) -> CylinderGeometry"""
    return _IMP_display._object_cast_to_CylinderGeometry(o)

_object_types.append("EllipsoidGeometry")


def _object_cast_to_EllipsoidGeometry(o):
    """_object_cast_to_EllipsoidGeometry(Object o) -> EllipsoidGeometry"""
    return _IMP_display._object_cast_to_EllipsoidGeometry(o)

_object_types.append("PointGeometry")


def _object_cast_to_PointGeometry(o):
    """_object_cast_to_PointGeometry(Object o) -> PointGeometry"""
    return _IMP_display._object_cast_to_PointGeometry(o)

_object_types.append("SegmentGeometry")


def _object_cast_to_SegmentGeometry(o):
    """_object_cast_to_SegmentGeometry(Object o) -> SegmentGeometry"""
    return _IMP_display._object_cast_to_SegmentGeometry(o)

_object_types.append("PolygonGeometry")


def _object_cast_to_PolygonGeometry(o):
    """_object_cast_to_PolygonGeometry(Object o) -> PolygonGeometry"""
    return _IMP_display._object_cast_to_PolygonGeometry(o)

_object_types.append("ReferenceFrameGeometry")


def _object_cast_to_ReferenceFrameGeometry(o):
    """_object_cast_to_ReferenceFrameGeometry(Object o) -> ReferenceFrameGeometry"""
    return _IMP_display._object_cast_to_ReferenceFrameGeometry(o)

_object_types.append("BoundingBoxGeometry")


def _object_cast_to_BoundingBoxGeometry(o):
    """_object_cast_to_BoundingBoxGeometry(Object o) -> BoundingBoxGeometry"""
    return _IMP_display._object_cast_to_BoundingBoxGeometry(o)

_object_types.append("LabelGeometry")


def _object_cast_to_LabelGeometry(o):
    """_object_cast_to_LabelGeometry(Object o) -> LabelGeometry"""
    return _IMP_display._object_cast_to_LabelGeometry(o)

_object_types.append("RestraintGeometry")


def _object_cast_to_RestraintGeometry(o):
    """_object_cast_to_RestraintGeometry(Object o) -> RestraintGeometry"""
    return _IMP_display._object_cast_to_RestraintGeometry(o)

_object_types.append("RestraintSetGeometry")


def _object_cast_to_RestraintSetGeometry(o):
    """_object_cast_to_RestraintSetGeometry(Object o) -> RestraintSetGeometry"""
    return _IMP_display._object_cast_to_RestraintSetGeometry(o)

_object_types.append("GeometrySet")


def _object_cast_to_GeometrySet(o):
    """_object_cast_to_GeometrySet(Object o) -> GeometrySet"""
    return _IMP_display._object_cast_to_GeometrySet(o)

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(o):
    """_object_cast_to_FilterGeometry(Object o) -> FilterGeometry"""
    return _IMP_display._object_cast_to_FilterGeometry(o)

_object_types.append("WriteOptimizerState")


def _object_cast_to_WriteOptimizerState(o):
    """_object_cast_to_WriteOptimizerState(Object o) -> WriteOptimizerState"""
    return _IMP_display._object_cast_to_WriteOptimizerState(o)

_object_types.append("TriangleGeometry")


def _object_cast_to_TriangleGeometry(o):
    """_object_cast_to_TriangleGeometry(Object o) -> TriangleGeometry"""
    return _IMP_display._object_cast_to_TriangleGeometry(o)

_object_types.append("SurfaceMeshGeometry")


def _object_cast_to_SurfaceMeshGeometry(o):
    """_object_cast_to_SurfaceMeshGeometry(Object o) -> SurfaceMeshGeometry"""
    return _IMP_display._object_cast_to_SurfaceMeshGeometry(o)

_object_types.append("PlaneGeometry")


def _object_cast_to_PlaneGeometry(o):
    """_object_cast_to_PlaneGeometry(Object o) -> PlaneGeometry"""
    return _IMP_display._object_cast_to_PlaneGeometry(o)

_object_types.append("IsosurfaceGeometry")


def _object_cast_to_IsosurfaceGeometry(o):
    """_object_cast_to_IsosurfaceGeometry(Object o) -> IsosurfaceGeometry"""
    return _IMP_display._object_cast_to_IsosurfaceGeometry(o)

_object_types.append("SkinSurfaceGeometry")


def _object_cast_to_SkinSurfaceGeometry(o):
    """_object_cast_to_SkinSurfaceGeometry(Object o) -> SkinSurfaceGeometry"""
    return _IMP_display._object_cast_to_SkinSurfaceGeometry(o)
class Color(IMP._Value):
    """Proxy of C++ IMP::display::Color class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)
        show(Color self)
        """
        return _IMP_display.Color_show(self, *args)


    def __cmp__(self, o):
        """__cmp__(Color self, Color o) -> int"""
        return _IMP_display.Color___cmp__(self, o)


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


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


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


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


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


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


    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(i):
    """get_display_color(unsigned int i) -> Color"""
    return _IMP_display.get_display_color(i)

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

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

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

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

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

def get_gray_color(f):
    """get_gray_color(double f) -> Color"""
    return _IMP_display.get_gray_color(f)

def get_gnuplot_color(f):
    """get_gnuplot_color(double f) -> Color"""
    return _IMP_display.get_gnuplot_color(f)
class Geometry(IMP.Object):
    """Proxy of C++ IMP::display::Geometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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:
            _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, tf):
        """set_has_color(Geometry self, bool tf)"""
        return _IMP_display.Geometry_set_has_color(self, tf)


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


    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)


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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Geometry(o)

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

    def do_destroy(self):
        """do_destroy(Geometry self)"""
        return _IMP_display.Geometry_do_destroy(self)

Geometry_swigregister = _IMP_display.Geometry_swigregister
Geometry_swigregister(Geometry)

class GeometrySet(Geometry):
    """Proxy of C++ IMP::display::GeometrySet class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


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

GeometrySet_swigregister = _IMP_display.GeometrySet_swigregister
GeometrySet_swigregister(GeometrySet)

class SphereGeometry(Geometry):
    """Proxy of C++ IMP::display::SphereGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(SphereGeometry self, Sphere3D v)"""
        return _IMP_display.SphereGeometry_set_geometry(self, v)


    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)


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

SphereGeometry_swigregister = _IMP_display.SphereGeometry_swigregister
SphereGeometry_swigregister(SphereGeometry)

class CylinderGeometry(Geometry):
    """Proxy of C++ IMP::display::CylinderGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(CylinderGeometry self, Cylinder3D v)"""
        return _IMP_display.CylinderGeometry_set_geometry(self, v)


    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)


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

CylinderGeometry_swigregister = _IMP_display.CylinderGeometry_swigregister
CylinderGeometry_swigregister(CylinderGeometry)

class EllipsoidGeometry(Geometry):
    """Proxy of C++ IMP::display::EllipsoidGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(EllipsoidGeometry self, Ellipsoid3D v)"""
        return _IMP_display.EllipsoidGeometry_set_geometry(self, v)


    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)


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

EllipsoidGeometry_swigregister = _IMP_display.EllipsoidGeometry_swigregister
EllipsoidGeometry_swigregister(EllipsoidGeometry)

class PointGeometry(Geometry):
    """Proxy of C++ IMP::display::PointGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(PointGeometry self, Vector3D v)"""
        return _IMP_display.PointGeometry_set_geometry(self, v)


    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)


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

PointGeometry_swigregister = _IMP_display.PointGeometry_swigregister
PointGeometry_swigregister(PointGeometry)

class SegmentGeometry(Geometry):
    """Proxy of C++ IMP::display::SegmentGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(SegmentGeometry self, Segment3D v)"""
        return _IMP_display.SegmentGeometry_set_geometry(self, v)


    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)


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

SegmentGeometry_swigregister = _IMP_display.SegmentGeometry_swigregister
SegmentGeometry_swigregister(SegmentGeometry)

class PolygonGeometry(Geometry):
    """Proxy of C++ IMP::display::PolygonGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(PolygonGeometry self, IMP::algebra::Vector3Ds const & v)"""
        return _IMP_display.PolygonGeometry_set_geometry(self, v)


    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)


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

PolygonGeometry_swigregister = _IMP_display.PolygonGeometry_swigregister
PolygonGeometry_swigregister(PolygonGeometry)

class TriangleGeometry(Geometry):
    """Proxy of C++ IMP::display::TriangleGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(TriangleGeometry self, Triangle3D v)"""
        return _IMP_display.TriangleGeometry_set_geometry(self, v)


    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)


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

TriangleGeometry_swigregister = _IMP_display.TriangleGeometry_swigregister
TriangleGeometry_swigregister(TriangleGeometry)

class BoundingBoxGeometry(Geometry):
    """Proxy of C++ IMP::display::BoundingBoxGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(BoundingBoxGeometry self, BoundingBox3D v)"""
        return _IMP_display.BoundingBoxGeometry_set_geometry(self, v)


    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)


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

BoundingBoxGeometry_swigregister = _IMP_display.BoundingBoxGeometry_swigregister
BoundingBoxGeometry_swigregister(BoundingBoxGeometry)

class ReferenceFrameGeometry(Geometry):
    """Proxy of C++ IMP::display::ReferenceFrameGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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, v):
        """set_geometry(ReferenceFrameGeometry self, ReferenceFrame3D v)"""
        return _IMP_display.ReferenceFrameGeometry_set_geometry(self, v)


    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)


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

ReferenceFrameGeometry_swigregister = _IMP_display.ReferenceFrameGeometry_swigregister
ReferenceFrameGeometry_swigregister(ReferenceFrameGeometry)


def create_geometry(*args):
    """
    create_geometry(Sphere3D t, std::string name) -> SphereGeometry
    create_geometry(Sphere3D t) -> SphereGeometry
    create_geometry(Cylinder3D t, std::string name) -> CylinderGeometry
    create_geometry(Cylinder3D t) -> CylinderGeometry
    create_geometry(Ellipsoid3D t, std::string name) -> EllipsoidGeometry
    create_geometry(Ellipsoid3D t) -> EllipsoidGeometry
    create_geometry(Vector3D t, std::string name) -> PointGeometry
    create_geometry(Vector3D t) -> PointGeometry
    create_geometry(Segment3D t, std::string name) -> SegmentGeometry
    create_geometry(Segment3D t) -> SegmentGeometry
    create_geometry(IMP::algebra::Vector3Ds const & t, std::string name) -> PolygonGeometry
    create_geometry(IMP::algebra::Vector3Ds const & t) -> PolygonGeometry
    create_geometry(Triangle3D t, std::string name) -> TriangleGeometry
    create_geometry(Triangle3D t) -> TriangleGeometry
    create_geometry(BoundingBox3D t, std::string name) -> BoundingBoxGeometry
    create_geometry(BoundingBox3D t) -> BoundingBoxGeometry
    create_geometry(ReferenceFrame3D t, std::string name) -> ReferenceFrameGeometry
    create_geometry(ReferenceFrame3D t) -> ReferenceFrameGeometry
    """
    return _IMP_display.create_geometry(*args)
class LabelGeometry(Geometry):
    """Proxy of C++ IMP::display::LabelGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


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

LabelGeometry_swigregister = _IMP_display.LabelGeometry_swigregister
LabelGeometry_swigregister(LabelGeometry)

class SurfaceMeshGeometry(Geometry):
    """Proxy of C++ IMP::display::SurfaceMeshGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, vertices, faces):
        """__init__(IMP::display::SurfaceMeshGeometry self, IMP::algebra::Vector3Ds const & vertices, IMP::Ints const & faces) -> SurfaceMeshGeometry"""
        this = _IMP_display.new_SurfaceMeshGeometry(vertices, faces)
        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)


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

SurfaceMeshGeometry_swigregister = _IMP_display.SurfaceMeshGeometry_swigregister
SurfaceMeshGeometry_swigregister(SurfaceMeshGeometry)

class PlaneGeometry(Geometry):
    """Proxy of C++ IMP::display::PlaneGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, loc, box):
        """__init__(IMP::display::PlaneGeometry self, Plane3D loc, BoundingBox3D box) -> PlaneGeometry"""
        this = _IMP_display.new_PlaneGeometry(loc, box)
        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)


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

PlaneGeometry_swigregister = _IMP_display.PlaneGeometry_swigregister
PlaneGeometry_swigregister(PlaneGeometry)

class IsosurfaceGeometry(SurfaceMeshGeometry):
    """Proxy of C++ IMP::display::IsosurfaceGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, balls):
        """__init__(IMP::display::SkinSurfaceGeometry self, IMP::algebra::Sphere3Ds const & balls) -> SkinSurfaceGeometry"""
        this = _IMP_display.new_SkinSurfaceGeometry(balls)
        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)


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

    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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.Object):
    """Proxy of C++ IMP::display::Writer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, name):
        """__init__(IMP::display::Writer self, std::string name) -> Writer"""
        if self.__class__ == Writer:
            _self = None
        else:
            _self = self
        this = _IMP_display.new_Writer(_self, name)
        try:
            self.this.append(this)
        except:
            self.this = this

        if self.__class__ != Writer:
            _director_objects.register(self)



    __swig_destroy__ = _IMP_display.delete_Writer
    __del__ = lambda self: None

    def set_frame(self, i):
        """set_frame(Writer self, unsigned int i)"""
        return _IMP_display.Writer_set_frame(self, i)


    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)


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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_Writer(o)

    def __disown__(self):
        self.this.disown()
        _IMP_display.disown_Writer(self)
        return weakref_proxy(self)

    def handle_sphere(self, arg0, arg1, arg2):
        """handle_sphere(Writer self, SphereGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.Writer_handle_sphere(self, arg0, arg1, arg2)


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


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


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


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


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


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


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


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


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


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


    def do_destroy(self):
        """do_destroy(Writer self)"""
        return _IMP_display.Writer_do_destroy(self)

Writer_swigregister = _IMP_display.Writer_swigregister
Writer_swigregister(Writer)

class TextWriter(Writer):
    """Proxy of C++ IMP::display::TextWriter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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:
            _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)


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


    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(self.__module__,
                             __import__(self.__module__).get_module_version())
        else:
          return IMP.VersionInfo(self.__module__,
                             __import__(self.__module__).get_module_version())
    @staticmethod
    def get_from(o):
       return _object_cast_to_TextWriter(o)

    def __disown__(self):
        self.this.disown()
        _IMP_display.disown_TextWriter(self)
        return weakref_proxy(self)

    def handle_sphere(self, arg0, arg1, arg2):
        """handle_sphere(TextWriter self, SphereGeometry arg0, Color arg1, std::string arg2) -> bool"""
        return _IMP_display.TextWriter_handle_sphere(self, arg0, arg1, arg2)


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


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


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


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


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


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


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


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


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


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


    def do_destroy(self):
        """do_destroy(TextWriter self)"""
        return _IMP_display.TextWriter_do_destroy(self)


    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(filename):
    """create_writer(std::string filename) -> Writer"""
    return _IMP_display.create_writer(filename)
class WriterAdaptor(IMP._InputAdaptor):
    """Proxy of C++ IMP::display::WriterAdaptor class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)
        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 Colored(IMP.Decorator):
    """Proxy of C++ IMP::display::Colored class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def set_color(self, c):
        """set_color(Colored self, Color c)"""
        return _IMP_display.Colored_set_color(self, c)


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


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

    get_color_keys = staticmethod(get_color_keys)

    def __init__(self, *args):
        """
        __init__(IMP::display::Colored self) -> Colored
        __init__(IMP::display::Colored self, Model m, 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 get_is_setup(*args):
        """
        get_is_setup(Model m, ParticleIndex pi) -> bool
        get_is_setup(_ParticleAdaptor p) -> bool
        """
        return _IMP_display.Colored_get_is_setup(*args)

    get_is_setup = staticmethod(get_is_setup)

    def show(self, *args):
        """
        show(Colored self, _ostream out)
        show(Colored self)
        """
        return _IMP_display.Colored_show(self, *args)


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

    setup_particle = staticmethod(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, a0):
        """get_derivative(Colored self, FloatKey a0) -> double"""
        return _IMP_display.Colored_get_derivative(self, a0)


    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, a0):
        """set_name(Colored self, std::string a0)"""
        return _IMP_display.Colored_set_name(self, a0)


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


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


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


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


    def get_check_level(self):
        """get_check_level(Colored self) -> IMP::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 __hash__(self):
        """__hash__(Colored self) -> std::size_t"""
        return _IMP_display.Colored___hash__(self)


    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::FloatKeys const &"""
    return _IMP_display.Colored_get_color_keys()

def Colored_get_is_setup(*args):
    """
    get_is_setup(Model m, 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, ParticleIndex pi, Color color) -> Colored
    Colored_setup_particle(_ParticleAdaptor decorator, Color color) -> Colored
    """
    return _IMP_display.Colored_setup_particle(*args)


def __lshift__(out, n):
    """__lshift__(_ostream out, Colored n) -> _ostream"""
    return _IMP_display.__lshift__(out, n)
class FilterGeometry(GeometryProcessor, Geometry):
    """Proxy of C++ IMP::display::FilterGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, p):
        """__init__(IMP::display::FilterGeometry self, Plane3D p) -> FilterGeometry"""
        this = _IMP_display.new_FilterGeometry(p)
        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)


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

FilterGeometry_swigregister = _IMP_display.FilterGeometry_swigregister
FilterGeometry_swigregister(FilterGeometry)

class WriteOptimizerState(IMP.OptimizerState):
    """Proxy of C++ IMP::display::WriteOptimizerState class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, m, w):
        """__init__(IMP::display::WriteOptimizerState self, Model m, WriterAdaptor w) -> WriteOptimizerState"""
        this = _IMP_display.new_WriteOptimizerState(m, w)
        try:
            self.this.append(this)
        except:
            self.this = this

    def write(self, w):
        """write(WriteOptimizerState self, WriterAdaptor w)"""
        return _IMP_display.WriteOptimizerState_write(self, w)


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


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


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


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


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


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


    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, i):
        """get_geometry(WriteOptimizerState self, unsigned int i) -> Geometry"""
        return _IMP_display.WriteOptimizerState_get_geometry(self, i)


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


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


    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)


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

WriteOptimizerState_swigregister = _IMP_display.WriteOptimizerState_swigregister
WriteOptimizerState_swigregister(WriteOptimizerState)

class SingletonGeometry(Geometry):
    """Proxy of C++ IMP::display::SingletonGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, p):
        """__init__(IMP::display::SingletonGeometry self, Particle p) -> SingletonGeometry"""
        this = _IMP_display.new_SingletonGeometry(p)
        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)


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

SingletonGeometry_swigregister = _IMP_display.SingletonGeometry_swigregister
SingletonGeometry_swigregister(SingletonGeometry)

class SingletonsGeometry(Geometry):
    """Proxy of C++ IMP::display::SingletonsGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args):
        """
        __init__(IMP::display::SingletonsGeometry self, _SingletonContainerAdaptor pc, Color c) -> SingletonsGeometry
        __init__(IMP::display::SingletonsGeometry self, _SingletonContainerAdaptor 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)


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

SingletonsGeometry_swigregister = _IMP_display.SingletonsGeometry_swigregister
SingletonsGeometry_swigregister(SingletonsGeometry)

class PairGeometry(Geometry):
    """Proxy of C++ IMP::display::PairGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, pp):
        """__init__(IMP::display::PairGeometry self, IMP::ParticlePair const & pp) -> PairGeometry"""
        this = _IMP_display.new_PairGeometry(pp)
        try:
            self.this.append(this)
        except:
            self.this = this

    def get_particle_pair(self):
        """get_particle_pair(PairGeometry self) -> IMP::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)


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

PairGeometry_swigregister = _IMP_display.PairGeometry_swigregister
PairGeometry_swigregister(PairGeometry)

class PairsGeometry(Geometry):
    """Proxy of C++ IMP::display::PairsGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


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

PairsGeometry_swigregister = _IMP_display.PairsGeometry_swigregister
PairsGeometry_swigregister(PairsGeometry)

class PymolWriter(TextWriter):
    """Proxy of C++ IMP::display::PymolWriter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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)


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

PymolWriter_swigregister = _IMP_display.PymolWriter_swigregister
PymolWriter_swigregister(PymolWriter)

class RestraintGeometry(Geometry):
    """Proxy of C++ IMP::display::RestraintGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, p):
        """__init__(IMP::display::RestraintGeometry self, Restraint p) -> RestraintGeometry"""
        this = _IMP_display.new_RestraintGeometry(p)
        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)


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

RestraintGeometry_swigregister = _IMP_display.RestraintGeometry_swigregister
RestraintGeometry_swigregister(RestraintGeometry)

class RestraintSetGeometry(Geometry):
    """Proxy of C++ IMP::display::RestraintSetGeometry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, p):
        """__init__(IMP::display::RestraintSetGeometry self, RestraintSet p) -> RestraintSetGeometry"""
        this = _IMP_display.new_RestraintSetGeometry(p)
        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)


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

RestraintSetGeometry_swigregister = _IMP_display.RestraintSetGeometry_swigregister
RestraintSetGeometry_swigregister(RestraintSetGeometry)


from . 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(fname):
    """get_example_path(std::string fname) -> std::string"""
    return _IMP_display.get_example_path(fname)

def get_data_path(fname):
    """get_data_path(std::string fname) -> std::string"""
    return _IMP_display.get_data_path(fname)

from . import _version_check
_version_check.check_version(get_module_version())
__version__ = get_module_version()