kinematics/__init__.py

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

from __future__ import print_function, division, absolute_import




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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        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(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


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 __builtin__.Exception:
    weakref_proxy = lambda x: x


class IMP_KINEMATICS_SwigPyIterator(object):
    """Proxy of C++ swig::IMP_KINEMATICS_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_kinematics.delete_IMP_KINEMATICS_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        """value(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_value(self)


    def incr(self, n=1):
        """
        incr(IMP_KINEMATICS_SwigPyIterator self, size_t n=1) -> IMP_KINEMATICS_SwigPyIterator
        incr(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_incr(self, n)


    def decr(self, n=1):
        """
        decr(IMP_KINEMATICS_SwigPyIterator self, size_t n=1) -> IMP_KINEMATICS_SwigPyIterator
        decr(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_decr(self, n)


    def distance(self, x):
        """distance(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_distance(self, x)


    def equal(self, x):
        """equal(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_equal(self, x)


    def copy(self):
        """copy(IMP_KINEMATICS_SwigPyIterator self) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_copy(self)


    def next(self):
        """next(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_next(self)


    def __next__(self):
        """__next__(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___next__(self)


    def previous(self):
        """previous(IMP_KINEMATICS_SwigPyIterator self) -> PyObject *"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_previous(self)


    def advance(self, n):
        """advance(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_advance(self, n)


    def __eq__(self, x):
        """__eq__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___eq__(self, x)


    def __ne__(self, x):
        """__ne__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> bool"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___ne__(self, x)


    def __iadd__(self, n):
        """__iadd__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___iadd__(self, n)


    def __isub__(self, n):
        """__isub__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___isub__(self, n)


    def __add__(self, n):
        """__add__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator"""
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___add__(self, n)


    def __sub__(self, *args):
        """
        __sub__(IMP_KINEMATICS_SwigPyIterator self, ptrdiff_t n) -> IMP_KINEMATICS_SwigPyIterator
        __sub__(IMP_KINEMATICS_SwigPyIterator self, IMP_KINEMATICS_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator___sub__(self, *args)

    def __iter__(self):
        return self
IMP_KINEMATICS_SwigPyIterator_swigregister = _IMP_kinematics.IMP_KINEMATICS_SwigPyIterator_swigregister
IMP_KINEMATICS_SwigPyIterator_swigregister(IMP_KINEMATICS_SwigPyIterator)


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

IMP_DEBUG = _IMP_kinematics.IMP_DEBUG
IMP_RELEASE = _IMP_kinematics.IMP_RELEASE
IMP_SILENT = _IMP_kinematics.IMP_SILENT
IMP_PROGRESS = _IMP_kinematics.IMP_PROGRESS
IMP_TERSE = _IMP_kinematics.IMP_TERSE
IMP_VERBOSE = _IMP_kinematics.IMP_VERBOSE
IMP_MEMORY = _IMP_kinematics.IMP_MEMORY
IMP_NONE = _IMP_kinematics.IMP_NONE
IMP_USAGE = _IMP_kinematics.IMP_USAGE
IMP_INTERNAL = _IMP_kinematics.IMP_INTERNAL
IMP_KERNEL_HAS_LOG4CXX = _IMP_kinematics.IMP_KERNEL_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_kinematics.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_kinematics.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_COMPILER_HAS_UNIQUE_PTR = _IMP_kinematics.IMP_COMPILER_HAS_UNIQUE_PTR
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_GPERFTOOLS = _IMP_kinematics.IMP_KERNEL_HAS_GPERFTOOLS
IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_kinematics.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
IMPKERNEL_SHOW_WARNINGS = _IMP_kinematics.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_kinematics._ostream_write(self, osa_buf)

_ostream_swigregister = _IMP_kinematics._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_kinematics.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_kinematics.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_kinematics.IMP_HAS_NOEXCEPT
import IMP
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_kinematics.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_kinematics.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_kinematics.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_kinematics.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_kinematics.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_kinematics.IMPDISPLAY_SHOW_WARNINGS
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_CGAL
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_kinematics.IMP_SCORE_FUNCTOR_HAS_HDF5
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_kinematics.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor
IMP_CORE_HAS_IMP_CGAL = _IMP_kinematics.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_kinematics.IMP_CORE_HAS_CGAL
IMP_CORE_HAS_HDF5 = _IMP_kinematics.IMP_CORE_HAS_HDF5
IMPCORE_SHOW_WARNINGS = _IMP_kinematics.IMPCORE_SHOW_WARNINGS
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_kinematics.IMP_CONTAINER_HAS_CGAL
IMP_CONTAINER_HAS_HDF5 = _IMP_kinematics.IMP_CONTAINER_HAS_HDF5
IMPCONTAINER_SHOW_WARNINGS = _IMP_kinematics.IMPCONTAINER_SHOW_WARNINGS
import IMP.container
IMP_ATOM_HAS_IMP_CGAL = _IMP_kinematics.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_kinematics.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_kinematics.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_kinematics.IMP_ATOM_HAS_CGAL
IMP_ATOM_HAS_HDF5 = _IMP_kinematics.IMP_ATOM_HAS_HDF5
IMPATOM_SHOW_WARNINGS = _IMP_kinematics.IMPATOM_SHOW_WARNINGS
IMP_ATOM_TYPE_INDEX = _IMP_kinematics.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_kinematics.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_kinematics.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_SAXS_HAS_IMP_CGAL = _IMP_kinematics.IMP_SAXS_HAS_IMP_CGAL
IMP_SAXS_HAS_IMP_CONTAINER = _IMP_kinematics.IMP_SAXS_HAS_IMP_CONTAINER
IMP_SAXS_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_SAXS_HAS_IMP_DISPLAY
IMP_SAXS_HAS_IMP_KERNEL = _IMP_kinematics.IMP_SAXS_HAS_IMP_KERNEL
IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR
IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_FILESYSTEM
IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS
IMP_SAXS_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_RANDOM
IMP_SAXS_HAS_BOOST_REGEX = _IMP_kinematics.IMP_SAXS_HAS_BOOST_REGEX
IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_SAXS_HAS_BOOST_SYSTEM
IMP_SAXS_HAS_CGAL = _IMP_kinematics.IMP_SAXS_HAS_CGAL
IMP_SAXS_HAS_HDF5 = _IMP_kinematics.IMP_SAXS_HAS_HDF5
IMPSAXS_SHOW_WARNINGS = _IMP_kinematics.IMPSAXS_SHOW_WARNINGS
import IMP.saxs
IMP_KINEMATICS_HAS_IMP_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_CGAL
IMP_KINEMATICS_HAS_IMP_DISPLAY = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_DISPLAY
IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR = _IMP_kinematics.IMP_KINEMATICS_HAS_IMP_SCORE_FUNCTOR
IMP_KINEMATICS_HAS_BOOST_FILESYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_FILESYSTEM
IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_PROGRAMOPTIONS
IMP_KINEMATICS_HAS_BOOST_RANDOM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_RANDOM
IMP_KINEMATICS_HAS_BOOST_REGEX = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_REGEX
IMP_KINEMATICS_HAS_BOOST_SYSTEM = _IMP_kinematics.IMP_KINEMATICS_HAS_BOOST_SYSTEM
IMP_KINEMATICS_HAS_CGAL = _IMP_kinematics.IMP_KINEMATICS_HAS_CGAL
IMP_KINEMATICS_HAS_HDF5 = _IMP_kinematics.IMP_KINEMATICS_HAS_HDF5
IMPKINEMATICS_SHOW_WARNINGS = _IMP_kinematics.IMPKINEMATICS_SHOW_WARNINGS

_object_types.append("Joint")


def _object_cast_to_Joint(o):
    """_object_cast_to_Joint(Object o) -> Joint"""
    return _IMP_kinematics._object_cast_to_Joint(o)

_object_types.append("TransformationJoint")


def _object_cast_to_TransformationJoint(o):
    """_object_cast_to_TransformationJoint(Object o) -> TransformationJoint"""
    return _IMP_kinematics._object_cast_to_TransformationJoint(o)

_object_types.append("RevoluteJoint")


def _object_cast_to_RevoluteJoint(o):
    """_object_cast_to_RevoluteJoint(Object o) -> RevoluteJoint"""
    return _IMP_kinematics._object_cast_to_RevoluteJoint(o)

_object_types.append("DihedralAngleRevoluteJoint")


def _object_cast_to_DihedralAngleRevoluteJoint(o):
    """_object_cast_to_DihedralAngleRevoluteJoint(Object o) -> DihedralAngleRevoluteJoint"""
    return _IMP_kinematics._object_cast_to_DihedralAngleRevoluteJoint(o)

_object_types.append("BondAngleRevoluteJoint")


def _object_cast_to_BondAngleRevoluteJoint(o):
    """_object_cast_to_BondAngleRevoluteJoint(Object o) -> BondAngleRevoluteJoint"""
    return _IMP_kinematics._object_cast_to_BondAngleRevoluteJoint(o)

_object_types.append("PrismaticJoint")


def _object_cast_to_PrismaticJoint(o):
    """_object_cast_to_PrismaticJoint(Object o) -> PrismaticJoint"""
    return _IMP_kinematics._object_cast_to_PrismaticJoint(o)

_object_types.append("KinematicForest")


def _object_cast_to_KinematicForest(o):
    """_object_cast_to_KinematicForest(Object o) -> KinematicForest"""
    return _IMP_kinematics._object_cast_to_KinematicForest(o)

_object_types.append("KinematicForestScoreState")


def _object_cast_to_KinematicForestScoreState(o):
    """_object_cast_to_KinematicForestScoreState(Object o) -> KinematicForestScoreState"""
    return _IMP_kinematics._object_cast_to_KinematicForestScoreState(o)

_object_types.append("CompositeJoint")


def _object_cast_to_CompositeJoint(o):
    """_object_cast_to_CompositeJoint(Object o) -> CompositeJoint"""
    return _IMP_kinematics._object_cast_to_CompositeJoint(o)

_object_types.append("RevoluteJointMover")


def _object_cast_to_RevoluteJointMover(o):
    """_object_cast_to_RevoluteJointMover(Object o) -> RevoluteJointMover"""
    return _IMP_kinematics._object_cast_to_RevoluteJointMover(o)

_object_types.append("DOF")


def _object_cast_to_DOF(o):
    """_object_cast_to_DOF(Object o) -> DOF"""
    return _IMP_kinematics._object_cast_to_DOF(o)

DOFValuesList=list
_plural_types.append("DOFValuesList")
_value_types.append("DOFValues")


_object_types.append("DirectionalDOF")


def _object_cast_to_DirectionalDOF(o):
    """_object_cast_to_DirectionalDOF(Object o) -> DirectionalDOF"""
    return _IMP_kinematics._object_cast_to_DirectionalDOF(o)

_object_types.append("DOFsSampler")


def _object_cast_to_DOFsSampler(o):
    """_object_cast_to_DOFsSampler(Object o) -> DOFsSampler"""
    return _IMP_kinematics._object_cast_to_DOFsSampler(o)

_object_types.append("UniformBackboneSampler")


def _object_cast_to_UniformBackboneSampler(o):
    """_object_cast_to_UniformBackboneSampler(Object o) -> UniformBackboneSampler"""
    return _IMP_kinematics._object_cast_to_UniformBackboneSampler(o)

_object_types.append("ProteinKinematics")


def _object_cast_to_ProteinKinematics(o):
    """_object_cast_to_ProteinKinematics(Object o) -> ProteinKinematics"""
    return _IMP_kinematics._object_cast_to_ProteinKinematics(o)

_object_types.append("LocalPlanner")


def _object_cast_to_LocalPlanner(o):
    """_object_cast_to_LocalPlanner(Object o) -> LocalPlanner"""
    return _IMP_kinematics._object_cast_to_LocalPlanner(o)

_object_types.append("PathLocalPlanner")


def _object_cast_to_PathLocalPlanner(o):
    """_object_cast_to_PathLocalPlanner(Object o) -> PathLocalPlanner"""
    return _IMP_kinematics._object_cast_to_PathLocalPlanner(o)

_object_types.append("RRT")


def _object_cast_to_RRT(o):
    """_object_cast_to_RRT(Object o) -> RRT"""
    return _IMP_kinematics._object_cast_to_RRT(o)
class Joint(IMP.Object):
    """Proxy of C++ IMP::kinematics::Joint class."""

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

    def get_version_info(self):
        """get_version_info(Joint self) -> VersionInfo"""
        return _IMP_kinematics.Joint_get_version_info(self)


    def __init__(self, parent, child):
        """__init__(IMP::kinematics::Joint self, RigidBody parent, RigidBody child) -> Joint"""
        this = _IMP_kinematics.new_Joint(parent, child)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_owner_kf(self):
        """get_owner_kf(Joint self) -> KinematicForest"""
        return _IMP_kinematics.Joint_get_owner_kf(self)


    def get_transformation_child_to_parent(self):
        """get_transformation_child_to_parent(Joint self) -> Transformation3D"""
        return _IMP_kinematics.Joint_get_transformation_child_to_parent(self)


    def get_parent_node(self):
        """get_parent_node(Joint self) -> RigidBody"""
        return _IMP_kinematics.Joint_get_parent_node(self)


    def get_child_node(self):
        """get_child_node(Joint self) -> RigidBody"""
        return _IMP_kinematics.Joint_get_child_node(self)


    def __str__(self):
        """__str__(Joint self) -> std::string"""
        return _IMP_kinematics.Joint___str__(self)


    def __repr__(self):
        """__repr__(Joint self) -> std::string"""
        return _IMP_kinematics.Joint___repr__(self)


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

Joint_swigregister = _IMP_kinematics.Joint_swigregister
Joint_swigregister(Joint)

class TransformationJoint(Joint):
    """Proxy of C++ IMP::kinematics::TransformationJoint class."""

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

    def __init__(self, parent, child):
        """__init__(IMP::kinematics::TransformationJoint self, RigidBody parent, RigidBody child) -> TransformationJoint"""
        this = _IMP_kinematics.new_TransformationJoint(parent, child)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def set_transformation_child_to_parent(self, transformation):
        """set_transformation_child_to_parent(TransformationJoint self, Transformation3D transformation)"""
        return _IMP_kinematics.TransformationJoint_set_transformation_child_to_parent(self, transformation)


    def __str__(self):
        """__str__(TransformationJoint self) -> std::string"""
        return _IMP_kinematics.TransformationJoint___str__(self)


    def __repr__(self):
        """__repr__(TransformationJoint self) -> std::string"""
        return _IMP_kinematics.TransformationJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_TransformationJoint
    __del__ = lambda self: None
TransformationJoint_swigregister = _IMP_kinematics.TransformationJoint_swigregister
TransformationJoint_swigregister(TransformationJoint)

class PrismaticJoint(Joint):
    """Proxy of C++ IMP::kinematics::PrismaticJoint 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::kinematics::PrismaticJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b) -> PrismaticJoint
        __init__(IMP::kinematics::PrismaticJoint self, RigidBody parent, RigidBody child) -> PrismaticJoint
        """
        this = _IMP_kinematics.new_PrismaticJoint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_length(self):
        """get_length(PrismaticJoint self) -> double"""
        return _IMP_kinematics.PrismaticJoint_get_length(self)


    def set_length(self, l):
        """set_length(PrismaticJoint self, double l)"""
        return _IMP_kinematics.PrismaticJoint_set_length(self, l)


    def __str__(self):
        """__str__(PrismaticJoint self) -> std::string"""
        return _IMP_kinematics.PrismaticJoint___str__(self)


    def __repr__(self):
        """__repr__(PrismaticJoint self) -> std::string"""
        return _IMP_kinematics.PrismaticJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_PrismaticJoint
    __del__ = lambda self: None
PrismaticJoint_swigregister = _IMP_kinematics.PrismaticJoint_swigregister
PrismaticJoint_swigregister(PrismaticJoint)

class CompositeJoint(Joint):
    """Proxy of C++ IMP::kinematics::CompositeJoint 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::kinematics::CompositeJoint self, RigidBody parent, RigidBody child, IMP::kinematics::Joints joints) -> CompositeJoint
        __init__(IMP::kinematics::CompositeJoint self, RigidBody parent, RigidBody child) -> CompositeJoint
        """
        this = _IMP_kinematics.new_CompositeJoint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add_downstream_joint(self, j):
        """add_downstream_joint(CompositeJoint self, Joint j)"""
        return _IMP_kinematics.CompositeJoint_add_downstream_joint(self, j)


    def add_upstream_joint(self, j):
        """add_upstream_joint(CompositeJoint self, Joint j)"""
        return _IMP_kinematics.CompositeJoint_add_upstream_joint(self, j)


    def set_joints(self, joints):
        """set_joints(CompositeJoint self, IMP::kinematics::Joints joints)"""
        return _IMP_kinematics.CompositeJoint_set_joints(self, joints)


    def get_inner_joints(self):
        """get_inner_joints(CompositeJoint self) -> IMP::kinematics::Joints const &"""
        return _IMP_kinematics.CompositeJoint_get_inner_joints(self)


    def __str__(self):
        """__str__(CompositeJoint self) -> std::string"""
        return _IMP_kinematics.CompositeJoint___str__(self)


    def __repr__(self):
        """__repr__(CompositeJoint self) -> std::string"""
        return _IMP_kinematics.CompositeJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_CompositeJoint
    __del__ = lambda self: None
CompositeJoint_swigregister = _IMP_kinematics.CompositeJoint_swigregister
CompositeJoint_swigregister(CompositeJoint)

class RevoluteJoint(Joint):
    """Proxy of C++ IMP::kinematics::RevoluteJoint class."""

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

    def __init__(self, parent, child):
        """__init__(IMP::kinematics::RevoluteJoint self, RigidBody parent, RigidBody child) -> RevoluteJoint"""
        if self.__class__ == RevoluteJoint:
            _self = None
        else:
            _self = self
        this = _IMP_kinematics.new_RevoluteJoint(_self, parent, child)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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



    __swig_destroy__ = _IMP_kinematics.delete_RevoluteJoint
    __del__ = lambda self: None

    def set_angle(self, angle):
        """set_angle(RevoluteJoint self, double angle)"""
        return _IMP_kinematics.RevoluteJoint_set_angle(self, angle)


    def get_angle(self):
        """get_angle(RevoluteJoint self) -> double"""
        return _IMP_kinematics.RevoluteJoint_get_angle(self)


    def get_rot_axis_origin(self):
        """get_rot_axis_origin(RevoluteJoint self) -> Vector3D"""
        return _IMP_kinematics.RevoluteJoint_get_rot_axis_origin(self)


    def get_rot_axis_unit_vector(self):
        """get_rot_axis_unit_vector(RevoluteJoint self) -> Vector3D"""
        return _IMP_kinematics.RevoluteJoint_get_rot_axis_unit_vector(self)


    def update_child_node_reference_frame(self):
        """update_child_node_reference_frame(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_child_node_reference_frame(self)


    def update_axis_of_rotation_from_cartesian_witnesses(self):
        """update_axis_of_rotation_from_cartesian_witnesses(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_axis_of_rotation_from_cartesian_witnesses(self)


    def get_current_angle_from_cartesian_witnesses(self):
        """get_current_angle_from_cartesian_witnesses(RevoluteJoint self) -> double"""
        return _IMP_kinematics.RevoluteJoint_get_current_angle_from_cartesian_witnesses(self)


    def update_joint_from_cartesian_witnesses(self):
        """update_joint_from_cartesian_witnesses(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_update_joint_from_cartesian_witnesses(self)


    def get_rotation_about_joint_in_parent_coordinates(self):
        """get_rotation_about_joint_in_parent_coordinates(RevoluteJoint self) -> Transformation3D"""
        return _IMP_kinematics.RevoluteJoint_get_rotation_about_joint_in_parent_coordinates(self)

    angle_ = _swig_property(_IMP_kinematics.RevoluteJoint_angle__get, _IMP_kinematics.RevoluteJoint_angle__set)
    last_updated_angle_ = _swig_property(_IMP_kinematics.RevoluteJoint_last_updated_angle__get, _IMP_kinematics.RevoluteJoint_last_updated_angle__set)
    rot_axis_unit_vector_ = _swig_property(_IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__get, _IMP_kinematics.RevoluteJoint_rot_axis_unit_vector__set)
    rot_axis_origin_ = _swig_property(_IMP_kinematics.RevoluteJoint_rot_axis_origin__get, _IMP_kinematics.RevoluteJoint_rot_axis_origin__set)

    def __str__(self):
        """__str__(RevoluteJoint self) -> std::string"""
        return _IMP_kinematics.RevoluteJoint___str__(self)


    def __repr__(self):
        """__repr__(RevoluteJoint self) -> std::string"""
        return _IMP_kinematics.RevoluteJoint___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kinematics" == "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_RevoluteJoint(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kinematics.disown_RevoluteJoint(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(RevoluteJoint self)"""
        return _IMP_kinematics.RevoluteJoint_do_destroy(self)

RevoluteJoint_swigregister = _IMP_kinematics.RevoluteJoint_swigregister
RevoluteJoint_swigregister(RevoluteJoint)

class DihedralAngleRevoluteJoint(RevoluteJoint):
    """Proxy of C++ IMP::kinematics::DihedralAngleRevoluteJoint class."""

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

    def __init__(self, parent, child, a, b, c, d):
        """__init__(IMP::kinematics::DihedralAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c, XYZ d) -> DihedralAngleRevoluteJoint"""
        this = _IMP_kinematics.new_DihedralAngleRevoluteJoint(parent, child, a, b, c, d)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_a(self):
        """get_a(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_a(self)


    def get_b(self):
        """get_b(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_b(self)


    def get_c(self):
        """get_c(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_c(self)


    def get_d(self):
        """get_d(DihedralAngleRevoluteJoint self) -> XYZ"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint_get_d(self)


    def __str__(self):
        """__str__(DihedralAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint___str__(self)


    def __repr__(self):
        """__repr__(DihedralAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.DihedralAngleRevoluteJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_DihedralAngleRevoluteJoint
    __del__ = lambda self: None
DihedralAngleRevoluteJoint_swigregister = _IMP_kinematics.DihedralAngleRevoluteJoint_swigregister
DihedralAngleRevoluteJoint_swigregister(DihedralAngleRevoluteJoint)

class BondAngleRevoluteJoint(RevoluteJoint):
    """Proxy of C++ IMP::kinematics::BondAngleRevoluteJoint class."""

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

    def __init__(self, parent, child, a, b, c):
        """__init__(IMP::kinematics::BondAngleRevoluteJoint self, RigidBody parent, RigidBody child, XYZ a, XYZ b, XYZ c) -> BondAngleRevoluteJoint"""
        this = _IMP_kinematics.new_BondAngleRevoluteJoint(parent, child, a, b, c)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        """__str__(BondAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.BondAngleRevoluteJoint___str__(self)


    def __repr__(self):
        """__repr__(BondAngleRevoluteJoint self) -> std::string"""
        return _IMP_kinematics.BondAngleRevoluteJoint___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_BondAngleRevoluteJoint
    __del__ = lambda self: None
BondAngleRevoluteJoint_swigregister = _IMP_kinematics.BondAngleRevoluteJoint_swigregister
BondAngleRevoluteJoint_swigregister(BondAngleRevoluteJoint)

class RevoluteJointMover(IMP.core.MonteCarloMover):
    """Proxy of C++ IMP::kinematics::RevoluteJointMover class."""

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

    def __init__(self, m, joints, stddev=0.01):
        """
        __init__(IMP::kinematics::RevoluteJointMover self, Model m, IMP::kinematics::RevoluteJoints const & joints, double const stddev=0.01) -> RevoluteJointMover
        __init__(IMP::kinematics::RevoluteJointMover self, Model m, IMP::kinematics::RevoluteJoints const & joints) -> RevoluteJointMover
        """
        this = _IMP_kinematics.new_RevoluteJointMover(m, joints, stddev)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def set_sigma(self, sigma):
        """set_sigma(RevoluteJointMover self, IMP::Float sigma)"""
        return _IMP_kinematics.RevoluteJointMover_set_sigma(self, sigma)


    def get_sigma(self):
        """get_sigma(RevoluteJointMover self) -> IMP::Float"""
        return _IMP_kinematics.RevoluteJointMover_get_sigma(self)


    def get_version_info(self):
        """get_version_info(RevoluteJointMover self) -> VersionInfo"""
        return _IMP_kinematics.RevoluteJointMover_get_version_info(self)


    def __str__(self):
        """__str__(RevoluteJointMover self) -> std::string"""
        return _IMP_kinematics.RevoluteJointMover___str__(self)


    def __repr__(self):
        """__repr__(RevoluteJointMover self) -> std::string"""
        return _IMP_kinematics.RevoluteJointMover___repr__(self)


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

RevoluteJointMover_swigregister = _IMP_kinematics.RevoluteJointMover_swigregister
RevoluteJointMover_swigregister(RevoluteJointMover)

class KinematicForest(IMP.Object):
    """Proxy of C++ IMP::kinematics::KinematicForest class."""

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

    def get_version_info(self):
        """get_version_info(KinematicForest self) -> VersionInfo"""
        return _IMP_kinematics.KinematicForest_get_version_info(self)


    def __init__(self, *args):
        """
        __init__(IMP::kinematics::KinematicForest self, Model m) -> KinematicForest
        __init__(IMP::kinematics::KinematicForest self, Model m, Hierarchy hierarchy) -> KinematicForest
        """
        this = _IMP_kinematics.new_KinematicForest(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add_edge(self, *args):
        """
        add_edge(KinematicForest self, RigidBody parent, RigidBody child) -> Joint
        add_edge(KinematicForest self, Joint joint)
        """
        return _IMP_kinematics.KinematicForest_add_edge(self, *args)


    def add_rigid_bodies_in_chain(self, rbs):
        """add_rigid_bodies_in_chain(KinematicForest self, IMP::core::RigidBodies rbs)"""
        return _IMP_kinematics.KinematicForest_add_rigid_bodies_in_chain(self, rbs)


    def reset_root(self, new_root):
        """reset_root(KinematicForest self, Particle new_root)"""
        return _IMP_kinematics.KinematicForest_reset_root(self, new_root)


    def update_all_internal_coordinates(self):
        """update_all_internal_coordinates(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_update_all_internal_coordinates(self)


    def update_all_external_coordinates(self):
        """update_all_external_coordinates(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_update_all_external_coordinates(self)


    def get_ordered_joints(self):
        """get_ordered_joints(KinematicForest self) -> IMP::kinematics::Joints"""
        return _IMP_kinematics.KinematicForest_get_ordered_joints(self)


    def mark_internal_coordinates_changed(self):
        """mark_internal_coordinates_changed(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_mark_internal_coordinates_changed(self)


    def mark_external_coordinates_changed(self):
        """mark_external_coordinates_changed(KinematicForest self)"""
        return _IMP_kinematics.KinematicForest_mark_external_coordinates_changed(self)


    def set_coordinates_safe(self, rb, c):
        """set_coordinates_safe(KinematicForest self, RigidBody rb, Vector3D c)"""
        return _IMP_kinematics.KinematicForest_set_coordinates_safe(self, rb, c)


    def get_coordinates_safe(self, rb):
        """get_coordinates_safe(KinematicForest self, RigidBody rb) -> Vector3D"""
        return _IMP_kinematics.KinematicForest_get_coordinates_safe(self, rb)


    def get_is_member(self, rb):
        """get_is_member(KinematicForest self, RigidBody rb) -> bool"""
        return _IMP_kinematics.KinematicForest_get_is_member(self, rb)


    def get_reference_frame_safe(self, rb):
        """get_reference_frame_safe(KinematicForest self, RigidBody rb) -> ReferenceFrame3D"""
        return _IMP_kinematics.KinematicForest_get_reference_frame_safe(self, rb)


    def set_reference_frame_safe(self, rb, r):
        """set_reference_frame_safe(KinematicForest self, RigidBody rb, ReferenceFrame3D r)"""
        return _IMP_kinematics.KinematicForest_set_reference_frame_safe(self, rb, r)


    def __str__(self):
        """__str__(KinematicForest self) -> std::string"""
        return _IMP_kinematics.KinematicForest___str__(self)


    def __repr__(self):
        """__repr__(KinematicForest self) -> std::string"""
        return _IMP_kinematics.KinematicForest___repr__(self)


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

KinematicForest_swigregister = _IMP_kinematics.KinematicForest_swigregister
KinematicForest_swigregister(KinematicForest)

class KinematicForestScoreState(IMP.ScoreState):
    """Proxy of C++ IMP::kinematics::KinematicForestScoreState class."""

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

    def get_version_info(self):
        """get_version_info(KinematicForestScoreState self) -> VersionInfo"""
        return _IMP_kinematics.KinematicForestScoreState_get_version_info(self)


    def __init__(self, kf, rbs, atoms):
        """__init__(IMP::kinematics::KinematicForestScoreState self, KinematicForest kf, IMP::core::RigidBodies rbs, IMP::ParticlesTemp atoms) -> KinematicForestScoreState"""
        this = _IMP_kinematics.new_KinematicForestScoreState(kf, rbs, atoms)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def do_before_evaluate(self):
        """do_before_evaluate(KinematicForestScoreState self)"""
        return _IMP_kinematics.KinematicForestScoreState_do_before_evaluate(self)


    def do_after_evaluate(self, da):
        """do_after_evaluate(KinematicForestScoreState self, DerivativeAccumulator da)"""
        return _IMP_kinematics.KinematicForestScoreState_do_after_evaluate(self, da)


    def do_get_inputs(self):
        """do_get_inputs(KinematicForestScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kinematics.KinematicForestScoreState_do_get_inputs(self)


    def do_get_outputs(self):
        """do_get_outputs(KinematicForestScoreState self) -> IMP::ModelObjectsTemp"""
        return _IMP_kinematics.KinematicForestScoreState_do_get_outputs(self)


    def __str__(self):
        """__str__(KinematicForestScoreState self) -> std::string"""
        return _IMP_kinematics.KinematicForestScoreState___str__(self)


    def __repr__(self):
        """__repr__(KinematicForestScoreState self) -> std::string"""
        return _IMP_kinematics.KinematicForestScoreState___repr__(self)


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

KinematicForestScoreState_swigregister = _IMP_kinematics.KinematicForestScoreState_swigregister
KinematicForestScoreState_swigregister(KinematicForestScoreState)

class DOF(IMP.Object):
    """Proxy of C++ IMP::kinematics::DOF class."""

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

    def get_version_info(self):
        """get_version_info(DOF self) -> VersionInfo"""
        return _IMP_kinematics.DOF_get_version_info(self)


    def __init__(self, *args):
        """
        __init__(IMP::kinematics::DOF self, double v) -> DOF
        __init__(IMP::kinematics::DOF self, double v, double min, double max, double step_size) -> DOF
        """
        this = _IMP_kinematics.new_DOF(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_value(self):
        """get_value(DOF self) -> double"""
        return _IMP_kinematics.DOF_get_value(self)


    def set_value(self, v):
        """set_value(DOF self, double v)"""
        return _IMP_kinematics.DOF_set_value(self, v)


    def get_range(self):
        """get_range(DOF self) -> std::pair< double,double >"""
        return _IMP_kinematics.DOF_get_range(self)


    def set_range(self, range):
        """set_range(DOF self, std::pair< double,double > range)"""
        return _IMP_kinematics.DOF_set_range(self, range)


    def get_step_size(self):
        """get_step_size(DOF self) -> double"""
        return _IMP_kinematics.DOF_get_step_size(self)


    def set_step_size(self, step_size):
        """set_step_size(DOF self, double step_size)"""
        return _IMP_kinematics.DOF_set_step_size(self, step_size)


    def get_number_of_steps(self, *args):
        """
        get_number_of_steps(DOF self, double value) -> int
        get_number_of_steps(DOF self, double value1, double value2) -> int
        """
        return _IMP_kinematics.DOF_get_number_of_steps(self, *args)


    def __str__(self):
        """__str__(DOF self) -> std::string"""
        return _IMP_kinematics.DOF___str__(self)


    def __repr__(self):
        """__repr__(DOF self) -> std::string"""
        return _IMP_kinematics.DOF___repr__(self)


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

DOF_swigregister = _IMP_kinematics.DOF_swigregister
DOF_swigregister(DOF)

class DOFValues(IMP.saxs.DistBase):
    """Proxy of C++ IMP::kinematics::DOFValues 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::kinematics::DOFValues self, IMP::kinematics::DOFs const & dofs) -> DOFValues
        __init__(IMP::kinematics::DOFValues self) -> DOFValues
        """
        this = _IMP_kinematics.new_DOFValues(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_distance2(self, *args):
        """
        get_distance2(DOFValues self, DOFValues other_dof_values) -> double
        get_distance2(DOFValues self, DOFValues other_dof_values, std::vector< bool,std::allocator< bool > > const & active_dofs) -> double
        """
        return _IMP_kinematics.DOFValues_get_distance2(self, *args)


    def get_distance(self, *args):
        """
        get_distance(DOFValues self, DOFValues other_dof_values) -> double
        get_distance(DOFValues self, DOFValues other_dof_values, std::vector< bool,std::allocator< bool > > const & active_dofs) -> double
        """
        return _IMP_kinematics.DOFValues_get_distance(self, *args)


    def show(self, *args):
        """
        show(DOFValues self, _ostream out)
        show(DOFValues self)
        """
        return _IMP_kinematics.DOFValues_show(self, *args)


    def __str__(self):
        """__str__(DOFValues self) -> std::string"""
        return _IMP_kinematics.DOFValues___str__(self)


    def __repr__(self):
        """__repr__(DOFValues self) -> std::string"""
        return _IMP_kinematics.DOFValues___repr__(self)

    __swig_destroy__ = _IMP_kinematics.delete_DOFValues
    __del__ = lambda self: None
DOFValues_swigregister = _IMP_kinematics.DOFValues_swigregister
DOFValues_swigregister(DOFValues)

class DirectionalDOF(IMP.Object):
    """Proxy of C++ IMP::kinematics::DirectionalDOF class."""

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

    def __init__(self, dofs):
        """__init__(IMP::kinematics::DirectionalDOF self, IMP::kinematics::DOFs const & dofs) -> DirectionalDOF"""
        this = _IMP_kinematics.new_DirectionalDOF(dofs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def set_end_points(self, q1, q2):
        """set_end_points(DirectionalDOF self, DOFValues q1, DOFValues q2)"""
        return _IMP_kinematics.DirectionalDOF_set_end_points(self, q1, q2)


    def get_dofs_values(self):
        """get_dofs_values(DirectionalDOF self) -> DOFValues"""
        return _IMP_kinematics.DirectionalDOF_get_dofs_values(self)


    def get_value(self):
        """get_value(DirectionalDOF self) -> double"""
        return _IMP_kinematics.DirectionalDOF_get_value(self)


    def get_version_info(self):
        """get_version_info(DirectionalDOF self) -> VersionInfo"""
        return _IMP_kinematics.DirectionalDOF_get_version_info(self)


    def __str__(self):
        """__str__(DirectionalDOF self) -> std::string"""
        return _IMP_kinematics.DirectionalDOF___str__(self)


    def __repr__(self):
        """__repr__(DirectionalDOF self) -> std::string"""
        return _IMP_kinematics.DirectionalDOF___repr__(self)


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

DirectionalDOF_swigregister = _IMP_kinematics.DirectionalDOF_swigregister
DirectionalDOF_swigregister(DirectionalDOF)

class DOFsSampler(IMP.Object):
    """Proxy of C++ IMP::kinematics::DOFsSampler class."""

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

    def get_type_name(self):
        """get_type_name(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler_get_type_name(self)


    def get_version_info(self):
        """get_version_info(DOFsSampler self) -> VersionInfo"""
        return _IMP_kinematics.DOFsSampler_get_version_info(self)


    def __init__(self, dofs):
        """__init__(IMP::kinematics::DOFsSampler self, IMP::kinematics::DOFs dofs) -> DOFsSampler"""
        if self.__class__ == DOFsSampler:
            _self = None
        else:
            _self = self
        this = _IMP_kinematics.new_DOFsSampler(_self, dofs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

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




    def get_sample(self):
        """get_sample(DOFsSampler self) -> DOFValues"""
        return _IMP_kinematics.DOFsSampler_get_sample(self)


    def apply(self, values):
        """apply(DOFsSampler self, DOFValues values)"""
        return _IMP_kinematics.DOFsSampler_apply(self, values)


    def apply_last_sample(self):
        """apply_last_sample(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_apply_last_sample(self)


    def sample_and_apply(self):
        """sample_and_apply(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_sample_and_apply(self)


    def get_dofs(self):
        """get_dofs(DOFsSampler self) -> IMP::kinematics::DOFs const &"""
        return _IMP_kinematics.DOFsSampler_get_dofs(self)


    def get_dof(self, i):
        """get_dof(DOFsSampler self, unsigned int i) -> DOF"""
        return _IMP_kinematics.DOFsSampler_get_dof(self, i)


    def get_number_of_dofs(self):
        """get_number_of_dofs(DOFsSampler self) -> unsigned int"""
        return _IMP_kinematics.DOFsSampler_get_number_of_dofs(self)


    def do_get_sample(self):
        """do_get_sample(DOFsSampler self) -> DOFValues"""
        return _IMP_kinematics.DOFsSampler_do_get_sample(self)


    def __str__(self):
        """__str__(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler___str__(self)


    def __repr__(self):
        """__repr__(DOFsSampler self) -> std::string"""
        return _IMP_kinematics.DOFsSampler___repr__(self)


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


    def get_type_name(self):
        return self.__class__.__name__
    def do_show(self, out):
        pass
    def get_version_info(self):
        if"IMP::kinematics" == "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_DOFsSampler(o)

    def __disown__(self):
        self.this.disown()
        _IMP_kinematics.disown_DOFsSampler(self)
        return weakref_proxy(self)

    def do_destroy(self):
        """do_destroy(DOFsSampler self)"""
        return _IMP_kinematics.DOFsSampler_do_destroy(self)

DOFsSampler_swigregister = _IMP_kinematics.DOFsSampler_swigregister
DOFsSampler_swigregister(DOFsSampler)

class UniformBackboneSampler(DOFsSampler):
    """Proxy of C++ IMP::kinematics::UniformBackboneSampler class."""

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

    def __init__(self, joints, dofs):
        """__init__(IMP::kinematics::UniformBackboneSampler self, IMP::kinematics::DihedralAngleRevoluteJoints joints, IMP::kinematics::DOFs dofs) -> UniformBackboneSampler"""
        this = _IMP_kinematics.new_UniformBackboneSampler(joints, dofs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        """__str__(UniformBackboneSampler self) -> std::string"""
        return _IMP_kinematics.UniformBackboneSampler___str__(self)


    def __repr__(self):
        """__repr__(UniformBackboneSampler self) -> std::string"""
        return _IMP_kinematics.UniformBackboneSampler___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_UniformBackboneSampler
    __del__ = lambda self: None
UniformBackboneSampler_swigregister = _IMP_kinematics.UniformBackboneSampler_swigregister
UniformBackboneSampler_swigregister(UniformBackboneSampler)

class ProteinKinematics(IMP.Object):
    """Proxy of C++ IMP::kinematics::ProteinKinematics 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::kinematics::ProteinKinematics self, Hierarchy mhd, bool flexible_backbone=True, bool flexible_side_chains=False) -> ProteinKinematics
        __init__(IMP::kinematics::ProteinKinematics self, Hierarchy mhd, bool flexible_backbone=True) -> ProteinKinematics
        __init__(IMP::kinematics::ProteinKinematics self, Hierarchy mhd) -> ProteinKinematics
        __init__(IMP::kinematics::ProteinKinematics self, Hierarchy mhd, IMP::atom::Residues const & flexible_residues, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & dihedral_angles, IMP::atom::Atoms open_loop_bond_atoms, bool flexible_backbone=True, bool flexible_side_chains=False) -> ProteinKinematics
        __init__(IMP::kinematics::ProteinKinematics self, Hierarchy mhd, IMP::atom::Residues const & flexible_residues, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & dihedral_angles, IMP::atom::Atoms open_loop_bond_atoms, bool flexible_backbone=True) -> ProteinKinematics
        __init__(IMP::kinematics::ProteinKinematics self, Hierarchy mhd, IMP::atom::Residues const & flexible_residues, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & dihedral_angles, IMP::atom::Atoms open_loop_bond_atoms) -> ProteinKinematics
        __init__(IMP::kinematics::ProteinKinematics self, Hierarchy mhd, IMP::atom::Residues const & flexible_residues, std::vector< IMP::atom::Atoms,std::allocator< IMP::atom::Atoms > > const & dihedral_angles) -> ProteinKinematics
        """
        this = _IMP_kinematics.new_ProteinKinematics(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_phi(self, r):
        """get_phi(ProteinKinematics self, Residue r) -> double"""
        return _IMP_kinematics.ProteinKinematics_get_phi(self, r)


    def get_psi(self, r):
        """get_psi(ProteinKinematics self, Residue r) -> double"""
        return _IMP_kinematics.ProteinKinematics_get_psi(self, r)


    def get_joints(self):
        """get_joints(ProteinKinematics self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.ProteinKinematics_get_joints(self)


    def get_loop_joints(self):
        """get_loop_joints(ProteinKinematics self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.ProteinKinematics_get_loop_joints(self)


    def get_ordered_joints(self):
        """get_ordered_joints(ProteinKinematics self) -> IMP::kinematics::DihedralAngleRevoluteJoints"""
        return _IMP_kinematics.ProteinKinematics_get_ordered_joints(self)


    def get_kinematic_forest(self):
        """get_kinematic_forest(ProteinKinematics self) -> KinematicForest"""
        return _IMP_kinematics.ProteinKinematics_get_kinematic_forest(self)


    def get_rigid_bodies(self):
        """get_rigid_bodies(ProteinKinematics self) -> IMP::core::RigidBodies"""
        return _IMP_kinematics.ProteinKinematics_get_rigid_bodies(self)


    def set_phi(self, r, angle):
        """set_phi(ProteinKinematics self, Residue r, double angle)"""
        return _IMP_kinematics.ProteinKinematics_set_phi(self, r, angle)


    def set_psi(self, r, angle):
        """set_psi(ProteinKinematics self, Residue r, double angle)"""
        return _IMP_kinematics.ProteinKinematics_set_psi(self, r, angle)


    def get_version_info(self):
        """get_version_info(ProteinKinematics self) -> VersionInfo"""
        return _IMP_kinematics.ProteinKinematics_get_version_info(self)


    def __str__(self):
        """__str__(ProteinKinematics self) -> std::string"""
        return _IMP_kinematics.ProteinKinematics___str__(self)


    def __repr__(self):
        """__repr__(ProteinKinematics self) -> std::string"""
        return _IMP_kinematics.ProteinKinematics___repr__(self)


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

ProteinKinematics_swigregister = _IMP_kinematics.ProteinKinematics_swigregister
ProteinKinematics_swigregister(ProteinKinematics)

class LocalPlanner(IMP.Object):
    """Proxy of C++ IMP::kinematics::LocalPlanner 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")

    def get_version_info(self):
        """get_version_info(LocalPlanner self) -> VersionInfo"""
        return _IMP_kinematics.LocalPlanner_get_version_info(self)


    def plan(self, q_near, q_rand, sf):
        """plan(LocalPlanner self, DOFValues q_near, DOFValues q_rand, ScoringFunction sf) -> std::vector< IMP::kinematics::DOFValues,std::allocator< IMP::kinematics::DOFValues > >"""
        return _IMP_kinematics.LocalPlanner_plan(self, q_near, q_rand, sf)


    def is_valid(self, values, sf):
        """is_valid(LocalPlanner self, DOFValues values, ScoringFunction sf) -> bool"""
        return _IMP_kinematics.LocalPlanner_is_valid(self, values, sf)


    def __str__(self):
        """__str__(LocalPlanner self) -> std::string"""
        return _IMP_kinematics.LocalPlanner___str__(self)


    def __repr__(self):
        """__repr__(LocalPlanner self) -> std::string"""
        return _IMP_kinematics.LocalPlanner___repr__(self)


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

LocalPlanner_swigregister = _IMP_kinematics.LocalPlanner_swigregister
LocalPlanner_swigregister(LocalPlanner)

class PathLocalPlanner(LocalPlanner):
    """Proxy of C++ IMP::kinematics::PathLocalPlanner class."""

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

    def __init__(self, model, dofs_sampler, directional_dof, save_step_interval=1):
        """
        __init__(IMP::kinematics::PathLocalPlanner self, Model model, DOFsSampler dofs_sampler, DirectionalDOF directional_dof, int save_step_interval=1) -> PathLocalPlanner
        __init__(IMP::kinematics::PathLocalPlanner self, Model model, DOFsSampler dofs_sampler, DirectionalDOF directional_dof) -> PathLocalPlanner
        """
        this = _IMP_kinematics.new_PathLocalPlanner(model, dofs_sampler, directional_dof, save_step_interval)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __str__(self):
        """__str__(PathLocalPlanner self) -> std::string"""
        return _IMP_kinematics.PathLocalPlanner___str__(self)


    def __repr__(self):
        """__repr__(PathLocalPlanner self) -> std::string"""
        return _IMP_kinematics.PathLocalPlanner___repr__(self)


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

    __swig_destroy__ = _IMP_kinematics.delete_PathLocalPlanner
    __del__ = lambda self: None
PathLocalPlanner_swigregister = _IMP_kinematics.PathLocalPlanner_swigregister
PathLocalPlanner_swigregister(PathLocalPlanner)

class RRT(IMP.Sampler):
    """Proxy of C++ IMP::kinematics::RRT class."""

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

    def get_version_info(self):
        """get_version_info(RRT self) -> VersionInfo"""
        return _IMP_kinematics.RRT_get_version_info(self)


    def __init__(self, m, sampler, planner, cspace_dofs, iteration_number=1000, tree_size=100, number_of_sampled_dofs=0):
        """
        __init__(IMP::kinematics::RRT self, Model m, DOFsSampler sampler, LocalPlanner planner, IMP::kinematics::DOFs const & cspace_dofs, unsigned int iteration_number=1000, unsigned int tree_size=100, unsigned int number_of_sampled_dofs=0) -> RRT
        __init__(IMP::kinematics::RRT self, Model m, DOFsSampler sampler, LocalPlanner planner, IMP::kinematics::DOFs const & cspace_dofs, unsigned int iteration_number=1000, unsigned int tree_size=100) -> RRT
        __init__(IMP::kinematics::RRT self, Model m, DOFsSampler sampler, LocalPlanner planner, IMP::kinematics::DOFs const & cspace_dofs, unsigned int iteration_number=1000) -> RRT
        __init__(IMP::kinematics::RRT self, Model m, DOFsSampler sampler, LocalPlanner planner, IMP::kinematics::DOFs const & cspace_dofs) -> RRT
        """
        this = _IMP_kinematics.new_RRT(m, sampler, planner, cspace_dofs, iteration_number, tree_size, number_of_sampled_dofs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def do_sample(self):
        """do_sample(RRT self) -> ConfigurationSet"""
        return _IMP_kinematics.RRT_do_sample(self)


    def run(self, number_of_iterations=0):
        """
        run(RRT self, unsigned int number_of_iterations=0) -> bool
        run(RRT self) -> bool
        """
        return _IMP_kinematics.RRT_run(self, number_of_iterations)


    def get_DOFValues(self):
        """get_DOFValues(RRT self) -> std::vector< IMP::kinematics::DOFValues,std::allocator< IMP::kinematics::DOFValues > >"""
        return _IMP_kinematics.RRT_get_DOFValues(self)


    def set_number_of_iterations(self, num):
        """set_number_of_iterations(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_number_of_iterations(self, num)


    def set_tree_size(self, num):
        """set_tree_size(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_tree_size(self, num)


    def set_actual_tree_size(self, num):
        """set_actual_tree_size(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_actual_tree_size(self, num)


    def set_number_of_collisions(self, num):
        """set_number_of_collisions(RRT self, unsigned int num)"""
        return _IMP_kinematics.RRT_set_number_of_collisions(self, num)


    def __str__(self):
        """__str__(RRT self) -> std::string"""
        return _IMP_kinematics.RRT___str__(self)


    def __repr__(self):
        """__repr__(RRT self) -> std::string"""
        return _IMP_kinematics.RRT___repr__(self)


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

RRT_swigregister = _IMP_kinematics.RRT_swigregister
RRT_swigregister(RRT)


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

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

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

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