em/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.12
#
# 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_em', [dirname(__file__)])
        except ImportError:
            import _IMP_em
            return _IMP_em
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_em', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_em = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_em
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_EM_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_EM_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_EM_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_EM_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_em.delete_IMP_EM_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_EM_SwigPyIterator self) -> PyObject *"""
        return _IMP_em.IMP_EM_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_EM_SwigPyIterator self, size_t n=1) -> IMP_EM_SwigPyIterator
        incr(IMP_EM_SwigPyIterator self) -> IMP_EM_SwigPyIterator
        """
        return _IMP_em.IMP_EM_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_EM_SwigPyIterator self, size_t n=1) -> IMP_EM_SwigPyIterator
        decr(IMP_EM_SwigPyIterator self) -> IMP_EM_SwigPyIterator
        """
        return _IMP_em.IMP_EM_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_EM_SwigPyIterator self, IMP_EM_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_em.IMP_EM_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_EM_SwigPyIterator self, IMP_EM_SwigPyIterator x) -> bool"""
        return _IMP_em.IMP_EM_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_EM_SwigPyIterator self) -> IMP_EM_SwigPyIterator"""
        return _IMP_em.IMP_EM_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_EM_SwigPyIterator self) -> PyObject *"""
        return _IMP_em.IMP_EM_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_EM_SwigPyIterator self) -> PyObject *"""
        return _IMP_em.IMP_EM_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_EM_SwigPyIterator self) -> PyObject *"""
        return _IMP_em.IMP_EM_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_EM_SwigPyIterator self, ptrdiff_t n) -> IMP_EM_SwigPyIterator"""
        return _IMP_em.IMP_EM_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_EM_SwigPyIterator self, IMP_EM_SwigPyIterator x) -> bool"""
        return _IMP_em.IMP_EM_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_EM_SwigPyIterator self, IMP_EM_SwigPyIterator x) -> bool"""
        return _IMP_em.IMP_EM_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_EM_SwigPyIterator self, ptrdiff_t n) -> IMP_EM_SwigPyIterator"""
        return _IMP_em.IMP_EM_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_EM_SwigPyIterator self, ptrdiff_t n) -> IMP_EM_SwigPyIterator"""
        return _IMP_em.IMP_EM_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_EM_SwigPyIterator self, ptrdiff_t n) -> IMP_EM_SwigPyIterator"""
        return _IMP_em.IMP_EM_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_EM_SwigPyIterator self, ptrdiff_t n) -> IMP_EM_SwigPyIterator
        __sub__(IMP_EM_SwigPyIterator self, IMP_EM_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_em.IMP_EM_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_EM_SwigPyIterator_swigregister = _IMP_em.IMP_EM_SwigPyIterator_swigregister
IMP_EM_SwigPyIterator_swigregister(IMP_EM_SwigPyIterator)

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

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

DEFAULT_CHECK = _IMP_em.DEFAULT_CHECK
NONE = _IMP_em.NONE
USAGE = _IMP_em.USAGE
USAGE_AND_INTERNAL = _IMP_em.USAGE_AND_INTERNAL

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

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_em.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_em._ostream_write(self, *args)

_ostream_swigregister = _IMP_em._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_em.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_em.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_em.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_em.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_em.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_em.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_em.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_em.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_em.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_em.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_em.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_em.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_em.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_em.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_em.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_em.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_em.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_em.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_em.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_em.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_em.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_em.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_em.IMPDISPLAY_SHOW_WARNINGS
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_em.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_em.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_em.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_em.IMP_SCORE_FUNCTOR_HAS_CGAL
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_em.IMP_SCORE_FUNCTOR_HAS_HDF5
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_em.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor
IMP_STATISTICS_HAS_IMP_BASE = _IMP_em.IMP_STATISTICS_HAS_IMP_BASE
IMP_STATISTICS_HAS_IMP_CGAL = _IMP_em.IMP_STATISTICS_HAS_IMP_CGAL
IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_em.IMP_STATISTICS_HAS_BOOST_RANDOM
IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_em.IMP_STATISTICS_HAS_BOOST_SYSTEM
IMP_STATISTICS_HAS_CGAL = _IMP_em.IMP_STATISTICS_HAS_CGAL
IMPSTATISTICS_SHOW_WARNINGS = _IMP_em.IMPSTATISTICS_SHOW_WARNINGS
import IMP.statistics
IMP_CORE_HAS_IMP_BASE = _IMP_em.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_em.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_em.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_em.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_em.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_em.IMP_CORE_HAS_CGAL
IMP_CORE_HAS_HDF5 = _IMP_em.IMP_CORE_HAS_HDF5
IMPCORE_SHOW_WARNINGS = _IMP_em.IMPCORE_SHOW_WARNINGS
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_em.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_em.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_em.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_em.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_em.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_em.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_em.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_em.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_em.IMP_CONTAINER_HAS_CGAL
IMP_CONTAINER_HAS_HDF5 = _IMP_em.IMP_CONTAINER_HAS_HDF5
IMPCONTAINER_SHOW_WARNINGS = _IMP_em.IMPCONTAINER_SHOW_WARNINGS
import IMP.container
IMP_ATOM_HAS_IMP_BASE = _IMP_em.IMP_ATOM_HAS_IMP_BASE
IMP_ATOM_HAS_IMP_CGAL = _IMP_em.IMP_ATOM_HAS_IMP_CGAL
IMP_ATOM_HAS_IMP_KERNEL = _IMP_em.IMP_ATOM_HAS_IMP_KERNEL
IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_em.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
IMP_ATOM_HAS_BOOST_RANDOM = _IMP_em.IMP_ATOM_HAS_BOOST_RANDOM
IMP_ATOM_HAS_BOOST_REGEX = _IMP_em.IMP_ATOM_HAS_BOOST_REGEX
IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_em.IMP_ATOM_HAS_BOOST_SYSTEM
IMP_ATOM_HAS_CGAL = _IMP_em.IMP_ATOM_HAS_CGAL
IMP_ATOM_HAS_HDF5 = _IMP_em.IMP_ATOM_HAS_HDF5
IMPATOM_SHOW_WARNINGS = _IMP_em.IMPATOM_SHOW_WARNINGS
IMP_ATOM_TYPE_INDEX = _IMP_em.IMP_ATOM_TYPE_INDEX
IMP_RESIDUE_TYPE_INDEX = _IMP_em.IMP_RESIDUE_TYPE_INDEX
IMP_HIERARCHY_TYPE_INDEX = _IMP_em.IMP_HIERARCHY_TYPE_INDEX
import IMP.atom
IMP_EM_HAS_IMP_CGAL = _IMP_em.IMP_EM_HAS_IMP_CGAL
IMP_EM_HAS_IMP_CONTAINER = _IMP_em.IMP_EM_HAS_IMP_CONTAINER
IMP_EM_HAS_IMP_DISPLAY = _IMP_em.IMP_EM_HAS_IMP_DISPLAY
IMP_EM_HAS_IMP_KERNEL = _IMP_em.IMP_EM_HAS_IMP_KERNEL
IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_em.IMP_EM_HAS_IMP_SCORE_FUNCTOR
IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_em.IMP_EM_HAS_BOOST_FILESYSTEM
IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em.IMP_EM_HAS_BOOST_PROGRAMOPTIONS
IMP_EM_HAS_BOOST_RANDOM = _IMP_em.IMP_EM_HAS_BOOST_RANDOM
IMP_EM_HAS_BOOST_REGEX = _IMP_em.IMP_EM_HAS_BOOST_REGEX
IMP_EM_HAS_BOOST_SYSTEM = _IMP_em.IMP_EM_HAS_BOOST_SYSTEM
IMP_EM_HAS_CGAL = _IMP_em.IMP_EM_HAS_CGAL
IMP_EM_HAS_HDF5 = _IMP_em.IMP_EM_HAS_HDF5
IMPEM_SHOW_WARNINGS = _IMP_em.IMPEM_SHOW_WARNINGS
_object_types.append("DensityMap")


def _object_cast_to_DensityMap(*args):
  """_object_cast_to_DensityMap(Object o) -> DensityMap"""
  return _IMP_em._object_cast_to_DensityMap(*args)
_object_types.append("SampledDensityMap")


def _object_cast_to_SampledDensityMap(*args):
  """_object_cast_to_SampledDensityMap(Object o) -> SampledDensityMap"""
  return _IMP_em._object_cast_to_SampledDensityMap(*args)
_object_types.append("SurfaceShellDensityMap")


def _object_cast_to_SurfaceShellDensityMap(*args):
  """_object_cast_to_SurfaceShellDensityMap(Object o) -> SurfaceShellDensityMap"""
  return _IMP_em._object_cast_to_SurfaceShellDensityMap(*args)
_object_types.append("FitRestraint")


def _object_cast_to_FitRestraint(*args):
  """_object_cast_to_FitRestraint(Object o) -> FitRestraint"""
  return _IMP_em._object_cast_to_FitRestraint(*args)
_object_types.append("PCAFitRestraint")


def _object_cast_to_PCAFitRestraint(*args):
  """_object_cast_to_PCAFitRestraint(Object o) -> PCAFitRestraint"""
  return _IMP_em._object_cast_to_PCAFitRestraint(*args)
_object_types.append("EnvelopePenetrationRestraint")


def _object_cast_to_EnvelopePenetrationRestraint(*args):
  """_object_cast_to_EnvelopePenetrationRestraint(Object o) -> EnvelopePenetrationRestraint"""
  return _IMP_em._object_cast_to_EnvelopePenetrationRestraint(*args)
_object_types.append("EnvelopeFitRestraint")


def _object_cast_to_EnvelopeFitRestraint(*args):
  """_object_cast_to_EnvelopeFitRestraint(Object o) -> EnvelopeFitRestraint"""
  return _IMP_em._object_cast_to_EnvelopeFitRestraint(*args)
RadiusDependentKernelParametersList=list
_plural_types.append("RadiusDependentKernelParametersList")
_value_types.append("RadiusDependentKernelParameters")

KernelParametersList=list
_plural_types.append("KernelParametersList")
_value_types.append("KernelParameters")

_object_types.append("HighDensityEmbedding")


def _object_cast_to_HighDensityEmbedding(*args):
  """_object_cast_to_HighDensityEmbedding(Object o) -> HighDensityEmbedding"""
  return _IMP_em._object_cast_to_HighDensityEmbedding(*args)
_object_types.append("MapReaderWriter")


def _object_cast_to_MapReaderWriter(*args):
  """_object_cast_to_MapReaderWriter(Object o) -> MapReaderWriter"""
  return _IMP_em._object_cast_to_MapReaderWriter(*args)
_object_types.append("MRCReaderWriter")


def _object_cast_to_MRCReaderWriter(*args):
  """_object_cast_to_MRCReaderWriter(Object o) -> MRCReaderWriter"""
  return _IMP_em._object_cast_to_MRCReaderWriter(*args)
_object_types.append("SpiderMapReaderWriter")


def _object_cast_to_SpiderMapReaderWriter(*args):
  """_object_cast_to_SpiderMapReaderWriter(Object o) -> SpiderMapReaderWriter"""
  return _IMP_em._object_cast_to_SpiderMapReaderWriter(*args)
_object_types.append("EMReaderWriter")


def _object_cast_to_EMReaderWriter(*args):
  """_object_cast_to_EMReaderWriter(Object o) -> EMReaderWriter"""
  return _IMP_em._object_cast_to_EMReaderWriter(*args)
_object_types.append("XplorReaderWriter")


def _object_cast_to_XplorReaderWriter(*args):
  """_object_cast_to_XplorReaderWriter(Object o) -> XplorReaderWriter"""
  return _IMP_em._object_cast_to_XplorReaderWriter(*args)
_object_types.append("CoarseCC")


def _object_cast_to_CoarseCC(*args):
  """_object_cast_to_CoarseCC(Object o) -> CoarseCC"""
  return _IMP_em._object_cast_to_CoarseCC(*args)
_object_types.append("CoarseCCatIntervals")


def _object_cast_to_CoarseCCatIntervals(*args):
  """_object_cast_to_CoarseCCatIntervals(Object o) -> CoarseCCatIntervals"""
  return _IMP_em._object_cast_to_CoarseCCatIntervals(*args)
FittingSolutionsList=list
_plural_types.append("FittingSolutionsList")
_value_types.append("FittingSolutions")

class MapReaderWriter(IMP.base.Object):
    """Proxy of C++ IMP::em::MapReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapReaderWriter, name)
    def __init__(self): 
        """__init__(IMP::em::MapReaderWriter self) -> MapReaderWriter"""
        this = _IMP_em.new_MapReaderWriter()
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(MapReaderWriter self) -> VersionInfo"""
        return _IMP_em.MapReaderWriter_get_version_info(self)

    def __str__(self):
        """__str__(MapReaderWriter self) -> std::string"""
        return _IMP_em.MapReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(MapReaderWriter self) -> std::string"""
        return _IMP_em.MapReaderWriter___repr__(self)

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

MapReaderWriter_swigregister = _IMP_em.MapReaderWriter_swigregister
MapReaderWriter_swigregister(MapReaderWriter)
cvar = _IMP_em.cvar
EPS = cvar.EPS

class DensityHeader(_object):
    """Proxy of C++ IMP::em::DensityHeader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DensityHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DensityHeader, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::em::DensityHeader self) -> DensityHeader"""
        this = _IMP_em.new_DensityHeader()
        try: self.this.append(this)
        except: self.this = this
    def get_top(self, *args):
        """get_top(DensityHeader self, int ind) -> IMP::em::emreal"""
        return _IMP_em.DensityHeader_get_top(self, *args)

    def compute_xyz_top(self, force=False):
        """
        compute_xyz_top(DensityHeader self, bool force=False)
        compute_xyz_top(DensityHeader self)
        """
        return _IMP_em.DensityHeader_compute_xyz_top(self, force)

    def update_map_dimensions(self, *args):
        """update_map_dimensions(DensityHeader self, int nnx, int nny, int nnz)"""
        return _IMP_em.DensityHeader_update_map_dimensions(self, *args)

    def update_cell_dimensions(self):
        """update_cell_dimensions(DensityHeader self)"""
        return _IMP_em.DensityHeader_update_cell_dimensions(self)

    def show(self, *args):
        """
        show(DensityHeader self, _ostream out=std::cout)
        show(DensityHeader self)
        """
        return _IMP_em.DensityHeader_show(self, *args)

    MAP_FIELD_SIZE = _IMP_em.DensityHeader_MAP_FIELD_SIZE
    USER_FIELD_SIZE = _IMP_em.DensityHeader_USER_FIELD_SIZE
    COMMENT_FIELD_NUM_OF = _IMP_em.DensityHeader_COMMENT_FIELD_NUM_OF
    COMMENT_FIELD_SINGLE_SIZE = _IMP_em.DensityHeader_COMMENT_FIELD_SINGLE_SIZE
    __swig_setmethods__["nxstart"] = _IMP_em.DensityHeader_nxstart_set
    __swig_getmethods__["nxstart"] = _IMP_em.DensityHeader_nxstart_get
    if _newclass:nxstart = _swig_property(_IMP_em.DensityHeader_nxstart_get, _IMP_em.DensityHeader_nxstart_set)
    __swig_setmethods__["nystart"] = _IMP_em.DensityHeader_nystart_set
    __swig_getmethods__["nystart"] = _IMP_em.DensityHeader_nystart_get
    if _newclass:nystart = _swig_property(_IMP_em.DensityHeader_nystart_get, _IMP_em.DensityHeader_nystart_set)
    __swig_setmethods__["nzstart"] = _IMP_em.DensityHeader_nzstart_set
    __swig_getmethods__["nzstart"] = _IMP_em.DensityHeader_nzstart_get
    if _newclass:nzstart = _swig_property(_IMP_em.DensityHeader_nzstart_get, _IMP_em.DensityHeader_nzstart_set)
    __swig_setmethods__["mx"] = _IMP_em.DensityHeader_mx_set
    __swig_getmethods__["mx"] = _IMP_em.DensityHeader_mx_get
    if _newclass:mx = _swig_property(_IMP_em.DensityHeader_mx_get, _IMP_em.DensityHeader_mx_set)
    __swig_setmethods__["my"] = _IMP_em.DensityHeader_my_set
    __swig_getmethods__["my"] = _IMP_em.DensityHeader_my_get
    if _newclass:my = _swig_property(_IMP_em.DensityHeader_my_get, _IMP_em.DensityHeader_my_set)
    __swig_setmethods__["mz"] = _IMP_em.DensityHeader_mz_set
    __swig_getmethods__["mz"] = _IMP_em.DensityHeader_mz_get
    if _newclass:mz = _swig_property(_IMP_em.DensityHeader_mz_get, _IMP_em.DensityHeader_mz_set)
    __swig_setmethods__["xlen"] = _IMP_em.DensityHeader_xlen_set
    __swig_getmethods__["xlen"] = _IMP_em.DensityHeader_xlen_get
    if _newclass:xlen = _swig_property(_IMP_em.DensityHeader_xlen_get, _IMP_em.DensityHeader_xlen_set)
    __swig_setmethods__["ylen"] = _IMP_em.DensityHeader_ylen_set
    __swig_getmethods__["ylen"] = _IMP_em.DensityHeader_ylen_get
    if _newclass:ylen = _swig_property(_IMP_em.DensityHeader_ylen_get, _IMP_em.DensityHeader_ylen_set)
    __swig_setmethods__["zlen"] = _IMP_em.DensityHeader_zlen_set
    __swig_getmethods__["zlen"] = _IMP_em.DensityHeader_zlen_get
    if _newclass:zlen = _swig_property(_IMP_em.DensityHeader_zlen_get, _IMP_em.DensityHeader_zlen_set)
    __swig_setmethods__["alpha"] = _IMP_em.DensityHeader_alpha_set
    __swig_getmethods__["alpha"] = _IMP_em.DensityHeader_alpha_get
    if _newclass:alpha = _swig_property(_IMP_em.DensityHeader_alpha_get, _IMP_em.DensityHeader_alpha_set)
    __swig_setmethods__["beta"] = _IMP_em.DensityHeader_beta_set
    __swig_getmethods__["beta"] = _IMP_em.DensityHeader_beta_get
    if _newclass:beta = _swig_property(_IMP_em.DensityHeader_beta_get, _IMP_em.DensityHeader_beta_set)
    __swig_setmethods__["gamma"] = _IMP_em.DensityHeader_gamma_set
    __swig_getmethods__["gamma"] = _IMP_em.DensityHeader_gamma_get
    if _newclass:gamma = _swig_property(_IMP_em.DensityHeader_gamma_get, _IMP_em.DensityHeader_gamma_set)
    __swig_setmethods__["mapc"] = _IMP_em.DensityHeader_mapc_set
    __swig_getmethods__["mapc"] = _IMP_em.DensityHeader_mapc_get
    if _newclass:mapc = _swig_property(_IMP_em.DensityHeader_mapc_get, _IMP_em.DensityHeader_mapc_set)
    __swig_setmethods__["mapr"] = _IMP_em.DensityHeader_mapr_set
    __swig_getmethods__["mapr"] = _IMP_em.DensityHeader_mapr_get
    if _newclass:mapr = _swig_property(_IMP_em.DensityHeader_mapr_get, _IMP_em.DensityHeader_mapr_set)
    __swig_setmethods__["maps"] = _IMP_em.DensityHeader_maps_set
    __swig_getmethods__["maps"] = _IMP_em.DensityHeader_maps_get
    if _newclass:maps = _swig_property(_IMP_em.DensityHeader_maps_get, _IMP_em.DensityHeader_maps_set)
    __swig_setmethods__["dmin"] = _IMP_em.DensityHeader_dmin_set
    __swig_getmethods__["dmin"] = _IMP_em.DensityHeader_dmin_get
    if _newclass:dmin = _swig_property(_IMP_em.DensityHeader_dmin_get, _IMP_em.DensityHeader_dmin_set)
    __swig_setmethods__["dmax"] = _IMP_em.DensityHeader_dmax_set
    __swig_getmethods__["dmax"] = _IMP_em.DensityHeader_dmax_get
    if _newclass:dmax = _swig_property(_IMP_em.DensityHeader_dmax_get, _IMP_em.DensityHeader_dmax_set)
    __swig_setmethods__["dmean"] = _IMP_em.DensityHeader_dmean_set
    __swig_getmethods__["dmean"] = _IMP_em.DensityHeader_dmean_get
    if _newclass:dmean = _swig_property(_IMP_em.DensityHeader_dmean_get, _IMP_em.DensityHeader_dmean_set)
    __swig_setmethods__["ispg"] = _IMP_em.DensityHeader_ispg_set
    __swig_getmethods__["ispg"] = _IMP_em.DensityHeader_ispg_get
    if _newclass:ispg = _swig_property(_IMP_em.DensityHeader_ispg_get, _IMP_em.DensityHeader_ispg_set)
    __swig_setmethods__["nsymbt"] = _IMP_em.DensityHeader_nsymbt_set
    __swig_getmethods__["nsymbt"] = _IMP_em.DensityHeader_nsymbt_get
    if _newclass:nsymbt = _swig_property(_IMP_em.DensityHeader_nsymbt_get, _IMP_em.DensityHeader_nsymbt_set)
    __swig_setmethods__["user"] = _IMP_em.DensityHeader_user_set
    __swig_getmethods__["user"] = _IMP_em.DensityHeader_user_get
    if _newclass:user = _swig_property(_IMP_em.DensityHeader_user_get, _IMP_em.DensityHeader_user_set)
    __swig_setmethods__["map"] = _IMP_em.DensityHeader_map_set
    __swig_getmethods__["map"] = _IMP_em.DensityHeader_map_get
    if _newclass:map = _swig_property(_IMP_em.DensityHeader_map_get, _IMP_em.DensityHeader_map_set)
    __swig_setmethods__["machinestamp"] = _IMP_em.DensityHeader_machinestamp_set
    __swig_getmethods__["machinestamp"] = _IMP_em.DensityHeader_machinestamp_get
    if _newclass:machinestamp = _swig_property(_IMP_em.DensityHeader_machinestamp_get, _IMP_em.DensityHeader_machinestamp_set)
    __swig_setmethods__["rms"] = _IMP_em.DensityHeader_rms_set
    __swig_getmethods__["rms"] = _IMP_em.DensityHeader_rms_get
    if _newclass:rms = _swig_property(_IMP_em.DensityHeader_rms_get, _IMP_em.DensityHeader_rms_set)
    __swig_setmethods__["nlabl"] = _IMP_em.DensityHeader_nlabl_set
    __swig_getmethods__["nlabl"] = _IMP_em.DensityHeader_nlabl_get
    if _newclass:nlabl = _swig_property(_IMP_em.DensityHeader_nlabl_get, _IMP_em.DensityHeader_nlabl_set)
    __swig_setmethods__["comments"] = _IMP_em.DensityHeader_comments_set
    __swig_getmethods__["comments"] = _IMP_em.DensityHeader_comments_get
    if _newclass:comments = _swig_property(_IMP_em.DensityHeader_comments_get, _IMP_em.DensityHeader_comments_set)
    __swig_setmethods__["magic"] = _IMP_em.DensityHeader_magic_set
    __swig_getmethods__["magic"] = _IMP_em.DensityHeader_magic_get
    if _newclass:magic = _swig_property(_IMP_em.DensityHeader_magic_get, _IMP_em.DensityHeader_magic_set)
    __swig_setmethods__["voltage"] = _IMP_em.DensityHeader_voltage_set
    __swig_getmethods__["voltage"] = _IMP_em.DensityHeader_voltage_get
    if _newclass:voltage = _swig_property(_IMP_em.DensityHeader_voltage_get, _IMP_em.DensityHeader_voltage_set)
    __swig_setmethods__["Cs"] = _IMP_em.DensityHeader_Cs_set
    __swig_getmethods__["Cs"] = _IMP_em.DensityHeader_Cs_get
    if _newclass:Cs = _swig_property(_IMP_em.DensityHeader_Cs_get, _IMP_em.DensityHeader_Cs_set)
    __swig_setmethods__["Aperture"] = _IMP_em.DensityHeader_Aperture_set
    __swig_getmethods__["Aperture"] = _IMP_em.DensityHeader_Aperture_get
    if _newclass:Aperture = _swig_property(_IMP_em.DensityHeader_Aperture_get, _IMP_em.DensityHeader_Aperture_set)
    __swig_setmethods__["Magnification"] = _IMP_em.DensityHeader_Magnification_set
    __swig_getmethods__["Magnification"] = _IMP_em.DensityHeader_Magnification_get
    if _newclass:Magnification = _swig_property(_IMP_em.DensityHeader_Magnification_get, _IMP_em.DensityHeader_Magnification_set)
    __swig_setmethods__["Postmagnification"] = _IMP_em.DensityHeader_Postmagnification_set
    __swig_getmethods__["Postmagnification"] = _IMP_em.DensityHeader_Postmagnification_get
    if _newclass:Postmagnification = _swig_property(_IMP_em.DensityHeader_Postmagnification_get, _IMP_em.DensityHeader_Postmagnification_set)
    __swig_setmethods__["Exposuretime"] = _IMP_em.DensityHeader_Exposuretime_set
    __swig_getmethods__["Exposuretime"] = _IMP_em.DensityHeader_Exposuretime_get
    if _newclass:Exposuretime = _swig_property(_IMP_em.DensityHeader_Exposuretime_get, _IMP_em.DensityHeader_Exposuretime_set)
    __swig_setmethods__["Microscope"] = _IMP_em.DensityHeader_Microscope_set
    __swig_getmethods__["Microscope"] = _IMP_em.DensityHeader_Microscope_get
    if _newclass:Microscope = _swig_property(_IMP_em.DensityHeader_Microscope_get, _IMP_em.DensityHeader_Microscope_set)
    __swig_setmethods__["Pixelsize"] = _IMP_em.DensityHeader_Pixelsize_set
    __swig_getmethods__["Pixelsize"] = _IMP_em.DensityHeader_Pixelsize_get
    if _newclass:Pixelsize = _swig_property(_IMP_em.DensityHeader_Pixelsize_get, _IMP_em.DensityHeader_Pixelsize_set)
    __swig_setmethods__["CCDArea"] = _IMP_em.DensityHeader_CCDArea_set
    __swig_getmethods__["CCDArea"] = _IMP_em.DensityHeader_CCDArea_get
    if _newclass:CCDArea = _swig_property(_IMP_em.DensityHeader_CCDArea_get, _IMP_em.DensityHeader_CCDArea_set)
    __swig_setmethods__["Defocus"] = _IMP_em.DensityHeader_Defocus_set
    __swig_getmethods__["Defocus"] = _IMP_em.DensityHeader_Defocus_get
    if _newclass:Defocus = _swig_property(_IMP_em.DensityHeader_Defocus_get, _IMP_em.DensityHeader_Defocus_set)
    __swig_setmethods__["Astigmatism"] = _IMP_em.DensityHeader_Astigmatism_set
    __swig_getmethods__["Astigmatism"] = _IMP_em.DensityHeader_Astigmatism_get
    if _newclass:Astigmatism = _swig_property(_IMP_em.DensityHeader_Astigmatism_get, _IMP_em.DensityHeader_Astigmatism_set)
    __swig_setmethods__["AstigmatismAngle"] = _IMP_em.DensityHeader_AstigmatismAngle_set
    __swig_getmethods__["AstigmatismAngle"] = _IMP_em.DensityHeader_AstigmatismAngle_get
    if _newclass:AstigmatismAngle = _swig_property(_IMP_em.DensityHeader_AstigmatismAngle_get, _IMP_em.DensityHeader_AstigmatismAngle_set)
    __swig_setmethods__["FocusIncrement"] = _IMP_em.DensityHeader_FocusIncrement_set
    __swig_getmethods__["FocusIncrement"] = _IMP_em.DensityHeader_FocusIncrement_get
    if _newclass:FocusIncrement = _swig_property(_IMP_em.DensityHeader_FocusIncrement_get, _IMP_em.DensityHeader_FocusIncrement_set)
    __swig_setmethods__["CountsPerElectron"] = _IMP_em.DensityHeader_CountsPerElectron_set
    __swig_getmethods__["CountsPerElectron"] = _IMP_em.DensityHeader_CountsPerElectron_get
    if _newclass:CountsPerElectron = _swig_property(_IMP_em.DensityHeader_CountsPerElectron_get, _IMP_em.DensityHeader_CountsPerElectron_set)
    __swig_setmethods__["Intensity"] = _IMP_em.DensityHeader_Intensity_set
    __swig_getmethods__["Intensity"] = _IMP_em.DensityHeader_Intensity_get
    if _newclass:Intensity = _swig_property(_IMP_em.DensityHeader_Intensity_get, _IMP_em.DensityHeader_Intensity_set)
    __swig_setmethods__["EnergySlitwidth"] = _IMP_em.DensityHeader_EnergySlitwidth_set
    __swig_getmethods__["EnergySlitwidth"] = _IMP_em.DensityHeader_EnergySlitwidth_get
    if _newclass:EnergySlitwidth = _swig_property(_IMP_em.DensityHeader_EnergySlitwidth_get, _IMP_em.DensityHeader_EnergySlitwidth_set)
    __swig_setmethods__["EnergyOffset"] = _IMP_em.DensityHeader_EnergyOffset_set
    __swig_getmethods__["EnergyOffset"] = _IMP_em.DensityHeader_EnergyOffset_get
    if _newclass:EnergyOffset = _swig_property(_IMP_em.DensityHeader_EnergyOffset_get, _IMP_em.DensityHeader_EnergyOffset_set)
    __swig_setmethods__["Tiltangle"] = _IMP_em.DensityHeader_Tiltangle_set
    __swig_getmethods__["Tiltangle"] = _IMP_em.DensityHeader_Tiltangle_get
    if _newclass:Tiltangle = _swig_property(_IMP_em.DensityHeader_Tiltangle_get, _IMP_em.DensityHeader_Tiltangle_set)
    __swig_setmethods__["Tiltaxis"] = _IMP_em.DensityHeader_Tiltaxis_set
    __swig_getmethods__["Tiltaxis"] = _IMP_em.DensityHeader_Tiltaxis_get
    if _newclass:Tiltaxis = _swig_property(_IMP_em.DensityHeader_Tiltaxis_get, _IMP_em.DensityHeader_Tiltaxis_set)
    __swig_setmethods__["MarkerX"] = _IMP_em.DensityHeader_MarkerX_set
    __swig_getmethods__["MarkerX"] = _IMP_em.DensityHeader_MarkerX_get
    if _newclass:MarkerX = _swig_property(_IMP_em.DensityHeader_MarkerX_get, _IMP_em.DensityHeader_MarkerX_set)
    __swig_setmethods__["MarkerY"] = _IMP_em.DensityHeader_MarkerY_set
    __swig_getmethods__["MarkerY"] = _IMP_em.DensityHeader_MarkerY_get
    if _newclass:MarkerY = _swig_property(_IMP_em.DensityHeader_MarkerY_get, _IMP_em.DensityHeader_MarkerY_set)
    __swig_setmethods__["lswap"] = _IMP_em.DensityHeader_lswap_set
    __swig_getmethods__["lswap"] = _IMP_em.DensityHeader_lswap_get
    if _newclass:lswap = _swig_property(_IMP_em.DensityHeader_lswap_get, _IMP_em.DensityHeader_lswap_set)
    def get_resolution(self):
        """get_resolution(DensityHeader self) -> float"""
        return _IMP_em.DensityHeader_get_resolution(self)

    def get_has_resolution(self):
        """get_has_resolution(DensityHeader self) -> bool"""
        return _IMP_em.DensityHeader_get_has_resolution(self)

    def set_resolution(self, *args):
        """set_resolution(DensityHeader self, float resolution)"""
        return _IMP_em.DensityHeader_set_resolution(self, *args)

    def get_spacing(self):
        """get_spacing(DensityHeader self) -> float"""
        return _IMP_em.DensityHeader_get_spacing(self)

    def get_xorigin(self):
        """get_xorigin(DensityHeader self) -> float"""
        return _IMP_em.DensityHeader_get_xorigin(self)

    def get_yorigin(self):
        """get_yorigin(DensityHeader self) -> float"""
        return _IMP_em.DensityHeader_get_yorigin(self)

    def get_zorigin(self):
        """get_zorigin(DensityHeader self) -> float"""
        return _IMP_em.DensityHeader_get_zorigin(self)

    def get_origin(self, *args):
        """get_origin(DensityHeader self, int i) -> float"""
        return _IMP_em.DensityHeader_get_origin(self, *args)

    def set_xorigin(self, *args):
        """set_xorigin(DensityHeader self, float x)"""
        return _IMP_em.DensityHeader_set_xorigin(self, *args)

    def set_yorigin(self, *args):
        """set_yorigin(DensityHeader self, float y)"""
        return _IMP_em.DensityHeader_set_yorigin(self, *args)

    def set_zorigin(self, *args):
        """set_zorigin(DensityHeader self, float z)"""
        return _IMP_em.DensityHeader_set_zorigin(self, *args)

    def is_top_calculated(self):
        """is_top_calculated(DensityHeader self) -> bool"""
        return _IMP_em.DensityHeader_is_top_calculated(self)

    __swig_setmethods__["Objectpixelsize_"] = _IMP_em.DensityHeader_Objectpixelsize__set
    __swig_getmethods__["Objectpixelsize_"] = _IMP_em.DensityHeader_Objectpixelsize__get
    if _newclass:Objectpixelsize_ = _swig_property(_IMP_em.DensityHeader_Objectpixelsize__get, _IMP_em.DensityHeader_Objectpixelsize__set)
    def get_nx(self):
        """get_nx(DensityHeader self) -> int"""
        return _IMP_em.DensityHeader_get_nx(self)

    def get_ny(self):
        """get_ny(DensityHeader self) -> int"""
        return _IMP_em.DensityHeader_get_ny(self)

    def get_nz(self):
        """get_nz(DensityHeader self) -> int"""
        return _IMP_em.DensityHeader_get_nz(self)

    def get_number_of_voxels(self):
        """get_number_of_voxels(DensityHeader self) -> int"""
        return _IMP_em.DensityHeader_get_number_of_voxels(self)

    def get_data_type(self):
        """get_data_type(DensityHeader self) -> int"""
        return _IMP_em.DensityHeader_get_data_type(self)

    def set_data_type(self, *args):
        """set_data_type(DensityHeader self, int data_type)"""
        return _IMP_em.DensityHeader_set_data_type(self, *args)

    __swig_destroy__ = _IMP_em.delete_DensityHeader
    __del__ = lambda self : None;
DensityHeader_swigregister = _IMP_em.DensityHeader_swigregister
DensityHeader_swigregister(DensityHeader)


def create_density_header(*args):
  """create_density_header(BoundingBox3D bb, float spacing) -> DensityHeader"""
  return _IMP_em.create_density_header(*args)

def read_map(*args):
  """
    read_map(std::string filename, MapReaderWriter reader) -> DensityMap
    read_map(std::string filename) -> DensityMap
    """
  return _IMP_em.read_map(*args)

def write_map(*args):
  """
    write_map(DensityMap m, std::string filename, MapReaderWriter writer)
    write_map(DensityMap m, std::string filename)
    """
  return _IMP_em.write_map(*args)

def approximate_molecular_mass(*args):
  """approximate_molecular_mass(DensityMap m, IMP::Float threshold) -> IMP::Float"""
  return _IMP_em.approximate_molecular_mass(*args)
class DensityMap(IMP.base.Object):
    """Proxy of C++ IMP::em::DensityMap class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DensityMap, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DensityMap, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::DensityMap self, std::string name="DensityMap%1%") -> DensityMap
        __init__(IMP::em::DensityMap self) -> DensityMap
        __init__(IMP::em::DensityMap self, DensityHeader header, std::string name="DensityMap%1%") -> DensityMap
        __init__(IMP::em::DensityMap self, DensityHeader header) -> DensityMap
        """
        this = _IMP_em.new_DensityMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def reset_data(self, value=0.0):
        """
        reset_data(DensityMap self, float value=0.0)
        reset_data(DensityMap self)
        """
        return _IMP_em.DensityMap_reset_data(self, value)

    def calcRMS(self):
        """calcRMS(DensityMap self) -> IMP::em::emreal"""
        return _IMP_em.DensityMap_calcRMS(self)

    def std_normalize(self):
        """std_normalize(DensityMap self)"""
        return _IMP_em.DensityMap_std_normalize(self)

    def is_normalized(self):
        """is_normalized(DensityMap self) -> bool"""
        return _IMP_em.DensityMap_is_normalized(self)

    def get_location_in_dim_by_voxel(self, *args):
        """get_location_in_dim_by_voxel(DensityMap self, long index, int dim) -> float"""
        return _IMP_em.DensityMap_get_location_in_dim_by_voxel(self, *args)

    def xyz_ind2voxel(self, *args):
        """xyz_ind2voxel(DensityMap self, int x, int y, int z) -> long"""
        return _IMP_em.DensityMap_xyz_ind2voxel(self, *args)

    def get_voxel_by_location(self, *args):
        """
        get_voxel_by_location(DensityMap self, float x, float y, float z) -> long
        get_voxel_by_location(DensityMap self, Vector3D v) -> long
        """
        return _IMP_em.DensityMap_get_voxel_by_location(self, *args)

    def get_location_by_voxel(self, *args):
        """get_location_by_voxel(DensityMap self, long index) -> Vector3D"""
        return _IMP_em.DensityMap_get_location_by_voxel(self, *args)

    def is_xyz_ind_part_of_volume(self, *args):
        """is_xyz_ind_part_of_volume(DensityMap self, int ix, int iy, int iz) -> bool"""
        return _IMP_em.DensityMap_is_xyz_ind_part_of_volume(self, *args)

    def is_part_of_volume(self, *args):
        """
        is_part_of_volume(DensityMap self, float x, float y, float z) -> bool
        is_part_of_volume(DensityMap self, Vector3D v) -> bool
        """
        return _IMP_em.DensityMap_is_part_of_volume(self, *args)

    def get_value(self, *args):
        """
        get_value(DensityMap self, float x, float y, float z) -> IMP::em::emreal
        get_value(DensityMap self, Vector3D point) -> IMP::em::emreal
        get_value(DensityMap self, long index) -> IMP::em::emreal
        """
        return _IMP_em.DensityMap_get_value(self, *args)

    def set_value(self, *args):
        """
        set_value(DensityMap self, long index, IMP::em::emreal value)
        set_value(DensityMap self, float x, float y, float z, IMP::em::emreal value)
        """
        return _IMP_em.DensityMap_set_value(self, *args)

    def set_origin(self, *args):
        """
        set_origin(DensityMap self, float x, float y, float z)
        set_origin(DensityMap self, Vector3D v)
        """
        return _IMP_em.DensityMap_set_origin(self, *args)

    def get_origin(self):
        """get_origin(DensityMap self) -> Vector3D"""
        return _IMP_em.DensityMap_get_origin(self)

    def get_top(self):
        """get_top(DensityMap self) -> Vector3D"""
        return _IMP_em.DensityMap_get_top(self)

    def get_header(self):
        h = _IMP_em.DensityMap_get_header(self)
        h._owner = self
        return h


    def get_header_writable(self):
        h = _IMP_em.DensityMap_get_header_writable(self)
        h._owner = self
        return h


    def same_origin(self, *args):
        """same_origin(DensityMap self, DensityMap other) -> bool"""
        return _IMP_em.DensityMap_same_origin(self, *args)

    def same_dimensions(self, *args):
        """same_dimensions(DensityMap self, DensityMap other) -> bool"""
        return _IMP_em.DensityMap_same_dimensions(self, *args)

    def same_voxel_size(self, *args):
        """same_voxel_size(DensityMap self, DensityMap other) -> bool"""
        return _IMP_em.DensityMap_same_voxel_size(self, *args)

    def get_centroid(self, threshold=0.0):
        """
        get_centroid(DensityMap self, IMP::em::emreal threshold=0.0) -> Vector3D
        get_centroid(DensityMap self) -> Vector3D
        """
        return _IMP_em.DensityMap_get_centroid(self, threshold)

    def get_max_value(self):
        """get_max_value(DensityMap self) -> IMP::em::emreal"""
        return _IMP_em.DensityMap_get_max_value(self)

    def get_min_value(self):
        """get_min_value(DensityMap self) -> IMP::em::emreal"""
        return _IMP_em.DensityMap_get_min_value(self)

    def add(self, *args):
        """add(DensityMap self, DensityMap other)"""
        return _IMP_em.DensityMap_add(self, *args)

    def pick_max(self, *args):
        """pick_max(DensityMap self, DensityMap other)"""
        return _IMP_em.DensityMap_pick_max(self, *args)

    def get_number_of_voxels(self):
        """get_number_of_voxels(DensityMap self) -> long"""
        return _IMP_em.DensityMap_get_number_of_voxels(self)

    def set_void_map(self, *args):
        """set_void_map(DensityMap self, int nx, int ny, int nz)"""
        return _IMP_em.DensityMap_set_void_map(self, *args)

    def pad(self, *args):
        """
        pad(DensityMap self, int nx, int ny, int nz, float val=0.0)
        pad(DensityMap self, int nx, int ny, int nz)
        """
        return _IMP_em.DensityMap_pad(self, *args)

    def pad_margin(self, *args):
        """
        pad_margin(DensityMap self, int mrg_x, int mrg_y, int mrg_z, float val=0.0) -> DensityMap
        pad_margin(DensityMap self, int mrg_x, int mrg_y, int mrg_z) -> DensityMap
        """
        return _IMP_em.DensityMap_pad_margin(self, *args)

    def get_cropped(self, *args):
        """
        get_cropped(DensityMap self, float threshold) -> DensityMap
        get_cropped(DensityMap self, BoundingBox3D bb) -> DensityMap
        """
        return _IMP_em.DensityMap_get_cropped(self, *args)

    def get_maximum_value_in_xy_plane(self, *args):
        """get_maximum_value_in_xy_plane(DensityMap self, int z_ind) -> float"""
        return _IMP_em.DensityMap_get_maximum_value_in_xy_plane(self, *args)

    def get_maximum_value_in_xz_plane(self, *args):
        """get_maximum_value_in_xz_plane(DensityMap self, int y_ind) -> float"""
        return _IMP_em.DensityMap_get_maximum_value_in_xz_plane(self, *args)

    def get_maximum_value_in_yz_plane(self, *args):
        """get_maximum_value_in_yz_plane(DensityMap self, int x_ind) -> float"""
        return _IMP_em.DensityMap_get_maximum_value_in_yz_plane(self, *args)

    def multiply(self, *args):
        """multiply(DensityMap self, float factor)"""
        return _IMP_em.DensityMap_multiply(self, *args)

    def get_locations_string(self, *args):
        """get_locations_string(DensityMap self, float t) -> std::string"""
        return _IMP_em.DensityMap_get_locations_string(self, *args)

    def update_voxel_size(self, *args):
        """update_voxel_size(DensityMap self, float new_apix)"""
        return _IMP_em.DensityMap_update_voxel_size(self, *args)

    def get_spacing(self):
        """get_spacing(DensityMap self) -> IMP::Float"""
        return _IMP_em.DensityMap_get_spacing(self)

    def calc_all_voxel2loc(self):
        """calc_all_voxel2loc(DensityMap self)"""
        return _IMP_em.DensityMap_calc_all_voxel2loc(self)

    def copy_map(self, *args):
        """copy_map(DensityMap self, DensityMap other)"""
        return _IMP_em.DensityMap_copy_map(self, *args)

    def get_version_info(self):
        """get_version_info(DensityMap self) -> VersionInfo"""
        return _IMP_em.DensityMap_get_version_info(self)

    def lower_voxel_shift(self, *args):
        """lower_voxel_shift(DensityMap self, IMP::em::emreal loc, IMP::em::emreal kdist, IMP::em::emreal orig, int ndim) -> int"""
        return _IMP_em.DensityMap_lower_voxel_shift(self, *args)

    def upper_voxel_shift(self, *args):
        """upper_voxel_shift(DensityMap self, IMP::em::emreal loc, IMP::em::emreal kdist, IMP::em::emreal orig, int ndim) -> int"""
        return _IMP_em.DensityMap_upper_voxel_shift(self, *args)

    def get_rms_calculated(self):
        """get_rms_calculated(DensityMap self) -> bool"""
        return _IMP_em.DensityMap_get_rms_calculated(self)

    def get_dim_index_by_location(self, *args):
        """
        get_dim_index_by_location(DensityMap self, Vector3D v, int ind) -> int
        get_dim_index_by_location(DensityMap self, float loc_val, int ind) -> int
        """
        return _IMP_em.DensityMap_get_dim_index_by_location(self, *args)

    def __str__(self):
        """__str__(DensityMap self) -> std::string"""
        return _IMP_em.DensityMap___str__(self)

    def __repr__(self):
        """__repr__(DensityMap self) -> std::string"""
        return _IMP_em.DensityMap___repr__(self)

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

DensityMap_swigregister = _IMP_em.DensityMap_swigregister
DensityMap_swigregister(DensityMap)


def get_bounding_box(*args):
  """
    get_bounding_box(DensityMap m, IMP::Float threshold) -> BoundingBox3D
    get_bounding_box(DensityMap m) -> BoundingBox3D
    """
  return _IMP_em.get_bounding_box(*args)

def get_density(*args):
  """get_density(DensityMap m, Vector3D v) -> double"""
  return _IMP_em.get_density(*args)

def get_transformed(*args):
  """
    get_transformed(DensityMap input, Transformation3D tr, double threshold) -> DensityMap
    get_transformed(DensityMap input, Transformation3D tr) -> DensityMap
    """
  return _IMP_em.get_transformed(*args)

def get_resampled(*args):
  """get_resampled(DensityMap input, double scaling) -> DensityMap"""
  return _IMP_em.get_resampled(*args)

def get_transformed_into(*args):
  """
    get_transformed_into(DensityMap source, Transformation3D tr, DensityMap into, bool calc_rms=True)
    get_transformed_into(DensityMap source, Transformation3D tr, DensityMap into)
    """
  return _IMP_em.get_transformed_into(*args)

def get_transformed_into2(*args):
  """get_transformed_into2(DensityMap source, Transformation3D tr, DensityMap into)"""
  return _IMP_em.get_transformed_into2(*args)

def get_interiors_intersect(*args):
  """get_interiors_intersect(DensityMap d1, DensityMap d2) -> bool"""
  return _IMP_em.get_interiors_intersect(*args)

def get_segment(*args):
  """
    get_segment(DensityMap map_to_segment, int nx_start, int nx_end, int ny_start, int ny_end, int nz_start, 
        int nz_end) -> DensityMap
    get_segment(DensityMap map_to_segment, IMP::algebra::Vector3Ds vecs, float dist) -> DensityMap
    """
  return _IMP_em.get_segment(*args)

def get_segment_by_masking(*args):
  """get_segment_by_masking(DensityMap map_to_segment, DensityMap mask, float mas_threshold) -> DensityMap"""
  return _IMP_em.get_segment_by_masking(*args)

def binarize(*args):
  """
    binarize(DensityMap orig_map, float threshold, bool reverse=False) -> DensityMap
    binarize(DensityMap orig_map, float threshold) -> DensityMap
    """
  return _IMP_em.binarize(*args)

def get_threshold_map(*args):
  """get_threshold_map(DensityMap orig_map, float threshold) -> DensityMap"""
  return _IMP_em.get_threshold_map(*args)

def multiply(*args):
  """multiply(DensityMap m1, DensityMap m2) -> DensityMap"""
  return _IMP_em.multiply(*args)

def convolute(*args):
  """convolute(DensityMap m1, DensityMap m2) -> double"""
  return _IMP_em.convolute(*args)

def get_sum(*args):
  """get_sum(DensityMap m1) -> double"""
  return _IMP_em.get_sum(*args)

def get_max_map(*args):
  """get_max_map(IMP::em::DensityMaps maps) -> DensityMap"""
  return _IMP_em.get_max_map(*args)

def interpolate_map(*args):
  """interpolate_map(DensityMap in_map, double new_spacing) -> DensityMap"""
  return _IMP_em.interpolate_map(*args)

def get_grid(*args):
  """get_grid(DensityMap in_map) -> IMP::algebra::GridD< 3,IMP::algebra::DenseGridStorageD< 3,float >,float,IMP::algebra::DefaultEmbeddingD< 3 > >"""
  return _IMP_em.get_grid(*args)

def create_density_map(*args):
  """
    create_density_map(DensityMap other) -> DensityMap
    create_density_map(BoundingBox3D bb, double spacing) -> DensityMap
    create_density_map(int nx, int ny, int nz, double spacing) -> DensityMap
    create_density_map(IMP::algebra::GridD< 3,IMP::algebra::DenseGridStorageD< 3,float >,float,IMP::algebra::DefaultEmbeddingD< 3 > > const & grid) -> DensityMap
    """
  return _IMP_em.create_density_map(*args)

def get_binarized_interior(*args):
  """get_binarized_interior(DensityMap dmap) -> DensityMap"""
  return _IMP_em.get_binarized_interior(*args)

def add_to_map(*args):
  """add_to_map(DensityMap dm, IMP::kernel::Particles const & pis)"""
  return _IMP_em.add_to_map(*args)
class RadiusDependentDistanceMask(_object):
    """Proxy of C++ IMP::em::RadiusDependentDistanceMask class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RadiusDependentDistanceMask, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RadiusDependentDistanceMask, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(IMP::em::RadiusDependentDistanceMask self, float sampling_radius, DensityHeader header) -> RadiusDependentDistanceMask"""
        this = _IMP_em.new_RadiusDependentDistanceMask(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_neighbor_shift(self):
        """get_neighbor_shift(RadiusDependentDistanceMask self) -> std::vector< double,std::allocator< double > > const *"""
        return _IMP_em.RadiusDependentDistanceMask_get_neighbor_shift(self)

    def get_neighbor_dist(self):
        """get_neighbor_dist(RadiusDependentDistanceMask self) -> std::vector< double,std::allocator< double > > const *"""
        return _IMP_em.RadiusDependentDistanceMask_get_neighbor_dist(self)

    def get_neighbor_dist_exp(self):
        """get_neighbor_dist_exp(RadiusDependentDistanceMask self) -> std::vector< double,std::allocator< double > > const *"""
        return _IMP_em.RadiusDependentDistanceMask_get_neighbor_dist_exp(self)

    def show(self, *args):
        """show(RadiusDependentDistanceMask self, _ostream out)"""
        return _IMP_em.RadiusDependentDistanceMask_show(self, *args)

    __swig_destroy__ = _IMP_em.delete_RadiusDependentDistanceMask
    __del__ = lambda self : None;
RadiusDependentDistanceMask_swigregister = _IMP_em.RadiusDependentDistanceMask_swigregister
RadiusDependentDistanceMask_swigregister(RadiusDependentDistanceMask)

class DistanceMask(_object):
    """Proxy of C++ IMP::em::DistanceMask class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistanceMask, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DistanceMask, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::em::DistanceMask self) -> DistanceMask
        __init__(IMP::em::DistanceMask self, DensityHeader header) -> DistanceMask
        """
        this = _IMP_em.new_DistanceMask(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """show(DistanceMask self, _ostream out)"""
        return _IMP_em.DistanceMask_show(self, *args)

    def is_mask_set(self, *args):
        """
        is_mask_set(DistanceMask self, float radius, float eps=0.001) -> bool
        is_mask_set(DistanceMask self, float radius) -> bool
        """
        return _IMP_em.DistanceMask_is_mask_set(self, *args)

    __swig_destroy__ = _IMP_em.delete_DistanceMask
    __del__ = lambda self : None;
DistanceMask_swigregister = _IMP_em.DistanceMask_swigregister
DistanceMask_swigregister(DistanceMask)

class EMReaderWriter(MapReaderWriter):
    """Proxy of C++ IMP::em::EMReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [MapReaderWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EMReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [MapReaderWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EMReaderWriter, name)
    def __str__(self):
        """__str__(EMReaderWriter self) -> std::string"""
        return _IMP_em.EMReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(EMReaderWriter self) -> std::string"""
        return _IMP_em.EMReaderWriter___repr__(self)

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

    def __init__(self): 
        """__init__(IMP::em::EMReaderWriter self) -> EMReaderWriter"""
        this = _IMP_em.new_EMReaderWriter()
        try: self.this.append(this)
        except: self.this = this
EMReaderWriter_swigregister = _IMP_em.EMReaderWriter_swigregister
EMReaderWriter_swigregister(EMReaderWriter)

class XplorReaderWriter(MapReaderWriter):
    """Proxy of C++ IMP::em::XplorReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [MapReaderWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, XplorReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [MapReaderWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, XplorReaderWriter, name)
    def __str__(self):
        """__str__(XplorReaderWriter self) -> std::string"""
        return _IMP_em.XplorReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(XplorReaderWriter self) -> std::string"""
        return _IMP_em.XplorReaderWriter___repr__(self)

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

    def __init__(self): 
        """__init__(IMP::em::XplorReaderWriter self) -> XplorReaderWriter"""
        this = _IMP_em.new_XplorReaderWriter()
        try: self.this.append(this)
        except: self.this = this
XplorReaderWriter_swigregister = _IMP_em.XplorReaderWriter_swigregister
XplorReaderWriter_swigregister(XplorReaderWriter)

class MRCReaderWriter(MapReaderWriter):
    """Proxy of C++ IMP::em::MRCReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [MapReaderWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MRCReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [MapReaderWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MRCReaderWriter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::MRCReaderWriter self) -> MRCReaderWriter
        __init__(IMP::em::MRCReaderWriter self, std::string fn) -> MRCReaderWriter
        """
        this = _IMP_em.new_MRCReaderWriter(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(MRCReaderWriter self) -> std::string"""
        return _IMP_em.MRCReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(MRCReaderWriter self) -> std::string"""
        return _IMP_em.MRCReaderWriter___repr__(self)

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

MRCReaderWriter_swigregister = _IMP_em.MRCReaderWriter_swigregister
MRCReaderWriter_swigregister(MRCReaderWriter)

class RadiusDependentKernelParameters(_object):
    """Proxy of C++ IMP::em::RadiusDependentKernelParameters class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RadiusDependentKernelParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RadiusDependentKernelParameters, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::RadiusDependentKernelParameters self, float radii, float rsigsq, float timessig, float sq2pi3, float inv_rsigsq, float rnormfac, 
            float rkdist) -> RadiusDependentKernelParameters
        """
        this = _IMP_em.new_RadiusDependentKernelParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(RadiusDependentKernelParameters self, _ostream s=std::cout)
        show(RadiusDependentKernelParameters self)
        """
        return _IMP_em.RadiusDependentKernelParameters_show(self, *args)

    def get_vsig(self):
        """get_vsig(RadiusDependentKernelParameters self) -> float"""
        return _IMP_em.RadiusDependentKernelParameters_get_vsig(self)

    def get_vsigsq(self):
        """get_vsigsq(RadiusDependentKernelParameters self) -> float"""
        return _IMP_em.RadiusDependentKernelParameters_get_vsigsq(self)

    def get_inv_sigsq(self):
        """get_inv_sigsq(RadiusDependentKernelParameters self) -> float"""
        return _IMP_em.RadiusDependentKernelParameters_get_inv_sigsq(self)

    def get_sig(self):
        """get_sig(RadiusDependentKernelParameters self) -> float"""
        return _IMP_em.RadiusDependentKernelParameters_get_sig(self)

    def get_kdist(self):
        """get_kdist(RadiusDependentKernelParameters self) -> float"""
        return _IMP_em.RadiusDependentKernelParameters_get_kdist(self)

    def get_normfac(self):
        """get_normfac(RadiusDependentKernelParameters self) -> float"""
        return _IMP_em.RadiusDependentKernelParameters_get_normfac(self)

    __swig_destroy__ = _IMP_em.delete_RadiusDependentKernelParameters
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(RadiusDependentKernelParameters self) -> std::string"""
        return _IMP_em.RadiusDependentKernelParameters___str__(self)

    def __repr__(self):
        """__repr__(RadiusDependentKernelParameters self) -> std::string"""
        return _IMP_em.RadiusDependentKernelParameters___repr__(self)

RadiusDependentKernelParameters_swigregister = _IMP_em.RadiusDependentKernelParameters_swigregister
RadiusDependentKernelParameters_swigregister(RadiusDependentKernelParameters)

class KernelParameters(_object):
    """Proxy of C++ IMP::em::KernelParameters class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KernelParameters, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KernelParameters, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::KernelParameters self) -> KernelParameters
        __init__(IMP::em::KernelParameters self, float resolution) -> KernelParameters
        """
        this = _IMP_em.new_KernelParameters(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em.delete_KernelParameters
    __del__ = lambda self : None;
    def set_params(self, *args):
        """set_params(KernelParameters self, float radius) -> RadiusDependentKernelParameters"""
        return _IMP_em.KernelParameters_set_params(self, *args)

    def get_params(self, *args):
        """
        get_params(KernelParameters self, float radius, float eps=0.001) -> RadiusDependentKernelParameters
        get_params(KernelParameters self, float radius) -> RadiusDependentKernelParameters
        """
        return _IMP_em.KernelParameters_get_params(self, *args)

    def get_rsig(self):
        """get_rsig(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_rsig(self)

    def get_rsigsq(self):
        """get_rsigsq(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_rsigsq(self)

    def get_inv_rsigsq(self):
        """get_inv_rsigsq(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_inv_rsigsq(self)

    def get_timessig(self):
        """get_timessig(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_timessig(self)

    def get_sq2pi3(self):
        """get_sq2pi3(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_sq2pi3(self)

    def get_rnormfac(self):
        """get_rnormfac(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_rnormfac(self)

    def get_rkdist(self):
        """get_rkdist(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_rkdist(self)

    def get_lim(self):
        """get_lim(KernelParameters self) -> float"""
        return _IMP_em.KernelParameters_get_lim(self)

    def show(self, *args):
        """
        show(KernelParameters self, _ostream out=std::cout)
        show(KernelParameters self)
        """
        return _IMP_em.KernelParameters_show(self, *args)

    def __str__(self):
        """__str__(KernelParameters self) -> std::string"""
        return _IMP_em.KernelParameters___str__(self)

    def __repr__(self):
        """__repr__(KernelParameters self) -> std::string"""
        return _IMP_em.KernelParameters___repr__(self)

KernelParameters_swigregister = _IMP_em.KernelParameters_swigregister
KernelParameters_swigregister(KernelParameters)

GAUSSIAN = _IMP_em.GAUSSIAN
BINARIZED_SPHERE = _IMP_em.BINARIZED_SPHERE
SPHERE = _IMP_em.SPHERE
class SampledDensityMap(DensityMap):
    """Proxy of C++ IMP::em::SampledDensityMap class"""
    __swig_setmethods__ = {}
    for _s in [DensityMap]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SampledDensityMap, name, value)
    __swig_getmethods__ = {}
    for _s in [DensityMap]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SampledDensityMap, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::SampledDensityMap self, IMP::em::KernelType kt=GAUSSIAN) -> SampledDensityMap
        __init__(IMP::em::SampledDensityMap self) -> SampledDensityMap
        __init__(IMP::em::SampledDensityMap self, DensityHeader header, IMP::em::KernelType kt=GAUSSIAN) -> SampledDensityMap
        __init__(IMP::em::SampledDensityMap self, DensityHeader header) -> SampledDensityMap
        __init__(IMP::em::SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, IMP::em::emreal resolution, IMP::em::emreal voxel_size, 
            FloatKey mass_key=IMP::atom::Mass::get_mass_key(), int sig_cuttoff=3, 
            IMP::em::KernelType kt=GAUSSIAN) -> SampledDensityMap
        __init__(IMP::em::SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, IMP::em::emreal resolution, IMP::em::emreal voxel_size, 
            FloatKey mass_key=IMP::atom::Mass::get_mass_key(), int sig_cuttoff=3) -> SampledDensityMap
        __init__(IMP::em::SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, IMP::em::emreal resolution, IMP::em::emreal voxel_size, 
            FloatKey mass_key=IMP::atom::Mass::get_mass_key()) -> SampledDensityMap
        __init__(IMP::em::SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, IMP::em::emreal resolution, IMP::em::emreal voxel_size) -> SampledDensityMap
        """
        this = _IMP_em.new_SampledDensityMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def resample(self):
        """resample(SampledDensityMap self)"""
        return _IMP_em.SampledDensityMap_resample(self)

    def project(self, *args):
        """
        project(SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, int x_margin, int y_margin, int z_margin, 
            Vector3D shift=IMP::algebra::Vector3D(0., 0., 0.), FloatKey mass_key=IMP::atom::Mass::get_mass_key())
        project(SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, int x_margin, int y_margin, int z_margin, 
            Vector3D shift=IMP::algebra::Vector3D(0., 0., 0.))
        project(SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, int x_margin, int y_margin, int z_margin)
        """
        return _IMP_em.SampledDensityMap_project(self, *args)

    def set_particles(self, *args):
        """
        set_particles(SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps, FloatKey mass_key=IMP::atom::Mass::get_mass_key())
        set_particles(SampledDensityMap self, IMP::kernel::ParticlesTemp const & ps)
        """
        return _IMP_em.SampledDensityMap_set_particles(self, *args)

    def get_xyzr_particles(self):
        """get_xyzr_particles(SampledDensityMap self) -> IMP::core::XYZRs const &"""
        return _IMP_em.SampledDensityMap_get_xyzr_particles(self)

    def get_sampled_particles(self):
        """get_sampled_particles(SampledDensityMap self) -> IMP::kernel::Particles const &"""
        return _IMP_em.SampledDensityMap_get_sampled_particles(self)

    def get_weight_key(self):
        """get_weight_key(SampledDensityMap self) -> FloatKey"""
        return _IMP_em.SampledDensityMap_get_weight_key(self)

    def get_minimum_resampled_value(self):
        """get_minimum_resampled_value(SampledDensityMap self) -> float"""
        return _IMP_em.SampledDensityMap_get_minimum_resampled_value(self)

    __swig_destroy__ = _IMP_em.delete_SampledDensityMap
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SampledDensityMap self) -> std::string"""
        return _IMP_em.SampledDensityMap___str__(self)

    def __repr__(self):
        """__repr__(SampledDensityMap self) -> std::string"""
        return _IMP_em.SampledDensityMap___repr__(self)

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

SampledDensityMap_swigregister = _IMP_em.SampledDensityMap_swigregister
SampledDensityMap_swigregister(SampledDensityMap)

IMP_DEFAULT_NUM_SHELLS = _IMP_em.IMP_DEFAULT_NUM_SHELLS
IMP_SIG_CUTOFF = _IMP_em.IMP_SIG_CUTOFF
class SurfaceShellDensityMap(SampledDensityMap):
    """Proxy of C++ IMP::em::SurfaceShellDensityMap class"""
    __swig_setmethods__ = {}
    for _s in [SampledDensityMap]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SurfaceShellDensityMap, name, value)
    __swig_getmethods__ = {}
    for _s in [SampledDensityMap]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SurfaceShellDensityMap, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::SurfaceShellDensityMap self) -> SurfaceShellDensityMap
        __init__(IMP::em::SurfaceShellDensityMap self, DensityHeader header) -> SurfaceShellDensityMap
        __init__(IMP::em::SurfaceShellDensityMap self, IMP::kernel::ParticlesTemp const & ps, float voxel_size, FloatKey mass_key=IMP::atom::Mass::get_mass_key(), 
            int num_shells=5) -> SurfaceShellDensityMap
        __init__(IMP::em::SurfaceShellDensityMap self, IMP::kernel::ParticlesTemp const & ps, float voxel_size, FloatKey mass_key=IMP::atom::Mass::get_mass_key()) -> SurfaceShellDensityMap
        __init__(IMP::em::SurfaceShellDensityMap self, IMP::kernel::ParticlesTemp const & ps, float voxel_size) -> SurfaceShellDensityMap
        """
        this = _IMP_em.new_SurfaceShellDensityMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def binaries(self, *args):
        """binaries(SurfaceShellDensityMap self, float scene_val)"""
        return _IMP_em.SurfaceShellDensityMap_binaries(self, *args)

    def has_background_neighbor(self, *args):
        """has_background_neighbor(SurfaceShellDensityMap self, long voxel_ind) -> bool"""
        return _IMP_em.SurfaceShellDensityMap_has_background_neighbor(self, *args)

    __swig_destroy__ = _IMP_em.delete_SurfaceShellDensityMap
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(SurfaceShellDensityMap self) -> std::string"""
        return _IMP_em.SurfaceShellDensityMap___str__(self)

    def __repr__(self):
        """__repr__(SurfaceShellDensityMap self) -> std::string"""
        return _IMP_em.SurfaceShellDensityMap___repr__(self)

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

SurfaceShellDensityMap_swigregister = _IMP_em.SurfaceShellDensityMap_swigregister
SurfaceShellDensityMap_swigregister(SurfaceShellDensityMap)

class CoarseCC(IMP.base.Object):
    """Proxy of C++ IMP::em::CoarseCC class"""
    __swig_setmethods__ = {}
    for _s in [IMP.base.Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoarseCC, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.base.Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoarseCC, name)
    def __init__(self): 
        """__init__(IMP::em::CoarseCC self) -> CoarseCC"""
        this = _IMP_em.new_CoarseCC()
        try: self.this.append(this)
        except: self.this = this
    def calc_score(*args):
        """
        calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor, bool recalc_rms=True, 
            bool resample=True, IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.)) -> float
        calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor, bool recalc_rms=True, 
            bool resample=True) -> float
        calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor, bool recalc_rms=True) -> float
        calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor) -> float
        """
        return _IMP_em.CoarseCC_calc_score(*args)

    if _newclass:calc_score = staticmethod(calc_score)
    __swig_getmethods__["calc_score"] = lambda x: calc_score
    def cross_correlation_coefficient(*args):
        """
        cross_correlation_coefficient(DensityMap grid1, DensityMap grid2, float grid2_voxel_data_threshold, bool allow_padding=False, 
            IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.)) -> double
        cross_correlation_coefficient(DensityMap grid1, DensityMap grid2, float grid2_voxel_data_threshold, bool allow_padding=False) -> double
        cross_correlation_coefficient(DensityMap grid1, DensityMap grid2, float grid2_voxel_data_threshold) -> double
        """
        return _IMP_em.CoarseCC_cross_correlation_coefficient(*args)

    if _newclass:cross_correlation_coefficient = staticmethod(cross_correlation_coefficient)
    __swig_getmethods__["cross_correlation_coefficient"] = lambda x: cross_correlation_coefficient
    def local_cross_correlation_coefficient(*args):
        """local_cross_correlation_coefficient(DensityMap em_map, DensityMap model_map, float voxel_data_threshold) -> float"""
        return _IMP_em.CoarseCC_local_cross_correlation_coefficient(*args)

    if _newclass:local_cross_correlation_coefficient = staticmethod(local_cross_correlation_coefficient)
    __swig_getmethods__["local_cross_correlation_coefficient"] = lambda x: local_cross_correlation_coefficient
    def get_version_info(self):
        """get_version_info(CoarseCC self) -> VersionInfo"""
        return _IMP_em.CoarseCC_get_version_info(self)

    def __str__(self):
        """__str__(CoarseCC self) -> std::string"""
        return _IMP_em.CoarseCC___str__(self)

    def __repr__(self):
        """__repr__(CoarseCC self) -> std::string"""
        return _IMP_em.CoarseCC___repr__(self)

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

CoarseCC_swigregister = _IMP_em.CoarseCC_swigregister
CoarseCC_swigregister(CoarseCC)

def CoarseCC_calc_score(*args):
  """
    calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor, bool recalc_rms=True, 
        bool resample=True, IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.)) -> float
    calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor, bool recalc_rms=True, 
        bool resample=True) -> float
    calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor, bool recalc_rms=True) -> float
    CoarseCC_calc_score(DensityMap data, SampledDensityMap model_map, float scalefactor) -> float
    """
  return _IMP_em.CoarseCC_calc_score(*args)

def CoarseCC_cross_correlation_coefficient(*args):
  """
    cross_correlation_coefficient(DensityMap grid1, DensityMap grid2, float grid2_voxel_data_threshold, bool allow_padding=False, 
        IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.)) -> double
    cross_correlation_coefficient(DensityMap grid1, DensityMap grid2, float grid2_voxel_data_threshold, bool allow_padding=False) -> double
    CoarseCC_cross_correlation_coefficient(DensityMap grid1, DensityMap grid2, float grid2_voxel_data_threshold) -> double
    """
  return _IMP_em.CoarseCC_cross_correlation_coefficient(*args)

def CoarseCC_local_cross_correlation_coefficient(*args):
  """CoarseCC_local_cross_correlation_coefficient(DensityMap em_map, DensityMap model_map, float voxel_data_threshold) -> float"""
  return _IMP_em.CoarseCC_local_cross_correlation_coefficient(*args)

class CoarseConvolution(_object):
    """Proxy of C++ IMP::em::CoarseConvolution class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoarseConvolution, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CoarseConvolution, name)
    __repr__ = _swig_repr
    def convolution(*args):
        """
        convolution(DensityMap em_map, DensityMap model_map, float voxel_data_threshold, bool recalc_ccnormfac=True) -> float
        convolution(DensityMap em_map, DensityMap model_map, float voxel_data_threshold) -> float
        """
        return _IMP_em.CoarseConvolution_convolution(*args)

    if _newclass:convolution = staticmethod(convolution)
    __swig_getmethods__["convolution"] = lambda x: convolution
    def __init__(self): 
        """__init__(IMP::em::CoarseConvolution self) -> CoarseConvolution"""
        this = _IMP_em.new_CoarseConvolution()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em.delete_CoarseConvolution
    __del__ = lambda self : None;
CoarseConvolution_swigregister = _IMP_em.CoarseConvolution_swigregister
CoarseConvolution_swigregister(CoarseConvolution)

def CoarseConvolution_convolution(*args):
  """
    convolution(DensityMap em_map, DensityMap model_map, float voxel_data_threshold, bool recalc_ccnormfac=True) -> float
    CoarseConvolution_convolution(DensityMap em_map, DensityMap model_map, float voxel_data_threshold) -> float
    """
  return _IMP_em.CoarseConvolution_convolution(*args)

class CoarseCCatIntervals(CoarseCC):
    """Proxy of C++ IMP::em::CoarseCCatIntervals class"""
    __swig_setmethods__ = {}
    for _s in [CoarseCC]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoarseCCatIntervals, name, value)
    __swig_getmethods__ = {}
    for _s in [CoarseCC]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoarseCCatIntervals, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::CoarseCCatIntervals self, int const & ncd) -> CoarseCCatIntervals
        __init__(IMP::em::CoarseCCatIntervals self) -> CoarseCCatIntervals
        """
        this = _IMP_em.new_CoarseCCatIntervals(*args)
        try: self.this.append(this)
        except: self.this = this
    def evaluate(self, *args):
        """
        evaluate(CoarseCCatIntervals self, DensityMap em_map, SampledDensityMap model_map, IMP::algebra::Vector3Ds const & deriv, 
            float scalefac, bool lderiv, unsigned long eval_interval) -> std::pair< double,IMP::algebra::Vector3Ds >
        """
        return _IMP_em.CoarseCCatIntervals_evaluate(self, *args)

    def __str__(self):
        """__str__(CoarseCCatIntervals self) -> std::string"""
        return _IMP_em.CoarseCCatIntervals___str__(self)

    def __repr__(self):
        """__repr__(CoarseCCatIntervals self) -> std::string"""
        return _IMP_em.CoarseCCatIntervals___repr__(self)

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

CoarseCCatIntervals_swigregister = _IMP_em.CoarseCCatIntervals_swigregister
CoarseCCatIntervals_swigregister(CoarseCCatIntervals)

class FitRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em::FitRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FitRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FitRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::FitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.), 
            FloatKey weight_key=IMP::atom::Mass::get_mass_key(), float scale=1, 
            bool use_rigid_bodies=True, IMP::em::KernelType kt=GAUSSIAN) -> FitRestraint
        __init__(IMP::em::FitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.), 
            FloatKey weight_key=IMP::atom::Mass::get_mass_key(), float scale=1, 
            bool use_rigid_bodies=True) -> FitRestraint
        __init__(IMP::em::FitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.), 
            FloatKey weight_key=IMP::atom::Mass::get_mass_key(), float scale=1) -> FitRestraint
        __init__(IMP::em::FitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.), 
            FloatKey weight_key=IMP::atom::Mass::get_mass_key()) -> FitRestraint
        __init__(IMP::em::FitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map, IMP::FloatPair norm_factors=IMP::FloatPair(0., 0.)) -> FitRestraint
        __init__(IMP::em::FitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map) -> FitRestraint
        """
        this = _IMP_em.new_FitRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_model_dens_map(self):
        """get_model_dens_map(FitRestraint self) -> SampledDensityMap"""
        return _IMP_em.FitRestraint_get_model_dens_map(self)

    def set_scale_factor(self, *args):
        """set_scale_factor(FitRestraint self, float scale)"""
        return _IMP_em.FitRestraint_set_scale_factor(self, *args)

    def get_scale_factor(self):
        """get_scale_factor(FitRestraint self) -> float"""
        return _IMP_em.FitRestraint_get_scale_factor(self)

    def do_get_inputs(self):
        """do_get_inputs(FitRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em.FitRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(FitRestraint self) -> VersionInfo"""
        return _IMP_em.FitRestraint_get_version_info(self)

    def __str__(self):
        """__str__(FitRestraint self) -> std::string"""
        return _IMP_em.FitRestraint___str__(self)

    def __repr__(self):
        """__repr__(FitRestraint self) -> std::string"""
        return _IMP_em.FitRestraint___repr__(self)

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

    def cast(*args):
        """cast(Restraint r) -> FitRestraint"""
        return _IMP_em.FitRestraint_cast(*args)

    if _newclass:cast = staticmethod(cast)
    __swig_getmethods__["cast"] = lambda x: cast
FitRestraint_swigregister = _IMP_em.FitRestraint_swigregister
FitRestraint_swigregister(FitRestraint)

def FitRestraint_cast(*args):
  """FitRestraint_cast(Restraint r) -> FitRestraint"""
  return _IMP_em.FitRestraint_cast(*args)


def density2particles(*args):
  """
    density2particles(DensityMap dmap, IMP::Float threshold, Model m, int step=1) -> IMP::kernel::Particles
    density2particles(DensityMap dmap, IMP::Float threshold, Model m) -> IMP::kernel::Particles
    """
  return _IMP_em.density2particles(*args)

def density2vectors(*args):
  """density2vectors(DensityMap dmap, IMP::Float threshold) -> IMP::algebra::Vector3Ds"""
  return _IMP_em.density2vectors(*args)

def particles2density(*args):
  """
    particles2density(IMP::kernel::ParticlesTemp const & ps, IMP::Float resolution, IMP::Float apix, int sig_cutoff=3, 
        FloatKey weight_key=IMP::atom::Mass::get_mass_key()) -> SampledDensityMap
    particles2density(IMP::kernel::ParticlesTemp const & ps, IMP::Float resolution, IMP::Float apix, int sig_cutoff=3) -> SampledDensityMap
    particles2density(IMP::kernel::ParticlesTemp const & ps, IMP::Float resolution, IMP::Float apix) -> SampledDensityMap
    """
  return _IMP_em.particles2density(*args)

def particles2binarized_density(*args):
  """
    particles2binarized_density(IMP::kernel::ParticlesTemp const & ps, IMP::Float resolution, IMP::Float apix, int sig_cutoff=3, 
        FloatKey weight_key=IMP::atom::Mass::get_mass_key()) -> SampledDensityMap
    particles2binarized_density(IMP::kernel::ParticlesTemp const & ps, IMP::Float resolution, IMP::Float apix, int sig_cutoff=3) -> SampledDensityMap
    particles2binarized_density(IMP::kernel::ParticlesTemp const & ps, IMP::Float resolution, IMP::Float apix) -> SampledDensityMap
    """
  return _IMP_em.particles2binarized_density(*args)

def particles2surface(*args):
  """
    particles2surface(IMP::kernel::ParticlesTemp const & ps, IMP::Float apix, FloatKey weight_key=IMP::atom::Mass::get_mass_key()) -> SurfaceShellDensityMap
    particles2surface(IMP::kernel::ParticlesTemp const & ps, IMP::Float apix) -> SurfaceShellDensityMap
    """
  return _IMP_em.particles2surface(*args)

def calculate_intersection_score(*args):
  """calculate_intersection_score(SurfaceShellDensityMap d1, SurfaceShellDensityMap d2) -> IMP::Float"""
  return _IMP_em.calculate_intersection_score(*args)
class SpiderHeader(_object):
    """Proxy of C++ IMP::em::SpiderHeader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpiderHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SpiderHeader, name)
    __repr__ = _swig_repr
    __swig_setmethods__["fNslice"] = _IMP_em.SpiderHeader_fNslice_set
    __swig_getmethods__["fNslice"] = _IMP_em.SpiderHeader_fNslice_get
    if _newclass:fNslice = _swig_property(_IMP_em.SpiderHeader_fNslice_get, _IMP_em.SpiderHeader_fNslice_set)
    __swig_setmethods__["fNrow"] = _IMP_em.SpiderHeader_fNrow_set
    __swig_getmethods__["fNrow"] = _IMP_em.SpiderHeader_fNrow_get
    if _newclass:fNrow = _swig_property(_IMP_em.SpiderHeader_fNrow_get, _IMP_em.SpiderHeader_fNrow_set)
    __swig_setmethods__["fNrec"] = _IMP_em.SpiderHeader_fNrec_set
    __swig_getmethods__["fNrec"] = _IMP_em.SpiderHeader_fNrec_get
    if _newclass:fNrec = _swig_property(_IMP_em.SpiderHeader_fNrec_get, _IMP_em.SpiderHeader_fNrec_set)
    __swig_setmethods__["fNlabel"] = _IMP_em.SpiderHeader_fNlabel_set
    __swig_getmethods__["fNlabel"] = _IMP_em.SpiderHeader_fNlabel_get
    if _newclass:fNlabel = _swig_property(_IMP_em.SpiderHeader_fNlabel_get, _IMP_em.SpiderHeader_fNlabel_set)
    __swig_setmethods__["fIform"] = _IMP_em.SpiderHeader_fIform_set
    __swig_getmethods__["fIform"] = _IMP_em.SpiderHeader_fIform_get
    if _newclass:fIform = _swig_property(_IMP_em.SpiderHeader_fIform_get, _IMP_em.SpiderHeader_fIform_set)
    __swig_setmethods__["fImami"] = _IMP_em.SpiderHeader_fImami_set
    __swig_getmethods__["fImami"] = _IMP_em.SpiderHeader_fImami_get
    if _newclass:fImami = _swig_property(_IMP_em.SpiderHeader_fImami_get, _IMP_em.SpiderHeader_fImami_set)
    __swig_setmethods__["fFmax"] = _IMP_em.SpiderHeader_fFmax_set
    __swig_getmethods__["fFmax"] = _IMP_em.SpiderHeader_fFmax_get
    if _newclass:fFmax = _swig_property(_IMP_em.SpiderHeader_fFmax_get, _IMP_em.SpiderHeader_fFmax_set)
    __swig_setmethods__["fFmin"] = _IMP_em.SpiderHeader_fFmin_set
    __swig_getmethods__["fFmin"] = _IMP_em.SpiderHeader_fFmin_get
    if _newclass:fFmin = _swig_property(_IMP_em.SpiderHeader_fFmin_get, _IMP_em.SpiderHeader_fFmin_set)
    __swig_setmethods__["fAv"] = _IMP_em.SpiderHeader_fAv_set
    __swig_getmethods__["fAv"] = _IMP_em.SpiderHeader_fAv_get
    if _newclass:fAv = _swig_property(_IMP_em.SpiderHeader_fAv_get, _IMP_em.SpiderHeader_fAv_set)
    __swig_setmethods__["fSig"] = _IMP_em.SpiderHeader_fSig_set
    __swig_getmethods__["fSig"] = _IMP_em.SpiderHeader_fSig_get
    if _newclass:fSig = _swig_property(_IMP_em.SpiderHeader_fSig_get, _IMP_em.SpiderHeader_fSig_set)
    __swig_setmethods__["fIhist"] = _IMP_em.SpiderHeader_fIhist_set
    __swig_getmethods__["fIhist"] = _IMP_em.SpiderHeader_fIhist_get
    if _newclass:fIhist = _swig_property(_IMP_em.SpiderHeader_fIhist_get, _IMP_em.SpiderHeader_fIhist_set)
    __swig_setmethods__["fNcol"] = _IMP_em.SpiderHeader_fNcol_set
    __swig_getmethods__["fNcol"] = _IMP_em.SpiderHeader_fNcol_get
    if _newclass:fNcol = _swig_property(_IMP_em.SpiderHeader_fNcol_get, _IMP_em.SpiderHeader_fNcol_set)
    __swig_setmethods__["fLabrec"] = _IMP_em.SpiderHeader_fLabrec_set
    __swig_getmethods__["fLabrec"] = _IMP_em.SpiderHeader_fLabrec_get
    if _newclass:fLabrec = _swig_property(_IMP_em.SpiderHeader_fLabrec_get, _IMP_em.SpiderHeader_fLabrec_set)
    __swig_setmethods__["fIangle"] = _IMP_em.SpiderHeader_fIangle_set
    __swig_getmethods__["fIangle"] = _IMP_em.SpiderHeader_fIangle_get
    if _newclass:fIangle = _swig_property(_IMP_em.SpiderHeader_fIangle_get, _IMP_em.SpiderHeader_fIangle_set)
    __swig_setmethods__["fPhi"] = _IMP_em.SpiderHeader_fPhi_set
    __swig_getmethods__["fPhi"] = _IMP_em.SpiderHeader_fPhi_get
    if _newclass:fPhi = _swig_property(_IMP_em.SpiderHeader_fPhi_get, _IMP_em.SpiderHeader_fPhi_set)
    __swig_setmethods__["fTheta"] = _IMP_em.SpiderHeader_fTheta_set
    __swig_getmethods__["fTheta"] = _IMP_em.SpiderHeader_fTheta_get
    if _newclass:fTheta = _swig_property(_IMP_em.SpiderHeader_fTheta_get, _IMP_em.SpiderHeader_fTheta_set)
    __swig_setmethods__["fPsi"] = _IMP_em.SpiderHeader_fPsi_set
    __swig_getmethods__["fPsi"] = _IMP_em.SpiderHeader_fPsi_get
    if _newclass:fPsi = _swig_property(_IMP_em.SpiderHeader_fPsi_get, _IMP_em.SpiderHeader_fPsi_set)
    __swig_setmethods__["fXoff"] = _IMP_em.SpiderHeader_fXoff_set
    __swig_getmethods__["fXoff"] = _IMP_em.SpiderHeader_fXoff_get
    if _newclass:fXoff = _swig_property(_IMP_em.SpiderHeader_fXoff_get, _IMP_em.SpiderHeader_fXoff_set)
    __swig_setmethods__["fYoff"] = _IMP_em.SpiderHeader_fYoff_set
    __swig_getmethods__["fYoff"] = _IMP_em.SpiderHeader_fYoff_get
    if _newclass:fYoff = _swig_property(_IMP_em.SpiderHeader_fYoff_get, _IMP_em.SpiderHeader_fYoff_set)
    __swig_setmethods__["fZoff"] = _IMP_em.SpiderHeader_fZoff_set
    __swig_getmethods__["fZoff"] = _IMP_em.SpiderHeader_fZoff_get
    if _newclass:fZoff = _swig_property(_IMP_em.SpiderHeader_fZoff_get, _IMP_em.SpiderHeader_fZoff_set)
    __swig_setmethods__["fScale"] = _IMP_em.SpiderHeader_fScale_set
    __swig_getmethods__["fScale"] = _IMP_em.SpiderHeader_fScale_get
    if _newclass:fScale = _swig_property(_IMP_em.SpiderHeader_fScale_get, _IMP_em.SpiderHeader_fScale_set)
    __swig_setmethods__["fLabbyt"] = _IMP_em.SpiderHeader_fLabbyt_set
    __swig_getmethods__["fLabbyt"] = _IMP_em.SpiderHeader_fLabbyt_get
    if _newclass:fLabbyt = _swig_property(_IMP_em.SpiderHeader_fLabbyt_get, _IMP_em.SpiderHeader_fLabbyt_set)
    __swig_setmethods__["fLenbyt"] = _IMP_em.SpiderHeader_fLenbyt_set
    __swig_getmethods__["fLenbyt"] = _IMP_em.SpiderHeader_fLenbyt_get
    if _newclass:fLenbyt = _swig_property(_IMP_em.SpiderHeader_fLenbyt_get, _IMP_em.SpiderHeader_fLenbyt_set)
    __swig_setmethods__["fNothing"] = _IMP_em.SpiderHeader_fNothing_set
    __swig_getmethods__["fNothing"] = _IMP_em.SpiderHeader_fNothing_get
    if _newclass:fNothing = _swig_property(_IMP_em.SpiderHeader_fNothing_get, _IMP_em.SpiderHeader_fNothing_set)
    __swig_setmethods__["fFlag"] = _IMP_em.SpiderHeader_fFlag_set
    __swig_getmethods__["fFlag"] = _IMP_em.SpiderHeader_fFlag_get
    if _newclass:fFlag = _swig_property(_IMP_em.SpiderHeader_fFlag_get, _IMP_em.SpiderHeader_fFlag_set)
    __swig_setmethods__["fPhi1"] = _IMP_em.SpiderHeader_fPhi1_set
    __swig_getmethods__["fPhi1"] = _IMP_em.SpiderHeader_fPhi1_get
    if _newclass:fPhi1 = _swig_property(_IMP_em.SpiderHeader_fPhi1_get, _IMP_em.SpiderHeader_fPhi1_set)
    __swig_setmethods__["fTheta1"] = _IMP_em.SpiderHeader_fTheta1_set
    __swig_getmethods__["fTheta1"] = _IMP_em.SpiderHeader_fTheta1_get
    if _newclass:fTheta1 = _swig_property(_IMP_em.SpiderHeader_fTheta1_get, _IMP_em.SpiderHeader_fTheta1_set)
    __swig_setmethods__["fPsi1"] = _IMP_em.SpiderHeader_fPsi1_set
    __swig_getmethods__["fPsi1"] = _IMP_em.SpiderHeader_fPsi1_get
    if _newclass:fPsi1 = _swig_property(_IMP_em.SpiderHeader_fPsi1_get, _IMP_em.SpiderHeader_fPsi1_set)
    __swig_setmethods__["fPhi2"] = _IMP_em.SpiderHeader_fPhi2_set
    __swig_getmethods__["fPhi2"] = _IMP_em.SpiderHeader_fPhi2_get
    if _newclass:fPhi2 = _swig_property(_IMP_em.SpiderHeader_fPhi2_get, _IMP_em.SpiderHeader_fPhi2_set)
    __swig_setmethods__["fTheta2"] = _IMP_em.SpiderHeader_fTheta2_set
    __swig_getmethods__["fTheta2"] = _IMP_em.SpiderHeader_fTheta2_get
    if _newclass:fTheta2 = _swig_property(_IMP_em.SpiderHeader_fTheta2_get, _IMP_em.SpiderHeader_fTheta2_set)
    __swig_setmethods__["fPsi2"] = _IMP_em.SpiderHeader_fPsi2_set
    __swig_getmethods__["fPsi2"] = _IMP_em.SpiderHeader_fPsi2_get
    if _newclass:fPsi2 = _swig_property(_IMP_em.SpiderHeader_fPsi2_get, _IMP_em.SpiderHeader_fPsi2_set)
    __swig_setmethods__["fGeo_matrix"] = _IMP_em.SpiderHeader_fGeo_matrix_set
    __swig_getmethods__["fGeo_matrix"] = _IMP_em.SpiderHeader_fGeo_matrix_get
    if _newclass:fGeo_matrix = _swig_property(_IMP_em.SpiderHeader_fGeo_matrix_get, _IMP_em.SpiderHeader_fGeo_matrix_set)
    __swig_setmethods__["fAngle1"] = _IMP_em.SpiderHeader_fAngle1_set
    __swig_getmethods__["fAngle1"] = _IMP_em.SpiderHeader_fAngle1_get
    if _newclass:fAngle1 = _swig_property(_IMP_em.SpiderHeader_fAngle1_get, _IMP_em.SpiderHeader_fAngle1_set)
    __swig_setmethods__["fr1"] = _IMP_em.SpiderHeader_fr1_set
    __swig_getmethods__["fr1"] = _IMP_em.SpiderHeader_fr1_get
    if _newclass:fr1 = _swig_property(_IMP_em.SpiderHeader_fr1_get, _IMP_em.SpiderHeader_fr1_set)
    __swig_setmethods__["fr2"] = _IMP_em.SpiderHeader_fr2_set
    __swig_getmethods__["fr2"] = _IMP_em.SpiderHeader_fr2_get
    if _newclass:fr2 = _swig_property(_IMP_em.SpiderHeader_fr2_get, _IMP_em.SpiderHeader_fr2_set)
    __swig_setmethods__["RTflag"] = _IMP_em.SpiderHeader_RTflag_set
    __swig_getmethods__["RTflag"] = _IMP_em.SpiderHeader_RTflag_get
    if _newclass:RTflag = _swig_property(_IMP_em.SpiderHeader_RTflag_get, _IMP_em.SpiderHeader_RTflag_set)
    __swig_setmethods__["Astart"] = _IMP_em.SpiderHeader_Astart_set
    __swig_getmethods__["Astart"] = _IMP_em.SpiderHeader_Astart_get
    if _newclass:Astart = _swig_property(_IMP_em.SpiderHeader_Astart_get, _IMP_em.SpiderHeader_Astart_set)
    __swig_setmethods__["Aend"] = _IMP_em.SpiderHeader_Aend_set
    __swig_getmethods__["Aend"] = _IMP_em.SpiderHeader_Aend_get
    if _newclass:Aend = _swig_property(_IMP_em.SpiderHeader_Aend_get, _IMP_em.SpiderHeader_Aend_set)
    __swig_setmethods__["Ainc"] = _IMP_em.SpiderHeader_Ainc_set
    __swig_getmethods__["Ainc"] = _IMP_em.SpiderHeader_Ainc_get
    if _newclass:Ainc = _swig_property(_IMP_em.SpiderHeader_Ainc_get, _IMP_em.SpiderHeader_Ainc_set)
    __swig_setmethods__["Rsigma"] = _IMP_em.SpiderHeader_Rsigma_set
    __swig_getmethods__["Rsigma"] = _IMP_em.SpiderHeader_Rsigma_get
    if _newclass:Rsigma = _swig_property(_IMP_em.SpiderHeader_Rsigma_get, _IMP_em.SpiderHeader_Rsigma_set)
    __swig_setmethods__["Tstart"] = _IMP_em.SpiderHeader_Tstart_set
    __swig_getmethods__["Tstart"] = _IMP_em.SpiderHeader_Tstart_get
    if _newclass:Tstart = _swig_property(_IMP_em.SpiderHeader_Tstart_get, _IMP_em.SpiderHeader_Tstart_set)
    __swig_setmethods__["Tend"] = _IMP_em.SpiderHeader_Tend_set
    __swig_getmethods__["Tend"] = _IMP_em.SpiderHeader_Tend_get
    if _newclass:Tend = _swig_property(_IMP_em.SpiderHeader_Tend_get, _IMP_em.SpiderHeader_Tend_set)
    __swig_setmethods__["Tinc"] = _IMP_em.SpiderHeader_Tinc_set
    __swig_getmethods__["Tinc"] = _IMP_em.SpiderHeader_Tinc_get
    if _newclass:Tinc = _swig_property(_IMP_em.SpiderHeader_Tinc_get, _IMP_em.SpiderHeader_Tinc_set)
    __swig_setmethods__["Weight"] = _IMP_em.SpiderHeader_Weight_set
    __swig_getmethods__["Weight"] = _IMP_em.SpiderHeader_Weight_get
    if _newclass:Weight = _swig_property(_IMP_em.SpiderHeader_Weight_get, _IMP_em.SpiderHeader_Weight_set)
    __swig_setmethods__["Flip"] = _IMP_em.SpiderHeader_Flip_set
    __swig_getmethods__["Flip"] = _IMP_em.SpiderHeader_Flip_get
    if _newclass:Flip = _swig_property(_IMP_em.SpiderHeader_Flip_get, _IMP_em.SpiderHeader_Flip_set)
    __swig_setmethods__["empty"] = _IMP_em.SpiderHeader_empty_set
    __swig_getmethods__["empty"] = _IMP_em.SpiderHeader_empty_get
    if _newclass:empty = _swig_property(_IMP_em.SpiderHeader_empty_get, _IMP_em.SpiderHeader_empty_set)
    __swig_setmethods__["szIDat"] = _IMP_em.SpiderHeader_szIDat_set
    __swig_getmethods__["szIDat"] = _IMP_em.SpiderHeader_szIDat_get
    if _newclass:szIDat = _swig_property(_IMP_em.SpiderHeader_szIDat_get, _IMP_em.SpiderHeader_szIDat_set)
    __swig_setmethods__["szITim"] = _IMP_em.SpiderHeader_szITim_set
    __swig_getmethods__["szITim"] = _IMP_em.SpiderHeader_szITim_get
    if _newclass:szITim = _swig_property(_IMP_em.SpiderHeader_szITim_get, _IMP_em.SpiderHeader_szITim_set)
    __swig_setmethods__["szITit"] = _IMP_em.SpiderHeader_szITit_set
    __swig_getmethods__["szITit"] = _IMP_em.SpiderHeader_szITit_get
    if _newclass:szITit = _swig_property(_IMP_em.SpiderHeader_szITit_get, _IMP_em.SpiderHeader_szITit_set)
    def show(self, *args):
        """show(SpiderHeader self, _ostream out)"""
        return _IMP_em.SpiderHeader_show(self, *args)

    def __init__(self): 
        """__init__(IMP::em::SpiderHeader self) -> SpiderHeader"""
        this = _IMP_em.new_SpiderHeader()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_em.delete_SpiderHeader
    __del__ = lambda self : None;
SpiderHeader_swigregister = _IMP_em.SpiderHeader_swigregister
SpiderHeader_swigregister(SpiderHeader)

class ImageHeader(_object):
    """Proxy of C++ IMP::em::ImageHeader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageHeader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ImageHeader, name)
    __repr__ = _swig_repr
    IMG_BYTE = _IMP_em.ImageHeader_IMG_BYTE
    IMG_IMPEM = _IMP_em.ImageHeader_IMG_IMPEM
    IMG_INT = _IMP_em.ImageHeader_IMG_INT
    VOL_BYTE = _IMP_em.ImageHeader_VOL_BYTE
    VOL_IMPEM = _IMP_em.ImageHeader_VOL_IMPEM
    VOL_INT = _IMP_em.ImageHeader_VOL_INT
    IMG_FOURIER = _IMP_em.ImageHeader_IMG_FOURIER
    VOL_FOURIER = _IMP_em.ImageHeader_VOL_FOURIER
    def __init__(self, *args): 
        """
        __init__(IMP::em::ImageHeader self) -> ImageHeader
        __init__(IMP::em::ImageHeader self, IMP::em::ImageHeader::img_type im) -> ImageHeader
        __init__(IMP::em::ImageHeader self, float im) -> ImageHeader
        """
        this = _IMP_em.new_ImageHeader(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_image_type(self):
        """get_image_type(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_image_type(self)

    def set_image_type(self, *args):
        """
        set_image_type(ImageHeader self, IMP::em::ImageHeader::img_type im)
        set_image_type(ImageHeader self, float im)
        """
        return _IMP_em.ImageHeader_set_image_type(self, *args)

    def do_show(self, *args):
        """do_show(ImageHeader self, _ostream out)"""
        return _IMP_em.ImageHeader_do_show(self, *args)

    def show(self, *args):
        """
        show(ImageHeader self, _ostream out=std::cout)
        show(ImageHeader self)
        """
        return _IMP_em.ImageHeader_show(self, *args)

    def print_hard(self, *args):
        """print_hard(ImageHeader self, _ostream out)"""
        return _IMP_em.ImageHeader_print_hard(self, *args)

    def show_projection_params(self, *args):
        """show_projection_params(ImageHeader self, _ostream out)"""
        return _IMP_em.ImageHeader_show_projection_params(self, *args)

    def read(self, *args):
        """
        read(ImageHeader self, IMP::String const filename, bool skip_type_check=False, bool force_reversed=False, 
            bool skip_extra_checkings=False) -> int
        read(ImageHeader self, IMP::String const filename, bool skip_type_check=False, bool force_reversed=False) -> int
        read(ImageHeader self, IMP::String const filename, bool skip_type_check=False) -> int
        read(ImageHeader self, IMP::String const filename) -> int
        read(ImageHeader self, std::ifstream & f, bool skip_type_check=False, bool force_reversed=False, bool skip_extra_checkings=False) -> bool
        read(ImageHeader self, std::ifstream & f, bool skip_type_check=False, bool force_reversed=False) -> bool
        read(ImageHeader self, std::ifstream & f, bool skip_type_check=False) -> bool
        read(ImageHeader self, std::ifstream & f) -> bool
        """
        return _IMP_em.ImageHeader_read(self, *args)

    def write(self, *args):
        """
        write(ImageHeader self, IMP::String const & filename, bool force_reversed=False)
        write(ImageHeader self, IMP::String const & filename)
        write(ImageHeader self, std::ofstream & f, bool force_reversed=False)
        write(ImageHeader self, std::ofstream & f)
        """
        return _IMP_em.ImageHeader_write(self, *args)

    def clear(self):
        """clear(ImageHeader self)"""
        return _IMP_em.ImageHeader_clear(self)

    def set_header(self):
        """set_header(ImageHeader self)"""
        return _IMP_em.ImageHeader_set_header(self)

    def get_reversed(self):
        """get_reversed(ImageHeader self) -> bool"""
        return _IMP_em.ImageHeader_get_reversed(self)

    def set_reversed(self, *args):
        """set_reversed(ImageHeader self, bool value)"""
        return _IMP_em.ImageHeader_set_reversed(self, *args)

    def get_number_of_slices(self):
        """get_number_of_slices(ImageHeader self) -> unsigned int"""
        return _IMP_em.ImageHeader_get_number_of_slices(self)

    def set_number_of_slices(self, *args):
        """set_number_of_slices(ImageHeader self, unsigned int n)"""
        return _IMP_em.ImageHeader_set_number_of_slices(self, *args)

    def get_number_of_rows(self):
        """get_number_of_rows(ImageHeader self) -> unsigned int"""
        return _IMP_em.ImageHeader_get_number_of_rows(self)

    def set_number_of_rows(self, *args):
        """set_number_of_rows(ImageHeader self, unsigned int n)"""
        return _IMP_em.ImageHeader_set_number_of_rows(self, *args)

    def get_number_of_columns(self):
        """get_number_of_columns(ImageHeader self) -> unsigned int"""
        return _IMP_em.ImageHeader_get_number_of_columns(self)

    def set_number_of_columns(self, *args):
        """set_number_of_columns(ImageHeader self, unsigned int n)"""
        return _IMP_em.ImageHeader_set_number_of_columns(self, *args)

    def get_old_rot(self):
        """get_old_rot(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_old_rot(self)

    def set_old_rot(self, *args):
        """set_old_rot(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_old_rot(self, *args)

    def get_fAngle1(self):
        """get_fAngle1(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fAngle1(self)

    def set_fAngle1(self, *args):
        """set_fAngle1(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fAngle1(self, *args)

    def get_Scale(self):
        """get_Scale(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_Scale(self)

    def set_Scale(self, *args):
        """set_Scale(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_Scale(self, *args)

    def get_Flip(self):
        """get_Flip(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_Flip(self)

    def set_Flip(self, *args):
        """set_Flip(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_Flip(self, *args)

    def get_Weight(self):
        """get_Weight(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_Weight(self)

    def set_Weight(self, *args):
        """set_Weight(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_Weight(self, *args)

    def get_fNrec(self):
        """get_fNrec(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fNrec(self)

    def set_fNrec(self, *args):
        """set_fNrec(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fNrec(self, *args)

    def get_fNlabel(self):
        """get_fNlabel(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fNlabel(self)

    def set_fNlabel(self, *args):
        """set_fNlabel(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fNlabel(self, *args)

    def get_fIform(self):
        """get_fIform(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fIform(self)

    def set_fIform(self, *args):
        """set_fIform(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fIform(self, *args)

    def get_fImami(self):
        """get_fImami(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fImami(self)

    def set_fImami(self, *args):
        """set_fImami(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fImami(self, *args)

    def get_fFmax(self):
        """get_fFmax(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fFmax(self)

    def set_fFmax(self, *args):
        """set_fFmax(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fFmax(self, *args)

    def get_fFmin(self):
        """get_fFmin(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fFmin(self)

    def set_fFmin(self, *args):
        """set_fFmin(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fFmin(self, *args)

    def get_fAv(self):
        """get_fAv(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fAv(self)

    def set_fAv(self, *args):
        """set_fAv(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fAv(self, *args)

    def get_fSig(self):
        """get_fSig(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fSig(self)

    def set_fSig(self, *args):
        """set_fSig(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fSig(self, *args)

    def get_fIhist(self):
        """get_fIhist(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fIhist(self)

    def set_fIhist(self, *args):
        """set_fIhist(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fIhist(self, *args)

    def get_fLabrec(self):
        """get_fLabrec(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fLabrec(self)

    def set_fLabrec(self, *args):
        """set_fLabrec(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fLabrec(self, *args)

    def get_fIangle(self):
        """get_fIangle(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fIangle(self)

    def set_fIangle(self, *args):
        """set_fIangle(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fIangle(self, *args)

    def get_origin(self):
        """get_origin(ImageHeader self) -> Vector3D"""
        return _IMP_em.ImageHeader_get_origin(self)

    def set_origin(self, *args):
        """
        set_origin(ImageHeader self, Vector3D v)
        set_origin(ImageHeader self, Vector2D v)
        """
        return _IMP_em.ImageHeader_set_origin(self, *args)

    def get_object_pixel_size(self):
        """get_object_pixel_size(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_object_pixel_size(self)

    def set_object_pixel_size(self, *args):
        """set_object_pixel_size(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_object_pixel_size(self, *args)

    def get_fLabbyt(self):
        """get_fLabbyt(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fLabbyt(self)

    def set_fLabbyt(self, *args):
        """set_fLabbyt(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fLabbyt(self, *args)

    def get_fLenbyt(self):
        """get_fLenbyt(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fLenbyt(self)

    def set_fLenbyt(self, *args):
        """set_fLenbyt(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fLenbyt(self, *args)

    def get_fGeo_matrix(self, *args):
        """get_fGeo_matrix(ImageHeader self, unsigned int i, unsigned int j) -> double"""
        return _IMP_em.ImageHeader_get_fGeo_matrix(self, *args)

    def get_fFlag(self):
        """get_fFlag(ImageHeader self) -> float"""
        return _IMP_em.ImageHeader_get_fFlag(self)

    def set_fFlag(self, *args):
        """set_fFlag(ImageHeader self, float value)"""
        return _IMP_em.ImageHeader_set_fFlag(self, *args)

    def get_euler_angles(self):
        """get_euler_angles(ImageHeader self) -> Vector3D"""
        return _IMP_em.ImageHeader_get_euler_angles(self)

    def get_euler_angles1(self):
        """get_euler_angles1(ImageHeader self) -> Vector3D"""
        return _IMP_em.ImageHeader_get_euler_angles1(self)

    def get_euler_angles2(self):
        """get_euler_angles2(ImageHeader self) -> Vector3D"""
        return _IMP_em.ImageHeader_get_euler_angles2(self)

    def set_euler_angles(self, *args):
        """set_euler_angles(ImageHeader self, Vector3D euler)"""
        return _IMP_em.ImageHeader_set_euler_angles(self, *args)

    def set_euler_angles1(self, *args):
        """set_euler_angles1(ImageHeader self, Vector3D euler)"""
        return _IMP_em.ImageHeader_set_euler_angles1(self, *args)

    def set_euler_angles2(self, *args):
        """set_euler_angles2(ImageHeader self, Vector3D euler)"""
        return _IMP_em.ImageHeader_set_euler_angles2(self, *args)

    def is_normalized(self):
        """is_normalized(ImageHeader self) -> bool"""
        return _IMP_em.ImageHeader_is_normalized(self)

    def set_date(self):
        """set_date(ImageHeader self)"""
        return _IMP_em.ImageHeader_set_date(self)

    def set_time(self):
        """set_time(ImageHeader self)"""
        return _IMP_em.ImageHeader_set_time(self)

    def set_title(self, *args):
        """set_title(ImageHeader self, IMP::String newName)"""
        return _IMP_em.ImageHeader_set_title(self, *args)

    __swig_destroy__ = _IMP_em.delete_ImageHeader
    __del__ = lambda self : None;
ImageHeader_swigregister = _IMP_em.ImageHeader_swigregister
ImageHeader_swigregister(ImageHeader)

class SpiderMapReaderWriter(MapReaderWriter):
    """Proxy of C++ IMP::em::SpiderMapReaderWriter class"""
    __swig_setmethods__ = {}
    for _s in [MapReaderWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpiderMapReaderWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [MapReaderWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpiderMapReaderWriter, name)
    __swig_setmethods__["filename_"] = _IMP_em.SpiderMapReaderWriter_filename__set
    __swig_getmethods__["filename_"] = _IMP_em.SpiderMapReaderWriter_filename__get
    if _newclass:filename_ = _swig_property(_IMP_em.SpiderMapReaderWriter_filename__get, _IMP_em.SpiderMapReaderWriter_filename__set)
    __swig_setmethods__["skip_type_check_"] = _IMP_em.SpiderMapReaderWriter_skip_type_check__set
    __swig_getmethods__["skip_type_check_"] = _IMP_em.SpiderMapReaderWriter_skip_type_check__get
    if _newclass:skip_type_check_ = _swig_property(_IMP_em.SpiderMapReaderWriter_skip_type_check__get, _IMP_em.SpiderMapReaderWriter_skip_type_check__set)
    __swig_setmethods__["force_reversed_"] = _IMP_em.SpiderMapReaderWriter_force_reversed__set
    __swig_getmethods__["force_reversed_"] = _IMP_em.SpiderMapReaderWriter_force_reversed__get
    if _newclass:force_reversed_ = _swig_property(_IMP_em.SpiderMapReaderWriter_force_reversed__get, _IMP_em.SpiderMapReaderWriter_force_reversed__set)
    __swig_setmethods__["skip_extra_checkings_"] = _IMP_em.SpiderMapReaderWriter_skip_extra_checkings__set
    __swig_getmethods__["skip_extra_checkings_"] = _IMP_em.SpiderMapReaderWriter_skip_extra_checkings__get
    if _newclass:skip_extra_checkings_ = _swig_property(_IMP_em.SpiderMapReaderWriter_skip_extra_checkings__get, _IMP_em.SpiderMapReaderWriter_skip_extra_checkings__set)
    def __init__(self, *args): 
        """
        __init__(IMP::em::SpiderMapReaderWriter self) -> SpiderMapReaderWriter
        __init__(IMP::em::SpiderMapReaderWriter self, IMP::String filename, bool skip_type_check, bool force_reversed, bool skip_extra_checkings) -> SpiderMapReaderWriter
        """
        this = _IMP_em.new_SpiderMapReaderWriter(*args)
        try: self.this.append(this)
        except: self.this = this
    def __str__(self):
        """__str__(SpiderMapReaderWriter self) -> std::string"""
        return _IMP_em.SpiderMapReaderWriter___str__(self)

    def __repr__(self):
        """__repr__(SpiderMapReaderWriter self) -> std::string"""
        return _IMP_em.SpiderMapReaderWriter___repr__(self)

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

SpiderMapReaderWriter_swigregister = _IMP_em.SpiderMapReaderWriter_swigregister
SpiderMapReaderWriter_swigregister(SpiderMapReaderWriter)

class FittingSolutions(_object):
    """Proxy of C++ IMP::em::FittingSolutions class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FittingSolutions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FittingSolutions, name)
    def __init__(self): 
        """__init__(IMP::em::FittingSolutions self) -> FittingSolutions"""
        this = _IMP_em.new_FittingSolutions()
        try: self.this.append(this)
        except: self.this = this
    def get_number_of_solutions(self):
        """get_number_of_solutions(FittingSolutions self) -> int"""
        return _IMP_em.FittingSolutions_get_number_of_solutions(self)

    def get_transformation(self, *args):
        """get_transformation(FittingSolutions self, unsigned int i) -> Transformation3D"""
        return _IMP_em.FittingSolutions_get_transformation(self, *args)

    def get_score(self, *args):
        """get_score(FittingSolutions self, unsigned int i) -> IMP::Float"""
        return _IMP_em.FittingSolutions_get_score(self, *args)

    def set_score(self, *args):
        """set_score(FittingSolutions self, unsigned int i, IMP::Float score)"""
        return _IMP_em.FittingSolutions_set_score(self, *args)

    def add_solution(self, *args):
        """add_solution(FittingSolutions self, Transformation3D t, IMP::Float score)"""
        return _IMP_em.FittingSolutions_add_solution(self, *args)

    def sort(self, reverse=False):
        """
        sort(FittingSolutions self, bool reverse=False)
        sort(FittingSolutions self)
        """
        return _IMP_em.FittingSolutions_sort(self, reverse)

    def multiply(self, *args):
        """multiply(FittingSolutions self, Transformation3D t)"""
        return _IMP_em.FittingSolutions_multiply(self, *args)

    def get_transformations(self):
        """get_transformations(FittingSolutions self) -> IMP::algebra::Transformation3Ds"""
        return _IMP_em.FittingSolutions_get_transformations(self)

    def show(self, *args):
        """
        show(FittingSolutions self, _ostream out=std::cout)
        show(FittingSolutions self)
        """
        return _IMP_em.FittingSolutions_show(self, *args)

    def __str__(self):
        """__str__(FittingSolutions self) -> std::string"""
        return _IMP_em.FittingSolutions___str__(self)

    def __repr__(self):
        """__repr__(FittingSolutions self) -> std::string"""
        return _IMP_em.FittingSolutions___repr__(self)

    __swig_destroy__ = _IMP_em.delete_FittingSolutions
    __del__ = lambda self : None;
FittingSolutions_swigregister = _IMP_em.FittingSolutions_swigregister
FittingSolutions_swigregister(FittingSolutions)


def local_rigid_fitting_around_point(*args):
  """
    local_rigid_fitting_around_point(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, Vector3D anchor_centroid, 
        IMP::kernel::OptimizerStates display_log, IMP::Int number_of_optimization_runs=5, 
        IMP::Int number_of_mc_steps=10, IMP::Int number_of_cg_steps=100, 
        IMP::Float max_translation=2., IMP::Float max_rotation=.3, bool fast=False) -> FittingSolutions
    local_rigid_fitting_around_point(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, Vector3D anchor_centroid, 
        IMP::kernel::OptimizerStates display_log, IMP::Int number_of_optimization_runs=5, 
        IMP::Int number_of_mc_steps=10, IMP::Int number_of_cg_steps=100, 
        IMP::Float max_translation=2., IMP::Float max_rotation=.3) -> FittingSolutions
    local_rigid_fitting_around_point(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, Vector3D anchor_centroid, 
        IMP::kernel::OptimizerStates display_log, IMP::Int number_of_optimization_runs=5, 
        IMP::Int number_of_mc_steps=10, IMP::Int number_of_cg_steps=100, 
        IMP::Float max_translation=2.) -> FittingSolutions
    local_rigid_fitting_around_point(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, Vector3D anchor_centroid, 
        IMP::kernel::OptimizerStates display_log, IMP::Int number_of_optimization_runs=5, 
        IMP::Int number_of_mc_steps=10, IMP::Int number_of_cg_steps=100) -> FittingSolutions
    local_rigid_fitting_around_point(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, Vector3D anchor_centroid, 
        IMP::kernel::OptimizerStates display_log, IMP::Int number_of_optimization_runs=5, 
        IMP::Int number_of_mc_steps=10) -> FittingSolutions
    local_rigid_fitting_around_point(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, Vector3D anchor_centroid, 
        IMP::kernel::OptimizerStates display_log, IMP::Int number_of_optimization_runs=5) -> FittingSolutions
    local_rigid_fitting_around_point(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, Vector3D anchor_centroid, 
        IMP::kernel::OptimizerStates display_log) -> FittingSolutions
    """
  return _IMP_em.local_rigid_fitting_around_point(*args)

def local_rigid_fitting(*args):
  """
    local_rigid_fitting(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10, 
        IMP::Int number_of_cg_steps=100, IMP::Float max_translation=2., 
        IMP::Float max_rotation=.3, bool fast=True) -> FittingSolutions
    local_rigid_fitting(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10, 
        IMP::Int number_of_cg_steps=100, IMP::Float max_translation=2., 
        IMP::Float max_rotation=.3) -> FittingSolutions
    local_rigid_fitting(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10, 
        IMP::Int number_of_cg_steps=100, IMP::Float max_translation=2.) -> FittingSolutions
    local_rigid_fitting(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10, 
        IMP::Int number_of_cg_steps=100) -> FittingSolutions
    local_rigid_fitting(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10) -> FittingSolutions
    local_rigid_fitting(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5) -> FittingSolutions
    local_rigid_fitting(Particle p, Refiner refiner, FloatKey weight_key, DensityMap dmap, IMP::kernel::OptimizerStates display_log) -> FittingSolutions
    """
  return _IMP_em.local_rigid_fitting(*args)

def local_rigid_fitting_around_points(*args):
  """
    local_rigid_fitting_around_points(Particle p, Refiner refiner, FloatKey wei_key, DensityMap dmap, IMP::algebra::Vector3Ds const & anchor_centroids, 
        IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10, IMP::Int number_of_cg_steps=100, 
        IMP::Float max_translation=2., IMP::Float max_rotation=.3) -> FittingSolutions
    local_rigid_fitting_around_points(Particle p, Refiner refiner, FloatKey wei_key, DensityMap dmap, IMP::algebra::Vector3Ds const & anchor_centroids, 
        IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10, IMP::Int number_of_cg_steps=100, 
        IMP::Float max_translation=2.) -> FittingSolutions
    local_rigid_fitting_around_points(Particle p, Refiner refiner, FloatKey wei_key, DensityMap dmap, IMP::algebra::Vector3Ds const & anchor_centroids, 
        IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10, IMP::Int number_of_cg_steps=100) -> FittingSolutions
    local_rigid_fitting_around_points(Particle p, Refiner refiner, FloatKey wei_key, DensityMap dmap, IMP::algebra::Vector3Ds const & anchor_centroids, 
        IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5, IMP::Int number_of_mc_steps=10) -> FittingSolutions
    local_rigid_fitting_around_points(Particle p, Refiner refiner, FloatKey wei_key, DensityMap dmap, IMP::algebra::Vector3Ds const & anchor_centroids, 
        IMP::kernel::OptimizerStates display_log, 
        IMP::Int number_of_optimization_runs=5) -> FittingSolutions
    local_rigid_fitting_around_points(Particle p, Refiner refiner, FloatKey wei_key, DensityMap dmap, IMP::algebra::Vector3Ds const & anchor_centroids, 
        IMP::kernel::OptimizerStates display_log) -> FittingSolutions
    """
  return _IMP_em.local_rigid_fitting_around_points(*args)

def local_rigid_fitting_grid_search(*args):
  """
    local_rigid_fitting_grid_search(IMP::kernel::ParticlesTemp const & ps, FloatKey wei_key, DensityMap dmap, IMP::Int max_voxels_translation=2, 
        IMP::Int translation_step=1, IMP::Float max_angle_in_radians=0.174, 
        IMP::Int number_of_rotations=100) -> FittingSolutions
    local_rigid_fitting_grid_search(IMP::kernel::ParticlesTemp const & ps, FloatKey wei_key, DensityMap dmap, IMP::Int max_voxels_translation=2, 
        IMP::Int translation_step=1, IMP::Float max_angle_in_radians=0.174) -> FittingSolutions
    local_rigid_fitting_grid_search(IMP::kernel::ParticlesTemp const & ps, FloatKey wei_key, DensityMap dmap, IMP::Int max_voxels_translation=2, 
        IMP::Int translation_step=1) -> FittingSolutions
    local_rigid_fitting_grid_search(IMP::kernel::ParticlesTemp const & ps, FloatKey wei_key, DensityMap dmap, IMP::Int max_voxels_translation=2) -> FittingSolutions
    local_rigid_fitting_grid_search(IMP::kernel::ParticlesTemp const & ps, FloatKey wei_key, DensityMap dmap) -> FittingSolutions
    """
  return _IMP_em.local_rigid_fitting_grid_search(*args)

def compute_fitting_scores(*args):
  """
    compute_fitting_scores(IMP::kernel::ParticlesTemp const & ps, DensityMap em_map, IMP::algebra::Transformation3Ds const & transformations, 
        bool fast_version=False, bool local_score=False, 
        FloatKey wei_key=IMP::atom::Mass::get_mass_key()) -> FittingSolutions
    compute_fitting_scores(IMP::kernel::ParticlesTemp const & ps, DensityMap em_map, IMP::algebra::Transformation3Ds const & transformations, 
        bool fast_version=False, bool local_score=False) -> FittingSolutions
    compute_fitting_scores(IMP::kernel::ParticlesTemp const & ps, DensityMap em_map, IMP::algebra::Transformation3Ds const & transformations, 
        bool fast_version=False) -> FittingSolutions
    compute_fitting_scores(IMP::kernel::ParticlesTemp const & ps, DensityMap em_map, IMP::algebra::Transformation3Ds const & transformations) -> FittingSolutions
    compute_fitting_scores(DensityMap em_map, RigidBody rb, Refiner refiner, IMP::algebra::Transformation3Ds const & transformations) -> FittingSolutions
    """
  return _IMP_em.compute_fitting_scores(*args)

def compute_fitting_score(*args):
  """
    compute_fitting_score(IMP::kernel::ParticlesTemp const & ps, DensityMap em_map, FloatKey wei_key=IMP::atom::Mass::get_mass_key()) -> IMP::Float
    compute_fitting_score(IMP::kernel::ParticlesTemp const & ps, DensityMap em_map) -> IMP::Float
    """
  return _IMP_em.compute_fitting_score(*args)

def get_number_of_particles_outside_of_the_density(*args):
  """
    get_number_of_particles_outside_of_the_density(DensityMap dmap, IMP::kernel::Particles const & ps, Transformation3D t=IMP::algebra::get_identity_transformation_3d(), 
        float thr=0.0) -> long
    get_number_of_particles_outside_of_the_density(DensityMap dmap, IMP::kernel::Particles const & ps, Transformation3D t=IMP::algebra::get_identity_transformation_3d()) -> long
    get_number_of_particles_outside_of_the_density(DensityMap dmap, IMP::kernel::Particles const & ps) -> long
    """
  return _IMP_em.get_number_of_particles_outside_of_the_density(*args)

def get_numbers_of_particles_outside_of_the_density(*args):
  """
    get_numbers_of_particles_outside_of_the_density(DensityMap dmap, IMP::kernel::Particles const & ps, IMP::algebra::Transformation3Ds const & transformations, 
        float thr=0.0) -> IMP::Ints
    get_numbers_of_particles_outside_of_the_density(DensityMap dmap, IMP::kernel::Particles const & ps, IMP::algebra::Transformation3Ds const & transformations) -> IMP::Ints
    """
  return _IMP_em.get_numbers_of_particles_outside_of_the_density(*args)

def get_percentage_of_voxels_covered_by_particles(*args):
  """
    get_percentage_of_voxels_covered_by_particles(DensityMap dmap, IMP::kernel::Particles const & ps, float smoothing_radius=3., Transformation3D t=IMP::algebra::get_identity_transformation_3d(), 
        float thr=0.0) -> double
    get_percentage_of_voxels_covered_by_particles(DensityMap dmap, IMP::kernel::Particles const & ps, float smoothing_radius=3., Transformation3D t=IMP::algebra::get_identity_transformation_3d()) -> double
    get_percentage_of_voxels_covered_by_particles(DensityMap dmap, IMP::kernel::Particles const & ps, float smoothing_radius=3.) -> double
    get_percentage_of_voxels_covered_by_particles(DensityMap dmap, IMP::kernel::Particles const & ps) -> double
    """
  return _IMP_em.get_percentage_of_voxels_covered_by_particles(*args)
class HighDensityEmbedding(IMP.statistics.Embedding):
    """Proxy of C++ IMP::em::HighDensityEmbedding class"""
    __swig_setmethods__ = {}
    for _s in [IMP.statistics.Embedding]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HighDensityEmbedding, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.statistics.Embedding]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HighDensityEmbedding, name)
    def __init__(self, *args): 
        """__init__(IMP::em::HighDensityEmbedding self, DensityMap dm, double threshold) -> HighDensityEmbedding"""
        this = _IMP_em.new_HighDensityEmbedding(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(HighDensityEmbedding self) -> VersionInfo"""
        return _IMP_em.HighDensityEmbedding_get_version_info(self)

    def __str__(self):
        """__str__(HighDensityEmbedding self) -> std::string"""
        return _IMP_em.HighDensityEmbedding___str__(self)

    def __repr__(self):
        """__repr__(HighDensityEmbedding self) -> std::string"""
        return _IMP_em.HighDensityEmbedding___repr__(self)

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

HighDensityEmbedding_swigregister = _IMP_em.HighDensityEmbedding_swigregister
HighDensityEmbedding_swigregister(HighDensityEmbedding)


def mask_and_norm(*args):
  """mask_and_norm(DensityMap dmap, DensityMap mask) -> DensityMap"""
  return _IMP_em.mask_and_norm(*args)

def get_volume_at_threshold(*args):
  """get_volume_at_threshold(DensityMap m, IMP::Float threshold) -> IMP::Float"""
  return _IMP_em.get_volume_at_threshold(*args)

def get_molecular_mass_at_threshold(*args):
  """
    get_molecular_mass_at_threshold(DensityMap m, IMP::Float threshold, IMP::atom::ProteinDensityReference ref=HARPAZ) -> IMP::Float
    get_molecular_mass_at_threshold(DensityMap m, IMP::Float threshold) -> IMP::Float
    """
  return _IMP_em.get_molecular_mass_at_threshold(*args)

def get_threshold_for_approximate_volume(*args):
  """get_threshold_for_approximate_volume(DensityMap m, IMP::Float desired_volume) -> IMP::Float"""
  return _IMP_em.get_threshold_for_approximate_volume(*args)

def get_threshold_for_approximate_mass(*args):
  """
    get_threshold_for_approximate_mass(DensityMap m, IMP::Float desired_mass, IMP::atom::ProteinDensityReference ref=HARPAZ) -> IMP::Float
    get_threshold_for_approximate_mass(DensityMap m, IMP::Float desired_mass) -> IMP::Float
    """
  return _IMP_em.get_threshold_for_approximate_mass(*args)
class EnvelopePenetrationRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em::EnvelopePenetrationRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnvelopePenetrationRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EnvelopePenetrationRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::em::EnvelopePenetrationRestraint self, IMP::kernel::Particles ps, DensityMap em_map, IMP::Float threshold) -> EnvelopePenetrationRestraint"""
        this = _IMP_em.new_EnvelopePenetrationRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(EnvelopePenetrationRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em.EnvelopePenetrationRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(EnvelopePenetrationRestraint self) -> VersionInfo"""
        return _IMP_em.EnvelopePenetrationRestraint_get_version_info(self)

    def __str__(self):
        """__str__(EnvelopePenetrationRestraint self) -> std::string"""
        return _IMP_em.EnvelopePenetrationRestraint___str__(self)

    def __repr__(self):
        """__repr__(EnvelopePenetrationRestraint self) -> std::string"""
        return _IMP_em.EnvelopePenetrationRestraint___repr__(self)

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

EnvelopePenetrationRestraint_swigregister = _IMP_em.EnvelopePenetrationRestraint_swigregister
EnvelopePenetrationRestraint_swigregister(EnvelopePenetrationRestraint)

class PCAFitRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em::PCAFitRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PCAFitRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PCAFitRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::em::PCAFitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map, float threahold, float max_pca_size_diff, 
            float max_angle_diff, float max_centroid_diff, FloatKey weight_key=IMP::atom::Mass::get_mass_key()) -> PCAFitRestraint
        __init__(IMP::em::PCAFitRestraint self, IMP::kernel::ParticlesTemp ps, DensityMap em_map, float threahold, float max_pca_size_diff, 
            float max_angle_diff, float max_centroid_diff) -> PCAFitRestraint
        """
        this = _IMP_em.new_PCAFitRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(PCAFitRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em.PCAFitRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(PCAFitRestraint self) -> VersionInfo"""
        return _IMP_em.PCAFitRestraint_get_version_info(self)

    def __str__(self):
        """__str__(PCAFitRestraint self) -> std::string"""
        return _IMP_em.PCAFitRestraint___str__(self)

    def __repr__(self):
        """__repr__(PCAFitRestraint self) -> std::string"""
        return _IMP_em.PCAFitRestraint___repr__(self)

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

PCAFitRestraint_swigregister = _IMP_em.PCAFitRestraint_swigregister
PCAFitRestraint_swigregister(PCAFitRestraint)

class EnvelopeFitRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::em::EnvelopeFitRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EnvelopeFitRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EnvelopeFitRestraint, name)
    def __init__(self, *args): 
        """__init__(IMP::em::EnvelopeFitRestraint self, IMP::kernel::Particles particles, DensityMap em_map, double density_threshold, double penetration_threshold) -> EnvelopeFitRestraint"""
        this = _IMP_em.new_EnvelopeFitRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_transformation(self):
        """get_transformation(EnvelopeFitRestraint self) -> Transformation3D"""
        return _IMP_em.EnvelopeFitRestraint_get_transformation(self)

    def apply_transformation(self):
        """apply_transformation(EnvelopeFitRestraint self)"""
        return _IMP_em.EnvelopeFitRestraint_apply_transformation(self)

    def do_get_inputs(self):
        """do_get_inputs(EnvelopeFitRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_em.EnvelopeFitRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(EnvelopeFitRestraint self) -> VersionInfo"""
        return _IMP_em.EnvelopeFitRestraint_get_version_info(self)

    def __str__(self):
        """__str__(EnvelopeFitRestraint self) -> std::string"""
        return _IMP_em.EnvelopeFitRestraint___str__(self)

    def __repr__(self):
        """__repr__(EnvelopeFitRestraint self) -> std::string"""
        return _IMP_em.EnvelopeFitRestraint___repr__(self)

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

EnvelopeFitRestraint_swigregister = _IMP_em.EnvelopeFitRestraint_swigregister
EnvelopeFitRestraint_swigregister(EnvelopeFitRestraint)

import math

def write_pca_cmm(pca, fh):
    """Write out principal components to a file in Chimera Marker format"""
    eigen_values = pca.get_principal_values()
    eigen_vecs = pca.get_principal_components()
    centroid = pca.get_centroid()

    print >> fh, "<marker_set>"
    print >> fh, "<!-- PCA with eigen values: (%g,%g,%g) and " \
                 "centroid (%g,%g,%g) -->" \
          % (math.sqrt(eigen_values[0]),
             math.sqrt(eigen_values[1]),
             math.sqrt(eigen_values[2]),
             centroid[0], centroid[1], centroid[2])

    radius = 2.

    for i in range(3):
        val = math.sqrt(eigen_values[i])
        v1 = centroid - val * eigen_vecs[i]
        v2 = centroid + val * eigen_vecs[i]
        for markerid, v in ((i*2+1, v1), (i*2+2, v2)):
            print >> fh, "<marker id=\"%d\" x=\"%g\" y=\"%g\" z=\"%g\" " \
                         "radius=\"%g\"/>" \
                  % (markerid, v[0], v[1], v[2], radius)

    for i in range(1, 7, 2):
        print >> fh, "<link id1= \"%d\" id2=\"%d\" radius=\"%g\"/>" \
              % (i, i+1, radius)
    print >> fh, "</marker_set>"


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

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

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_em.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.