em2d/__init__.py

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



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_IMP_em2d', [dirname(__file__)])
        except ImportError:
            import _IMP_em2d
            return _IMP_em2d
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_em2d', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_em2d = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_em2d
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

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


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


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

    def incr(self, n=1):
        """
        incr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator
        incr(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator
        """
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator
        decr(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator
        """
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
        return _IMP_em2d.IMP_EM2D_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator
        __sub__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_em2d.IMP_EM2D_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_EM2D_SwigPyIterator_swigregister = _IMP_em2d.IMP_EM2D_SwigPyIterator_swigregister
IMP_EM2D_SwigPyIterator_swigregister(IMP_EM2D_SwigPyIterator)

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

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

DEFAULT_CHECK = _IMP_em2d.DEFAULT_CHECK
NONE = _IMP_em2d.NONE
USAGE = _IMP_em2d.USAGE
USAGE_AND_INTERNAL = _IMP_em2d.USAGE_AND_INTERNAL

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

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

_ostream_swigregister = _IMP_em2d._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_em2d.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_em2d.IMP_COMPILER_HAS_FINAL
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_SYSTEM
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_em2d.IMP_ALGEBRA_HAS_ANN
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_em2d.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_em2d.IMP_KERNEL_HAS_CGAL
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_em2d.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_CGAL
import IMP.display
IMP_GSL_HAS_IMP_BASE = _IMP_em2d.IMP_GSL_HAS_IMP_BASE
IMP_GSL_HAS_IMP_CGAL = _IMP_em2d.IMP_GSL_HAS_IMP_CGAL
IMP_GSL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_FILESYSTEM
IMP_GSL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_GSL_HAS_BOOST_PROGRAMOPTIONS
IMP_GSL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_GSL_HAS_BOOST_RANDOM
IMP_GSL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_SYSTEM
IMP_GSL_HAS_CGAL = _IMP_em2d.IMP_GSL_HAS_CGAL
import IMP.gsl
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_CGAL
import IMP.score_functor
IMP_STATISTICS_HAS_IMP_BASE = _IMP_em2d.IMP_STATISTICS_HAS_IMP_BASE
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_IMP_CGAL
IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_RANDOM
IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_SYSTEM
IMP_STATISTICS_HAS_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_CGAL
import IMP.statistics
IMP_CORE_HAS_IMP_BASE = _IMP_em2d.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_em2d.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_em2d.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_em2d.IMP_CORE_HAS_CGAL
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_em2d.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_em2d.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_em2d.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_CGAL
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_em2d.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_em2d.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_em2d.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_em2d.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_em2d.IMP_ATOM_HAS_CGAL
IMP_ATOM_TYPE_INDEX = _IMP_em2d.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_em2d.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_em2d.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_em2d.IMP_EM_HAS_IMP_CGAL
IMP_EM_HAS_IMP_CONTAINER = _IMP_em2d.IMP_EM_HAS_IMP_CONTAINER
IMP_EM_HAS_IMP_DISPLAY = _IMP_em2d.IMP_EM_HAS_IMP_DISPLAY
IMP_EM_HAS_IMP_KERNEL = _IMP_em2d.IMP_EM_HAS_IMP_KERNEL
IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM_HAS_IMP_SCORE_FUNCTOR
IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_FILESYSTEM
IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_EM_HAS_BOOST_PROGRAMOPTIONS
IMP_EM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM_HAS_BOOST_RANDOM
IMP_EM_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM_HAS_BOOST_REGEX
IMP_EM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_SYSTEM
IMP_EM_HAS_CGAL = _IMP_em2d.IMP_EM_HAS_CGAL
import IMP.em
IMP_RMF_HAS_IMP_BASE = _IMP_em2d.IMP_RMF_HAS_IMP_BASE
IMP_RMF_HAS_IMP_CGAL = _IMP_em2d.IMP_RMF_HAS_IMP_CGAL
IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_FILESYSTEM
IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
IMP_RMF_HAS_BOOST_RANDOM = _IMP_em2d.IMP_RMF_HAS_BOOST_RANDOM
IMP_RMF_HAS_BOOST_REGEX = _IMP_em2d.IMP_RMF_HAS_BOOST_REGEX
IMP_RMF_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_SYSTEM
IMP_RMF_HAS_CGAL = _IMP_em2d.IMP_RMF_HAS_CGAL
import IMP.rmf
import RMF
IMP_DOMINO_HAS_IMP_ATOM = _IMP_em2d.IMP_DOMINO_HAS_IMP_ATOM
IMP_DOMINO_HAS_IMP_BASE = _IMP_em2d.IMP_DOMINO_HAS_IMP_BASE
IMP_DOMINO_HAS_IMP_CGAL = _IMP_em2d.IMP_DOMINO_HAS_IMP_CGAL
IMP_DOMINO_HAS_IMP_KERNEL = _IMP_em2d.IMP_DOMINO_HAS_IMP_KERNEL
IMP_DOMINO_HAS_IMP_RMF = _IMP_em2d.IMP_DOMINO_HAS_IMP_RMF
IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR
IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_FILESYSTEM
IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS
IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_RANDOM
IMP_DOMINO_HAS_BOOST_REGEX = _IMP_em2d.IMP_DOMINO_HAS_BOOST_REGEX
IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_SYSTEM
IMP_DOMINO_HAS_CGAL = _IMP_em2d.IMP_DOMINO_HAS_CGAL
IMP_DOMINO_HAS_HDF5 = _IMP_em2d.IMP_DOMINO_HAS_HDF5
IMP_DOMINO_HAS_RMF = _IMP_em2d.IMP_DOMINO_HAS_RMF
import RMF_HDF5
import IMP.domino
IMP_EM2D_HAS_IMP_BASE = _IMP_em2d.IMP_EM2D_HAS_IMP_BASE
IMP_EM2D_HAS_IMP_CGAL = _IMP_em2d.IMP_EM2D_HAS_IMP_CGAL
IMP_EM2D_HAS_IMP_KERNEL = _IMP_em2d.IMP_EM2D_HAS_IMP_KERNEL
IMP_EM2D_HAS_IMP_RMF = _IMP_em2d.IMP_EM2D_HAS_IMP_RMF
IMP_EM2D_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM2D_HAS_IMP_SCORE_FUNCTOR
IMP_EM2D_HAS_IMP_STATISTICS = _IMP_em2d.IMP_EM2D_HAS_IMP_STATISTICS
IMP_EM2D_HAS_BOOST_GRAPH = _IMP_em2d.IMP_EM2D_HAS_BOOST_GRAPH
IMP_EM2D_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM2D_HAS_BOOST_RANDOM
IMP_EM2D_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM2D_HAS_BOOST_REGEX
IMP_EM2D_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM2D_HAS_BOOST_SYSTEM
IMP_EM2D_HAS_CGAL = _IMP_em2d.IMP_EM2D_HAS_CGAL
IMP_EM2D_HAS_GSL = _IMP_em2d.IMP_EM2D_HAS_GSL
IMP_EM2D_HAS_HDF5 = _IMP_em2d.IMP_EM2D_HAS_HDF5
IMP_EM2D_HAS_OPENCV22 = _IMP_em2d.IMP_EM2D_HAS_OPENCV22
IMP_EM2D_HAS_RMF = _IMP_em2d.IMP_EM2D_HAS_RMF
IMP_EM2D_HAS_OPENCV21 = _IMP_em2d.IMP_EM2D_HAS_OPENCV21
PolarResamplingParametersList=list
_plural_types.append("PolarResamplingParametersList")
_value_types.append("PolarResamplingParameters")

ProjectionMasks=list
_plural_types.append("ProjectionMasks")
_value_types.append("ProjectionMask")

MasksManagers=list
_plural_types.append("MasksManagers")
_value_types.append("MasksManager")

RegistrationResults=list
_plural_types.append("RegistrationResults")
_value_types.append("RegistrationResult")

ClusterSets=list
_plural_types.append("ClusterSets")
_value_types.append("ClusterSet")

SingleLinkages=list
_plural_types.append("SingleLinkages")
_value_types.append("SingleLinkage")

CompleteLinkages=list
_plural_types.append("CompleteLinkages")
_value_types.append("CompleteLinkage")

AverageDistanceLinkages=list
_plural_types.append("AverageDistanceLinkages")
_value_types.append("AverageDistanceLinkage")

SegmentationParametersList=list
_plural_types.append("SegmentationParametersList")
_value_types.append("SegmentationParameters")

MatchTemplateResults=list
_plural_types.append("MatchTemplateResults")
_value_types.append("MatchTemplateResult")

ProjectingParametersList=list
_plural_types.append("ProjectingParametersList")
_value_types.append("ProjectingParameters")

ProjectingOptionsList=list
_plural_types.append("ProjectingOptionsList")
_value_types.append("ProjectingOptions")

Em2DRestraintParametersList=list
_plural_types.append("Em2DRestraintParametersList")
_value_types.append("Em2DRestraintParameters")

_object_types.append("ProjectionFinder")


def _object_cast_to_ProjectionFinder(*args):
  """_object_cast_to_ProjectionFinder(Object o) -> ProjectionFinder"""
  return _IMP_em2d._object_cast_to_ProjectionFinder(*args)
_object_types.append("ScoreFunction")


def _object_cast_to_ScoreFunction(*args):
  """_object_cast_to_ScoreFunction(Object o) -> ScoreFunction"""
  return _IMP_em2d._object_cast_to_ScoreFunction(*args)
_object_types.append("ChiSquaredScore")


def _object_cast_to_ChiSquaredScore(*args):
  """_object_cast_to_ChiSquaredScore(Object o) -> ChiSquaredScore"""
  return _IMP_em2d._object_cast_to_ChiSquaredScore(*args)
_object_types.append("EM2DScore")


def _object_cast_to_EM2DScore(*args):
  """_object_cast_to_EM2DScore(Object o) -> EM2DScore"""
  return _IMP_em2d._object_cast_to_EM2DScore(*args)
_object_types.append("MeanAbsoluteDifference")


def _object_cast_to_MeanAbsoluteDifference(*args):
  """_object_cast_to_MeanAbsoluteDifference(Object o) -> MeanAbsoluteDifference"""
  return _IMP_em2d._object_cast_to_MeanAbsoluteDifference(*args)
_object_types.append("ProjectionParametersScoreState")


def _object_cast_to_ProjectionParametersScoreState(*args):
  """_object_cast_to_ProjectionParametersScoreState(Object o) -> ProjectionParametersScoreState"""
  return _IMP_em2d._object_cast_to_ProjectionParametersScoreState(*args)
_object_types.append("Em2DRestraint")


def _object_cast_to_Em2DRestraint(*args):
  """_object_cast_to_Em2DRestraint(Object o) -> Em2DRestraint"""
  return _IMP_em2d._object_cast_to_Em2DRestraint(*args)
_object_types.append("Image")


def _object_cast_to_Image(*args):
  """_object_cast_to_Image(Object o) -> Image"""
  return _IMP_em2d._object_cast_to_Image(*args)
_object_types.append("ImageReaderWriter")


def _object_cast_to_ImageReaderWriter(*args):
  """_object_cast_to_ImageReaderWriter(Object o) -> ImageReaderWriter"""
  return _IMP_em2d._object_cast_to_ImageReaderWriter(*args)
_object_types.append("JPGImageReaderWriter")


def _object_cast_to_JPGImageReaderWriter(*args):
  """_object_cast_to_JPGImageReaderWriter(Object o) -> JPGImageReaderWriter"""
  return _IMP_em2d._object_cast_to_JPGImageReaderWriter(*args)
_object_types.append("TIFFImageReaderWriter")


def _object_cast_to_TIFFImageReaderWriter(*args):
  """_object_cast_to_TIFFImageReaderWriter(Object o) -> TIFFImageReaderWriter"""
  return _IMP_em2d._object_cast_to_TIFFImageReaderWriter(*args)
_object_types.append("SpiderImageReaderWriter")


def _object_cast_to_SpiderImageReaderWriter(*args):
  """_object_cast_to_SpiderImageReaderWriter(Object o) -> SpiderImageReaderWriter"""
  return _IMP_em2d._object_cast_to_SpiderImageReaderWriter(*args)
_object_types.append("CollisionCrossSection")


def _object_cast_to_CollisionCrossSection(*args):
  """_object_cast_to_CollisionCrossSection(Object o) -> CollisionCrossSection"""
  return _IMP_em2d._object_cast_to_CollisionCrossSection(*args)
_object_types.append("GridStates")


def _object_cast_to_GridStates(*args):
  """_object_cast_to_GridStates(Object o) -> GridStates"""
  return _IMP_em2d._object_cast_to_GridStates(*args)
_object_types.append("ProjectionStates")


def _object_cast_to_ProjectionStates(*args):
  """_object_cast_to_ProjectionStates(Object o) -> ProjectionStates"""
  return _IMP_em2d._object_cast_to_ProjectionStates(*args)
_object_types.append("DistanceFilter")


def _object_cast_to_DistanceFilter(*args):
  """_object_cast_to_DistanceFilter(Object o) -> DistanceFilter"""
  return _IMP_em2d._object_cast_to_DistanceFilter(*args)
_object_types.append("DistanceFilterTable")


def _object_cast_to_DistanceFilterTable(*args):
  """_object_cast_to_DistanceFilterTable(Object o) -> DistanceFilterTable"""
  return _IMP_em2d._object_cast_to_DistanceFilterTable(*args)
_object_types.append("RigidBodiesImageFitRestraint")


def _object_cast_to_RigidBodiesImageFitRestraint(*args):
  """_object_cast_to_RigidBodiesImageFitRestraint(Object o) -> RigidBodiesImageFitRestraint"""
  return _IMP_em2d._object_cast_to_RigidBodiesImageFitRestraint(*args)
_object_types.append("DummyRestraint")


def _object_cast_to_DummyRestraint(*args):
  """_object_cast_to_DummyRestraint(Object o) -> DummyRestraint"""
  return _IMP_em2d._object_cast_to_DummyRestraint(*args)
_object_types.append("ParticlesDummyRestraint")


def _object_cast_to_ParticlesDummyRestraint(*args):
  """_object_cast_to_ParticlesDummyRestraint(Object o) -> ParticlesDummyRestraint"""
  return _IMP_em2d._object_cast_to_ParticlesDummyRestraint(*args)
_object_types.append("RelativePositionMover")


def _object_cast_to_RelativePositionMover(*args):
  """_object_cast_to_RelativePositionMover(Object o) -> RelativePositionMover"""
  return _IMP_em2d._object_cast_to_RelativePositionMover(*args)
def ProjectionParametersList(l=[]):
    return [ProjectionParameters(x) for x in l]
_plural_types.append("ProjectionParametersList")

_value_types.append("ProjectionParameters")


def show(*args):
  """
    show(cv::Mat const & m, _ostream out=std::cout)
    show(cv::Mat const & m)
    """
  return _IMP_em2d.show(*args)

def write_matrix(*args):
  """write_matrix(cv::Mat & m, std::string name)"""
  return _IMP_em2d.write_matrix(*args)
class ImageReaderWriter(IMP.base.Object):
    """Proxy of C++ IMP::em2d::ImageReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ImageReaderWriter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def read(self, *args):
        """read(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
        return _IMP_em2d.ImageReaderWriter_read(self, *args)

    def read_from_floats(self, *args):
        """read_from_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
        return _IMP_em2d.ImageReaderWriter_read_from_floats(self, *args)

    def read_from_ints(self, *args):
        """read_from_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
        return _IMP_em2d.ImageReaderWriter_read_from_ints(self, *args)

    def write(self, *args):
        """write(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
        return _IMP_em2d.ImageReaderWriter_write(self, *args)

    def write_to_floats(self, *args):
        """write_to_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
        return _IMP_em2d.ImageReaderWriter_write_to_floats(self, *args)

    def write_to_ints(self, *args):
        """write_to_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
        return _IMP_em2d.ImageReaderWriter_write_to_ints(self, *args)

    def get_version_info(self):
        """get_version_info(ImageReaderWriter self) -> VersionInfo"""
        return _IMP_em2d.ImageReaderWriter_get_version_info(self)

    __swig_destroy__ = _IMP_em2d.delete_ImageReaderWriter
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ImageReaderWriter self) -> std::string"""
        return _IMP_em2d.ImageReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(ImageReaderWriter self) -> std::string"""
        return _IMP_em2d.ImageReaderWriter___repr__(self)

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

ImageReaderWriter_swigregister = _IMP_em2d.ImageReaderWriter_swigregister
ImageReaderWriter_swigregister(ImageReaderWriter)

class PolarResamplingParameters(_object):
    """Proxy of C++ IMP::em2d::PolarResamplingParameters class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PolarResamplingParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PolarResamplingParameters, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::PolarResamplingParameters self) -> PolarResamplingParameters
        __init__(IMP::em2d::PolarResamplingParameters self, unsigned int rows, unsigned int cols) -> PolarResamplingParameters
        __init__(IMP::em2d::PolarResamplingParameters self, cv::Mat const & m) -> PolarResamplingParameters
        """
        this = _IMP_em2d.new_PolarResamplingParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em2d.delete_PolarResamplingParameters
    __del__ = lambda self : None;
    def setup(self, *args):
        """setup(PolarResamplingParameters self, unsigned int rows, unsigned int cols)"""
        return _IMP_em2d.PolarResamplingParameters_setup(self, *args)

    def get_starting_radius(self):
        """get_starting_radius(PolarResamplingParameters self) -> double"""
        return _IMP_em2d.PolarResamplingParameters_get_starting_radius(self)

    def get_ending_radius(self):
        """get_ending_radius(PolarResamplingParameters self) -> double"""
        return _IMP_em2d.PolarResamplingParameters_get_ending_radius(self)

    def get_radius(self, *args):
        """get_radius(PolarResamplingParameters self, unsigned int n_ring) -> double"""
        return _IMP_em2d.PolarResamplingParameters_get_radius(self, *args)

    def get_number_of_rings(self):
        """get_number_of_rings(PolarResamplingParameters self) -> unsigned int"""
        return _IMP_em2d.PolarResamplingParameters_get_number_of_rings(self)

    def set_estimated_number_of_angles(self, *args):
        """set_estimated_number_of_angles(PolarResamplingParameters self, unsigned int aprox_value)"""
        return _IMP_em2d.PolarResamplingParameters_set_estimated_number_of_angles(self, *args)

    def get_number_of_angles(self):
        """get_number_of_angles(PolarResamplingParameters self) -> unsigned int"""
        return _IMP_em2d.PolarResamplingParameters_get_number_of_angles(self)

    def get_angle_step(self):
        """get_angle_step(PolarResamplingParameters self) -> double"""
        return _IMP_em2d.PolarResamplingParameters_get_angle_step(self)

    def get_radius_step(self):
        """get_radius_step(PolarResamplingParameters self) -> double"""
        return _IMP_em2d.PolarResamplingParameters_get_radius_step(self)

    def create_maps_for_resampling(self):
        """create_maps_for_resampling(PolarResamplingParameters self)"""
        return _IMP_em2d.PolarResamplingParameters_create_maps_for_resampling(self)

    def get_resampling_maps(self, *args):
        """get_resampling_maps(PolarResamplingParameters self, cv::Mat & m1, cv::Mat & m2)"""
        return _IMP_em2d.PolarResamplingParameters_get_resampling_maps(self, *args)

    def get_resampling_map(self, *args):
        """get_resampling_map(PolarResamplingParameters self, cv::Mat & m1)"""
        return _IMP_em2d.PolarResamplingParameters_get_resampling_map(self, *args)

    def show(self, *args):
        """show(PolarResamplingParameters self, _ostream out)"""
        return _IMP_em2d.PolarResamplingParameters_show(self, *args)

    def get_is_setup(self):
        """get_is_setup(PolarResamplingParameters self) -> bool"""
        return _IMP_em2d.PolarResamplingParameters_get_is_setup(self)

    def __str__(self):
        """__str__(PolarResamplingParameters self) -> std::string"""
        return _IMP_em2d.PolarResamplingParameters___str__(self)

    def __repr__(self):
        """__repr__(PolarResamplingParameters self) -> std::string"""
        return _IMP_em2d.PolarResamplingParameters___repr__(self)

PolarResamplingParameters_swigregister = _IMP_em2d.PolarResamplingParameters_swigregister
PolarResamplingParameters_swigregister(PolarResamplingParameters)

class SegmentationParameters(_object):
    """Proxy of C++ IMP::em2d::SegmentationParameters class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SegmentationParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SegmentationParameters, name)
    __swig_setmethods__["image_pixel_size"] = _IMP_em2d.SegmentationParameters_image_pixel_size_set
    __swig_getmethods__["image_pixel_size"] = _IMP_em2d.SegmentationParameters_image_pixel_size_get
    if _newclass:image_pixel_size = _swig_property(_IMP_em2d.SegmentationParameters_image_pixel_size_get, _IMP_em2d.SegmentationParameters_image_pixel_size_set)
    __swig_setmethods__["diffusion_beta"] = _IMP_em2d.SegmentationParameters_diffusion_beta_set
    __swig_getmethods__["diffusion_beta"] = _IMP_em2d.SegmentationParameters_diffusion_beta_get
    if _newclass:diffusion_beta = _swig_property(_IMP_em2d.SegmentationParameters_diffusion_beta_get, _IMP_em2d.SegmentationParameters_diffusion_beta_set)
    __swig_setmethods__["diffusion_timesteps"] = _IMP_em2d.SegmentationParameters_diffusion_timesteps_set
    __swig_getmethods__["diffusion_timesteps"] = _IMP_em2d.SegmentationParameters_diffusion_timesteps_get
    if _newclass:diffusion_timesteps = _swig_property(_IMP_em2d.SegmentationParameters_diffusion_timesteps_get, _IMP_em2d.SegmentationParameters_diffusion_timesteps_set)
    __swig_setmethods__["fill_holes_stddevs"] = _IMP_em2d.SegmentationParameters_fill_holes_stddevs_set
    __swig_getmethods__["fill_holes_stddevs"] = _IMP_em2d.SegmentationParameters_fill_holes_stddevs_get
    if _newclass:fill_holes_stddevs = _swig_property(_IMP_em2d.SegmentationParameters_fill_holes_stddevs_get, _IMP_em2d.SegmentationParameters_fill_holes_stddevs_set)
    __swig_setmethods__["opening_kernel"] = _IMP_em2d.SegmentationParameters_opening_kernel_set
    __swig_getmethods__["opening_kernel"] = _IMP_em2d.SegmentationParameters_opening_kernel_get
    if _newclass:opening_kernel = _swig_property(_IMP_em2d.SegmentationParameters_opening_kernel_get, _IMP_em2d.SegmentationParameters_opening_kernel_set)
    __swig_setmethods__["remove_sizing_percentage"] = _IMP_em2d.SegmentationParameters_remove_sizing_percentage_set
    __swig_getmethods__["remove_sizing_percentage"] = _IMP_em2d.SegmentationParameters_remove_sizing_percentage_get
    if _newclass:remove_sizing_percentage = _swig_property(_IMP_em2d.SegmentationParameters_remove_sizing_percentage_get, _IMP_em2d.SegmentationParameters_remove_sizing_percentage_set)
    __swig_setmethods__["binary_background"] = _IMP_em2d.SegmentationParameters_binary_background_set
    __swig_getmethods__["binary_background"] = _IMP_em2d.SegmentationParameters_binary_background_get
    if _newclass:binary_background = _swig_property(_IMP_em2d.SegmentationParameters_binary_background_get, _IMP_em2d.SegmentationParameters_binary_background_set)
    __swig_setmethods__["binary_foreground"] = _IMP_em2d.SegmentationParameters_binary_foreground_set
    __swig_getmethods__["binary_foreground"] = _IMP_em2d.SegmentationParameters_binary_foreground_get
    if _newclass:binary_foreground = _swig_property(_IMP_em2d.SegmentationParameters_binary_foreground_get, _IMP_em2d.SegmentationParameters_binary_foreground_set)
    __swig_setmethods__["threshold"] = _IMP_em2d.SegmentationParameters_threshold_set
    __swig_getmethods__["threshold"] = _IMP_em2d.SegmentationParameters_threshold_get
    if _newclass:threshold = _swig_property(_IMP_em2d.SegmentationParameters_threshold_get, _IMP_em2d.SegmentationParameters_threshold_set)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::SegmentationParameters self) -> SegmentationParameters
        __init__(IMP::em2d::SegmentationParameters self, double apix, double diff_beta, unsigned int diff_timesteps, double fh_stddevs, cv::Mat const & kr, 
            int background, int foreground) -> SegmentationParameters
        """
        this = _IMP_em2d.new_SegmentationParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(SegmentationParameters self, _ostream out=std::cout)
        show(SegmentationParameters self)
        """
        return _IMP_em2d.SegmentationParameters_show(self, *args)

    def __str__(self):
        """__str__(SegmentationParameters self) -> std::string"""
        return _IMP_em2d.SegmentationParameters___str__(self)

    def __repr__(self):
        """__repr__(SegmentationParameters self) -> std::string"""
        return _IMP_em2d.SegmentationParameters___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_SegmentationParameters
    __del__ = lambda self : None;
SegmentationParameters_swigregister = _IMP_em2d.SegmentationParameters_swigregister
SegmentationParameters_swigregister(SegmentationParameters)

class MatchTemplateResult(_object):
    """Proxy of C++ IMP::em2d::MatchTemplateResult class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatchTemplateResult, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatchTemplateResult, name)
    __swig_setmethods__["pair"] = _IMP_em2d.MatchTemplateResult_pair_set
    __swig_getmethods__["pair"] = _IMP_em2d.MatchTemplateResult_pair_get
    if _newclass:pair = _swig_property(_IMP_em2d.MatchTemplateResult_pair_get, _IMP_em2d.MatchTemplateResult_pair_set)
    __swig_setmethods__["cross_correlation"] = _IMP_em2d.MatchTemplateResult_cross_correlation_set
    __swig_getmethods__["cross_correlation"] = _IMP_em2d.MatchTemplateResult_cross_correlation_get
    if _newclass:cross_correlation = _swig_property(_IMP_em2d.MatchTemplateResult_cross_correlation_get, _IMP_em2d.MatchTemplateResult_cross_correlation_set)
    def __init__(self, *args): 
        """__init__(IMP::em2d::MatchTemplateResult self, IMP::IntPair p, double cc) -> MatchTemplateResult"""
        this = _IMP_em2d.new_MatchTemplateResult(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(MatchTemplateResult self, _ostream out=std::cout)
        show(MatchTemplateResult self)
        """
        return _IMP_em2d.MatchTemplateResult_show(self, *args)

    def __str__(self):
        """__str__(MatchTemplateResult self) -> std::string"""
        return _IMP_em2d.MatchTemplateResult___str__(self)

    def __repr__(self):
        """__repr__(MatchTemplateResult self) -> std::string"""
        return _IMP_em2d.MatchTemplateResult___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_MatchTemplateResult
    __del__ = lambda self : None;
MatchTemplateResult_swigregister = _IMP_em2d.MatchTemplateResult_swigregister
MatchTemplateResult_swigregister(MatchTemplateResult)


def apply_mask(*args):
  """apply_mask(cv::Mat const & m, cv::Mat & result, IMP::em2d::cvIntMat const & mask, double val)"""
  return _IMP_em2d.apply_mask(*args)

def apply_circular_mask(*args):
  """
    apply_circular_mask(cv::Mat const & mat, cv::Mat & result, int radius, double value=0.0)
    apply_circular_mask(cv::Mat const & mat, cv::Mat & result, int radius)
    """
  return _IMP_em2d.apply_circular_mask(*args)

def get_mean(*args):
  """get_mean(cv::Mat const & mat, IMP::em2d::cvIntMat const & mask) -> double"""
  return _IMP_em2d.get_mean(*args)

def create_circular_mask(*args):
  """create_circular_mask(int rows, int cols, int radius) -> IMP::em2d::cvIntMat"""
  return _IMP_em2d.create_circular_mask(*args)

def do_histogram_stretching(*args):
  """do_histogram_stretching(cv::Mat & m, int boxes, int offset)"""
  return _IMP_em2d.do_histogram_stretching(*args)

def do_dilate_and_shrink_warp(*args):
  """do_dilate_and_shrink_warp(cv::Mat & m, cv::Mat const & greyscale, cv::Mat & kernel)"""
  return _IMP_em2d.do_dilate_and_shrink_warp(*args)

def do_morphologic_reconstruction(*args):
  """
    do_morphologic_reconstruction(cv::Mat const & mask, cv::Mat & marker, int neighbors_mode=4)
    do_morphologic_reconstruction(cv::Mat const & mask, cv::Mat & marker)
    """
  return _IMP_em2d.do_morphologic_reconstruction(*args)

def do_labeling(*args):
  """do_labeling(IMP::em2d::cvIntMat const & m, IMP::em2d::cvIntMat & mat_to_label) -> int"""
  return _IMP_em2d.do_labeling(*args)

def get_diffusion_filtering_partial_derivative(*args):
  """get_diffusion_filtering_partial_derivative(cv::Mat const & m, cv::Mat & der, double dx, double dy, double ang)"""
  return _IMP_em2d.get_diffusion_filtering_partial_derivative(*args)

def get_domes(*args):
  """get_domes(cv::Mat & m, cv::Mat & result, double h)"""
  return _IMP_em2d.get_domes(*args)

def my_meanStdDev(*args):
  """my_meanStdDev(cv::Mat const & m, cv::Scalar & mean, cv::Scalar & stddev)"""
  return _IMP_em2d.my_meanStdDev(*args)

def get_transformed(*args):
  """get_transformed(cv::Mat const & input, cv::Mat & transformed, Transformation2D T)"""
  return _IMP_em2d.get_transformed(*args)

def apply_threshold(*args):
  """
    apply_threshold(cv::Mat & m, cv::Mat & result, double threshold=0.0)
    apply_threshold(cv::Mat & m, cv::Mat & result)
    """
  return _IMP_em2d.apply_threshold(*args)

def do_morphologic_contrast_enhancement(*args):
  """do_morphologic_contrast_enhancement(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel, unsigned int iterations)"""
  return _IMP_em2d.do_morphologic_contrast_enhancement(*args)

def get_morphologic_gradient(*args):
  """get_morphologic_gradient(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel)"""
  return _IMP_em2d.get_morphologic_gradient(*args)

def get_overlap_percentage(*args):
  """get_overlap_percentage(cv::Mat & m1, cv::Mat & m2, IMP::IntPair const & center) -> double"""
  return _IMP_em2d.get_overlap_percentage(*args)

def get_best_template_matches(*args):
  """get_best_template_matches(cv::Mat const & m, cv::Mat const & templ, unsigned int n) -> IMP::em2d::MatchTemplateResults"""
  return _IMP_em2d.get_best_template_matches(*args)
class Image(IMP.base.Object):
    """Proxy of C++ IMP::em2d::Image class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Image, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Image, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::Image self) -> Image
        __init__(IMP::em2d::Image self, int rows, int cols) -> Image
        __init__(IMP::em2d::Image self, IMP::String filename, ImageReaderWriter reader) -> Image
        """
        this = _IMP_em2d.new_Image(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_data(self):
        """get_data(Image self) -> cv::Mat &"""
        return _IMP_em2d.Image_get_data(self)

    def set_data(self, *args):
        """set_data(Image self, cv::Mat const & mat)"""
        return _IMP_em2d.Image_set_data(self, *args)

    def set_zeros(self):
        """set_zeros(Image self)"""
        return _IMP_em2d.Image_set_zeros(self)

    def set_value(self, *args):
        """
        set_value(Image self, double val)
        set_value(Image self, int i, int j, double val)
        """
        return _IMP_em2d.Image_set_value(self, *args)

    def __call__(self, *args):
        """__call__(Image self, int i, int j) -> double"""
        return _IMP_em2d.Image___call__(self, *args)

    def get_header(self):
        """get_header(Image self) -> ImageHeader"""
        return _IMP_em2d.Image_get_header(self)

    def set_size(self, *args):
        """
        set_size(Image self, int rows, int cols)
        set_size(Image self, Image img)
        """
        return _IMP_em2d.Image_set_size(self, *args)

    def update_header(self):
        """update_header(Image self)"""
        return _IMP_em2d.Image_update_header(self)

    def read(self, *args):
        """read(Image self, IMP::String filename, ImageReaderWriter reader)"""
        return _IMP_em2d.Image_read(self, *args)

    def write(self, *args):
        """write(Image self, IMP::String const & filename, ImageReaderWriter writer)"""
        return _IMP_em2d.Image_write(self, *args)

    def show(self, *args):
        """show(Image self, _ostream out)"""
        return _IMP_em2d.Image_show(self, *args)

    def get_version_info(self):
        """get_version_info(Image self) -> VersionInfo"""
        return _IMP_em2d.Image_get_version_info(self)

    __swig_destroy__ = _IMP_em2d.delete_Image
    __del__ = lambda self : None;
    def destroyed_msg(self):
        """destroyed_msg(Image self)"""
        return _IMP_em2d.Image_destroyed_msg(self)

    def set_name(self, *args):
        """set_name(Image self, IMP::String const & name)"""
        return _IMP_em2d.Image_set_name(self, *args)

    def get_name(self):
        """get_name(Image self) -> IMP::String"""
        return _IMP_em2d.Image_get_name(self)

    def get_min_and_max_values(self):
        """get_min_and_max_values(Image self) -> IMP::FloatRange"""
        return _IMP_em2d.Image_get_min_and_max_values(self)

    def __str__(self):
        """__str__(Image self) -> std::string"""
        return _IMP_em2d.Image___str__(self)

    def __repr__(self):
        """__repr__(Image self) -> std::string"""
        return _IMP_em2d.Image___repr__(self)

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

Image_swigregister = _IMP_em2d.Image_swigregister
Image_swigregister(Image)


def read_images(*args):
  """read_images(IMP::Strings const & names, ImageReaderWriter rw) -> IMP::em2d::Images"""
  return _IMP_em2d.read_images(*args)

def save_images(*args):
  """save_images(IMP::em2d::Images images, IMP::Strings const & names, ImageReaderWriter rw)"""
  return _IMP_em2d.save_images(*args)

def do_normalize(*args):
  """
    do_normalize(cv::Mat & m)
    do_normalize(Image im, bool force=False)
    do_normalize(Image im)
    """
  return _IMP_em2d.do_normalize(*args)

def get_histogram(*args):
  """
    get_histogram(cv::Mat const & m, int bins) -> IMP::Floats
    get_histogram(Image img, int bins) -> IMP::Floats
    """
  return _IMP_em2d.get_histogram(*args)

def apply_variance_filter(*args):
  """
    apply_variance_filter(cv::Mat const & input, cv::Mat & filtered, int kernelsize)
    apply_variance_filter(Image input, Image filtered, int kernelsize)
    """
  return _IMP_em2d.apply_variance_filter(*args)

def apply_diffusion_filter(*args):
  """
    apply_diffusion_filter(cv::Mat const & m, cv::Mat & result, double beta, double pixelsize, unsigned int time_steps)
    apply_diffusion_filter(Image input, Image filtered, double beta, double pixelsize, int time_steps)
    """
  return _IMP_em2d.apply_diffusion_filter(*args)

def do_fill_holes(*args):
  """
    do_fill_holes(cv::Mat const & m, cv::Mat & result, double h)
    do_fill_holes(Image input, Image result, double n_stddevs)
    """
  return _IMP_em2d.do_fill_holes(*args)

def do_combined_fill_holes_and_threshold(*args):
  """
    do_combined_fill_holes_and_threshold(cv::Mat & m, cv::Mat & result, double n_stddevs, double threshold=0.0)
    do_combined_fill_holes_and_threshold(cv::Mat & m, cv::Mat & result, double n_stddevs)
    do_combined_fill_holes_and_threshold(Image input, Image result, double n_stddevs)
    """
  return _IMP_em2d.do_combined_fill_holes_and_threshold(*args)

def do_extend_borders(*args):
  """
    do_extend_borders(cv::Mat & orig, cv::Mat & dst, unsigned int pix)
    do_extend_borders(Image im1, Image im2, unsigned int pix)
    """
  return _IMP_em2d.do_extend_borders(*args)

def do_segmentation(*args):
  """
    do_segmentation(cv::Mat const & m, cv::Mat & result, SegmentationParameters params)
    do_segmentation(Image input, Image result, SegmentationParameters params)
    """
  return _IMP_em2d.do_segmentation(*args)

def do_remove_small_objects(*args):
  """
    do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage, int background=0, int foreground=1)
    do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage, int background=0)
    do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage)
    do_remove_small_objects(Image input, double percentage, int background=0, int foreground=1)
    do_remove_small_objects(Image input, double percentage, int background=0)
    do_remove_small_objects(Image input, double percentage)
    """
  return _IMP_em2d.do_remove_small_objects(*args)

def do_subtract_images(*args):
  """do_subtract_images(Image first, Image second, Image result)"""
  return _IMP_em2d.do_subtract_images(*args)

def add_noise(*args):
  """
    add_noise(cv::Mat & v, double op1, double op2, IMP::String const & mode="uniform", double df=3)
    add_noise(cv::Mat & v, double op1, double op2, IMP::String const & mode="uniform")
    add_noise(cv::Mat & v, double op1, double op2)
    add_noise(Image im1, double op1, double op2, IMP::String const & mode="uniform", double df=3)
    add_noise(Image im1, double op1, double op2, IMP::String const & mode="uniform")
    add_noise(Image im1, double op1, double op2)
    """
  return _IMP_em2d.add_noise(*args)

def do_resample_polar(*args):
  """
    do_resample_polar(cv::Mat const & input, cv::Mat & resampled, PolarResamplingParameters polar_params)
    do_resample_polar(Image im1, Image im2, PolarResamplingParameters polar_params)
    """
  return _IMP_em2d.do_resample_polar(*args)

def crop(*args):
  """
    crop(cv::Mat const & m, IMP::IntPair const & center, int size) -> cv::Mat
    crop(Image img, IMP::IntPair const & center, int size)
    """
  return _IMP_em2d.crop(*args)

def apply_mean_outside_mask(*args):
  """apply_mean_outside_mask(Image img, double radius)"""
  return _IMP_em2d.apply_mean_outside_mask(*args)
class RegistrationResult(_object):
    """Proxy of C++ IMP::em2d::RegistrationResult class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RegistrationResult, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RegistrationResult, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::RegistrationResult self) -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0, int image_index=0, 
            IMP::String name="") -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0, int image_index=0) -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0) -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift) -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.), int projection_index=0, 
            int image_index=0, IMP::String name="") -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.), int projection_index=0, 
            int image_index=0) -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.), int projection_index=0) -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.)) -> RegistrationResult
        __init__(IMP::em2d::RegistrationResult self, Rotation3D R) -> RegistrationResult
        """
        this = _IMP_em2d.new_RegistrationResult(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_phi(self):
        """get_phi(RegistrationResult self) -> double"""
        return _IMP_em2d.RegistrationResult_get_phi(self)

    def get_theta(self):
        """get_theta(RegistrationResult self) -> double"""
        return _IMP_em2d.RegistrationResult_get_theta(self)

    def get_psi(self):
        """get_psi(RegistrationResult self) -> double"""
        return _IMP_em2d.RegistrationResult_get_psi(self)

    def get_shift(self):
        """get_shift(RegistrationResult self) -> Vector2D"""
        return _IMP_em2d.RegistrationResult_get_shift(self)

    def get_shift_3d(self):
        """get_shift_3d(RegistrationResult self) -> Vector3D"""
        return _IMP_em2d.RegistrationResult_get_shift_3d(self)

    def get_projection_index(self):
        """get_projection_index(RegistrationResult self) -> int"""
        return _IMP_em2d.RegistrationResult_get_projection_index(self)

    def set_projection_index(self, *args):
        """set_projection_index(RegistrationResult self, int index)"""
        return _IMP_em2d.RegistrationResult_set_projection_index(self, *args)

    def get_image_index(self):
        """get_image_index(RegistrationResult self) -> int"""
        return _IMP_em2d.RegistrationResult_get_image_index(self)

    def set_image_index(self, *args):
        """set_image_index(RegistrationResult self, int index)"""
        return _IMP_em2d.RegistrationResult_set_image_index(self, *args)

    def get_name(self):
        """get_name(RegistrationResult self) -> IMP::String"""
        return _IMP_em2d.RegistrationResult_get_name(self)

    def get_ccc(self):
        """get_ccc(RegistrationResult self) -> double"""
        return _IMP_em2d.RegistrationResult_get_ccc(self)

    def set_ccc(self, *args):
        """set_ccc(RegistrationResult self, double ccc)"""
        return _IMP_em2d.RegistrationResult_set_ccc(self, *args)

    def get_score(self):
        """get_score(RegistrationResult self) -> double"""
        return _IMP_em2d.RegistrationResult_get_score(self)

    def set_score(self, *args):
        """set_score(RegistrationResult self, double Score)"""
        return _IMP_em2d.RegistrationResult_set_score(self, *args)

    def set_rotation(self, *args):
        """
        set_rotation(RegistrationResult self, double phi, double theta, double psi)
        set_rotation(RegistrationResult self, Rotation3D R)
        """
        return _IMP_em2d.RegistrationResult_set_rotation(self, *args)

    def set_shift(self, *args):
        """set_shift(RegistrationResult self, Vector2D shift)"""
        return _IMP_em2d.RegistrationResult_set_shift(self, *args)

    def set_name(self, *args):
        """set_name(RegistrationResult self, IMP::String name)"""
        return _IMP_em2d.RegistrationResult_set_name(self, *args)

    def add_in_plane_transformation(self, *args):
        """add_in_plane_transformation(RegistrationResult self, Transformation2D t)"""
        return _IMP_em2d.RegistrationResult_add_in_plane_transformation(self, *args)

    def show(self, *args):
        """
        show(RegistrationResult self, _ostream out=std::cout)
        show(RegistrationResult self)
        """
        return _IMP_em2d.RegistrationResult_show(self, *args)

    def write(self, *args):
        """
        write(RegistrationResult self, _ostream out=std::cout)
        write(RegistrationResult self)
        """
        return _IMP_em2d.RegistrationResult_write(self, *args)

    def write_comment_line(self, *args):
        """
        write_comment_line(RegistrationResult self, _ostream out=std::cout)
        write_comment_line(RegistrationResult self)
        """
        return _IMP_em2d.RegistrationResult_write_comment_line(self, *args)

    def read(self, *args):
        """read(RegistrationResult self, IMP::String const & s)"""
        return _IMP_em2d.RegistrationResult_read(self, *args)

    def set_random_registration(self, *args):
        """set_random_registration(RegistrationResult self, unsigned int index, double maximum_shift)"""
        return _IMP_em2d.RegistrationResult_set_random_registration(self, *args)

    def get_rotation(self):
        """get_rotation(RegistrationResult self) -> Rotation3D"""
        return _IMP_em2d.RegistrationResult_get_rotation(self)

    def set_in_image(self, *args):
        """set_in_image(RegistrationResult self, ImageHeader header)"""
        return _IMP_em2d.RegistrationResult_set_in_image(self, *args)

    def read_from_image(self, *args):
        """read_from_image(RegistrationResult self, ImageHeader header)"""
        return _IMP_em2d.RegistrationResult_read_from_image(self, *args)

    def get_is_optimized_result(self):
        """get_is_optimized_result(RegistrationResult self) -> bool"""
        return _IMP_em2d.RegistrationResult_get_is_optimized_result(self)

    __swig_destroy__ = _IMP_em2d.delete_RegistrationResult
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RegistrationResult self) -> std::string"""
        return _IMP_em2d.RegistrationResult___str__(self)

    def __repr__(self):
        """__repr__(RegistrationResult self) -> std::string"""
        return _IMP_em2d.RegistrationResult___repr__(self)

RegistrationResult_swigregister = _IMP_em2d.RegistrationResult_swigregister
RegistrationResult_swigregister(RegistrationResult)


def read_registration_results(*args):
  """read_registration_results(IMP::String const & filename) -> IMP::em2d::RegistrationResults"""
  return _IMP_em2d.read_registration_results(*args)

def write_registration_results(*args):
  """write_registration_results(IMP::String filename, IMP::em2d::RegistrationResults const & results)"""
  return _IMP_em2d.write_registration_results(*args)

def get_random_registration_results(*args):
  """
    get_random_registration_results(unsigned int n, double maximum_shift=5.0) -> IMP::em2d::RegistrationResults
    get_random_registration_results(unsigned int n) -> IMP::em2d::RegistrationResults
    """
  return _IMP_em2d.get_random_registration_results(*args)

def get_evenly_distributed_registration_results(*args):
  """get_evenly_distributed_registration_results(unsigned int n_projections) -> IMP::em2d::RegistrationResults"""
  return _IMP_em2d.get_evenly_distributed_registration_results(*args)

def get_random_between_zero_and_one():
  """get_random_between_zero_and_one() -> double"""
  return _IMP_em2d.get_random_between_zero_and_one()
class SpiderImageReaderWriter(ImageReaderWriter):
    """Proxy of C++ IMP::em2d::SpiderImageReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpiderImageReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpiderImageReaderWriter, name)
    __swig_setmethods__["filename_"] = _IMP_em2d.SpiderImageReaderWriter_filename__set
    __swig_getmethods__["filename_"] = _IMP_em2d.SpiderImageReaderWriter_filename__get
    if _newclass:filename_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_filename__get, _IMP_em2d.SpiderImageReaderWriter_filename__set)
    __swig_setmethods__["skip_type_check_"] = _IMP_em2d.SpiderImageReaderWriter_skip_type_check__set
    __swig_getmethods__["skip_type_check_"] = _IMP_em2d.SpiderImageReaderWriter_skip_type_check__get
    if _newclass:skip_type_check_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_skip_type_check__get, _IMP_em2d.SpiderImageReaderWriter_skip_type_check__set)
    __swig_setmethods__["force_reversed_"] = _IMP_em2d.SpiderImageReaderWriter_force_reversed__set
    __swig_getmethods__["force_reversed_"] = _IMP_em2d.SpiderImageReaderWriter_force_reversed__get
    if _newclass:force_reversed_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_force_reversed__get, _IMP_em2d.SpiderImageReaderWriter_force_reversed__set)
    __swig_setmethods__["skip_extra_checkings_"] = _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__set
    __swig_getmethods__["skip_extra_checkings_"] = _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__get
    if _newclass:skip_extra_checkings_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__get, _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__set)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::SpiderImageReaderWriter self) -> SpiderImageReaderWriter
        __init__(IMP::em2d::SpiderImageReaderWriter self, IMP::String const & filename, bool skip_type_check, bool force_reversed, bool skip_extra_checkings) -> SpiderImageReaderWriter
        """
        this = _IMP_em2d.new_SpiderImageReaderWriter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em2d.delete_SpiderImageReaderWriter
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SpiderImageReaderWriter self) -> std::string"""
        return _IMP_em2d.SpiderImageReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(SpiderImageReaderWriter self) -> std::string"""
        return _IMP_em2d.SpiderImageReaderWriter___repr__(self)

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

SpiderImageReaderWriter_swigregister = _IMP_em2d.SpiderImageReaderWriter_swigregister
SpiderImageReaderWriter_swigregister(SpiderImageReaderWriter)

class JPGImageReaderWriter(ImageReaderWriter):
    """Proxy of C++ IMP::em2d::JPGImageReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, JPGImageReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, JPGImageReaderWriter, name)
    def __init__(self): 
        """__init__(IMP::em2d::JPGImageReaderWriter self) -> JPGImageReaderWriter"""
        this = _IMP_em2d.new_JPGImageReaderWriter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em2d.delete_JPGImageReaderWriter
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(JPGImageReaderWriter self) -> std::string"""
        return _IMP_em2d.JPGImageReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(JPGImageReaderWriter self) -> std::string"""
        return _IMP_em2d.JPGImageReaderWriter___repr__(self)

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

JPGImageReaderWriter_swigregister = _IMP_em2d.JPGImageReaderWriter_swigregister
JPGImageReaderWriter_swigregister(JPGImageReaderWriter)

class TIFFImageReaderWriter(ImageReaderWriter):
    """Proxy of C++ IMP::em2d::TIFFImageReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TIFFImageReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TIFFImageReaderWriter, name)
    def __init__(self): 
        """__init__(IMP::em2d::TIFFImageReaderWriter self) -> TIFFImageReaderWriter"""
        this = _IMP_em2d.new_TIFFImageReaderWriter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em2d.delete_TIFFImageReaderWriter
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(TIFFImageReaderWriter self) -> std::string"""
        return _IMP_em2d.TIFFImageReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(TIFFImageReaderWriter self) -> std::string"""
        return _IMP_em2d.TIFFImageReaderWriter___repr__(self)

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

TIFFImageReaderWriter_swigregister = _IMP_em2d.TIFFImageReaderWriter_swigregister
TIFFImageReaderWriter_swigregister(TIFFImageReaderWriter)


def do_matrix_to_image_flip(*args):
  """do_matrix_to_image_flip(cv::Mat & m)"""
  return _IMP_em2d.do_matrix_to_image_flip(*args)

def get_autocorrelation2d_no_preprocessing(*args):
  """get_autocorrelation2d_no_preprocessing(cv::Mat const & M, cv::Mat & corr)"""
  return _IMP_em2d.get_autocorrelation2d_no_preprocessing(*args)

def get_autocorrelation2d(*args):
  """
    get_autocorrelation2d(Image im1, Image im2)
    get_autocorrelation2d(cv::Mat const & m, cv::Mat & corr)
    """
  return _IMP_em2d.get_autocorrelation2d(*args)

def get_correlation2d(*args):
  """
    get_correlation2d(Image im1, Image im2, Image corr)
    get_correlation2d(cv::Mat const & A, cv::Mat const & B, cv::Mat & corr)
    """
  return _IMP_em2d.get_correlation2d(*args)

def get_correlation2d_no_preprocessing(*args):
  """get_correlation2d_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2, cv::Mat & corr)"""
  return _IMP_em2d.get_correlation2d_no_preprocessing(*args)

def get_fft_using_optimal_size(*args):
  """get_fft_using_optimal_size(cv::Mat const & m, cv::Mat & M)"""
  return _IMP_em2d.get_fft_using_optimal_size(*args)

def get_spectrum(*args):
  """get_spectrum(cv::Mat const & m, cv::Mat & real, cv::Mat & imag)"""
  return _IMP_em2d.get_spectrum(*args)

def get_rotation_error(*args):
  """get_rotation_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
  return _IMP_em2d.get_rotation_error(*args)

def get_shift_error(*args):
  """get_shift_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
  return _IMP_em2d.get_shift_error(*args)

def get_average_rotation_error(*args):
  """get_average_rotation_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
  return _IMP_em2d.get_average_rotation_error(*args)

def get_average_shift_error(*args):
  """get_average_shift_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
  return _IMP_em2d.get_average_shift_error(*args)

def get_cross_correlation_coefficient(*args):
  """
    get_cross_correlation_coefficient(Image im1, Image im2) -> double
    get_cross_correlation_coefficient(cv::Mat const & m1, cv::Mat const & m2) -> double
    """
  return _IMP_em2d.get_cross_correlation_coefficient(*args)

def get_global_score(*args):
  """get_global_score(IMP::em2d::RegistrationResults const & RRs) -> double"""
  return _IMP_em2d.get_global_score(*args)
class ScoreFunction(IMP.base.Object):
    """Proxy of C++ IMP::em2d::ScoreFunction class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoreFunction, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScoreFunction, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def get_score(self, *args):
        """get_score(ScoreFunction self, Image image, Image projection) -> double"""
        return _IMP_em2d.ScoreFunction_get_score(self, *args)

    def set_variance_image(self, *args):
        """set_variance_image(ScoreFunction self, Image var)"""
        return _IMP_em2d.ScoreFunction_set_variance_image(self, *args)

    def get_version_info(self):
        """get_version_info(ScoreFunction self) -> VersionInfo"""
        return _IMP_em2d.ScoreFunction_get_version_info(self)

    __swig_destroy__ = _IMP_em2d.delete_ScoreFunction
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ScoreFunction self) -> std::string"""
        return _IMP_em2d.ScoreFunction___str__(self)

    def __repr__(self):
        """__repr__(ScoreFunction self) -> std::string"""
        return _IMP_em2d.ScoreFunction___repr__(self)

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

ScoreFunction_swigregister = _IMP_em2d.ScoreFunction_swigregister
ScoreFunction_swigregister(ScoreFunction)

class ChiSquaredScore(ScoreFunction):
    """Proxy of C++ IMP::em2d::ChiSquaredScore class"""
    __swig_setmethods__ = {}
    for _s in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChiSquaredScore, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChiSquaredScore, name)
    def __init__(self): 
        """__init__(IMP::em2d::ChiSquaredScore self) -> ChiSquaredScore"""
        this = _IMP_em2d.new_ChiSquaredScore()
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(ChiSquaredScore self) -> std::string"""
        return _IMP_em2d.ChiSquaredScore___str__(self)

    def __repr__(self):
        """__repr__(ChiSquaredScore self) -> std::string"""
        return _IMP_em2d.ChiSquaredScore___repr__(self)

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

    __swig_destroy__ = _IMP_em2d.delete_ChiSquaredScore
    __del__ = lambda self : None;
ChiSquaredScore_swigregister = _IMP_em2d.ChiSquaredScore_swigregister
ChiSquaredScore_swigregister(ChiSquaredScore)

class EM2DScore(ScoreFunction):
    """Proxy of C++ IMP::em2d::EM2DScore class"""
    __swig_setmethods__ = {}
    for _s in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EM2DScore, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EM2DScore, name)
    def __init__(self): 
        """__init__(IMP::em2d::EM2DScore self) -> EM2DScore"""
        this = _IMP_em2d.new_EM2DScore()
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(EM2DScore self) -> std::string"""
        return _IMP_em2d.EM2DScore___str__(self)

    def __repr__(self):
        """__repr__(EM2DScore self) -> std::string"""
        return _IMP_em2d.EM2DScore___repr__(self)

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

    __swig_destroy__ = _IMP_em2d.delete_EM2DScore
    __del__ = lambda self : None;
EM2DScore_swigregister = _IMP_em2d.EM2DScore_swigregister
EM2DScore_swigregister(EM2DScore)

class MeanAbsoluteDifference(ScoreFunction):
    """Proxy of C++ IMP::em2d::MeanAbsoluteDifference class"""
    __swig_setmethods__ = {}
    for _s in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MeanAbsoluteDifference, name, value)
    __swig_getmethods__ = {}
    for _s in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MeanAbsoluteDifference, name)
    def __init__(self): 
        """__init__(IMP::em2d::MeanAbsoluteDifference self) -> MeanAbsoluteDifference"""
        this = _IMP_em2d.new_MeanAbsoluteDifference()
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(MeanAbsoluteDifference self) -> std::string"""
        return _IMP_em2d.MeanAbsoluteDifference___str__(self)

    def __repr__(self):
        """__repr__(MeanAbsoluteDifference self) -> std::string"""
        return _IMP_em2d.MeanAbsoluteDifference___repr__(self)

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

    __swig_destroy__ = _IMP_em2d.delete_MeanAbsoluteDifference
    __del__ = lambda self : None;
MeanAbsoluteDifference_swigregister = _IMP_em2d.MeanAbsoluteDifference_swigregister
MeanAbsoluteDifference_swigregister(MeanAbsoluteDifference)


def read_selection_file(*args):
  """read_selection_file(IMP::String fn) -> IMP::Strings"""
  return _IMP_em2d.read_selection_file(*args)

def create_filenames(*args):
  """create_filenames(unsigned long number, IMP::String basic_name, IMP::String extension) -> IMP::Strings"""
  return _IMP_em2d.create_filenames(*args)
class ProjectionParameters(IMP.kernel.Decorator):
    """Proxy of C++ IMP::em2d::ProjectionParameters class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjectionParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProjectionParameters, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::ProjectionParameters self) -> ProjectionParameters
        __init__(IMP::em2d::ProjectionParameters self, Model m, IMP::kernel::ParticleIndex id) -> ProjectionParameters
        __init__(IMP::em2d::ProjectionParameters self, Particle p) -> ProjectionParameters
        """
        this = _IMP_em2d.new_ProjectionParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    def decorate_particle(*args):
        """decorate_particle(Particle p) -> ProjectionParameters"""
        return _IMP_em2d.ProjectionParameters_decorate_particle(*args)

    if _newclass:decorate_particle = staticmethod(decorate_particle)
    __swig_getmethods__["decorate_particle"] = lambda x: decorate_particle
    def show(self, *args):
        """
        show(ProjectionParameters self, _ostream out=std::cout)
        show(ProjectionParameters self)
        """
        return _IMP_em2d.ProjectionParameters_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_ProjectionParameters
    __del__ = lambda self : None;
    def get_keys():
        """get_keys() -> IMP::kernel::FloatKeys const &"""
        return _IMP_em2d.ProjectionParameters_get_keys()

    if _newclass:get_keys = staticmethod(get_keys)
    __swig_getmethods__["get_keys"] = lambda x: get_keys
    def set_proper_ranges_for_keys(self, *args):
        """set_proper_ranges_for_keys(ProjectionParameters self, Model m, Vector3D min_translation_values, Vector3D max_translation_values)"""
        return _IMP_em2d.ProjectionParameters_set_proper_ranges_for_keys(self, *args)

    def setup_particle(*args):
        """setup_particle(Particle p) -> ProjectionParameters"""
        return _IMP_em2d.ProjectionParameters_setup_particle(*args)

    if _newclass:setup_particle = staticmethod(setup_particle)
    __swig_getmethods__["setup_particle"] = lambda x: setup_particle
    def particle_is_instance(*args):
        """particle_is_instance(Particle p) -> bool"""
        return _IMP_em2d.ProjectionParameters_particle_is_instance(*args)

    if _newclass:particle_is_instance = staticmethod(particle_is_instance)
    __swig_getmethods__["particle_is_instance"] = lambda x: particle_is_instance
    def get_parameters_optimized(self):
        """get_parameters_optimized(ProjectionParameters self) -> bool"""
        return _IMP_em2d.ProjectionParameters_get_parameters_optimized(self)

    def get_translation(self):
        """get_translation(ProjectionParameters self) -> Vector3D"""
        return _IMP_em2d.ProjectionParameters_get_translation(self)

    def set_translation(self, *args):
        """set_translation(ProjectionParameters self, Vector3D v)"""
        return _IMP_em2d.ProjectionParameters_set_translation(self, *args)

    def get_rotation(self):
        """get_rotation(ProjectionParameters self) -> Rotation3D"""
        return _IMP_em2d.ProjectionParameters_get_rotation(self)

    def set_rotation(self, *args):
        """set_rotation(ProjectionParameters self, Rotation3D R)"""
        return _IMP_em2d.ProjectionParameters_set_rotation(self, *args)

    def set_parameters_optimized(self, *args):
        """set_parameters_optimized(ProjectionParameters self, bool tf)"""
        return _IMP_em2d.ProjectionParameters_set_parameters_optimized(self, *args)

    def get_quaternion_1(self):
        """get_quaternion_1(ProjectionParameters self) -> double"""
        return _IMP_em2d.ProjectionParameters_get_quaternion_1(self)

    def set_quaternion_1(self, *args):
        """set_quaternion_1(ProjectionParameters self, double t)"""
        return _IMP_em2d.ProjectionParameters_set_quaternion_1(self, *args)

    def get_quaternion_2(self):
        """get_quaternion_2(ProjectionParameters self) -> double"""
        return _IMP_em2d.ProjectionParameters_get_quaternion_2(self)

    def set_quaternion_2(self, *args):
        """set_quaternion_2(ProjectionParameters self, double t)"""
        return _IMP_em2d.ProjectionParameters_set_quaternion_2(self, *args)

    def get_quaternion_3(self):
        """get_quaternion_3(ProjectionParameters self) -> double"""
        return _IMP_em2d.ProjectionParameters_get_quaternion_3(self)

    def set_quaternion_3(self, *args):
        """set_quaternion_3(ProjectionParameters self, double t)"""
        return _IMP_em2d.ProjectionParameters_set_quaternion_3(self, *args)

    def get_quaternion_4(self):
        """get_quaternion_4(ProjectionParameters self) -> double"""
        return _IMP_em2d.ProjectionParameters_get_quaternion_4(self)

    def set_quaternion_4(self, *args):
        """set_quaternion_4(ProjectionParameters self, double t)"""
        return _IMP_em2d.ProjectionParameters_set_quaternion_4(self, *args)

    def get_translation_x(self):
        """get_translation_x(ProjectionParameters self) -> double"""
        return _IMP_em2d.ProjectionParameters_get_translation_x(self)

    def set_translation_x(self, *args):
        """set_translation_x(ProjectionParameters self, double t)"""
        return _IMP_em2d.ProjectionParameters_set_translation_x(self, *args)

    def get_translation_y(self):
        """get_translation_y(ProjectionParameters self) -> double"""
        return _IMP_em2d.ProjectionParameters_get_translation_y(self)

    def set_translation_y(self, *args):
        """set_translation_y(ProjectionParameters self, double t)"""
        return _IMP_em2d.ProjectionParameters_set_translation_y(self, *args)

    def add_attribute(self, *args):
        """
        add_attribute(ProjectionParameters self, FloatKey k, IMP::Float v, bool opt)
        add_attribute(ProjectionParameters self, FloatKey a0, IMP::Float a1)
        add_attribute(ProjectionParameters self, IntKey a0, IMP::Int a1)
        add_attribute(ProjectionParameters self, StringKey a0, IMP::String a1)
        add_attribute(ProjectionParameters self, ParticleIndexKey a0, Particle a1)
        add_attribute(ProjectionParameters self, ObjectKey a0, IMP::Object * a1)
        """
        return _IMP_em2d.ProjectionParameters_add_attribute(self, *args)

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

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

    def remove_attribute(self, *args):
        """
        remove_attribute(ProjectionParameters self, FloatKey a0)
        remove_attribute(ProjectionParameters self, IntKey a0)
        remove_attribute(ProjectionParameters self, StringKey a0)
        remove_attribute(ProjectionParameters self, ParticleIndexKey a0)
        remove_attribute(ProjectionParameters self, ObjectKey a0)
        """
        return _IMP_em2d.ProjectionParameters_remove_attribute(self, *args)

    def has_attribute(self, *args):
        """
        has_attribute(ProjectionParameters self, FloatKey a0) -> bool
        has_attribute(ProjectionParameters self, IntKey a0) -> bool
        has_attribute(ProjectionParameters self, StringKey a0) -> bool
        has_attribute(ProjectionParameters self, ParticleIndexKey a0) -> bool
        has_attribute(ProjectionParameters self, ObjectKey a0) -> bool
        """
        return _IMP_em2d.ProjectionParameters_has_attribute(self, *args)

    def get_derivative(self, *args):
        """get_derivative(ProjectionParameters self, FloatKey a0) -> double"""
        return _IMP_em2d.ProjectionParameters_get_derivative(self, *args)

    def get_name(self):
        """get_name(ProjectionParameters self) -> std::string"""
        return _IMP_em2d.ProjectionParameters_get_name(self)

    def clear_caches(self):
        """clear_caches(ProjectionParameters self)"""
        return _IMP_em2d.ProjectionParameters_clear_caches(self)

    def set_name(self, *args):
        """set_name(ProjectionParameters self, std::string a0)"""
        return _IMP_em2d.ProjectionParameters_set_name(self, *args)

    def set_check_level(self, *args):
        """set_check_level(ProjectionParameters self, IMP::base::CheckLevel a0)"""
        return _IMP_em2d.ProjectionParameters_set_check_level(self, *args)

    def add_to_derivative(self, *args):
        """add_to_derivative(ProjectionParameters self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
        return _IMP_em2d.ProjectionParameters_add_to_derivative(self, *args)

    def set_is_optimized(self, *args):
        """set_is_optimized(ProjectionParameters self, FloatKey a0, bool a1)"""
        return _IMP_em2d.ProjectionParameters_set_is_optimized(self, *args)

    def get_is_optimized(self, *args):
        """get_is_optimized(ProjectionParameters self, FloatKey a0) -> bool"""
        return _IMP_em2d.ProjectionParameters_get_is_optimized(self, *args)

    def get_check_level(self):
        """get_check_level(ProjectionParameters self) -> IMP::base::CheckLevel"""
        return _IMP_em2d.ProjectionParameters_get_check_level(self)

    def __eq__(self, *args):
        """
        __eq__(ProjectionParameters self, ProjectionParameters o) -> bool
        __eq__(ProjectionParameters self, Particle d) -> bool
        """
        return _IMP_em2d.ProjectionParameters___eq__(self, *args)

    def __ne__(self, *args):
        """
        __ne__(ProjectionParameters self, ProjectionParameters o) -> bool
        __ne__(ProjectionParameters self, Particle d) -> bool
        """
        return _IMP_em2d.ProjectionParameters___ne__(self, *args)

    def __le__(self, *args):
        """
        __le__(ProjectionParameters self, ProjectionParameters o) -> bool
        __le__(ProjectionParameters self, Particle d) -> bool
        """
        return _IMP_em2d.ProjectionParameters___le__(self, *args)

    def __lt__(self, *args):
        """
        __lt__(ProjectionParameters self, ProjectionParameters o) -> bool
        __lt__(ProjectionParameters self, Particle d) -> bool
        """
        return _IMP_em2d.ProjectionParameters___lt__(self, *args)

    def __ge__(self, *args):
        """
        __ge__(ProjectionParameters self, ProjectionParameters o) -> bool
        __ge__(ProjectionParameters self, Particle d) -> bool
        """
        return _IMP_em2d.ProjectionParameters___ge__(self, *args)

    def __gt__(self, *args):
        """
        __gt__(ProjectionParameters self, ProjectionParameters o) -> bool
        __gt__(ProjectionParameters self, Particle d) -> bool
        """
        return _IMP_em2d.ProjectionParameters___gt__(self, *args)

    def __str__(self):
        """__str__(ProjectionParameters self) -> std::string"""
        return _IMP_em2d.ProjectionParameters___str__(self)

    def __repr__(self):
        """__repr__(ProjectionParameters self) -> std::string"""
        return _IMP_em2d.ProjectionParameters___repr__(self)

ProjectionParameters_swigregister = _IMP_em2d.ProjectionParameters_swigregister
ProjectionParameters_swigregister(ProjectionParameters)

def ProjectionParameters_decorate_particle(*args):
  """ProjectionParameters_decorate_particle(Particle p) -> ProjectionParameters"""
  return _IMP_em2d.ProjectionParameters_decorate_particle(*args)

def ProjectionParameters_get_keys():
  """ProjectionParameters_get_keys() -> IMP::kernel::FloatKeys const &"""
  return _IMP_em2d.ProjectionParameters_get_keys()

def ProjectionParameters_setup_particle(*args):
  """ProjectionParameters_setup_particle(Particle p) -> ProjectionParameters"""
  return _IMP_em2d.ProjectionParameters_setup_particle(*args)

def ProjectionParameters_particle_is_instance(*args):
  """ProjectionParameters_particle_is_instance(Particle p) -> bool"""
  return _IMP_em2d.ProjectionParameters_particle_is_instance(*args)


def __lshift__(*args):
  """__lshift__(_ostream out, ProjectionParameters n) -> _ostream"""
  return _IMP_em2d.__lshift__(*args)
class ProjectionParametersScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::em2d::ProjectionParametersScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjectionParametersScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProjectionParametersScoreState, name)
    def __init__(self, *args): 
        """__init__(IMP::em2d::ProjectionParametersScoreState self, Particle p) -> ProjectionParametersScoreState"""
        this = _IMP_em2d.new_ProjectionParametersScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_input_particles(self):
        """get_input_particles(ProjectionParametersScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_em2d.ProjectionParametersScoreState_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(ProjectionParametersScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_em2d.ProjectionParametersScoreState_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(ProjectionParametersScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em2d.ProjectionParametersScoreState_do_get_inputs(self)

    def get_output_particles(self):
        """get_output_particles(ProjectionParametersScoreState self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_em2d.ProjectionParametersScoreState_get_output_particles(self)

    def get_output_containers(self):
        """get_output_containers(ProjectionParametersScoreState self) -> IMP::kernel::ContainersTemp"""
        return _IMP_em2d.ProjectionParametersScoreState_get_output_containers(self)

    def do_get_outputs(self):
        """do_get_outputs(ProjectionParametersScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em2d.ProjectionParametersScoreState_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(ProjectionParametersScoreState self) -> VersionInfo"""
        return _IMP_em2d.ProjectionParametersScoreState_get_version_info(self)

    def do_show(self, *args):
        """do_show(ProjectionParametersScoreState self, _ostream out)"""
        return _IMP_em2d.ProjectionParametersScoreState_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_ProjectionParametersScoreState
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ProjectionParametersScoreState self) -> std::string"""
        return _IMP_em2d.ProjectionParametersScoreState___str__(self)

    def __repr__(self):
        """__repr__(ProjectionParametersScoreState self) -> std::string"""
        return _IMP_em2d.ProjectionParametersScoreState___repr__(self)

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

ProjectionParametersScoreState_swigregister = _IMP_em2d.ProjectionParametersScoreState_swigregister
ProjectionParametersScoreState_swigregister(ProjectionParametersScoreState)

class ProjectionMask(_object):
    """Proxy of C++ IMP::em2d::ProjectionMask class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjectionMask, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProjectionMask, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    def apply(self, *args):
        """apply(ProjectionMask self, cv::Mat & m, Vector2D v)"""
        return _IMP_em2d.ProjectionMask_apply(self, *args)

    def show(self, *args):
        """
        show(ProjectionMask self, _ostream out=std::cout)
        show(ProjectionMask self)
        """
        return _IMP_em2d.ProjectionMask_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_ProjectionMask
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ProjectionMask self) -> std::string"""
        return _IMP_em2d.ProjectionMask___str__(self)

    def __repr__(self):
        """__repr__(ProjectionMask self) -> std::string"""
        return _IMP_em2d.ProjectionMask___repr__(self)

ProjectionMask_swigregister = _IMP_em2d.ProjectionMask_swigregister
ProjectionMask_swigregister(ProjectionMask)


def do_place(*args):
  """do_place(cv::Mat & mask, cv::Mat & m, Vector2D v)"""
  return _IMP_em2d.do_place(*args)
class MasksManager(_object):
    """Proxy of C++ IMP::em2d::MasksManager class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MasksManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MasksManager, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::MasksManager self) -> MasksManager
        __init__(IMP::em2d::MasksManager self, double resolution, double pixelsize) -> MasksManager
        """
        this = _IMP_em2d.new_MasksManager(*args)
        try: self.this.append(this)
        except: self.this = this
    def setup_kernel(self, *args):
        """setup_kernel(MasksManager self, double resolution, double pixelsize)"""
        return _IMP_em2d.MasksManager_setup_kernel(self, *args)

    def create_masks(self, *args):
        """create_masks(MasksManager self, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_em2d.MasksManager_create_masks(self, *args)

    def create_mask(self, *args):
        """create_mask(MasksManager self, double radius, double mass)"""
        return _IMP_em2d.MasksManager_create_mask(self, *args)

    def find_mask(self, *args):
        """find_mask(MasksManager self, double radius) -> IMP::em2d::ProjectionMaskPtr"""
        return _IMP_em2d.MasksManager_find_mask(self, *args)

    def show(self, *args):
        """
        show(MasksManager self, _ostream out=std::cout)
        show(MasksManager self)
        """
        return _IMP_em2d.MasksManager_show(self, *args)

    def get_number_of_masks(self):
        """get_number_of_masks(MasksManager self) -> unsigned int"""
        return _IMP_em2d.MasksManager_get_number_of_masks(self)

    __swig_destroy__ = _IMP_em2d.delete_MasksManager
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(MasksManager self) -> std::string"""
        return _IMP_em2d.MasksManager___str__(self)

    def __repr__(self):
        """__repr__(MasksManager self) -> std::string"""
        return _IMP_em2d.MasksManager___repr__(self)

MasksManager_swigregister = _IMP_em2d.MasksManager_swigregister
MasksManager_swigregister(MasksManager)

class ProjectingParameters(_object):
    """Proxy of C++ IMP::em2d::ProjectingParameters class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjectingParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProjectingParameters, name)
    __swig_setmethods__["pixel_size"] = _IMP_em2d.ProjectingParameters_pixel_size_set
    __swig_getmethods__["pixel_size"] = _IMP_em2d.ProjectingParameters_pixel_size_get
    if _newclass:pixel_size = _swig_property(_IMP_em2d.ProjectingParameters_pixel_size_get, _IMP_em2d.ProjectingParameters_pixel_size_set)
    __swig_setmethods__["resolution"] = _IMP_em2d.ProjectingParameters_resolution_set
    __swig_getmethods__["resolution"] = _IMP_em2d.ProjectingParameters_resolution_get
    if _newclass:resolution = _swig_property(_IMP_em2d.ProjectingParameters_resolution_get, _IMP_em2d.ProjectingParameters_resolution_set)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::ProjectingParameters self) -> ProjectingParameters
        __init__(IMP::em2d::ProjectingParameters self, double ps, double res) -> ProjectingParameters
        """
        this = _IMP_em2d.new_ProjectingParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(ProjectingParameters self, _ostream out=std::cout)
        show(ProjectingParameters self)
        """
        return _IMP_em2d.ProjectingParameters_show(self, *args)

    def __str__(self):
        """__str__(ProjectingParameters self) -> std::string"""
        return _IMP_em2d.ProjectingParameters___str__(self)

    def __repr__(self):
        """__repr__(ProjectingParameters self) -> std::string"""
        return _IMP_em2d.ProjectingParameters___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_ProjectingParameters
    __del__ = lambda self : None;
ProjectingParameters_swigregister = _IMP_em2d.ProjectingParameters_swigregister
ProjectingParameters_swigregister(ProjectingParameters)

class ProjectingOptions(ProjectingParameters):
    """Proxy of C++ IMP::em2d::ProjectingOptions class"""
    __swig_setmethods__ = {}
    for _s in [ProjectingParameters]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjectingOptions, name, value)
    __swig_getmethods__ = {}
    for _s in [ProjectingParameters]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProjectingOptions, name)
    __swig_setmethods__["save_images"] = _IMP_em2d.ProjectingOptions_save_images_set
    __swig_getmethods__["save_images"] = _IMP_em2d.ProjectingOptions_save_images_get
    if _newclass:save_images = _swig_property(_IMP_em2d.ProjectingOptions_save_images_get, _IMP_em2d.ProjectingOptions_save_images_set)
    __swig_setmethods__["normalize"] = _IMP_em2d.ProjectingOptions_normalize_set
    __swig_getmethods__["normalize"] = _IMP_em2d.ProjectingOptions_normalize_get
    if _newclass:normalize = _swig_property(_IMP_em2d.ProjectingOptions_normalize_get, _IMP_em2d.ProjectingOptions_normalize_set)
    __swig_setmethods__["clear_matrix_before_projecting"] = _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_set
    __swig_getmethods__["clear_matrix_before_projecting"] = _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_get
    if _newclass:clear_matrix_before_projecting = _swig_property(_IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_get, _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_set)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::ProjectingOptions self) -> ProjectingOptions
        __init__(IMP::em2d::ProjectingOptions self, double ps, double res) -> ProjectingOptions
        __init__(IMP::em2d::ProjectingOptions self, double ps, double res, ImageReaderWriter irw) -> ProjectingOptions
        """
        this = _IMP_em2d.new_ProjectingOptions(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(ProjectingOptions self, _ostream out=std::cout)
        show(ProjectingOptions self)
        """
        return _IMP_em2d.ProjectingOptions_show(self, *args)

    def __str__(self):
        """__str__(ProjectingOptions self) -> std::string"""
        return _IMP_em2d.ProjectingOptions___str__(self)

    def __repr__(self):
        """__repr__(ProjectingOptions self) -> std::string"""
        return _IMP_em2d.ProjectingOptions___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_ProjectingOptions
    __del__ = lambda self : None;
ProjectingOptions_swigregister = _IMP_em2d.ProjectingOptions_swigregister
ProjectingOptions_swigregister(ProjectingOptions)


def get_projections(*args):
  """
    get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::algebra::SphericalVector3Ds const & vs, 
        int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
    get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::algebra::SphericalVector3Ds const & vs, 
        int rows, int cols, ProjectingOptions options) -> IMP::em2d::Images
    get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::em2d::RegistrationResults const & registration_values, 
        int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
    get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::em2d::RegistrationResults const & registration_values, 
        int rows, int cols, ProjectingOptions options) -> IMP::em2d::Images
    """
  return _IMP_em2d.get_projections(*args)

def get_projection(*args):
  """
    get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options, 
        IMP::em2d::MasksManagerPtr masks=IMP::em2d::MasksManagerPtr(), 
        IMP::String name="")
    get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options, 
        IMP::em2d::MasksManagerPtr masks=IMP::em2d::MasksManagerPtr())
    get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options)
    """
  return _IMP_em2d.get_projection(*args)

def do_project_particles(*args):
  """
    do_project_particles(IMP::kernel::ParticlesTemp const & ps, cv::Mat & m2, Rotation3D R, Vector3D translation, 
        ProjectingOptions options, IMP::em2d::MasksManagerPtr masks)
    """
  return _IMP_em2d.do_project_particles(*args)

def create_evenly_distributed_projections(*args):
  """create_evenly_distributed_projections(IMP::kernel::ParticlesTemp const & ps, unsigned int n, ProjectingOptions options) -> IMP::em2d::Images"""
  return _IMP_em2d.create_evenly_distributed_projections(*args)

def do_project_vectors(*args):
  """
    do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation) -> IMP::algebra::Vector2Ds
    do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation, Vector3D center) -> IMP::algebra::Vector2Ds
    """
  return _IMP_em2d.do_project_vectors(*args)

def get_enclosing_image_size(*args):
  """get_enclosing_image_size(IMP::kernel::ParticlesTemp const & ps, double pixel_size, unsigned int slack) -> unsigned int"""
  return _IMP_em2d.get_enclosing_image_size(*args)

def get_complete_alignment(*args):
  """
    get_complete_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
    get_complete_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
    """
  return _IMP_em2d.get_complete_alignment(*args)

def get_rotational_alignment(*args):
  """
    get_rotational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
    get_rotational_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
    """
  return _IMP_em2d.get_rotational_alignment(*args)

def get_translational_alignment(*args):
  """
    get_translational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
    get_translational_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
    """
  return _IMP_em2d.get_translational_alignment(*args)

def get_complete_alignment_no_preprocessing(*args):
  """
    get_complete_alignment_no_preprocessing(cv::Mat const & input, cv::Mat const & INPUT, cv::Mat const & POLAR1, cv::Mat & m_to_align, 
        cv::Mat const & POLAR2, bool apply=False) -> ResultAlign2D
    get_complete_alignment_no_preprocessing(cv::Mat const & input, cv::Mat const & INPUT, cv::Mat const & POLAR1, cv::Mat & m_to_align, 
        cv::Mat const & POLAR2) -> ResultAlign2D
    """
  return _IMP_em2d.get_complete_alignment_no_preprocessing(*args)

def get_rotational_alignment_no_preprocessing(*args):
  """get_rotational_alignment_no_preprocessing(cv::Mat const & POLAR1, cv::Mat const & POLAR2) -> ResultAlign2D"""
  return _IMP_em2d.get_rotational_alignment_no_preprocessing(*args)

def get_translational_alignment_no_preprocessing(*args):
  """get_translational_alignment_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2) -> ResultAlign2D"""
  return _IMP_em2d.get_translational_alignment_no_preprocessing(*args)

def get_complete_alignment_with_centers_no_preprocessing(*args):
  """get_complete_alignment_with_centers_no_preprocessing(Vector2D center1, Vector2D center2, cv::Mat const & AUTOC_POLAR1, cv::Mat const & AUTOC_POLAR2) -> ResultAlign2D"""
  return _IMP_em2d.get_complete_alignment_with_centers_no_preprocessing(*args)

def write_vectors_as_pdb(*args):
  """
    write_vectors_as_pdb(IMP::algebra::Vector2Ds const vs, IMP::String const filename)
    write_vectors_as_pdb(IMP::algebra::Vector3Ds const vs, IMP::String const filename)
    """
  return _IMP_em2d.write_vectors_as_pdb(*args)
class Em2DRestraintParameters(ProjectingParameters):
    """Proxy of C++ IMP::em2d::Em2DRestraintParameters class"""
    __swig_setmethods__ = {}
    for _s in [ProjectingParameters]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Em2DRestraintParameters, name, value)
    __swig_getmethods__ = {}
    for _s in [ProjectingParameters]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Em2DRestraintParameters, name)
    __swig_setmethods__["n_projections"] = _IMP_em2d.Em2DRestraintParameters_n_projections_set
    __swig_getmethods__["n_projections"] = _IMP_em2d.Em2DRestraintParameters_n_projections_get
    if _newclass:n_projections = _swig_property(_IMP_em2d.Em2DRestraintParameters_n_projections_get, _IMP_em2d.Em2DRestraintParameters_n_projections_set)
    __swig_setmethods__["coarse_registration_method"] = _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_set
    __swig_getmethods__["coarse_registration_method"] = _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_get
    if _newclass:coarse_registration_method = _swig_property(_IMP_em2d.Em2DRestraintParameters_coarse_registration_method_get, _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_set)
    __swig_setmethods__["save_match_images"] = _IMP_em2d.Em2DRestraintParameters_save_match_images_set
    __swig_getmethods__["save_match_images"] = _IMP_em2d.Em2DRestraintParameters_save_match_images_get
    if _newclass:save_match_images = _swig_property(_IMP_em2d.Em2DRestraintParameters_save_match_images_get, _IMP_em2d.Em2DRestraintParameters_save_match_images_set)
    __swig_setmethods__["optimization_steps"] = _IMP_em2d.Em2DRestraintParameters_optimization_steps_set
    __swig_getmethods__["optimization_steps"] = _IMP_em2d.Em2DRestraintParameters_optimization_steps_get
    if _newclass:optimization_steps = _swig_property(_IMP_em2d.Em2DRestraintParameters_optimization_steps_get, _IMP_em2d.Em2DRestraintParameters_optimization_steps_set)
    __swig_setmethods__["simplex_initial_length"] = _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_set
    __swig_getmethods__["simplex_initial_length"] = _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_get
    if _newclass:simplex_initial_length = _swig_property(_IMP_em2d.Em2DRestraintParameters_simplex_initial_length_get, _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_set)
    __swig_setmethods__["simplex_minimum_size"] = _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_set
    __swig_getmethods__["simplex_minimum_size"] = _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_get
    if _newclass:simplex_minimum_size = _swig_property(_IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_get, _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_set)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::Em2DRestraintParameters self) -> Em2DRestraintParameters
        __init__(IMP::em2d::Em2DRestraintParameters self, double ps, double res, unsigned int n_proj=20) -> Em2DRestraintParameters
        __init__(IMP::em2d::Em2DRestraintParameters self, double ps, double res) -> Em2DRestraintParameters
        """
        this = _IMP_em2d.new_Em2DRestraintParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(Em2DRestraintParameters self, _ostream out=std::cout)
        show(Em2DRestraintParameters self)
        """
        return _IMP_em2d.Em2DRestraintParameters_show(self, *args)

    def __str__(self):
        """__str__(Em2DRestraintParameters self) -> std::string"""
        return _IMP_em2d.Em2DRestraintParameters___str__(self)

    def __repr__(self):
        """__repr__(Em2DRestraintParameters self) -> std::string"""
        return _IMP_em2d.Em2DRestraintParameters___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_Em2DRestraintParameters
    __del__ = lambda self : None;
Em2DRestraintParameters_swigregister = _IMP_em2d.Em2DRestraintParameters_swigregister
Em2DRestraintParameters_swigregister(Em2DRestraintParameters)
cvar = _IMP_em2d.cvar
ALIGN2D_NO_PREPROCESSING = cvar.ALIGN2D_NO_PREPROCESSING
ALIGN2D_PREPROCESSING = cvar.ALIGN2D_PREPROCESSING
ALIGN2D_WITH_CENTERS = cvar.ALIGN2D_WITH_CENTERS

class ProjectionFinder(IMP.base.Object):
    """Proxy of C++ IMP::em2d::ProjectionFinder class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjectionFinder, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProjectionFinder, name)
    def __init__(self): 
        """__init__(IMP::em2d::ProjectionFinder self) -> ProjectionFinder"""
        this = _IMP_em2d.new_ProjectionFinder()
        try: self.this.append(this)
        except: self.this = this
    def setup(self, *args):
        """setup(ProjectionFinder self, ScoreFunction score_function, Em2DRestraintParameters params)"""
        return _IMP_em2d.ProjectionFinder_setup(self, *args)

    def set_subjects(self, *args):
        """set_subjects(ProjectionFinder self, IMP::em2d::Images const & subjects)"""
        return _IMP_em2d.ProjectionFinder_set_subjects(self, *args)

    def set_projections(self, *args):
        """set_projections(ProjectionFinder self, IMP::em2d::Images const & projections)"""
        return _IMP_em2d.ProjectionFinder_set_projections(self, *args)

    def set_variance_images(self, *args):
        """set_variance_images(ProjectionFinder self, IMP::em2d::Images const & variances)"""
        return _IMP_em2d.ProjectionFinder_set_variance_images(self, *args)

    def set_model_particles(self, *args):
        """set_model_particles(ProjectionFinder self, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_em2d.ProjectionFinder_set_model_particles(self, *args)

    def set_save_match_images(self, *args):
        """set_save_match_images(ProjectionFinder self, bool x)"""
        return _IMP_em2d.ProjectionFinder_set_save_match_images(self, *args)

    def get_save_match_images(self):
        """get_save_match_images(ProjectionFinder self) -> bool"""
        return _IMP_em2d.ProjectionFinder_get_save_match_images(self)

    def set_fast_mode(self, *args):
        """set_fast_mode(ProjectionFinder self, unsigned int n)"""
        return _IMP_em2d.ProjectionFinder_set_fast_mode(self, *args)

    def get_registration_results(self):
        """get_registration_results(ProjectionFinder self) -> IMP::em2d::RegistrationResults"""
        return _IMP_em2d.ProjectionFinder_get_registration_results(self)

    def get_coarse_registration(self):
        """get_coarse_registration(ProjectionFinder self)"""
        return _IMP_em2d.ProjectionFinder_get_coarse_registration(self)

    def get_complete_registration(self):
        """get_complete_registration(ProjectionFinder self)"""
        return _IMP_em2d.ProjectionFinder_get_complete_registration(self)

    def get_global_score(self):
        """get_global_score(ProjectionFinder self) -> double"""
        return _IMP_em2d.ProjectionFinder_get_global_score(self)

    def show(self, *args):
        """show(ProjectionFinder self, _ostream out)"""
        return _IMP_em2d.ProjectionFinder_show(self, *args)

    def get_preprocessing_time(self):
        """get_preprocessing_time(ProjectionFinder self) -> double"""
        return _IMP_em2d.ProjectionFinder_get_preprocessing_time(self)

    def get_coarse_registration_time(self):
        """get_coarse_registration_time(ProjectionFinder self) -> double"""
        return _IMP_em2d.ProjectionFinder_get_coarse_registration_time(self)

    def get_fine_registration_time(self):
        """get_fine_registration_time(ProjectionFinder self) -> double"""
        return _IMP_em2d.ProjectionFinder_get_fine_registration_time(self)

    def get_number_of_subjects(self):
        """get_number_of_subjects(ProjectionFinder self) -> unsigned int"""
        return _IMP_em2d.ProjectionFinder_get_number_of_subjects(self)

    def set_number_of_class_averages_members(self, *args):
        """set_number_of_class_averages_members(ProjectionFinder self, IMP::Ints n_members)"""
        return _IMP_em2d.ProjectionFinder_set_number_of_class_averages_members(self, *args)

    def get_number_of_projections(self):
        """get_number_of_projections(ProjectionFinder self) -> unsigned int"""
        return _IMP_em2d.ProjectionFinder_get_number_of_projections(self)

    def get_version_info(self):
        """get_version_info(ProjectionFinder self) -> VersionInfo"""
        return _IMP_em2d.ProjectionFinder_get_version_info(self)

    __swig_destroy__ = _IMP_em2d.delete_ProjectionFinder
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ProjectionFinder self) -> std::string"""
        return _IMP_em2d.ProjectionFinder___str__(self)

    def __repr__(self):
        """__repr__(ProjectionFinder self) -> std::string"""
        return _IMP_em2d.ProjectionFinder___repr__(self)

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

ProjectionFinder_swigregister = _IMP_em2d.ProjectionFinder_swigregister
ProjectionFinder_swigregister(ProjectionFinder)

class Em2DRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em2d::Em2DRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Em2DRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Em2DRestraint, name)
    def __init__(self): 
        """__init__(IMP::em2d::Em2DRestraint self) -> Em2DRestraint"""
        this = _IMP_em2d.new_Em2DRestraint()
        try: self.this.append(this)
        except: self.this = this
    def setup(self, *args):
        """setup(Em2DRestraint self, ScoreFunction score_function, Em2DRestraintParameters params)"""
        return _IMP_em2d.Em2DRestraint_setup(self, *args)

    def set_particles(self, *args):
        """set_particles(Em2DRestraint self, SingletonContainer particles_container)"""
        return _IMP_em2d.Em2DRestraint_set_particles(self, *args)

    def set_images(self, *args):
        """set_images(Em2DRestraint self, IMP::em2d::Images const em_images)"""
        return _IMP_em2d.Em2DRestraint_set_images(self, *args)

    def set_variance_images(self, *args):
        """set_variance_images(Em2DRestraint self, IMP::em2d::Images const variance_images)"""
        return _IMP_em2d.Em2DRestraint_set_variance_images(self, *args)

    def set_fast_mode(self, *args):
        """set_fast_mode(Em2DRestraint self, unsigned int n)"""
        return _IMP_em2d.Em2DRestraint_set_fast_mode(self, *args)

    def set_coarse_registration_mode(self, *args):
        """set_coarse_registration_mode(Em2DRestraint self, bool opt)"""
        return _IMP_em2d.Em2DRestraint_set_coarse_registration_mode(self, *args)

    def get_registration_results(self):
        """get_registration_results(Em2DRestraint self) -> IMP::em2d::RegistrationResults"""
        return _IMP_em2d.Em2DRestraint_get_registration_results(self)

    def get_input_particles(self):
        """get_input_particles(Em2DRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_em2d.Em2DRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(Em2DRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_em2d.Em2DRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(Em2DRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em2d.Em2DRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(Em2DRestraint self) -> VersionInfo"""
        return _IMP_em2d.Em2DRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(Em2DRestraint self, _ostream out)"""
        return _IMP_em2d.Em2DRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_Em2DRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(Em2DRestraint self) -> std::string"""
        return _IMP_em2d.Em2DRestraint___str__(self)

    def __repr__(self):
        """__repr__(Em2DRestraint self) -> std::string"""
        return _IMP_em2d.Em2DRestraint___repr__(self)

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

Em2DRestraint_swigregister = _IMP_em2d.Em2DRestraint_swigregister
Em2DRestraint_swigregister(Em2DRestraint)

class ClusterSet(_object):
    """Proxy of C++ IMP::em2d::ClusterSet class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClusterSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ClusterSet, name)
    def __init__(self, *args): 
        """__init__(IMP::em2d::ClusterSet self, unsigned int N) -> ClusterSet"""
        this = _IMP_em2d.new_ClusterSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_join_clusters(self, *args):
        """do_join_clusters(ClusterSet self, unsigned int cluster_id1, unsigned int cluster_id2, double distance_between_clusters)"""
        return _IMP_em2d.ClusterSet_do_join_clusters(self, *args)

    def get_cluster_elements(self, *args):
        """get_cluster_elements(ClusterSet self, unsigned int id) -> IMP::Ints"""
        return _IMP_em2d.ClusterSet_get_cluster_elements(self, *args)

    def get_clusters_below_cutoff(self, *args):
        """get_clusters_below_cutoff(ClusterSet self, double cutoff) -> IMP::Ints"""
        return _IMP_em2d.ClusterSet_get_clusters_below_cutoff(self, *args)

    def get_cluster_formed_at_step(self, *args):
        """get_cluster_formed_at_step(ClusterSet self, unsigned int step) -> IMP::Ints"""
        return _IMP_em2d.ClusterSet_get_cluster_formed_at_step(self, *args)

    def get_distance_at_step(self, *args):
        """get_distance_at_step(ClusterSet self, unsigned int step) -> double"""
        return _IMP_em2d.ClusterSet_get_distance_at_step(self, *args)

    def get_id_for_cluster_at_step(self, *args):
        """get_id_for_cluster_at_step(ClusterSet self, unsigned int step) -> unsigned int"""
        return _IMP_em2d.ClusterSet_get_id_for_cluster_at_step(self, *args)

    def get_linkage_matrix(self):
        """get_linkage_matrix(ClusterSet self) -> IMP::FloatsList"""
        return _IMP_em2d.ClusterSet_get_linkage_matrix(self)

    def get_linkage_matrix_in_matlab_format(self):
        """get_linkage_matrix_in_matlab_format(ClusterSet self) -> IMP::FloatsList"""
        return _IMP_em2d.ClusterSet_get_linkage_matrix_in_matlab_format(self)

    def get_number_of_steps(self):
        """get_number_of_steps(ClusterSet self) -> unsigned int"""
        return _IMP_em2d.ClusterSet_get_number_of_steps(self)

    def show(self, *args):
        """show(ClusterSet self, _ostream out)"""
        return _IMP_em2d.ClusterSet_show(self, *args)

    def __str__(self):
        """__str__(ClusterSet self) -> std::string"""
        return _IMP_em2d.ClusterSet___str__(self)

    def __repr__(self):
        """__repr__(ClusterSet self) -> std::string"""
        return _IMP_em2d.ClusterSet___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_ClusterSet
    __del__ = lambda self : None;
ClusterSet_swigregister = _IMP_em2d.ClusterSet_swigregister
ClusterSet_swigregister(ClusterSet)

class SingleLinkage(_object):
    """Proxy of C++ IMP::em2d::SingleLinkage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingleLinkage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SingleLinkage, name)
    def __init__(self): 
        """__init__(IMP::em2d::SingleLinkage self) -> SingleLinkage"""
        this = _IMP_em2d.new_SingleLinkage()
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args):
        """__call__(SingleLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
        return _IMP_em2d.SingleLinkage___call__(self, *args)

    def show(self, *args):
        """show(SingleLinkage self, _ostream out)"""
        return _IMP_em2d.SingleLinkage_show(self, *args)

    def __str__(self):
        """__str__(SingleLinkage self) -> std::string"""
        return _IMP_em2d.SingleLinkage___str__(self)

    def __repr__(self):
        """__repr__(SingleLinkage self) -> std::string"""
        return _IMP_em2d.SingleLinkage___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_SingleLinkage
    __del__ = lambda self : None;
SingleLinkage_swigregister = _IMP_em2d.SingleLinkage_swigregister
SingleLinkage_swigregister(SingleLinkage)

class CompleteLinkage(_object):
    """Proxy of C++ IMP::em2d::CompleteLinkage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompleteLinkage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CompleteLinkage, name)
    def __init__(self): 
        """__init__(IMP::em2d::CompleteLinkage self) -> CompleteLinkage"""
        this = _IMP_em2d.new_CompleteLinkage()
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args):
        """__call__(CompleteLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
        return _IMP_em2d.CompleteLinkage___call__(self, *args)

    def show(self, *args):
        """show(CompleteLinkage self, _ostream out)"""
        return _IMP_em2d.CompleteLinkage_show(self, *args)

    def __str__(self):
        """__str__(CompleteLinkage self) -> std::string"""
        return _IMP_em2d.CompleteLinkage___str__(self)

    def __repr__(self):
        """__repr__(CompleteLinkage self) -> std::string"""
        return _IMP_em2d.CompleteLinkage___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_CompleteLinkage
    __del__ = lambda self : None;
CompleteLinkage_swigregister = _IMP_em2d.CompleteLinkage_swigregister
CompleteLinkage_swigregister(CompleteLinkage)

class AverageDistanceLinkage(_object):
    """Proxy of C++ IMP::em2d::AverageDistanceLinkage class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AverageDistanceLinkage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AverageDistanceLinkage, name)
    def __init__(self): 
        """__init__(IMP::em2d::AverageDistanceLinkage self) -> AverageDistanceLinkage"""
        this = _IMP_em2d.new_AverageDistanceLinkage()
        try: self.this.append(this)
        except: self.this = this
    def __call__(self, *args):
        """__call__(AverageDistanceLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
        return _IMP_em2d.AverageDistanceLinkage___call__(self, *args)

    def show(self, *args):
        """show(AverageDistanceLinkage self, _ostream out)"""
        return _IMP_em2d.AverageDistanceLinkage_show(self, *args)

    def __str__(self):
        """__str__(AverageDistanceLinkage self) -> std::string"""
        return _IMP_em2d.AverageDistanceLinkage___str__(self)

    def __repr__(self):
        """__repr__(AverageDistanceLinkage self) -> std::string"""
        return _IMP_em2d.AverageDistanceLinkage___repr__(self)

    __swig_destroy__ = _IMP_em2d.delete_AverageDistanceLinkage
    __del__ = lambda self : None;
AverageDistanceLinkage_swigregister = _IMP_em2d.AverageDistanceLinkage_swigregister
AverageDistanceLinkage_swigregister(AverageDistanceLinkage)

class CollisionCrossSection(IMP.base.Object):
    """Proxy of C++ IMP::em2d::CollisionCrossSection class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CollisionCrossSection, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CollisionCrossSection, name)
    def __init__(self, *args): 
        """__init__(IMP::em2d::CollisionCrossSection self, unsigned int n_projections, double resolution, double pixel_size, double projection_image_size) -> CollisionCrossSection"""
        this = _IMP_em2d.new_CollisionCrossSection(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_model_particles(self, *args):
        """set_model_particles(CollisionCrossSection self, IMP::kernel::ParticlesTemp const & ps)"""
        return _IMP_em2d.CollisionCrossSection_set_model_particles(self, *args)

    def get_ccs(self):
        """get_ccs(CollisionCrossSection self) -> double"""
        return _IMP_em2d.CollisionCrossSection_get_ccs(self)

    def show(self, *args):
        """show(CollisionCrossSection self, _ostream out)"""
        return _IMP_em2d.CollisionCrossSection_show(self, *args)

    def get_version_info(self):
        """get_version_info(CollisionCrossSection self) -> VersionInfo"""
        return _IMP_em2d.CollisionCrossSection_get_version_info(self)

    __swig_destroy__ = _IMP_em2d.delete_CollisionCrossSection
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(CollisionCrossSection self) -> std::string"""
        return _IMP_em2d.CollisionCrossSection___str__(self)

    def __repr__(self):
        """__repr__(CollisionCrossSection self) -> std::string"""
        return _IMP_em2d.CollisionCrossSection___repr__(self)

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

CollisionCrossSection_swigregister = _IMP_em2d.CollisionCrossSection_swigregister
CollisionCrossSection_swigregister(CollisionCrossSection)

class GridStates(IMP.domino.ParticleStates):
    """Proxy of C++ IMP::em2d::GridStates class"""
    __swig_setmethods__ = {}
    for _s in [IMP.domino.ParticleStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GridStates, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.domino.ParticleStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GridStates, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::GridStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations, 
            IMP::String const & name="GridStates") -> GridStates
        __init__(IMP::em2d::GridStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations) -> GridStates
        """
        this = _IMP_em2d.new_GridStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_position(self, *args):
        """get_position(GridStates self, unsigned int i) -> Vector3D"""
        return _IMP_em2d.GridStates_get_position(self, *args)

    def get_orientation(self, *args):
        """get_orientation(GridStates self, unsigned int i) -> Rotation3D"""
        return _IMP_em2d.GridStates_get_orientation(self, *args)

    def get_version_info(self):
        """get_version_info(GridStates self) -> VersionInfo"""
        return _IMP_em2d.GridStates_get_version_info(self)

    def do_show(self, *args):
        """do_show(GridStates self, _ostream out)"""
        return _IMP_em2d.GridStates_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_GridStates
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(GridStates self) -> std::string"""
        return _IMP_em2d.GridStates___str__(self)

    def __repr__(self):
        """__repr__(GridStates self) -> std::string"""
        return _IMP_em2d.GridStates___repr__(self)

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

GridStates_swigregister = _IMP_em2d.GridStates_swigregister
GridStates_swigregister(GridStates)

class ProjectionStates(GridStates):
    """Proxy of C++ IMP::em2d::ProjectionStates class"""
    __swig_setmethods__ = {}
    for _s in [GridStates]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProjectionStates, name, value)
    __swig_getmethods__ = {}
    for _s in [GridStates]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProjectionStates, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::ProjectionStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations, 
            IMP::em2d::Images const & projections, IMP::String const & name="ProjectionStates") -> ProjectionStates
        __init__(IMP::em2d::ProjectionStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations, 
            IMP::em2d::Images const & projections) -> ProjectionStates
        """
        this = _IMP_em2d.new_ProjectionStates(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_projection(self, *args):
        """get_projection(ProjectionStates self, unsigned int i) -> Image"""
        return _IMP_em2d.ProjectionStates_get_projection(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_ProjectionStates
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ProjectionStates self) -> std::string"""
        return _IMP_em2d.ProjectionStates___str__(self)

    def __repr__(self):
        """__repr__(ProjectionStates self) -> std::string"""
        return _IMP_em2d.ProjectionStates___repr__(self)

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

ProjectionStates_swigregister = _IMP_em2d.ProjectionStates_swigregister
ProjectionStates_swigregister(ProjectionStates)

class DistanceFilter(IMP.domino.SubsetFilter):
    """Proxy of C++ IMP::em2d::DistanceFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.domino.SubsetFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistanceFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.domino.SubsetFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistanceFilter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em2d::DistanceFilter self, Subset subset_to_act_on, Subset subset_to_restrain, ParticleStatesTable ps_table, 
            double max_distance) -> DistanceFilter
        """
        this = _IMP_em2d.new_DistanceFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(DistanceFilter self, _ostream out=std::cout)
        show(DistanceFilter self)
        """
        return _IMP_em2d.DistanceFilter_show(self, *args)

    def get_version_info(self):
        """get_version_info(DistanceFilter self) -> VersionInfo"""
        return _IMP_em2d.DistanceFilter_get_version_info(self)

    def do_show(self, *args):
        """do_show(DistanceFilter self, _ostream out)"""
        return _IMP_em2d.DistanceFilter_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_DistanceFilter
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DistanceFilter self) -> std::string"""
        return _IMP_em2d.DistanceFilter___str__(self)

    def __repr__(self):
        """__repr__(DistanceFilter self) -> std::string"""
        return _IMP_em2d.DistanceFilter___repr__(self)

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

DistanceFilter_swigregister = _IMP_em2d.DistanceFilter_swigregister
DistanceFilter_swigregister(DistanceFilter)

class DistanceFilterTable(IMP.domino.SubsetFilterTable):
    """Proxy of C++ IMP::em2d::DistanceFilterTable class"""
    __swig_setmethods__ = {}
    for _s in [IMP.domino.SubsetFilterTable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistanceFilterTable, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.domino.SubsetFilterTable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistanceFilterTable, name)
    def __init__(self, *args): 
        """__init__(IMP::em2d::DistanceFilterTable self, Subset subset_to_act_on, ParticleStatesTable ps_table, double max_distance) -> DistanceFilterTable"""
        this = _IMP_em2d.new_DistanceFilterTable(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(DistanceFilterTable self, _ostream out=std::cout)
        show(DistanceFilterTable self)
        """
        return _IMP_em2d.DistanceFilterTable_show(self, *args)

    def get_version_info(self):
        """get_version_info(DistanceFilterTable self) -> VersionInfo"""
        return _IMP_em2d.DistanceFilterTable_get_version_info(self)

    def do_show(self, *args):
        """do_show(DistanceFilterTable self, _ostream out)"""
        return _IMP_em2d.DistanceFilterTable_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_DistanceFilterTable
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DistanceFilterTable self) -> std::string"""
        return _IMP_em2d.DistanceFilterTable___str__(self)

    def __repr__(self):
        """__repr__(DistanceFilterTable self) -> std::string"""
        return _IMP_em2d.DistanceFilterTable___repr__(self)

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

DistanceFilterTable_swigregister = _IMP_em2d.DistanceFilterTable_swigregister
DistanceFilterTable_swigregister(DistanceFilterTable)

class IntsOrder(_object):
    """Proxy of C++ IMP::em2d::IntsOrder class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntsOrder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntsOrder, name)
    __repr__ = _swig_repr
    def __call__(self, *args):
        """__call__(IntsOrder self, IMP::Ints const & a, IMP::Ints const & b) -> bool"""
        return _IMP_em2d.IntsOrder___call__(self, *args)

    def __init__(self): 
        """__init__(IMP::em2d::IntsOrder self) -> IntsOrder"""
        this = _IMP_em2d.new_IntsOrder()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em2d.delete_IntsOrder
    __del__ = lambda self : None;
IntsOrder_swigregister = _IMP_em2d.IntsOrder_swigregister
IntsOrder_swigregister(IntsOrder)

class RigidBodiesImageFitRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em2d::RigidBodiesImageFitRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBodiesImageFitRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBodiesImageFitRestraint, name)
    def get_input_particles(self):
        """get_input_particles(RigidBodiesImageFitRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(RigidBodiesImageFitRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(RigidBodiesImageFitRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(RigidBodiesImageFitRestraint self) -> VersionInfo"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(RigidBodiesImageFitRestraint self, _ostream out)"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_RigidBodiesImageFitRestraint
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """__init__(IMP::em2d::RigidBodiesImageFitRestraint self, ScoreFunction scf, IMP::core::RigidBodies const & rbs, Image img) -> RigidBodiesImageFitRestraint"""
        this = _IMP_em2d.new_RigidBodiesImageFitRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_projecting_parameters(self, *args):
        """set_projecting_parameters(RigidBodiesImageFitRestraint self, ProjectingParameters p)"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_set_projecting_parameters(self, *args)

    def set_orientations(self, *args):
        """set_orientations(RigidBodiesImageFitRestraint self, RigidBody rb, IMP::algebra::Rotation3Ds const & rots)"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_set_orientations(self, *args)

    def get_number_of_masks(self, *args):
        """get_number_of_masks(RigidBodiesImageFitRestraint self, RigidBody rb) -> unsigned int"""
        return _IMP_em2d.RigidBodiesImageFitRestraint_get_number_of_masks(self, *args)

    def __str__(self):
        """__str__(RigidBodiesImageFitRestraint self) -> std::string"""
        return _IMP_em2d.RigidBodiesImageFitRestraint___str__(self)

    def __repr__(self):
        """__repr__(RigidBodiesImageFitRestraint self) -> std::string"""
        return _IMP_em2d.RigidBodiesImageFitRestraint___repr__(self)

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

RigidBodiesImageFitRestraint_swigregister = _IMP_em2d.RigidBodiesImageFitRestraint_swigregister
RigidBodiesImageFitRestraint_swigregister(RigidBodiesImageFitRestraint)


def get_unique_index(*args):
  """get_unique_index(Rotation3D rot) -> IMP::Ints"""
  return _IMP_em2d.get_unique_index(*args)
class RelativePositionMover(IMP.core.RigidBodyMover):
    """Proxy of C++ IMP::em2d::RelativePositionMover class"""
    __swig_setmethods__ = {}
    for _s in [IMP.core.RigidBodyMover]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RelativePositionMover, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.core.RigidBodyMover]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RelativePositionMover, name)
    def __init__(self, *args): 
        """__init__(IMP::em2d::RelativePositionMover self, RigidBody d, IMP::Float max_translation, IMP::Float max_rotation) -> RelativePositionMover"""
        this = _IMP_em2d.new_RelativePositionMover(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_internal_transformations(self, *args):
        """add_internal_transformations(RelativePositionMover self, RigidBody d, IMP::algebra::Transformation3Ds transforms)"""
        return _IMP_em2d.RelativePositionMover_add_internal_transformations(self, *args)

    def set_random_move_probability(self, *args):
        """set_random_move_probability(RelativePositionMover self, IMP::Float p)"""
        return _IMP_em2d.RelativePositionMover_set_random_move_probability(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_RelativePositionMover
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RelativePositionMover self) -> std::string"""
        return _IMP_em2d.RelativePositionMover___str__(self)

    def __repr__(self):
        """__repr__(RelativePositionMover self) -> std::string"""
        return _IMP_em2d.RelativePositionMover___repr__(self)

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

RelativePositionMover_swigregister = _IMP_em2d.RelativePositionMover_swigregister
RelativePositionMover_swigregister(RelativePositionMover)

class DummyRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em2d::DummyRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DummyRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DummyRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::em2d::DummyRestraint self, Particle p, Particle q) -> DummyRestraint"""
        this = _IMP_em2d.new_DummyRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(DummyRestraint self, _ostream out=std::cout)
        show(DummyRestraint self)
        """
        return _IMP_em2d.DummyRestraint_show(self, *args)

    def get_input_particles(self):
        """get_input_particles(DummyRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_em2d.DummyRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(DummyRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_em2d.DummyRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(DummyRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em2d.DummyRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(DummyRestraint self) -> VersionInfo"""
        return _IMP_em2d.DummyRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(DummyRestraint self, _ostream out)"""
        return _IMP_em2d.DummyRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_DummyRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(DummyRestraint self) -> std::string"""
        return _IMP_em2d.DummyRestraint___str__(self)

    def __repr__(self):
        """__repr__(DummyRestraint self) -> std::string"""
        return _IMP_em2d.DummyRestraint___repr__(self)

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

DummyRestraint_swigregister = _IMP_em2d.DummyRestraint_swigregister
DummyRestraint_swigregister(DummyRestraint)

class ParticlesDummyRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em2d::ParticlesDummyRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParticlesDummyRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParticlesDummyRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::em2d::ParticlesDummyRestraint self, SingletonContainer sc) -> ParticlesDummyRestraint"""
        this = _IMP_em2d.new_ParticlesDummyRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(ParticlesDummyRestraint self, _ostream out=std::cout)
        show(ParticlesDummyRestraint self)
        """
        return _IMP_em2d.ParticlesDummyRestraint_show(self, *args)

    def get_input_particles(self):
        """get_input_particles(ParticlesDummyRestraint self) -> IMP::kernel::ParticlesTemp"""
        return _IMP_em2d.ParticlesDummyRestraint_get_input_particles(self)

    def get_input_containers(self):
        """get_input_containers(ParticlesDummyRestraint self) -> IMP::kernel::ContainersTemp"""
        return _IMP_em2d.ParticlesDummyRestraint_get_input_containers(self)

    def do_get_inputs(self):
        """do_get_inputs(ParticlesDummyRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em2d.ParticlesDummyRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(ParticlesDummyRestraint self) -> VersionInfo"""
        return _IMP_em2d.ParticlesDummyRestraint_get_version_info(self)

    def do_show(self, *args):
        """do_show(ParticlesDummyRestraint self, _ostream out)"""
        return _IMP_em2d.ParticlesDummyRestraint_do_show(self, *args)

    __swig_destroy__ = _IMP_em2d.delete_ParticlesDummyRestraint
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(ParticlesDummyRestraint self) -> std::string"""
        return _IMP_em2d.ParticlesDummyRestraint___str__(self)

    def __repr__(self):
        """__repr__(ParticlesDummyRestraint self) -> std::string"""
        return _IMP_em2d.ParticlesDummyRestraint___repr__(self)

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

ParticlesDummyRestraint_swigregister = _IMP_em2d.ParticlesDummyRestraint_swigregister
ParticlesDummyRestraint_swigregister(ParticlesDummyRestraint)

class ResultAlign2D(_object):
    """Proxy of C++ std::pair<(IMP::algebra::Transformation2D,double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ResultAlign2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ResultAlign2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(std::pair<(IMP::algebra::Transformation2D,double)> self) -> ResultAlign2D
        __init__(std::pair<(IMP::algebra::Transformation2D,double)> self, Transformation2D first, double second) -> ResultAlign2D
        __init__(std::pair<(IMP::algebra::Transformation2D,double)> self, ResultAlign2D p) -> ResultAlign2D
        """
        this = _IMP_em2d.new_ResultAlign2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["first"] = _IMP_em2d.ResultAlign2D_first_set
    __swig_getmethods__["first"] = _IMP_em2d.ResultAlign2D_first_get
    if _newclass:first = _swig_property(_IMP_em2d.ResultAlign2D_first_get, _IMP_em2d.ResultAlign2D_first_set)
    __swig_setmethods__["second"] = _IMP_em2d.ResultAlign2D_second_set
    __swig_getmethods__["second"] = _IMP_em2d.ResultAlign2D_second_get
    if _newclass:second = _swig_property(_IMP_em2d.ResultAlign2D_second_get, _IMP_em2d.ResultAlign2D_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _IMP_em2d.delete_ResultAlign2D
    __del__ = lambda self : None;
ResultAlign2D_swigregister = _IMP_em2d.ResultAlign2D_swigregister
ResultAlign2D_swigregister(ResultAlign2D)


def _do_hierarchical_clustering_single_linkage(*args):
  """_do_hierarchical_clustering_single_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
  return _IMP_em2d._do_hierarchical_clustering_single_linkage(*args)

def _do_hierarchical_clustering_complete_linkage(*args):
  """_do_hierarchical_clustering_complete_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
  return _IMP_em2d._do_hierarchical_clustering_complete_linkage(*args)

def _do_hierarchical_clustering_average_distance_linkage(*args):
  """_do_hierarchical_clustering_average_distance_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
  return _IMP_em2d._do_hierarchical_clustering_average_distance_linkage(*args)
do_hierarchical_clustering_single_linkage = _do_hierarchical_clustering_single_linkage
do_hierarchical_clustering_complete_linkage = _do_hierarchical_clustering_complete_linkage
do_hierarchical_clustering_average_distance_linkage = _do_hierarchical_clustering_average_distance_linkage


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

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

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

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