display/__init__.py

# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# 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-2023 IMP Inventors. All rights reserved.

from __future__ import print_function, division, absolute_import



from sys import version_info as _swig_python_version_info
import _IMP_display

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class IMP_DISPLAY_SwigPyIterator(object):
    r"""Proxy of C++ swig::IMP_DISPLAY_SwigPyIterator class."""

    thisown = 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

    def value(self):
        r"""value(IMP_DISPLAY_SwigPyIterator self) -> PyObject *"""
        return _IMP_display.IMP_DISPLAY_SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        r"""
        __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

# Register IMP_DISPLAY_SwigPyIterator in _IMP_display:
_IMP_display.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_KERNEL_HAS_LOG4CXX = _IMP_display.IMP_KERNEL_HAS_LOG4CXX

IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_display.IMP_COMPILER_HAS_CEREAL_RAW_POINTER

IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_display.IMP_COMPILER_HAS_DEBUG_VECTOR

IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_display.IMP_COMPILER_HAS_RANDOM_SHUFFLE

IMP_COMPILER_HAS_THREE_WAY = _IMP_display.IMP_COMPILER_HAS_THREE_WAY

IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_display.IMP_KERNEL_HAS_BOOST_RANDOM

IMP_KERNEL_HAS_NUMPY = _IMP_display.IMP_KERNEL_HAS_NUMPY

IMP_KERNEL_HAS_GPERFTOOLS = _IMP_display.IMP_KERNEL_HAS_GPERFTOOLS

IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_display.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER

IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_display.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER

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):
    r"""Proxy of C++ std::ostream class."""

    thisown = 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):
        r"""write(_ostream self, char const * osa_buf)"""
        return _IMP_display._ostream_write(self, osa_buf)

# Register _ostream in _IMP_display:
_IMP_display._ostream_swigregister(_ostream)
IMP_C_OPEN_BINARY = _IMP_display.IMP_C_OPEN_BINARY

import IMP
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

IMP_CGAL_HAS_NUMPY = _IMP_display.IMP_CGAL_HAS_NUMPY

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_NUMPY = _IMP_display.IMP_ALGEBRA_HAS_NUMPY

IMP_ALGEBRA_HAS_ANN = _IMP_display.IMP_ALGEBRA_HAS_ANN

IMPALGEBRA_SHOW_WARNINGS = _IMP_display.IMPALGEBRA_SHOW_WARNINGS

import IMP.algebra
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

IMP_DISPLAY_HAS_NUMPY = _IMP_display.IMP_DISPLAY_HAS_NUMPY

IMPDISPLAY_SHOW_WARNINGS = _IMP_display.IMPDISPLAY_SHOW_WARNINGS


_object_types.append("Writer")


def _object_cast_to_Writer(o):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_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):
    r"""_object_cast_to_SkinSurfaceGeometry(Object o) -> SkinSurfaceGeometry"""
    return _IMP_display._object_cast_to_SkinSurfaceGeometry(o)
class Color(IMP._Value):
    r"""Proxy of C++ IMP::display::Color class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Color self, Color arg2) -> Color
        __init__(Color self) -> Color
        __init__(Color self, double r, double g, double b) -> Color
        """
        _IMP_display.Color_swiginit(self, _IMP_display.new_Color(*args))
    __swig_destroy__ = _IMP_display.delete_Color

    def get_red(self):
        r"""get_red(Color self) -> double"""
        return _IMP_display.Color_get_red(self)

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

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

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

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

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

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

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

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

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

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

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Color self) -> PyObject *"""
        return _IMP_display.Color__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Color self, PyObject * p)"""
        return _IMP_display.Color__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)


# Register Color in _IMP_display:
_IMP_display.Color_swigregister(Color)

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

def get_interpolated_rgb(a, b, f):
    r"""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):
    r"""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):
    r"""get_jet_color(double f) -> Color"""
    return _IMP_display.get_jet_color(f)

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

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

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

def get_gnuplot_color(f):
    r"""get_gnuplot_color(double f) -> Color"""
    return _IMP_display.get_gnuplot_color(f)
class Geometry(IMP.Object):
    r"""Proxy of C++ IMP::display::Geometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(Geometry self, std::string name) -> Geometry
        __init__(Geometry self, Color c, std::string name) -> Geometry
        """
        if self.__class__ == Geometry:
            _self = None
        else:
            _self = self
        _IMP_display.Geometry_swiginit(self, _IMP_display.new_Geometry(_self, *args))

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




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

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

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

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

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

    def __str__(self):
        r"""__str__(Geometry self) -> std::string"""
        return _IMP_display.Geometry___str__(self)

    def __repr__(self):
        r"""__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):
        r"""do_destroy(Geometry self)"""
        return _IMP_display.Geometry_do_destroy(self)

# Register Geometry in _IMP_display:
_IMP_display.Geometry_swigregister(Geometry)
class GeometrySet(Geometry):
    r"""Proxy of C++ IMP::display::GeometrySet class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(GeometrySet self, IMP::display::Geometries const & v) -> GeometrySet
        __init__(GeometrySet self, IMP::display::Geometries const & v, Color c) -> GeometrySet
        __init__(GeometrySet self, IMP::display::Geometries const & v, std::string const n) -> GeometrySet
        __init__(GeometrySet self, IMP::display::Geometries const & v, Color c, std::string n) -> GeometrySet
        """
        _IMP_display.GeometrySet_swiginit(self, _IMP_display.new_GeometrySet(*args))

    def get_geometry(self):
        r"""get_geometry(GeometrySet self) -> IMP::display::Geometries"""
        return _IMP_display.GeometrySet_get_geometry(self)

    def get_version_info(self):
        r"""get_version_info(GeometrySet self) -> VersionInfo"""
        return _IMP_display.GeometrySet_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_GeometrySet

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

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

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


# Register GeometrySet in _IMP_display:
_IMP_display.GeometrySet_swigregister(GeometrySet)
class SphereGeometry(Geometry):
    r"""Proxy of C++ IMP::display::SphereGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SphereGeometry self, Sphere3D v) -> SphereGeometry
        __init__(SphereGeometry self, Sphere3D v, Color c) -> SphereGeometry
        __init__(SphereGeometry self, Sphere3D v, std::string const n) -> SphereGeometry
        __init__(SphereGeometry self, Sphere3D v, Color c, std::string n) -> SphereGeometry
        """
        _IMP_display.SphereGeometry_swiginit(self, _IMP_display.new_SphereGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(SphereGeometry self) -> Sphere3D"""
        return _IMP_display.SphereGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(SphereGeometry self) -> VersionInfo"""
        return _IMP_display.SphereGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_SphereGeometry

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

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

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


# Register SphereGeometry in _IMP_display:
_IMP_display.SphereGeometry_swigregister(SphereGeometry)
class CylinderGeometry(Geometry):
    r"""Proxy of C++ IMP::display::CylinderGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(CylinderGeometry self, Cylinder3D v) -> CylinderGeometry
        __init__(CylinderGeometry self, Cylinder3D v, Color c) -> CylinderGeometry
        __init__(CylinderGeometry self, Cylinder3D v, std::string const n) -> CylinderGeometry
        __init__(CylinderGeometry self, Cylinder3D v, Color c, std::string n) -> CylinderGeometry
        """
        _IMP_display.CylinderGeometry_swiginit(self, _IMP_display.new_CylinderGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(CylinderGeometry self) -> Cylinder3D"""
        return _IMP_display.CylinderGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(CylinderGeometry self) -> VersionInfo"""
        return _IMP_display.CylinderGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_CylinderGeometry

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

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

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


# Register CylinderGeometry in _IMP_display:
_IMP_display.CylinderGeometry_swigregister(CylinderGeometry)
class EllipsoidGeometry(Geometry):
    r"""Proxy of C++ IMP::display::EllipsoidGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(EllipsoidGeometry self, Ellipsoid3D v) -> EllipsoidGeometry
        __init__(EllipsoidGeometry self, Ellipsoid3D v, Color c) -> EllipsoidGeometry
        __init__(EllipsoidGeometry self, Ellipsoid3D v, std::string const n) -> EllipsoidGeometry
        __init__(EllipsoidGeometry self, Ellipsoid3D v, Color c, std::string n) -> EllipsoidGeometry
        """
        _IMP_display.EllipsoidGeometry_swiginit(self, _IMP_display.new_EllipsoidGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(EllipsoidGeometry self) -> Ellipsoid3D"""
        return _IMP_display.EllipsoidGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(EllipsoidGeometry self) -> VersionInfo"""
        return _IMP_display.EllipsoidGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_EllipsoidGeometry

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

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

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


# Register EllipsoidGeometry in _IMP_display:
_IMP_display.EllipsoidGeometry_swigregister(EllipsoidGeometry)
class PointGeometry(Geometry):
    r"""Proxy of C++ IMP::display::PointGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(PointGeometry self, Vector3D v) -> PointGeometry
        __init__(PointGeometry self, Vector3D v, Color c) -> PointGeometry
        __init__(PointGeometry self, Vector3D v, std::string const n) -> PointGeometry
        __init__(PointGeometry self, Vector3D v, Color c, std::string n) -> PointGeometry
        """
        _IMP_display.PointGeometry_swiginit(self, _IMP_display.new_PointGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(PointGeometry self) -> Vector3D"""
        return _IMP_display.PointGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(PointGeometry self) -> VersionInfo"""
        return _IMP_display.PointGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_PointGeometry

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

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

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


# Register PointGeometry in _IMP_display:
_IMP_display.PointGeometry_swigregister(PointGeometry)
class SegmentGeometry(Geometry):
    r"""Proxy of C++ IMP::display::SegmentGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SegmentGeometry self, Segment3D v) -> SegmentGeometry
        __init__(SegmentGeometry self, Segment3D v, Color c) -> SegmentGeometry
        __init__(SegmentGeometry self, Segment3D v, std::string const n) -> SegmentGeometry
        __init__(SegmentGeometry self, Segment3D v, Color c, std::string n) -> SegmentGeometry
        """
        _IMP_display.SegmentGeometry_swiginit(self, _IMP_display.new_SegmentGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(SegmentGeometry self) -> Segment3D"""
        return _IMP_display.SegmentGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(SegmentGeometry self) -> VersionInfo"""
        return _IMP_display.SegmentGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_SegmentGeometry

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

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

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


# Register SegmentGeometry in _IMP_display:
_IMP_display.SegmentGeometry_swigregister(SegmentGeometry)
class PolygonGeometry(Geometry):
    r"""Proxy of C++ IMP::display::PolygonGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(PolygonGeometry self, IMP::algebra::Vector3Ds const & v) -> PolygonGeometry
        __init__(PolygonGeometry self, IMP::algebra::Vector3Ds const & v, Color c) -> PolygonGeometry
        __init__(PolygonGeometry self, IMP::algebra::Vector3Ds const & v, std::string const n) -> PolygonGeometry
        __init__(PolygonGeometry self, IMP::algebra::Vector3Ds const & v, Color c, std::string n) -> PolygonGeometry
        """
        _IMP_display.PolygonGeometry_swiginit(self, _IMP_display.new_PolygonGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(PolygonGeometry self) -> IMP::algebra::Vector3Ds const &"""
        return _IMP_display.PolygonGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(PolygonGeometry self) -> VersionInfo"""
        return _IMP_display.PolygonGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_PolygonGeometry

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

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

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


# Register PolygonGeometry in _IMP_display:
_IMP_display.PolygonGeometry_swigregister(PolygonGeometry)
class TriangleGeometry(Geometry):
    r"""Proxy of C++ IMP::display::TriangleGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(TriangleGeometry self, Triangle3D v) -> TriangleGeometry
        __init__(TriangleGeometry self, Triangle3D v, Color c) -> TriangleGeometry
        __init__(TriangleGeometry self, Triangle3D v, std::string const n) -> TriangleGeometry
        __init__(TriangleGeometry self, Triangle3D v, Color c, std::string n) -> TriangleGeometry
        """
        _IMP_display.TriangleGeometry_swiginit(self, _IMP_display.new_TriangleGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(TriangleGeometry self) -> Triangle3D"""
        return _IMP_display.TriangleGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(TriangleGeometry self) -> VersionInfo"""
        return _IMP_display.TriangleGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_TriangleGeometry

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

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

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


# Register TriangleGeometry in _IMP_display:
_IMP_display.TriangleGeometry_swigregister(TriangleGeometry)
class BoundingBoxGeometry(Geometry):
    r"""Proxy of C++ IMP::display::BoundingBoxGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(BoundingBoxGeometry self, BoundingBox3D v) -> BoundingBoxGeometry
        __init__(BoundingBoxGeometry self, BoundingBox3D v, Color c) -> BoundingBoxGeometry
        __init__(BoundingBoxGeometry self, BoundingBox3D v, std::string const n) -> BoundingBoxGeometry
        __init__(BoundingBoxGeometry self, BoundingBox3D v, Color c, std::string n) -> BoundingBoxGeometry
        """
        _IMP_display.BoundingBoxGeometry_swiginit(self, _IMP_display.new_BoundingBoxGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(BoundingBoxGeometry self) -> BoundingBox3D"""
        return _IMP_display.BoundingBoxGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(BoundingBoxGeometry self) -> VersionInfo"""
        return _IMP_display.BoundingBoxGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_BoundingBoxGeometry

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

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

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


# Register BoundingBoxGeometry in _IMP_display:
_IMP_display.BoundingBoxGeometry_swigregister(BoundingBoxGeometry)
class ReferenceFrameGeometry(Geometry):
    r"""Proxy of C++ IMP::display::ReferenceFrameGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(ReferenceFrameGeometry self, ReferenceFrame3D v) -> ReferenceFrameGeometry
        __init__(ReferenceFrameGeometry self, ReferenceFrame3D v, Color c) -> ReferenceFrameGeometry
        __init__(ReferenceFrameGeometry self, ReferenceFrame3D v, std::string const n) -> ReferenceFrameGeometry
        __init__(ReferenceFrameGeometry self, ReferenceFrame3D v, Color c, std::string n) -> ReferenceFrameGeometry
        """
        _IMP_display.ReferenceFrameGeometry_swiginit(self, _IMP_display.new_ReferenceFrameGeometry(*args))

    def get_geometry(self):
        r"""get_geometry(ReferenceFrameGeometry self) -> ReferenceFrame3D"""
        return _IMP_display.ReferenceFrameGeometry_get_geometry(self)

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

    def get_version_info(self):
        r"""get_version_info(ReferenceFrameGeometry self) -> VersionInfo"""
        return _IMP_display.ReferenceFrameGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_ReferenceFrameGeometry

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

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

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


# Register ReferenceFrameGeometry in _IMP_display:
_IMP_display.ReferenceFrameGeometry_swigregister(ReferenceFrameGeometry)

def create_geometry(*args):
    r"""
    create_geometry(Sphere3D t, std::string name="algebra::Sphere3D+%1%") -> SphereGeometry
    create_geometry(Cylinder3D t, std::string name="algebra::Cylinder3D+%1%") -> CylinderGeometry
    create_geometry(Ellipsoid3D t, std::string name="algebra::Ellipsoid3D+%1%") -> EllipsoidGeometry
    create_geometry(Vector3D t, std::string name="algebra::Vector3D+%1%") -> PointGeometry
    create_geometry(Segment3D t, std::string name="algebra::Segment3D+%1%") -> SegmentGeometry
    create_geometry(IMP::algebra::Vector3Ds const & t, std::string name="algebra::Vector3Ds+%1%") -> PolygonGeometry
    create_geometry(Triangle3D t, std::string name="algebra::Triangle3D+%1%") -> TriangleGeometry
    create_geometry(BoundingBox3D t, std::string name="algebra::BoundingBoxD<3>+%1%") -> BoundingBoxGeometry
    create_geometry(ReferenceFrame3D t, std::string name="algebra::ReferenceFrame3D+%1%") -> ReferenceFrameGeometry
    """
    return _IMP_display.create_geometry(*args)
class LabelGeometry(Geometry):
    r"""Proxy of C++ IMP::display::LabelGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(LabelGeometry self, Sphere3D loc, std::string text) -> LabelGeometry
        __init__(LabelGeometry self, Vector3D loc, std::string text) -> LabelGeometry
        """
        _IMP_display.LabelGeometry_swiginit(self, _IMP_display.new_LabelGeometry(*args))

    def get_text(self):
        r"""get_text(LabelGeometry self) -> std::string"""
        return _IMP_display.LabelGeometry_get_text(self)

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

    def get_version_info(self):
        r"""get_version_info(LabelGeometry self) -> VersionInfo"""
        return _IMP_display.LabelGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_LabelGeometry

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

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

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


# Register LabelGeometry in _IMP_display:
_IMP_display.LabelGeometry_swigregister(LabelGeometry)
class SurfaceMeshGeometry(Geometry):
    r"""Proxy of C++ IMP::display::SurfaceMeshGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, vertices, faces):
        r"""__init__(SurfaceMeshGeometry self, IMP::algebra::Vector3Ds const & vertices, IMP::Ints const & faces) -> SurfaceMeshGeometry"""
        _IMP_display.SurfaceMeshGeometry_swiginit(self, _IMP_display.new_SurfaceMeshGeometry(vertices, faces))

    def get_vertexes(self):
        r"""get_vertexes(SurfaceMeshGeometry self) -> IMP::algebra::Vector3Ds const &"""
        return _IMP_display.SurfaceMeshGeometry_get_vertexes(self)

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

    def get_version_info(self):
        r"""get_version_info(SurfaceMeshGeometry self) -> VersionInfo"""
        return _IMP_display.SurfaceMeshGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_SurfaceMeshGeometry

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

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

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


# Register SurfaceMeshGeometry in _IMP_display:
_IMP_display.SurfaceMeshGeometry_swigregister(SurfaceMeshGeometry)
class PlaneGeometry(Geometry):
    r"""Proxy of C++ IMP::display::PlaneGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, loc, box):
        r"""__init__(PlaneGeometry self, Plane3D loc, BoundingBox3D box) -> PlaneGeometry"""
        _IMP_display.PlaneGeometry_swiginit(self, _IMP_display.new_PlaneGeometry(loc, box))

    def get_version_info(self):
        r"""get_version_info(PlaneGeometry self) -> VersionInfo"""
        return _IMP_display.PlaneGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_PlaneGeometry

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

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

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


# Register PlaneGeometry in _IMP_display:
_IMP_display.PlaneGeometry_swigregister(PlaneGeometry)
class IsosurfaceGeometry(SurfaceMeshGeometry):
    r"""Proxy of C++ IMP::display::IsosurfaceGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(IsosurfaceGeometry self, IMP::algebra::GridD< 3,IMP::algebra::DenseGridStorageD< 3,double >,double,IMP::algebra::DefaultEmbeddingD< 3 > > const & grid, double iso) -> IsosurfaceGeometry
        __init__(IsosurfaceGeometry self, IMP::algebra::GridD< 3,IMP::algebra::DenseGridStorageD< 3,float >,float,IMP::algebra::DefaultEmbeddingD< 3 > > const & grid, double iso) -> IsosurfaceGeometry
        """
        _IMP_display.IsosurfaceGeometry_swiginit(self, _IMP_display.new_IsosurfaceGeometry(*args))

    def __str__(self):
        r"""__str__(IsosurfaceGeometry self) -> std::string"""
        return _IMP_display.IsosurfaceGeometry___str__(self)

    def __repr__(self):
        r"""__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

# Register IsosurfaceGeometry in _IMP_display:
_IMP_display.IsosurfaceGeometry_swigregister(IsosurfaceGeometry)
class SkinSurfaceGeometry(SurfaceMeshGeometry):
    r"""Proxy of C++ IMP::display::SkinSurfaceGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, balls):
        r"""__init__(SkinSurfaceGeometry self, IMP::algebra::Sphere3Ds const & balls) -> SkinSurfaceGeometry"""
        _IMP_display.SkinSurfaceGeometry_swiginit(self, _IMP_display.new_SkinSurfaceGeometry(balls))

    def __str__(self):
        r"""__str__(SkinSurfaceGeometry self) -> std::string"""
        return _IMP_display.SkinSurfaceGeometry___str__(self)

    def __repr__(self):
        r"""__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

# Register SkinSurfaceGeometry in _IMP_display:
_IMP_display.SkinSurfaceGeometry_swigregister(SkinSurfaceGeometry)
class GeometryProcessor(object):
    r"""Proxy of C++ IMP::display::GeometryProcessor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(GeometryProcessor self) -> GeometryProcessor"""
        _IMP_display.GeometryProcessor_swiginit(self, _IMP_display.new_GeometryProcessor())

# Register GeometryProcessor in _IMP_display:
_IMP_display.GeometryProcessor_swigregister(GeometryProcessor)
class Writer(GeometryProcessor, IMP.Object):
    r"""Proxy of C++ IMP::display::Writer class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, name):
        r"""__init__(Writer self, std::string name) -> Writer"""
        if self.__class__ == Writer:
            _self = None
        else:
            _self = self
        _IMP_display.Writer_swiginit(self, _IMP_display.new_Writer(_self, name))

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



    __swig_destroy__ = _IMP_display.delete_Writer

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

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

    def add_geometry(self, *args):
        r"""
        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):
        r"""do_close(Writer self)"""
        return _IMP_display.Writer_do_close(self)

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

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

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

    def __repr__(self):
        r"""__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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""do_destroy(Writer self)"""
        return _IMP_display.Writer_do_destroy(self)

# Register Writer in _IMP_display:
_IMP_display.Writer_swigregister(Writer)
class TextWriter(Writer):
    r"""Proxy of C++ IMP::display::TextWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def open(self):
        r"""open(TextWriter self)"""
        return _IMP_display.TextWriter_open(self)

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

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

    def __init__(self, *args):
        r"""
        __init__(TextWriter self, TextOutput fn) -> TextWriter
        __init__(TextWriter self, std::string name) -> TextWriter
        """
        if self.__class__ == TextWriter:
            _self = None
        else:
            _self = self
        _IMP_display.TextWriter_swiginit(self, _IMP_display.new_TextWriter(_self, *args))

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




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

    def __str__(self):
        r"""__str__(TextWriter self) -> std::string"""
        return _IMP_display.TextWriter___str__(self)

    def __repr__(self):
        r"""__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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""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):
        r"""do_destroy(TextWriter self)"""
        return _IMP_display.TextWriter_do_destroy(self)

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

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

# Register TextWriter in _IMP_display:
_IMP_display.TextWriter_swigregister(TextWriter)

def create_writer(filename):
    r"""create_writer(std::string filename) -> Writer"""
    return _IMP_display.create_writer(filename)
class WriterAdaptor(IMP._InputAdaptor):
    r"""Proxy of C++ IMP::display::WriterAdaptor class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(WriterAdaptor self, std::string name) -> WriterAdaptor
        __init__(WriterAdaptor self, Writer w) -> WriterAdaptor
        """
        _IMP_display.WriterAdaptor_swiginit(self, _IMP_display.new_WriterAdaptor(*args))

    def get_writer(self):
        r"""get_writer(WriterAdaptor self) -> Writer"""
        return _IMP_display.WriterAdaptor_get_writer(self)

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

    def __str__(self):
        r"""__str__(WriterAdaptor self) -> std::string"""
        return _IMP_display.WriterAdaptor___str__(self)

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

# Register WriterAdaptor in _IMP_display:
_IMP_display.WriterAdaptor_swigregister(WriterAdaptor)
class Colored(IMP.Decorator):
    r"""Proxy of C++ IMP::display::Colored class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

    def __init__(self, *args):
        r"""
        __init__(Colored self) -> Colored
        __init__(Colored self, Model m, ParticleIndex id) -> Colored
        __init__(Colored self, _ParticleAdaptor d) -> Colored
        """
        _IMP_display.Colored_swiginit(self, _IMP_display.new_Colored(*args))

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

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

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

    def add_attribute(self, *args):
        r"""
        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, FloatsKey a0, IMP::Floats a1)
        add_attribute(Colored self, IntsKey a0, IMP::Ints 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):
        r"""
        get_value(Colored self, FloatKey a0) -> IMP::Float
        get_value(Colored self, IntKey a0) -> IMP::Int
        get_value(Colored self, FloatsKey a0) -> IMP::Floats
        get_value(Colored self, IntsKey a0) -> IMP::Ints
        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):
        r"""
        set_value(Colored self, FloatKey a0, IMP::Float a1)
        set_value(Colored self, IntKey a0, IMP::Int a1)
        set_value(Colored self, FloatsKey a0, IMP::Floats a1)
        set_value(Colored self, IntsKey a0, IMP::Ints 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):
        r"""
        remove_attribute(Colored self, FloatKey a0)
        remove_attribute(Colored self, IntKey a0)
        remove_attribute(Colored self, FloatsKey a0)
        remove_attribute(Colored self, IntsKey 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):
        r"""
        has_attribute(Colored self, FloatKey a0) -> bool
        has_attribute(Colored self, IntKey a0) -> bool
        has_attribute(Colored self, FloatsKey a0) -> bool
        has_attribute(Colored self, IntsKey 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):
        r"""get_derivative(Colored self, FloatKey a0) -> double"""
        return _IMP_display.Colored_get_derivative(self, a0)

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

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

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

    def set_check_level(self, a0):
        r"""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):
        r"""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):
        r"""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):
        r"""get_is_optimized(Colored self, FloatKey a0) -> bool"""
        return _IMP_display.Colored_get_is_optimized(self, a0)

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

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

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

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

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

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

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

    def __hash__(self):
        r"""__hash__(Colored self) -> std::size_t"""
        return _IMP_display.Colored___hash__(self)

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

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

    def _get_as_binary(self):
        r"""_get_as_binary(Colored self) -> PyObject *"""
        return _IMP_display.Colored__get_as_binary(self)

    def _set_from_binary(self, p):
        r"""_set_from_binary(Colored self, PyObject * p)"""
        return _IMP_display.Colored__set_from_binary(self, p)

    def __getstate__(self):
        p = self._get_as_binary()
        if len(self.__dict__) > 1:
            d = self.__dict__.copy()
            del d['this']
            p = (d, p)
        return p

    def __setstate__(self, p):
        if not hasattr(self, 'this'):
            self.__init__()
        if isinstance(p, tuple):
            d, p = p
            self.__dict__.update(d)
        return self._set_from_binary(p)

    __swig_destroy__ = _IMP_display.delete_Colored

# Register Colored in _IMP_display:
_IMP_display.Colored_swigregister(Colored)

def __lshift__(out, n):
    r"""__lshift__(_ostream out, Colored n) -> _ostream"""
    return _IMP_display.__lshift__(out, n)
class FilterGeometry(GeometryProcessor, Geometry):
    r"""Proxy of C++ IMP::display::FilterGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, p):
        r"""__init__(FilterGeometry self, Plane3D p) -> FilterGeometry"""
        _IMP_display.FilterGeometry_swiginit(self, _IMP_display.new_FilterGeometry(p))

    def add_geometry(self, *args):
        r"""
        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):
        r"""get_version_info(FilterGeometry self) -> VersionInfo"""
        return _IMP_display.FilterGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_FilterGeometry

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

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

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


# Register FilterGeometry in _IMP_display:
_IMP_display.FilterGeometry_swigregister(FilterGeometry)
class WriteOptimizerState(IMP.OptimizerState):
    r"""Proxy of C++ IMP::display::WriteOptimizerState class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, m, w):
        r"""__init__(WriteOptimizerState self, Model m, WriterAdaptor w) -> WriteOptimizerState"""
        _IMP_display.WriteOptimizerState_swiginit(self, _IMP_display.new_WriteOptimizerState(m, w))

    def write(self, w):
        r"""write(WriteOptimizerState self, WriterAdaptor w)"""
        return _IMP_display.WriteOptimizerState_write(self, w)
    def __get_geometries(self):  return IMP._list_util.VarList(getdimfunc=self.get_number_of_geometries,  getfunc=self.get_geometry, erasefunc=self.erase_geometry,  appendfunc=self.add_geometry, extendfunc=self.add_geometries,  clearfunc=self.clear_geometries, indexfunc=self._python_index_geometry)  
    def __set_geometries(self, obj): IMP._list_util.set_varlist(self.geometries, obj)  
    def __del_geometries(self): IMP._list_util.del_varlist(self.geometries)       
    geometries = property(__get_geometries, __set_geometries, __del_geometries, doc="List of ##ucnames")  

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

    def _python_index_geometry(self, d, start, stop):
        r"""_python_index_geometry(WriteOptimizerState self, Geometry d, unsigned int start, unsigned int stop) -> unsigned int"""
        return _IMP_display.WriteOptimizerState__python_index_geometry(self, d, start, stop)

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

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

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

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

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

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

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

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

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

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

    def erase_geometry(self, i):
        r"""erase_geometry(WriteOptimizerState self, unsigned int i)"""
        return _IMP_display.WriteOptimizerState_erase_geometry(self, i)

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

    def get_version_info(self):
        r"""get_version_info(WriteOptimizerState self) -> VersionInfo"""
        return _IMP_display.WriteOptimizerState_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_WriteOptimizerState

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

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

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


# Register WriteOptimizerState in _IMP_display:
_IMP_display.WriteOptimizerState_swigregister(WriteOptimizerState)
class SingletonGeometry(Geometry):
    r"""Proxy of C++ IMP::display::SingletonGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, p):
        r"""__init__(SingletonGeometry self, Particle p) -> SingletonGeometry"""
        _IMP_display.SingletonGeometry_swiginit(self, _IMP_display.new_SingletonGeometry(p))

    def get_particle(self):
        r"""get_particle(SingletonGeometry self) -> Particle"""
        return _IMP_display.SingletonGeometry_get_particle(self)
    __swig_destroy__ = _IMP_display.delete_SingletonGeometry

    def __str__(self):
        r"""__str__(SingletonGeometry self) -> std::string"""
        return _IMP_display.SingletonGeometry___str__(self)

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

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


# Register SingletonGeometry in _IMP_display:
_IMP_display.SingletonGeometry_swigregister(SingletonGeometry)
class SingletonsGeometry(Geometry):
    r"""Proxy of C++ IMP::display::SingletonsGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(SingletonsGeometry self, _SingletonContainerAdaptor pc, Color c) -> SingletonsGeometry
        __init__(SingletonsGeometry self, _SingletonContainerAdaptor pc) -> SingletonsGeometry
        """
        _IMP_display.SingletonsGeometry_swiginit(self, _IMP_display.new_SingletonsGeometry(*args))

    def get_container(self):
        r"""get_container(SingletonsGeometry self) -> SingletonContainer"""
        return _IMP_display.SingletonsGeometry_get_container(self)
    __swig_destroy__ = _IMP_display.delete_SingletonsGeometry

    def __str__(self):
        r"""__str__(SingletonsGeometry self) -> std::string"""
        return _IMP_display.SingletonsGeometry___str__(self)

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

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


# Register SingletonsGeometry in _IMP_display:
_IMP_display.SingletonsGeometry_swigregister(SingletonsGeometry)
class PairGeometry(Geometry):
    r"""Proxy of C++ IMP::display::PairGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, pp):
        r"""__init__(PairGeometry self, IMP::ParticlePair const & pp) -> PairGeometry"""
        _IMP_display.PairGeometry_swiginit(self, _IMP_display.new_PairGeometry(pp))

    def get_particle_pair(self):
        r"""get_particle_pair(PairGeometry self) -> IMP::ParticlePair"""
        return _IMP_display.PairGeometry_get_particle_pair(self)
    __swig_destroy__ = _IMP_display.delete_PairGeometry

    def __str__(self):
        r"""__str__(PairGeometry self) -> std::string"""
        return _IMP_display.PairGeometry___str__(self)

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

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


# Register PairGeometry in _IMP_display:
_IMP_display.PairGeometry_swigregister(PairGeometry)
class PairsGeometry(Geometry):
    r"""Proxy of C++ IMP::display::PairsGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(PairsGeometry self, PairContainer pc, Color c) -> PairsGeometry
        __init__(PairsGeometry self, PairContainer pc) -> PairsGeometry
        """
        _IMP_display.PairsGeometry_swiginit(self, _IMP_display.new_PairsGeometry(*args))

    def get_container(self):
        r"""get_container(PairsGeometry self) -> PairContainer"""
        return _IMP_display.PairsGeometry_get_container(self)
    __swig_destroy__ = _IMP_display.delete_PairsGeometry

    def __str__(self):
        r"""__str__(PairsGeometry self) -> std::string"""
        return _IMP_display.PairsGeometry___str__(self)

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

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


# Register PairsGeometry in _IMP_display:
_IMP_display.PairsGeometry_swigregister(PairsGeometry)
class PymolWriter(TextWriter):
    r"""Proxy of C++ IMP::display::PymolWriter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args):
        r"""
        __init__(PymolWriter self, TextOutput of) -> PymolWriter
        __init__(PymolWriter self, std::string name) -> PymolWriter
        __init__(PymolWriter self, char const * name) -> PymolWriter
        """
        _IMP_display.PymolWriter_swiginit(self, _IMP_display.new_PymolWriter(*args))

    def get_version_info(self):
        r"""get_version_info(PymolWriter self) -> VersionInfo"""
        return _IMP_display.PymolWriter_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_PymolWriter

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

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

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


# Register PymolWriter in _IMP_display:
_IMP_display.PymolWriter_swigregister(PymolWriter)
class RestraintGeometry(Geometry):
    r"""Proxy of C++ IMP::display::RestraintGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, p):
        r"""__init__(RestraintGeometry self, Restraint p) -> RestraintGeometry"""
        _IMP_display.RestraintGeometry_swiginit(self, _IMP_display.new_RestraintGeometry(p))

    def get_restraint(self):
        r"""get_restraint(RestraintGeometry self) -> Restraint"""
        return _IMP_display.RestraintGeometry_get_restraint(self)

    def get_version_info(self):
        r"""get_version_info(RestraintGeometry self) -> VersionInfo"""
        return _IMP_display.RestraintGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_RestraintGeometry

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

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

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


# Register RestraintGeometry in _IMP_display:
_IMP_display.RestraintGeometry_swigregister(RestraintGeometry)
class RestraintSetGeometry(Geometry):
    r"""Proxy of C++ IMP::display::RestraintSetGeometry class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, p):
        r"""__init__(RestraintSetGeometry self, RestraintSet p) -> RestraintSetGeometry"""
        _IMP_display.RestraintSetGeometry_swiginit(self, _IMP_display.new_RestraintSetGeometry(p))

    def get_restraint_set(self):
        r"""get_restraint_set(RestraintSetGeometry self) -> RestraintSet"""
        return _IMP_display.RestraintSetGeometry_get_restraint_set(self)

    def get_version_info(self):
        r"""get_version_info(RestraintSetGeometry self) -> VersionInfo"""
        return _IMP_display.RestraintSetGeometry_get_version_info(self)
    __swig_destroy__ = _IMP_display.delete_RestraintSetGeometry

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

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

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


# Register RestraintSetGeometry in _IMP_display:
_IMP_display.RestraintSetGeometry_swigregister(RestraintSetGeometry)

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


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

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

def get_data_path(fname):
    r"""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()