em/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.2
#
# 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


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


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


class IMP_EM_SwigPyIterator(object):
    """Proxy of C++ swig::IMP_EM_SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_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]
        # Do in two steps so the references are kept until the end of the
        # function (deleting references may trigger a fresh call to this method)
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

class _ostream(object):
    """Proxy of C++ std::ostream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(IMP::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
    nxstart = _swig_property(_IMP_em.DensityHeader_nxstart_get, _IMP_em.DensityHeader_nxstart_set)
    nystart = _swig_property(_IMP_em.DensityHeader_nystart_get, _IMP_em.DensityHeader_nystart_set)
    nzstart = _swig_property(_IMP_em.DensityHeader_nzstart_get, _IMP_em.DensityHeader_nzstart_set)
    mx = _swig_property(_IMP_em.DensityHeader_mx_get, _IMP_em.DensityHeader_mx_set)
    my = _swig_property(_IMP_em.DensityHeader_my_get, _IMP_em.DensityHeader_my_set)
    mz = _swig_property(_IMP_em.DensityHeader_mz_get, _IMP_em.DensityHeader_mz_set)
    xlen = _swig_property(_IMP_em.DensityHeader_xlen_get, _IMP_em.DensityHeader_xlen_set)
    ylen = _swig_property(_IMP_em.DensityHeader_ylen_get, _IMP_em.DensityHeader_ylen_set)
    zlen = _swig_property(_IMP_em.DensityHeader_zlen_get, _IMP_em.DensityHeader_zlen_set)
    alpha = _swig_property(_IMP_em.DensityHeader_alpha_get, _IMP_em.DensityHeader_alpha_set)
    beta = _swig_property(_IMP_em.DensityHeader_beta_get, _IMP_em.DensityHeader_beta_set)
    gamma = _swig_property(_IMP_em.DensityHeader_gamma_get, _IMP_em.DensityHeader_gamma_set)
    mapc = _swig_property(_IMP_em.DensityHeader_mapc_get, _IMP_em.DensityHeader_mapc_set)
    mapr = _swig_property(_IMP_em.DensityHeader_mapr_get, _IMP_em.DensityHeader_mapr_set)
    maps = _swig_property(_IMP_em.DensityHeader_maps_get, _IMP_em.DensityHeader_maps_set)
    dmin = _swig_property(_IMP_em.DensityHeader_dmin_get, _IMP_em.DensityHeader_dmin_set)
    dmax = _swig_property(_IMP_em.DensityHeader_dmax_get, _IMP_em.DensityHeader_dmax_set)
    dmean = _swig_property(_IMP_em.DensityHeader_dmean_get, _IMP_em.DensityHeader_dmean_set)
    ispg = _swig_property(_IMP_em.DensityHeader_ispg_get, _IMP_em.DensityHeader_ispg_set)
    nsymbt = _swig_property(_IMP_em.DensityHeader_nsymbt_get, _IMP_em.DensityHeader_nsymbt_set)
    user = _swig_property(_IMP_em.DensityHeader_user_get, _IMP_em.DensityHeader_user_set)
    map = _swig_property(_IMP_em.DensityHeader_map_get, _IMP_em.DensityHeader_map_set)
    machinestamp = _swig_property(_IMP_em.DensityHeader_machinestamp_get, _IMP_em.DensityHeader_machinestamp_set)
    rms = _swig_property(_IMP_em.DensityHeader_rms_get, _IMP_em.DensityHeader_rms_set)
    nlabl = _swig_property(_IMP_em.DensityHeader_nlabl_get, _IMP_em.DensityHeader_nlabl_set)
    comments = _swig_property(_IMP_em.DensityHeader_comments_get, _IMP_em.DensityHeader_comments_set)
    magic = _swig_property(_IMP_em.DensityHeader_magic_get, _IMP_em.DensityHeader_magic_set)
    voltage = _swig_property(_IMP_em.DensityHeader_voltage_get, _IMP_em.DensityHeader_voltage_set)
    Cs = _swig_property(_IMP_em.DensityHeader_Cs_get, _IMP_em.DensityHeader_Cs_set)
    Aperture = _swig_property(_IMP_em.DensityHeader_Aperture_get, _IMP_em.DensityHeader_Aperture_set)
    Magnification = _swig_property(_IMP_em.DensityHeader_Magnification_get, _IMP_em.DensityHeader_Magnification_set)
    Postmagnification = _swig_property(_IMP_em.DensityHeader_Postmagnification_get, _IMP_em.DensityHeader_Postmagnification_set)
    Exposuretime = _swig_property(_IMP_em.DensityHeader_Exposuretime_get, _IMP_em.DensityHeader_Exposuretime_set)
    Microscope = _swig_property(_IMP_em.DensityHeader_Microscope_get, _IMP_em.DensityHeader_Microscope_set)
    Pixelsize = _swig_property(_IMP_em.DensityHeader_Pixelsize_get, _IMP_em.DensityHeader_Pixelsize_set)
    CCDArea = _swig_property(_IMP_em.DensityHeader_CCDArea_get, _IMP_em.DensityHeader_CCDArea_set)
    Defocus = _swig_property(_IMP_em.DensityHeader_Defocus_get, _IMP_em.DensityHeader_Defocus_set)
    Astigmatism = _swig_property(_IMP_em.DensityHeader_Astigmatism_get, _IMP_em.DensityHeader_Astigmatism_set)
    AstigmatismAngle = _swig_property(_IMP_em.DensityHeader_AstigmatismAngle_get, _IMP_em.DensityHeader_AstigmatismAngle_set)
    FocusIncrement = _swig_property(_IMP_em.DensityHeader_FocusIncrement_get, _IMP_em.DensityHeader_FocusIncrement_set)
    CountsPerElectron = _swig_property(_IMP_em.DensityHeader_CountsPerElectron_get, _IMP_em.DensityHeader_CountsPerElectron_set)
    Intensity = _swig_property(_IMP_em.DensityHeader_Intensity_get, _IMP_em.DensityHeader_Intensity_set)
    EnergySlitwidth = _swig_property(_IMP_em.DensityHeader_EnergySlitwidth_get, _IMP_em.DensityHeader_EnergySlitwidth_set)
    EnergyOffset = _swig_property(_IMP_em.DensityHeader_EnergyOffset_get, _IMP_em.DensityHeader_EnergyOffset_set)
    Tiltangle = _swig_property(_IMP_em.DensityHeader_Tiltangle_get, _IMP_em.DensityHeader_Tiltangle_set)
    Tiltaxis = _swig_property(_IMP_em.DensityHeader_Tiltaxis_get, _IMP_em.DensityHeader_Tiltaxis_set)
    MarkerX = _swig_property(_IMP_em.DensityHeader_MarkerX_get, _IMP_em.DensityHeader_MarkerX_set)
    MarkerY = _swig_property(_IMP_em.DensityHeader_MarkerY_get, _IMP_em.DensityHeader_MarkerY_set)
    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)

    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    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)

    calc_score = staticmethod(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)

    cross_correlation_coefficient = staticmethod(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)

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

    convolution = staticmethod(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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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)

    cast = staticmethod(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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    fNslice = _swig_property(_IMP_em.SpiderHeader_fNslice_get, _IMP_em.SpiderHeader_fNslice_set)
    fNrow = _swig_property(_IMP_em.SpiderHeader_fNrow_get, _IMP_em.SpiderHeader_fNrow_set)
    fNrec = _swig_property(_IMP_em.SpiderHeader_fNrec_get, _IMP_em.SpiderHeader_fNrec_set)
    fNlabel = _swig_property(_IMP_em.SpiderHeader_fNlabel_get, _IMP_em.SpiderHeader_fNlabel_set)
    fIform = _swig_property(_IMP_em.SpiderHeader_fIform_get, _IMP_em.SpiderHeader_fIform_set)
    fImami = _swig_property(_IMP_em.SpiderHeader_fImami_get, _IMP_em.SpiderHeader_fImami_set)
    fFmax = _swig_property(_IMP_em.SpiderHeader_fFmax_get, _IMP_em.SpiderHeader_fFmax_set)
    fFmin = _swig_property(_IMP_em.SpiderHeader_fFmin_get, _IMP_em.SpiderHeader_fFmin_set)
    fAv = _swig_property(_IMP_em.SpiderHeader_fAv_get, _IMP_em.SpiderHeader_fAv_set)
    fSig = _swig_property(_IMP_em.SpiderHeader_fSig_get, _IMP_em.SpiderHeader_fSig_set)
    fIhist = _swig_property(_IMP_em.SpiderHeader_fIhist_get, _IMP_em.SpiderHeader_fIhist_set)
    fNcol = _swig_property(_IMP_em.SpiderHeader_fNcol_get, _IMP_em.SpiderHeader_fNcol_set)
    fLabrec = _swig_property(_IMP_em.SpiderHeader_fLabrec_get, _IMP_em.SpiderHeader_fLabrec_set)
    fIangle = _swig_property(_IMP_em.SpiderHeader_fIangle_get, _IMP_em.SpiderHeader_fIangle_set)
    fPhi = _swig_property(_IMP_em.SpiderHeader_fPhi_get, _IMP_em.SpiderHeader_fPhi_set)
    fTheta = _swig_property(_IMP_em.SpiderHeader_fTheta_get, _IMP_em.SpiderHeader_fTheta_set)
    fPsi = _swig_property(_IMP_em.SpiderHeader_fPsi_get, _IMP_em.SpiderHeader_fPsi_set)
    fXoff = _swig_property(_IMP_em.SpiderHeader_fXoff_get, _IMP_em.SpiderHeader_fXoff_set)
    fYoff = _swig_property(_IMP_em.SpiderHeader_fYoff_get, _IMP_em.SpiderHeader_fYoff_set)
    fZoff = _swig_property(_IMP_em.SpiderHeader_fZoff_get, _IMP_em.SpiderHeader_fZoff_set)
    fScale = _swig_property(_IMP_em.SpiderHeader_fScale_get, _IMP_em.SpiderHeader_fScale_set)
    fLabbyt = _swig_property(_IMP_em.SpiderHeader_fLabbyt_get, _IMP_em.SpiderHeader_fLabbyt_set)
    fLenbyt = _swig_property(_IMP_em.SpiderHeader_fLenbyt_get, _IMP_em.SpiderHeader_fLenbyt_set)
    fNothing = _swig_property(_IMP_em.SpiderHeader_fNothing_get, _IMP_em.SpiderHeader_fNothing_set)
    fFlag = _swig_property(_IMP_em.SpiderHeader_fFlag_get, _IMP_em.SpiderHeader_fFlag_set)
    fPhi1 = _swig_property(_IMP_em.SpiderHeader_fPhi1_get, _IMP_em.SpiderHeader_fPhi1_set)
    fTheta1 = _swig_property(_IMP_em.SpiderHeader_fTheta1_get, _IMP_em.SpiderHeader_fTheta1_set)
    fPsi1 = _swig_property(_IMP_em.SpiderHeader_fPsi1_get, _IMP_em.SpiderHeader_fPsi1_set)
    fPhi2 = _swig_property(_IMP_em.SpiderHeader_fPhi2_get, _IMP_em.SpiderHeader_fPhi2_set)
    fTheta2 = _swig_property(_IMP_em.SpiderHeader_fTheta2_get, _IMP_em.SpiderHeader_fTheta2_set)
    fPsi2 = _swig_property(_IMP_em.SpiderHeader_fPsi2_get, _IMP_em.SpiderHeader_fPsi2_set)
    fGeo_matrix = _swig_property(_IMP_em.SpiderHeader_fGeo_matrix_get, _IMP_em.SpiderHeader_fGeo_matrix_set)
    fAngle1 = _swig_property(_IMP_em.SpiderHeader_fAngle1_get, _IMP_em.SpiderHeader_fAngle1_set)
    fr1 = _swig_property(_IMP_em.SpiderHeader_fr1_get, _IMP_em.SpiderHeader_fr1_set)
    fr2 = _swig_property(_IMP_em.SpiderHeader_fr2_get, _IMP_em.SpiderHeader_fr2_set)
    RTflag = _swig_property(_IMP_em.SpiderHeader_RTflag_get, _IMP_em.SpiderHeader_RTflag_set)
    Astart = _swig_property(_IMP_em.SpiderHeader_Astart_get, _IMP_em.SpiderHeader_Astart_set)
    Aend = _swig_property(_IMP_em.SpiderHeader_Aend_get, _IMP_em.SpiderHeader_Aend_set)
    Ainc = _swig_property(_IMP_em.SpiderHeader_Ainc_get, _IMP_em.SpiderHeader_Ainc_set)
    Rsigma = _swig_property(_IMP_em.SpiderHeader_Rsigma_get, _IMP_em.SpiderHeader_Rsigma_set)
    Tstart = _swig_property(_IMP_em.SpiderHeader_Tstart_get, _IMP_em.SpiderHeader_Tstart_set)
    Tend = _swig_property(_IMP_em.SpiderHeader_Tend_get, _IMP_em.SpiderHeader_Tend_set)
    Tinc = _swig_property(_IMP_em.SpiderHeader_Tinc_get, _IMP_em.SpiderHeader_Tinc_set)
    Weight = _swig_property(_IMP_em.SpiderHeader_Weight_get, _IMP_em.SpiderHeader_Weight_set)
    Flip = _swig_property(_IMP_em.SpiderHeader_Flip_get, _IMP_em.SpiderHeader_Flip_set)
    empty = _swig_property(_IMP_em.SpiderHeader_empty_get, _IMP_em.SpiderHeader_empty_set)
    szIDat = _swig_property(_IMP_em.SpiderHeader_szIDat_get, _IMP_em.SpiderHeader_szIDat_set)
    szITim = _swig_property(_IMP_em.SpiderHeader_szITim_get, _IMP_em.SpiderHeader_szITim_set)
    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    filename_ = _swig_property(_IMP_em.SpiderMapReaderWriter_filename__get, _IMP_em.SpiderMapReaderWriter_filename__set)
    skip_type_check_ = _swig_property(_IMP_em.SpiderMapReaderWriter_skip_type_check__get, _IMP_em.SpiderMapReaderWriter_skip_type_check__set)
    force_reversed_ = _swig_property(_IMP_em.SpiderMapReaderWriter_force_reversed__get, _IMP_em.SpiderMapReaderWriter_force_reversed__set)
    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """
        __init__(IMP::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"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args): 
        """__init__(IMP::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()

    fh.write("<marker_set>\n")
    fh.write("<!-- PCA with eigen values: (%g,%g,%g) and "
                 "centroid (%g,%g,%g) -->\n"
          % (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)):
            fh.write("<marker id=\"%d\" x=\"%g\" y=\"%g\" z=\"%g\" "
                         "radius=\"%g\"/>\n"
                  % (markerid, v[0], v[1], v[2], radius))

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


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)
from . import _version_check
_version_check.check_version(get_module_version())