11 from __future__
import print_function, division, absolute_import
15 from sys
import version_info
as _swig_python_version_info
19 import builtins
as __builtin__
25 strthis =
"proxy of " + self.this.__repr__()
26 except __builtin__.Exception:
28 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
31 def _swig_setattr_nondynamic_instance_variable(set):
32 def set_instance_attr(self, name, value):
34 set(self, name, value)
35 elif name ==
"thisown":
37 elif hasattr(self, name)
and isinstance(getattr(type(self), name), property):
38 set(self, name, value)
40 raise AttributeError(
"You cannot add instance attributes to %s" % self)
41 return set_instance_attr
44 def _swig_setattr_nondynamic_class_variable(set):
45 def set_class_attr(cls, name, value):
46 if hasattr(cls, name)
and not isinstance(getattr(cls, name), property):
49 raise AttributeError(
"You cannot add class attributes to %s" % cls)
53 def _swig_add_metaclass(metaclass):
54 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
56 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
60 class _SwigNonDynamicMeta(type):
61 """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
62 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
67 class IMP_EM2D_SwigPyIterator(object):
68 r"""Proxy of C++ swig::IMP_EM2D_SwigPyIterator class."""
70 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
72 def __init__(self, *args, **kwargs):
73 raise AttributeError(
"No constructor defined - class is abstract")
75 __swig_destroy__ = _IMP_em2d.delete_IMP_EM2D_SwigPyIterator
78 r"""value(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
79 return _IMP_em2d.IMP_EM2D_SwigPyIterator_value(self)
82 r"""incr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator"""
83 return _IMP_em2d.IMP_EM2D_SwigPyIterator_incr(self, n)
86 r"""decr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator"""
87 return _IMP_em2d.IMP_EM2D_SwigPyIterator_decr(self, n)
89 def distance(self, x):
90 r"""distance(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t"""
91 return _IMP_em2d.IMP_EM2D_SwigPyIterator_distance(self, x)
94 r"""equal(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
95 return _IMP_em2d.IMP_EM2D_SwigPyIterator_equal(self, x)
98 r"""copy(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator"""
99 return _IMP_em2d.IMP_EM2D_SwigPyIterator_copy(self)
102 r"""next(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
103 return _IMP_em2d.IMP_EM2D_SwigPyIterator_next(self)
106 r"""__next__(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
107 return _IMP_em2d.IMP_EM2D_SwigPyIterator___next__(self)
110 r"""previous(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
111 return _IMP_em2d.IMP_EM2D_SwigPyIterator_previous(self)
113 def advance(self, n):
114 r"""advance(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
115 return _IMP_em2d.IMP_EM2D_SwigPyIterator_advance(self, n)
118 r"""__eq__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
119 return _IMP_em2d.IMP_EM2D_SwigPyIterator___eq__(self, x)
122 r"""__ne__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
123 return _IMP_em2d.IMP_EM2D_SwigPyIterator___ne__(self, x)
125 def __iadd__(self, n):
126 r"""__iadd__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
127 return _IMP_em2d.IMP_EM2D_SwigPyIterator___iadd__(self, n)
129 def __isub__(self, n):
130 r"""__isub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
131 return _IMP_em2d.IMP_EM2D_SwigPyIterator___isub__(self, n)
133 def __add__(self, n):
134 r"""__add__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
135 return _IMP_em2d.IMP_EM2D_SwigPyIterator___add__(self, n)
137 def __sub__(self, *args):
139 __sub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator
140 __sub__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t
142 return _IMP_em2d.IMP_EM2D_SwigPyIterator___sub__(self, *args)
147 _IMP_em2d.IMP_EM2D_SwigPyIterator_swigregister(IMP_EM2D_SwigPyIterator)
154 IMP_DEBUG = _IMP_em2d.IMP_DEBUG
156 IMP_RELEASE = _IMP_em2d.IMP_RELEASE
158 IMP_SILENT = _IMP_em2d.IMP_SILENT
160 IMP_PROGRESS = _IMP_em2d.IMP_PROGRESS
162 IMP_TERSE = _IMP_em2d.IMP_TERSE
164 IMP_VERBOSE = _IMP_em2d.IMP_VERBOSE
166 IMP_MEMORY = _IMP_em2d.IMP_MEMORY
168 IMP_NONE = _IMP_em2d.IMP_NONE
170 IMP_USAGE = _IMP_em2d.IMP_USAGE
172 IMP_INTERNAL = _IMP_em2d.IMP_INTERNAL
174 IMP_KERNEL_HAS_LOG4CXX = _IMP_em2d.IMP_KERNEL_HAS_LOG4CXX
176 IMP_COMPILER_HAS_CEREAL_RAW_POINTER = _IMP_em2d.IMP_COMPILER_HAS_CEREAL_RAW_POINTER
178 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_em2d.IMP_COMPILER_HAS_DEBUG_VECTOR
180 IMP_COMPILER_HAS_RANDOM_SHUFFLE = _IMP_em2d.IMP_COMPILER_HAS_RANDOM_SHUFFLE
182 IMP_COMPILER_HAS_THREE_WAY = _IMP_em2d.IMP_COMPILER_HAS_THREE_WAY
184 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_KERNEL_HAS_BOOST_RANDOM
186 IMP_KERNEL_HAS_NUMPY = _IMP_em2d.IMP_KERNEL_HAS_NUMPY
188 IMP_KERNEL_HAS_GPERFTOOLS = _IMP_em2d.IMP_KERNEL_HAS_GPERFTOOLS
190 IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER = _IMP_em2d.IMP_KERNEL_HAS_TCMALLOC_HEAPCHECKER
192 IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER = _IMP_em2d.IMP_KERNEL_HAS_TCMALLOC_HEAPPROFILER
194 IMPKERNEL_SHOW_WARNINGS = _IMP_em2d.IMPKERNEL_SHOW_WARNINGS
198 class _DirectorObjects(object):
199 """@internal Simple class to keep references to director objects
200 to prevent premature deletion."""
203 def register(self, obj):
204 """Take a reference to a director object; will only work for
205 refcounted C++ classes"""
206 if hasattr(obj,
'get_ref_count'):
207 self._objects.append(obj)
209 """Only drop our reference and allow cleanup by Python if no other
210 Python references exist (we hold 3 references: one in self._objects,
211 one in x, and one in the argument list for getrefcount) *and* no
212 other C++ references exist (the Python object always holds one)"""
213 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
214 or x.get_ref_count() > 1]
218 def get_object_count(self):
219 """Get number of director objects (useful for testing only)"""
220 return len(self._objects)
221 _director_objects = _DirectorObjects()
223 class _ostream(object):
224 r"""Proxy of C++ std::ostream class."""
226 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
228 def __init__(self, *args, **kwargs):
229 raise AttributeError(
"No constructor defined")
230 __repr__ = _swig_repr
232 def write(self, osa_buf):
233 r"""write(_ostream self, char const * osa_buf)"""
234 return _IMP_em2d._ostream_write(self, osa_buf)
237 _IMP_em2d._ostream_swigregister(_ostream)
238 IMP_C_OPEN_BINARY = _IMP_em2d.IMP_C_OPEN_BINARY
241 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_FILESYSTEM
243 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
245 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CGAL_HAS_BOOST_RANDOM
247 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_SYSTEM
249 IMP_CGAL_HAS_NUMPY = _IMP_em2d.IMP_CGAL_HAS_NUMPY
251 IMPCGAL_SHOW_WARNINGS = _IMP_em2d.IMPCGAL_SHOW_WARNINGS
254 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_IMP_CGAL
256 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
258 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
260 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_RANDOM
262 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_SYSTEM
264 IMP_ALGEBRA_HAS_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_CGAL
266 IMP_ALGEBRA_HAS_NUMPY = _IMP_em2d.IMP_ALGEBRA_HAS_NUMPY
268 IMP_ALGEBRA_HAS_ANN = _IMP_em2d.IMP_ALGEBRA_HAS_ANN
270 IMPALGEBRA_SHOW_WARNINGS = _IMP_em2d.IMPALGEBRA_SHOW_WARNINGS
273 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_IMP_CGAL
275 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
277 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
279 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_RANDOM
281 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_SYSTEM
283 IMP_DISPLAY_HAS_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_CGAL
285 IMP_DISPLAY_HAS_NUMPY = _IMP_em2d.IMP_DISPLAY_HAS_NUMPY
287 IMPDISPLAY_SHOW_WARNINGS = _IMP_em2d.IMPDISPLAY_SHOW_WARNINGS
290 IMP_GSL_HAS_IMP_CGAL = _IMP_em2d.IMP_GSL_HAS_IMP_CGAL
292 IMP_GSL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_FILESYSTEM
294 IMP_GSL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_GSL_HAS_BOOST_PROGRAMOPTIONS
296 IMP_GSL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_GSL_HAS_BOOST_RANDOM
298 IMP_GSL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_SYSTEM
300 IMP_GSL_HAS_CGAL = _IMP_em2d.IMP_GSL_HAS_CGAL
302 IMP_GSL_HAS_NUMPY = _IMP_em2d.IMP_GSL_HAS_NUMPY
304 IMPGSL_SHOW_WARNINGS = _IMP_em2d.IMPGSL_SHOW_WARNINGS
307 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
309 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
311 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
313 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
315 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
317 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_CGAL
319 IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_HDF5
321 IMP_SCORE_FUNCTOR_HAS_NUMPY = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_NUMPY
323 IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_em2d.IMPSCOREFUNCTOR_SHOW_WARNINGS
326 IMP_STATISTICS_HAS_IMP_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_IMP_CGAL
328 IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
330 IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
332 IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_RANDOM
334 IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_SYSTEM
336 IMP_STATISTICS_HAS_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_CGAL
338 IMP_STATISTICS_HAS_NUMPY = _IMP_em2d.IMP_STATISTICS_HAS_NUMPY
340 IMPSTATISTICS_SHOW_WARNINGS = _IMP_em2d.IMPSTATISTICS_SHOW_WARNINGS
343 IMP_CORE_HAS_IMP_CGAL = _IMP_em2d.IMP_CORE_HAS_IMP_CGAL
345 IMP_CORE_HAS_IMP_KERNEL = _IMP_em2d.IMP_CORE_HAS_IMP_KERNEL
347 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_FILESYSTEM
349 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
351 IMP_CORE_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CORE_HAS_BOOST_RANDOM
353 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_SYSTEM
355 IMP_CORE_HAS_CGAL = _IMP_em2d.IMP_CORE_HAS_CGAL
357 IMP_CORE_HAS_HDF5 = _IMP_em2d.IMP_CORE_HAS_HDF5
359 IMP_CORE_HAS_NUMPY = _IMP_em2d.IMP_CORE_HAS_NUMPY
361 IMPCORE_SHOW_WARNINGS = _IMP_em2d.IMPCORE_SHOW_WARNINGS
364 IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_em2d.IMP_CONTAINER_HAS_IMP_ALGEBRA
366 IMP_CONTAINER_HAS_IMP_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_CGAL
368 IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_em2d.IMP_CONTAINER_HAS_IMP_DISPLAY
370 IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_KERNEL
372 IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
374 IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
376 IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
378 IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_RANDOM
380 IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_SYSTEM
382 IMP_CONTAINER_HAS_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_CGAL
384 IMP_CONTAINER_HAS_HDF5 = _IMP_em2d.IMP_CONTAINER_HAS_HDF5
386 IMP_CONTAINER_HAS_NUMPY = _IMP_em2d.IMP_CONTAINER_HAS_NUMPY
388 IMP_CONTAINER_HAS_PYTHON_IHM = _IMP_em2d.IMP_CONTAINER_HAS_PYTHON_IHM
390 IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP = _IMP_em2d.IMP_CONTAINER_HAS_GOOGLE_DENSE_HASH_MAP
392 IMP_CONTAINER_HAS_ROBIN_MAP = _IMP_em2d.IMP_CONTAINER_HAS_ROBIN_MAP
394 IMPCONTAINER_SHOW_WARNINGS = _IMP_em2d.IMPCONTAINER_SHOW_WARNINGS
397 IMP_ATOM_HAS_IMP_CGAL = _IMP_em2d.IMP_ATOM_HAS_IMP_CGAL
399 IMP_ATOM_HAS_IMP_KERNEL = _IMP_em2d.IMP_ATOM_HAS_IMP_KERNEL
401 IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
403 IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
405 IMP_ATOM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ATOM_HAS_BOOST_RANDOM
407 IMP_ATOM_HAS_BOOST_REGEX = _IMP_em2d.IMP_ATOM_HAS_BOOST_REGEX
409 IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ATOM_HAS_BOOST_SYSTEM
411 IMP_ATOM_HAS_CGAL = _IMP_em2d.IMP_ATOM_HAS_CGAL
413 IMP_ATOM_HAS_HDF5 = _IMP_em2d.IMP_ATOM_HAS_HDF5
415 IMP_ATOM_HAS_NUMPY = _IMP_em2d.IMP_ATOM_HAS_NUMPY
417 IMP_ATOM_HAS_PYTHON_IHM = _IMP_em2d.IMP_ATOM_HAS_PYTHON_IHM
419 IMPATOM_SHOW_WARNINGS = _IMP_em2d.IMPATOM_SHOW_WARNINGS
421 IMP_ATOM_TYPE_INDEX = _IMP_em2d.IMP_ATOM_TYPE_INDEX
423 IMP_RESIDUE_TYPE_INDEX = _IMP_em2d.IMP_RESIDUE_TYPE_INDEX
425 IMP_HIERARCHY_TYPE_INDEX = _IMP_em2d.IMP_HIERARCHY_TYPE_INDEX
427 IMP_CHAIN_TYPE_INDEX = _IMP_em2d.IMP_CHAIN_TYPE_INDEX
430 IMP_EM_HAS_IMP_CGAL = _IMP_em2d.IMP_EM_HAS_IMP_CGAL
432 IMP_EM_HAS_IMP_CONTAINER = _IMP_em2d.IMP_EM_HAS_IMP_CONTAINER
434 IMP_EM_HAS_IMP_DISPLAY = _IMP_em2d.IMP_EM_HAS_IMP_DISPLAY
436 IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM_HAS_IMP_SCORE_FUNCTOR
438 IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_FILESYSTEM
440 IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_EM_HAS_BOOST_PROGRAMOPTIONS
442 IMP_EM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM_HAS_BOOST_RANDOM
444 IMP_EM_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM_HAS_BOOST_REGEX
446 IMP_EM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_SYSTEM
448 IMP_EM_HAS_CGAL = _IMP_em2d.IMP_EM_HAS_CGAL
450 IMP_EM_HAS_HDF5 = _IMP_em2d.IMP_EM_HAS_HDF5
452 IMP_EM_HAS_NUMPY = _IMP_em2d.IMP_EM_HAS_NUMPY
454 IMP_EM_HAS_PYTHON_IHM = _IMP_em2d.IMP_EM_HAS_PYTHON_IHM
456 IMPEM_SHOW_WARNINGS = _IMP_em2d.IMPEM_SHOW_WARNINGS
459 IMP_SAXS_HAS_IMP_CGAL = _IMP_em2d.IMP_SAXS_HAS_IMP_CGAL
461 IMP_SAXS_HAS_IMP_CONTAINER = _IMP_em2d.IMP_SAXS_HAS_IMP_CONTAINER
463 IMP_SAXS_HAS_IMP_DISPLAY = _IMP_em2d.IMP_SAXS_HAS_IMP_DISPLAY
465 IMP_SAXS_HAS_IMP_KERNEL = _IMP_em2d.IMP_SAXS_HAS_IMP_KERNEL
467 IMP_SAXS_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_SAXS_HAS_IMP_SCORE_FUNCTOR
469 IMP_SAXS_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_SAXS_HAS_BOOST_FILESYSTEM
471 IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_SAXS_HAS_BOOST_PROGRAMOPTIONS
473 IMP_SAXS_HAS_BOOST_RANDOM = _IMP_em2d.IMP_SAXS_HAS_BOOST_RANDOM
475 IMP_SAXS_HAS_BOOST_REGEX = _IMP_em2d.IMP_SAXS_HAS_BOOST_REGEX
477 IMP_SAXS_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_SAXS_HAS_BOOST_SYSTEM
479 IMP_SAXS_HAS_CGAL = _IMP_em2d.IMP_SAXS_HAS_CGAL
481 IMP_SAXS_HAS_HDF5 = _IMP_em2d.IMP_SAXS_HAS_HDF5
483 IMP_SAXS_HAS_NUMPY = _IMP_em2d.IMP_SAXS_HAS_NUMPY
485 IMP_SAXS_HAS_PYTHON_IHM = _IMP_em2d.IMP_SAXS_HAS_PYTHON_IHM
487 IMPSAXS_SHOW_WARNINGS = _IMP_em2d.IMPSAXS_SHOW_WARNINGS
490 IMP_ISD_HAS_IMP_CGAL = _IMP_em2d.IMP_ISD_HAS_IMP_CGAL
492 IMP_ISD_HAS_IMP_DISPLAY = _IMP_em2d.IMP_ISD_HAS_IMP_DISPLAY
494 IMP_ISD_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_ISD_HAS_IMP_SCORE_FUNCTOR
496 IMP_ISD_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_ISD_HAS_BOOST_FILESYSTEM
498 IMP_ISD_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ISD_HAS_BOOST_PROGRAMOPTIONS
500 IMP_ISD_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ISD_HAS_BOOST_RANDOM
502 IMP_ISD_HAS_BOOST_REGEX = _IMP_em2d.IMP_ISD_HAS_BOOST_REGEX
504 IMP_ISD_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ISD_HAS_BOOST_SYSTEM
506 IMP_ISD_HAS_CGAL = _IMP_em2d.IMP_ISD_HAS_CGAL
508 IMP_ISD_HAS_HDF5 = _IMP_em2d.IMP_ISD_HAS_HDF5
510 IMP_ISD_HAS_NUMPY = _IMP_em2d.IMP_ISD_HAS_NUMPY
512 IMP_ISD_HAS_PYTHON_IHM = _IMP_em2d.IMP_ISD_HAS_PYTHON_IHM
514 IMPISD_SHOW_WARNINGS = _IMP_em2d.IMPISD_SHOW_WARNINGS
517 IMP_RMF_HAS_IMP_CGAL = _IMP_em2d.IMP_RMF_HAS_IMP_CGAL
519 IMP_RMF_HAS_IMP_EM = _IMP_em2d.IMP_RMF_HAS_IMP_EM
521 IMP_RMF_HAS_IMP_SAXS = _IMP_em2d.IMP_RMF_HAS_IMP_SAXS
523 IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
525 IMP_RMF_HAS_IMP_STATISTICS = _IMP_em2d.IMP_RMF_HAS_IMP_STATISTICS
527 IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_FILESYSTEM
529 IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
531 IMP_RMF_HAS_BOOST_RANDOM = _IMP_em2d.IMP_RMF_HAS_BOOST_RANDOM
533 IMP_RMF_HAS_BOOST_REGEX = _IMP_em2d.IMP_RMF_HAS_BOOST_REGEX
535 IMP_RMF_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_SYSTEM
537 IMP_RMF_HAS_CGAL = _IMP_em2d.IMP_RMF_HAS_CGAL
539 IMP_RMF_HAS_HDF5 = _IMP_em2d.IMP_RMF_HAS_HDF5
541 IMP_RMF_HAS_NUMPY = _IMP_em2d.IMP_RMF_HAS_NUMPY
543 IMP_RMF_HAS_PYTHON_IHM = _IMP_em2d.IMP_RMF_HAS_PYTHON_IHM
545 IMPRMF_SHOW_WARNINGS = _IMP_em2d.IMPRMF_SHOW_WARNINGS
549 IMP_DOMINO_HAS_IMP_ATOM = _IMP_em2d.IMP_DOMINO_HAS_IMP_ATOM
551 IMP_DOMINO_HAS_IMP_CGAL = _IMP_em2d.IMP_DOMINO_HAS_IMP_CGAL
553 IMP_DOMINO_HAS_IMP_EM = _IMP_em2d.IMP_DOMINO_HAS_IMP_EM
555 IMP_DOMINO_HAS_IMP_ISD = _IMP_em2d.IMP_DOMINO_HAS_IMP_ISD
557 IMP_DOMINO_HAS_IMP_KERNEL = _IMP_em2d.IMP_DOMINO_HAS_IMP_KERNEL
559 IMP_DOMINO_HAS_IMP_RMF = _IMP_em2d.IMP_DOMINO_HAS_IMP_RMF
561 IMP_DOMINO_HAS_IMP_SAXS = _IMP_em2d.IMP_DOMINO_HAS_IMP_SAXS
563 IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR
565 IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_FILESYSTEM
567 IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS
569 IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_RANDOM
571 IMP_DOMINO_HAS_BOOST_REGEX = _IMP_em2d.IMP_DOMINO_HAS_BOOST_REGEX
573 IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_SYSTEM
575 IMP_DOMINO_HAS_CGAL = _IMP_em2d.IMP_DOMINO_HAS_CGAL
577 IMP_DOMINO_HAS_HDF5 = _IMP_em2d.IMP_DOMINO_HAS_HDF5
579 IMP_DOMINO_HAS_NUMPY = _IMP_em2d.IMP_DOMINO_HAS_NUMPY
581 IMP_DOMINO_HAS_RMF = _IMP_em2d.IMP_DOMINO_HAS_RMF
583 IMP_DOMINO_HAS_PYTHON_IHM = _IMP_em2d.IMP_DOMINO_HAS_PYTHON_IHM
585 IMPDOMINO_SHOW_WARNINGS = _IMP_em2d.IMPDOMINO_SHOW_WARNINGS
589 IMP_EM2D_HAS_IMP_CGAL = _IMP_em2d.IMP_EM2D_HAS_IMP_CGAL
591 IMP_EM2D_HAS_IMP_ISD = _IMP_em2d.IMP_EM2D_HAS_IMP_ISD
593 IMP_EM2D_HAS_IMP_KERNEL = _IMP_em2d.IMP_EM2D_HAS_IMP_KERNEL
595 IMP_EM2D_HAS_IMP_RMF = _IMP_em2d.IMP_EM2D_HAS_IMP_RMF
597 IMP_EM2D_HAS_IMP_SAXS = _IMP_em2d.IMP_EM2D_HAS_IMP_SAXS
599 IMP_EM2D_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM2D_HAS_IMP_SCORE_FUNCTOR
601 IMP_EM2D_HAS_IMP_STATISTICS = _IMP_em2d.IMP_EM2D_HAS_IMP_STATISTICS
603 IMP_EM2D_HAS_BOOST_GRAPH = _IMP_em2d.IMP_EM2D_HAS_BOOST_GRAPH
605 IMP_EM2D_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM2D_HAS_BOOST_RANDOM
607 IMP_EM2D_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM2D_HAS_BOOST_REGEX
609 IMP_EM2D_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM2D_HAS_BOOST_SYSTEM
611 IMP_EM2D_HAS_CGAL = _IMP_em2d.IMP_EM2D_HAS_CGAL
613 IMP_EM2D_HAS_GSL = _IMP_em2d.IMP_EM2D_HAS_GSL
615 IMP_EM2D_HAS_HDF5 = _IMP_em2d.IMP_EM2D_HAS_HDF5
617 IMP_EM2D_HAS_NUMPY = _IMP_em2d.IMP_EM2D_HAS_NUMPY
619 IMP_EM2D_HAS_OPENCV3 = _IMP_em2d.IMP_EM2D_HAS_OPENCV3
621 IMP_EM2D_HAS_RMF = _IMP_em2d.IMP_EM2D_HAS_RMF
623 IMP_EM2D_HAS_PYTHON_IHM = _IMP_em2d.IMP_EM2D_HAS_PYTHON_IHM
625 IMP_EM2D_HAS_OPENCV21 = _IMP_em2d.IMP_EM2D_HAS_OPENCV21
627 IMP_EM2D_HAS_OPENCV22 = _IMP_em2d.IMP_EM2D_HAS_OPENCV22
629 IMPEM2D_SHOW_WARNINGS = _IMP_em2d.IMPEM2D_SHOW_WARNINGS
632 PolarResamplingParametersList=list
633 _plural_types.append(
"PolarResamplingParametersList")
634 _value_types.append(
"PolarResamplingParameters")
638 _plural_types.append(
"ProjectionMasks")
639 _value_types.append(
"ProjectionMask")
643 _plural_types.append(
"MasksManagers")
644 _value_types.append(
"MasksManager")
647 RegistrationResults=list
648 _plural_types.append(
"RegistrationResults")
649 _value_types.append(
"RegistrationResult")
653 _plural_types.append(
"ClusterSets")
654 _value_types.append(
"ClusterSet")
658 _plural_types.append(
"SingleLinkages")
659 _value_types.append(
"SingleLinkage")
662 CompleteLinkages=list
663 _plural_types.append(
"CompleteLinkages")
664 _value_types.append(
"CompleteLinkage")
667 AverageDistanceLinkages=list
668 _plural_types.append(
"AverageDistanceLinkages")
669 _value_types.append(
"AverageDistanceLinkage")
672 SegmentationParametersList=list
673 _plural_types.append(
"SegmentationParametersList")
674 _value_types.append(
"SegmentationParameters")
677 MatchTemplateResults=list
678 _plural_types.append(
"MatchTemplateResults")
679 _value_types.append(
"MatchTemplateResult")
682 ProjectingParametersList=list
683 _plural_types.append(
"ProjectingParametersList")
684 _value_types.append(
"ProjectingParameters")
687 ProjectingOptionsList=list
688 _plural_types.append(
"ProjectingOptionsList")
689 _value_types.append(
"ProjectingOptions")
692 Em2DRestraintParametersList=list
693 _plural_types.append(
"Em2DRestraintParametersList")
694 _value_types.append(
"Em2DRestraintParameters")
697 _object_types.append(
"ProjectionFinder")
700 def _object_cast_to_ProjectionFinder(o):
701 r"""_object_cast_to_ProjectionFinder(Object o) -> ProjectionFinder"""
702 return _IMP_em2d._object_cast_to_ProjectionFinder(o)
704 _object_types.append(
"ScoreFunction")
707 def _object_cast_to_ScoreFunction(o):
708 r"""_object_cast_to_ScoreFunction(Object o) -> ScoreFunction"""
709 return _IMP_em2d._object_cast_to_ScoreFunction(o)
711 _object_types.append(
"ChiSquaredScore")
714 def _object_cast_to_ChiSquaredScore(o):
715 r"""_object_cast_to_ChiSquaredScore(Object o) -> ChiSquaredScore"""
716 return _IMP_em2d._object_cast_to_ChiSquaredScore(o)
718 _object_types.append(
"EM2DScore")
721 def _object_cast_to_EM2DScore(o):
722 r"""_object_cast_to_EM2DScore(Object o) -> EM2DScore"""
723 return _IMP_em2d._object_cast_to_EM2DScore(o)
725 _object_types.append(
"MeanAbsoluteDifference")
728 def _object_cast_to_MeanAbsoluteDifference(o):
729 r"""_object_cast_to_MeanAbsoluteDifference(Object o) -> MeanAbsoluteDifference"""
730 return _IMP_em2d._object_cast_to_MeanAbsoluteDifference(o)
732 _object_types.append(
"ProjectionParametersScoreState")
735 def _object_cast_to_ProjectionParametersScoreState(o):
736 r"""_object_cast_to_ProjectionParametersScoreState(Object o) -> ProjectionParametersScoreState"""
737 return _IMP_em2d._object_cast_to_ProjectionParametersScoreState(o)
739 _object_types.append(
"Em2DRestraint")
742 def _object_cast_to_Em2DRestraint(o):
743 r"""_object_cast_to_Em2DRestraint(Object o) -> Em2DRestraint"""
744 return _IMP_em2d._object_cast_to_Em2DRestraint(o)
746 _object_types.append(
"Image")
749 def _object_cast_to_Image(o):
750 r"""_object_cast_to_Image(Object o) -> Image"""
751 return _IMP_em2d._object_cast_to_Image(o)
753 _object_types.append(
"ImageReaderWriter")
756 def _object_cast_to_ImageReaderWriter(o):
757 r"""_object_cast_to_ImageReaderWriter(Object o) -> ImageReaderWriter"""
758 return _IMP_em2d._object_cast_to_ImageReaderWriter(o)
760 _object_types.append(
"JPGImageReaderWriter")
763 def _object_cast_to_JPGImageReaderWriter(o):
764 r"""_object_cast_to_JPGImageReaderWriter(Object o) -> JPGImageReaderWriter"""
765 return _IMP_em2d._object_cast_to_JPGImageReaderWriter(o)
767 _object_types.append(
"TIFFImageReaderWriter")
770 def _object_cast_to_TIFFImageReaderWriter(o):
771 r"""_object_cast_to_TIFFImageReaderWriter(Object o) -> TIFFImageReaderWriter"""
772 return _IMP_em2d._object_cast_to_TIFFImageReaderWriter(o)
774 _object_types.append(
"SpiderImageReaderWriter")
777 def _object_cast_to_SpiderImageReaderWriter(o):
778 r"""_object_cast_to_SpiderImageReaderWriter(Object o) -> SpiderImageReaderWriter"""
779 return _IMP_em2d._object_cast_to_SpiderImageReaderWriter(o)
781 _object_types.append(
"CollisionCrossSection")
784 def _object_cast_to_CollisionCrossSection(o):
785 r"""_object_cast_to_CollisionCrossSection(Object o) -> CollisionCrossSection"""
786 return _IMP_em2d._object_cast_to_CollisionCrossSection(o)
788 _object_types.append(
"GridStates")
791 def _object_cast_to_GridStates(o):
792 r"""_object_cast_to_GridStates(Object o) -> GridStates"""
793 return _IMP_em2d._object_cast_to_GridStates(o)
795 _object_types.append(
"ProjectionStates")
798 def _object_cast_to_ProjectionStates(o):
799 r"""_object_cast_to_ProjectionStates(Object o) -> ProjectionStates"""
800 return _IMP_em2d._object_cast_to_ProjectionStates(o)
802 _object_types.append(
"DistanceFilter")
805 def _object_cast_to_DistanceFilter(o):
806 r"""_object_cast_to_DistanceFilter(Object o) -> DistanceFilter"""
807 return _IMP_em2d._object_cast_to_DistanceFilter(o)
809 _object_types.append(
"DistanceFilterTable")
812 def _object_cast_to_DistanceFilterTable(o):
813 r"""_object_cast_to_DistanceFilterTable(Object o) -> DistanceFilterTable"""
814 return _IMP_em2d._object_cast_to_DistanceFilterTable(o)
816 _object_types.append(
"RigidBodiesImageFitRestraint")
819 def _object_cast_to_RigidBodiesImageFitRestraint(o):
820 r"""_object_cast_to_RigidBodiesImageFitRestraint(Object o) -> RigidBodiesImageFitRestraint"""
821 return _IMP_em2d._object_cast_to_RigidBodiesImageFitRestraint(o)
823 _object_types.append(
"DummyRestraint")
826 def _object_cast_to_DummyRestraint(o):
827 r"""_object_cast_to_DummyRestraint(Object o) -> DummyRestraint"""
828 return _IMP_em2d._object_cast_to_DummyRestraint(o)
830 _object_types.append(
"ParticlesDummyRestraint")
833 def _object_cast_to_ParticlesDummyRestraint(o):
834 r"""_object_cast_to_ParticlesDummyRestraint(Object o) -> ParticlesDummyRestraint"""
835 return _IMP_em2d._object_cast_to_ParticlesDummyRestraint(o)
837 _object_types.append(
"RelativePositionMover")
840 def _object_cast_to_RelativePositionMover(o):
841 r"""_object_cast_to_RelativePositionMover(Object o) -> RelativePositionMover"""
842 return _IMP_em2d._object_cast_to_RelativePositionMover(o)
844 _object_types.append(
"PCAFitRestraint")
847 def _object_cast_to_em2dPCAFitRestraint(o):
848 r"""_object_cast_to_em2dPCAFitRestraint(Object o) -> PCAFitRestraint"""
849 return _IMP_em2d._object_cast_to_em2dPCAFitRestraint(o)
851 def ProjectionParametersList(l=[]):
852 return [ProjectionParameters(x)
for x
in l]
853 _plural_types.append(
"ProjectionParametersList")
856 _value_types.append(
"ProjectionParameters")
860 r"""show(cv::Mat const & m, _ostream out=std::cout)"""
861 return _IMP_em2d.show(*args)
864 r"""write_matrix(cv::Mat & m, std::string name)"""
865 return _IMP_em2d.write_matrix(m, name)
867 r"""Proxy of C++ IMP::em2d::ImageReaderWriter class."""
869 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
871 def __init__(self, *args, **kwargs):
872 raise AttributeError(
"No constructor defined - class is abstract")
874 def read(self, filename, header, data):
875 r"""read(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
876 return _IMP_em2d.ImageReaderWriter_read(self, filename, header, data)
878 def read_from_floats(self, filename, header, data):
879 r"""read_from_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
880 return _IMP_em2d.ImageReaderWriter_read_from_floats(self, filename, header, data)
882 def read_from_ints(self, filename, header, data):
883 r"""read_from_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
884 return _IMP_em2d.ImageReaderWriter_read_from_ints(self, filename, header, data)
886 def write(self, filename, header, data):
887 r"""write(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
888 return _IMP_em2d.ImageReaderWriter_write(self, filename, header, data)
890 def write_to_floats(self, filename, header, data):
891 r"""write_to_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
892 return _IMP_em2d.ImageReaderWriter_write_to_floats(self, filename, header, data)
894 def write_to_ints(self, filename, header, data):
895 r"""write_to_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
896 return _IMP_em2d.ImageReaderWriter_write_to_ints(self, filename, header, data)
898 def get_version_info(self):
899 r"""get_version_info(ImageReaderWriter self) -> VersionInfo"""
900 return _IMP_em2d.ImageReaderWriter_get_version_info(self)
901 __swig_destroy__ = _IMP_em2d.delete_ImageReaderWriter
904 r"""__str__(ImageReaderWriter self) -> std::string"""
905 return _IMP_em2d.ImageReaderWriter___str__(self)
908 r"""__repr__(ImageReaderWriter self) -> std::string"""
909 return _IMP_em2d.ImageReaderWriter___repr__(self)
913 return _object_cast_to_ImageReaderWriter(o)
917 _IMP_em2d.ImageReaderWriter_swigregister(ImageReaderWriter)
918 class PolarResamplingParameters(object):
919 r"""Proxy of C++ IMP::em2d::PolarResamplingParameters class."""
921 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
923 def __init__(self, *args):
925 __init__(PolarResamplingParameters self) -> PolarResamplingParameters
926 __init__(PolarResamplingParameters self, unsigned int rows, unsigned int cols) -> PolarResamplingParameters
927 __init__(PolarResamplingParameters self, cv::Mat const & m) -> PolarResamplingParameters
929 _IMP_em2d.PolarResamplingParameters_swiginit(self, _IMP_em2d.new_PolarResamplingParameters(*args))
930 __swig_destroy__ = _IMP_em2d.delete_PolarResamplingParameters
932 def setup(self, rows, cols):
933 r"""setup(PolarResamplingParameters self, unsigned int rows, unsigned int cols)"""
934 return _IMP_em2d.PolarResamplingParameters_setup(self, rows, cols)
936 def get_starting_radius(self):
937 r"""get_starting_radius(PolarResamplingParameters self) -> double"""
938 return _IMP_em2d.PolarResamplingParameters_get_starting_radius(self)
940 def get_ending_radius(self):
941 r"""get_ending_radius(PolarResamplingParameters self) -> double"""
942 return _IMP_em2d.PolarResamplingParameters_get_ending_radius(self)
944 def get_radius(self, n_ring):
945 r"""get_radius(PolarResamplingParameters self, unsigned int n_ring) -> double"""
946 return _IMP_em2d.PolarResamplingParameters_get_radius(self, n_ring)
948 def get_number_of_rings(self):
949 r"""get_number_of_rings(PolarResamplingParameters self) -> unsigned int"""
950 return _IMP_em2d.PolarResamplingParameters_get_number_of_rings(self)
952 def set_estimated_number_of_angles(self, aprox_value):
953 r"""set_estimated_number_of_angles(PolarResamplingParameters self, unsigned int aprox_value)"""
954 return _IMP_em2d.PolarResamplingParameters_set_estimated_number_of_angles(self, aprox_value)
956 def get_number_of_angles(self):
957 r"""get_number_of_angles(PolarResamplingParameters self) -> unsigned int"""
958 return _IMP_em2d.PolarResamplingParameters_get_number_of_angles(self)
960 def get_angle_step(self):
961 r"""get_angle_step(PolarResamplingParameters self) -> double"""
962 return _IMP_em2d.PolarResamplingParameters_get_angle_step(self)
964 def get_radius_step(self):
965 r"""get_radius_step(PolarResamplingParameters self) -> double"""
966 return _IMP_em2d.PolarResamplingParameters_get_radius_step(self)
968 def create_maps_for_resampling(self):
969 r"""create_maps_for_resampling(PolarResamplingParameters self)"""
970 return _IMP_em2d.PolarResamplingParameters_create_maps_for_resampling(self)
972 def get_resampling_maps(self, m1, m2):
973 r"""get_resampling_maps(PolarResamplingParameters self, cv::Mat & m1, cv::Mat & m2)"""
974 return _IMP_em2d.PolarResamplingParameters_get_resampling_maps(self, m1, m2)
976 def get_resampling_map(self, m1):
977 r"""get_resampling_map(PolarResamplingParameters self, cv::Mat & m1)"""
978 return _IMP_em2d.PolarResamplingParameters_get_resampling_map(self, m1)
981 r"""show(PolarResamplingParameters self, _ostream out)"""
982 return _IMP_em2d.PolarResamplingParameters_show(self, out)
984 def get_is_setup(self):
985 r"""get_is_setup(PolarResamplingParameters self) -> bool"""
986 return _IMP_em2d.PolarResamplingParameters_get_is_setup(self)
989 r"""__str__(PolarResamplingParameters self) -> std::string"""
990 return _IMP_em2d.PolarResamplingParameters___str__(self)
993 r"""__repr__(PolarResamplingParameters self) -> std::string"""
994 return _IMP_em2d.PolarResamplingParameters___repr__(self)
996 def _get_as_binary(self):
997 r"""_get_as_binary(PolarResamplingParameters self) -> PyObject *"""
998 return _IMP_em2d.PolarResamplingParameters__get_as_binary(self)
1000 def _set_from_binary(self, p):
1001 r"""_set_from_binary(PolarResamplingParameters self, PyObject * p)"""
1002 return _IMP_em2d.PolarResamplingParameters__set_from_binary(self, p)
1004 def __getstate__(self):
1005 p = self._get_as_binary()
1006 if len(self.__dict__) > 1:
1007 d = self.__dict__.copy()
1012 def __setstate__(self, p):
1013 if not hasattr(self,
'this'):
1015 if isinstance(p, tuple):
1017 self.__dict__.update(d)
1018 return self._set_from_binary(p)
1022 _IMP_em2d.PolarResamplingParameters_swigregister(PolarResamplingParameters)
1023 class SegmentationParameters(object):
1024 r"""Proxy of C++ IMP::em2d::SegmentationParameters class."""
1026 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1027 image_pixel_size = property(_IMP_em2d.SegmentationParameters_image_pixel_size_get, _IMP_em2d.SegmentationParameters_image_pixel_size_set, doc=
r"""image_pixel_size : double""")
1028 diffusion_beta = property(_IMP_em2d.SegmentationParameters_diffusion_beta_get, _IMP_em2d.SegmentationParameters_diffusion_beta_set, doc=
r"""diffusion_beta : double""")
1029 diffusion_timesteps = property(_IMP_em2d.SegmentationParameters_diffusion_timesteps_get, _IMP_em2d.SegmentationParameters_diffusion_timesteps_set, doc=
r"""diffusion_timesteps : double""")
1030 fill_holes_stddevs = property(_IMP_em2d.SegmentationParameters_fill_holes_stddevs_get, _IMP_em2d.SegmentationParameters_fill_holes_stddevs_set, doc=
r"""fill_holes_stddevs : double""")
1031 opening_kernel = property(_IMP_em2d.SegmentationParameters_opening_kernel_get, _IMP_em2d.SegmentationParameters_opening_kernel_set, doc=
r"""opening_kernel : cv::Mat""")
1032 remove_sizing_percentage = property(_IMP_em2d.SegmentationParameters_remove_sizing_percentage_get, _IMP_em2d.SegmentationParameters_remove_sizing_percentage_set, doc=
r"""remove_sizing_percentage : double""")
1033 binary_background = property(_IMP_em2d.SegmentationParameters_binary_background_get, _IMP_em2d.SegmentationParameters_binary_background_set, doc=
r"""binary_background : int""")
1034 binary_foreground = property(_IMP_em2d.SegmentationParameters_binary_foreground_get, _IMP_em2d.SegmentationParameters_binary_foreground_set, doc=
r"""binary_foreground : int""")
1035 threshold = property(_IMP_em2d.SegmentationParameters_threshold_get, _IMP_em2d.SegmentationParameters_threshold_set, doc=
r"""threshold : double""")
1037 def __init__(self, *args):
1039 __init__(SegmentationParameters self) -> SegmentationParameters
1040 __init__(SegmentationParameters self, double apix, double diff_beta, unsigned int diff_timesteps, double fh_stddevs, cv::Mat const & kr, int background, int foreground) -> SegmentationParameters
1042 _IMP_em2d.SegmentationParameters_swiginit(self, _IMP_em2d.new_SegmentationParameters(*args))
1044 def show(self, *args):
1045 r"""show(SegmentationParameters self, _ostream out=std::cout)"""
1046 return _IMP_em2d.SegmentationParameters_show(self, *args)
1049 r"""__str__(SegmentationParameters self) -> std::string"""
1050 return _IMP_em2d.SegmentationParameters___str__(self)
1053 r"""__repr__(SegmentationParameters self) -> std::string"""
1054 return _IMP_em2d.SegmentationParameters___repr__(self)
1056 def _get_as_binary(self):
1057 r"""_get_as_binary(SegmentationParameters self) -> PyObject *"""
1058 return _IMP_em2d.SegmentationParameters__get_as_binary(self)
1060 def _set_from_binary(self, p):
1061 r"""_set_from_binary(SegmentationParameters self, PyObject * p)"""
1062 return _IMP_em2d.SegmentationParameters__set_from_binary(self, p)
1064 def __getstate__(self):
1065 p = self._get_as_binary()
1066 if len(self.__dict__) > 1:
1067 d = self.__dict__.copy()
1072 def __setstate__(self, p):
1073 if not hasattr(self,
'this'):
1075 if isinstance(p, tuple):
1077 self.__dict__.update(d)
1078 return self._set_from_binary(p)
1080 __swig_destroy__ = _IMP_em2d.delete_SegmentationParameters
1083 _IMP_em2d.SegmentationParameters_swigregister(SegmentationParameters)
1084 class MatchTemplateResult(object):
1085 r"""Proxy of C++ IMP::em2d::MatchTemplateResult class."""
1087 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1088 pair = property(_IMP_em2d.MatchTemplateResult_pair_get, _IMP_em2d.MatchTemplateResult_pair_set, doc=
r"""pair : IMP::IntPair""")
1089 cross_correlation = property(_IMP_em2d.MatchTemplateResult_cross_correlation_get, _IMP_em2d.MatchTemplateResult_cross_correlation_set, doc=
r"""cross_correlation : double""")
1091 def __init__(self, *args):
1093 __init__(MatchTemplateResult self, IMP::IntPair p, double cc) -> MatchTemplateResult
1094 __init__(MatchTemplateResult self) -> MatchTemplateResult
1096 _IMP_em2d.MatchTemplateResult_swiginit(self, _IMP_em2d.new_MatchTemplateResult(*args))
1098 def show(self, *args):
1099 r"""show(MatchTemplateResult self, _ostream out=std::cout)"""
1100 return _IMP_em2d.MatchTemplateResult_show(self, *args)
1103 r"""__str__(MatchTemplateResult self) -> std::string"""
1104 return _IMP_em2d.MatchTemplateResult___str__(self)
1107 r"""__repr__(MatchTemplateResult self) -> std::string"""
1108 return _IMP_em2d.MatchTemplateResult___repr__(self)
1110 def _get_as_binary(self):
1111 r"""_get_as_binary(MatchTemplateResult self) -> PyObject *"""
1112 return _IMP_em2d.MatchTemplateResult__get_as_binary(self)
1114 def _set_from_binary(self, p):
1115 r"""_set_from_binary(MatchTemplateResult self, PyObject * p)"""
1116 return _IMP_em2d.MatchTemplateResult__set_from_binary(self, p)
1118 def __getstate__(self):
1119 p = self._get_as_binary()
1120 if len(self.__dict__) > 1:
1121 d = self.__dict__.copy()
1126 def __setstate__(self, p):
1127 if not hasattr(self,
'this'):
1129 if isinstance(p, tuple):
1131 self.__dict__.update(d)
1132 return self._set_from_binary(p)
1134 __swig_destroy__ = _IMP_em2d.delete_MatchTemplateResult
1137 _IMP_em2d.MatchTemplateResult_swigregister(MatchTemplateResult)
1140 r"""apply_mask(cv::Mat const & m, cv::Mat & result, IMP::em2d::cvIntMat const & mask, double val)"""
1141 return _IMP_em2d.apply_mask(m, result, mask, val)
1144 r"""apply_circular_mask(cv::Mat const & mat, cv::Mat & result, int radius, double value=0.0)"""
1145 return _IMP_em2d.apply_circular_mask(mat, result, radius, value)
1148 r"""get_mean(cv::Mat const & mat, IMP::em2d::cvIntMat const & mask) -> double"""
1149 return _IMP_em2d.get_mean(mat, mask)
1152 r"""create_circular_mask(int rows, int cols, int radius) -> IMP::em2d::cvIntMat"""
1153 return _IMP_em2d.create_circular_mask(rows, cols, radius)
1155 def do_histogram_stretching(m, boxes, offset):
1156 r"""do_histogram_stretching(cv::Mat & m, int boxes, int offset)"""
1157 return _IMP_em2d.do_histogram_stretching(m, boxes, offset)
1160 r"""do_dilate_and_shrink_warp(cv::Mat & m, cv::Mat const & grayscale, cv::Mat & kernel)"""
1161 return _IMP_em2d.do_dilate_and_shrink_warp(m, grayscale, kernel)
1164 r"""do_morphologic_reconstruction(cv::Mat const & mask, cv::Mat & marker, int neighbors_mode=4)"""
1165 return _IMP_em2d.do_morphologic_reconstruction(mask, marker, neighbors_mode)
1168 r"""do_labeling(IMP::em2d::cvIntMat const & m, IMP::em2d::cvIntMat & mat_to_label) -> int"""
1169 return _IMP_em2d.do_labeling(m, mat_to_label)
1172 r"""get_diffusion_filtering_partial_derivative(cv::Mat const & m, cv::Mat & der, double dx, double dy, double ang)"""
1173 return _IMP_em2d.get_diffusion_filtering_partial_derivative(m, der, dx, dy, ang)
1176 r"""get_domes(cv::Mat & m, cv::Mat & result, double h)"""
1177 return _IMP_em2d.get_domes(m, result, h)
1179 def get_transformed(input, transformed, T):
1180 r"""get_transformed(cv::Mat const & input, cv::Mat & transformed, Transformation2D T)"""
1181 return _IMP_em2d.get_transformed(input, transformed, T)
1184 r"""apply_threshold(cv::Mat & m, cv::Mat & result, double threshold=0.0)"""
1185 return _IMP_em2d.apply_threshold(m, result, threshold)
1188 r"""do_morphologic_contrast_enhancement(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel, unsigned int iterations)"""
1189 return _IMP_em2d.do_morphologic_contrast_enhancement(m, result, kernel, iterations)
1192 r"""get_morphologic_gradient(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel)"""
1193 return _IMP_em2d.get_morphologic_gradient(m, result, kernel)
1196 r"""get_overlap_percentage(cv::Mat & m1, cv::Mat & m2, IMP::IntPair const & center) -> double"""
1197 return _IMP_em2d.get_overlap_percentage(m1, m2, center)
1200 r"""get_best_template_matches(cv::Mat const & m, cv::Mat const & templ, unsigned int n) -> IMP::em2d::MatchTemplateResults"""
1201 return _IMP_em2d.get_best_template_matches(m, templ, n)
1203 r"""Proxy of C++ IMP::em2d::Image class."""
1205 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1207 def __init__(self, *args):
1209 __init__(Image self) -> Image
1210 __init__(Image self, int rows, int cols) -> Image
1211 __init__(Image self, IMP::String filename, ImageReaderWriter reader) -> Image
1213 _IMP_em2d.Image_swiginit(self, _IMP_em2d.new_Image(*args))
1216 r"""get_data(Image self) -> cv::Mat &"""
1217 return _IMP_em2d.Image_get_data(self)
1219 def set_data(self, mat):
1220 r"""set_data(Image self, cv::Mat const & mat)"""
1221 return _IMP_em2d.Image_set_data(self, mat)
1223 def set_zeros(self):
1224 r"""set_zeros(Image self)"""
1225 return _IMP_em2d.Image_set_zeros(self)
1227 def set_value(self, *args):
1229 set_value(Image self, double val)
1230 set_value(Image self, int i, int j, double val)
1232 return _IMP_em2d.Image_set_value(self, *args)
1234 def __call__(self, i, j):
1235 r"""__call__(Image self, int i, int j) -> double"""
1236 return _IMP_em2d.Image___call__(self, i, j)
1238 def get_header(self):
1239 r"""get_header(Image self) -> ImageHeader"""
1240 return _IMP_em2d.Image_get_header(self)
1242 def set_size(self, *args):
1244 set_size(Image self, int rows, int cols)
1245 set_size(Image self, Image img)
1247 return _IMP_em2d.Image_set_size(self, *args)
1249 def update_header(self):
1250 r"""update_header(Image self)"""
1251 return _IMP_em2d.Image_update_header(self)
1253 def read(self, filename, reader):
1254 r"""read(Image self, IMP::String filename, ImageReaderWriter reader)"""
1255 return _IMP_em2d.Image_read(self, filename, reader)
1257 def write(self, filename, writer):
1258 r"""write(Image self, IMP::String const & filename, ImageReaderWriter writer)"""
1259 return _IMP_em2d.Image_write(self, filename, writer)
1261 def show(self, out):
1262 r"""show(Image self, _ostream out)"""
1263 return _IMP_em2d.Image_show(self, out)
1265 def get_version_info(self):
1266 r"""get_version_info(Image self) -> VersionInfo"""
1267 return _IMP_em2d.Image_get_version_info(self)
1268 __swig_destroy__ = _IMP_em2d.delete_Image
1270 def set_name(self, name):
1271 r"""set_name(Image self, IMP::String const & name)"""
1272 return _IMP_em2d.Image_set_name(self, name)
1275 r"""get_name(Image self) -> IMP::String"""
1276 return _IMP_em2d.Image_get_name(self)
1278 def get_min_and_max_values(self):
1279 r"""get_min_and_max_values(Image self) -> IMP::FloatRange"""
1280 return _IMP_em2d.Image_get_min_and_max_values(self)
1283 r"""__str__(Image self) -> std::string"""
1284 return _IMP_em2d.Image___str__(self)
1287 r"""__repr__(Image self) -> std::string"""
1288 return _IMP_em2d.Image___repr__(self)
1292 return _object_cast_to_Image(o)
1296 _IMP_em2d.Image_swigregister(Image)
1299 r"""read_images(IMP::Strings const & names, ImageReaderWriter rw) -> IMP::em2d::Images"""
1300 return _IMP_em2d.read_images(names, rw)
1303 r"""save_images(IMP::em2d::Images images, IMP::Strings const & names, ImageReaderWriter rw)"""
1304 return _IMP_em2d.save_images(images, names, rw)
1308 do_normalize(cv::Mat & m)
1309 do_normalize(Image im, bool force=False)
1311 return _IMP_em2d.do_normalize(*args)
1315 get_histogram(cv::Mat const & m, int bins) -> IMP::Floats
1316 get_histogram(Image img, int bins) -> IMP::Floats
1318 return _IMP_em2d.get_histogram(*args)
1322 apply_variance_filter(cv::Mat const & input, cv::Mat & filtered, int kernelsize)
1323 apply_variance_filter(Image input, Image filtered, int kernelsize)
1325 return _IMP_em2d.apply_variance_filter(*args)
1329 apply_diffusion_filter(cv::Mat const & m, cv::Mat & result, double beta, double pixelsize, unsigned int time_steps)
1330 apply_diffusion_filter(Image input, Image filtered, double beta, double pixelsize, int time_steps)
1332 return _IMP_em2d.apply_diffusion_filter(*args)
1334 def do_fill_holes(*args):
1336 do_fill_holes(cv::Mat const & m, cv::Mat & result, double h)
1337 do_fill_holes(Image input, Image result, double n_stddevs)
1339 return _IMP_em2d.do_fill_holes(*args)
1341 def do_combined_fill_holes_and_threshold(*args):
1343 do_combined_fill_holes_and_threshold(cv::Mat & m, cv::Mat & result, double n_stddevs, double threshold=0.0)
1344 do_combined_fill_holes_and_threshold(Image input, Image result, double n_stddevs)
1346 return _IMP_em2d.do_combined_fill_holes_and_threshold(*args)
1348 def do_extend_borders(*args):
1350 do_extend_borders(cv::Mat & orig, cv::Mat & dst, unsigned int pix)
1351 do_extend_borders(Image im1, Image im2, unsigned int pix)
1353 return _IMP_em2d.do_extend_borders(*args)
1355 def do_segmentation(*args):
1357 do_segmentation(cv::Mat const & m, cv::Mat & result, SegmentationParameters params)
1358 do_segmentation(Image input, Image result, SegmentationParameters params)
1360 return _IMP_em2d.do_segmentation(*args)
1362 def do_remove_small_objects(*args):
1364 do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage, int background=0, int foreground=1)
1365 do_remove_small_objects(Image input, double percentage, int background=0, int foreground=1)
1367 return _IMP_em2d.do_remove_small_objects(*args)
1370 r"""do_subtract_images(Image first, Image second, Image result)"""
1371 return _IMP_em2d.do_subtract_images(first, second, result)
1373 def add_noise(*args):
1375 add_noise(cv::Mat & v, double op1, double op2, IMP::String const & mode="uniform", double df=3)
1376 add_noise(Image im1, double op1, double op2, IMP::String const & mode="uniform", double df=3)
1378 return _IMP_em2d.add_noise(*args)
1382 do_resample_polar(cv::Mat const & input, cv::Mat & resampled, PolarResamplingParameters polar_params)
1383 do_resample_polar(Image im1, Image im2, PolarResamplingParameters polar_params)
1385 return _IMP_em2d.do_resample_polar(*args)
1389 crop(cv::Mat const & m, IMP::IntPair const & center, int size) -> cv::Mat
1390 crop(Image img, IMP::IntPair const & center, int size)
1392 return _IMP_em2d.crop(*args)
1395 r"""apply_mean_outside_mask(Image img, double radius)"""
1396 return _IMP_em2d.apply_mean_outside_mask(img, radius)
1397 class RegistrationResult(object):
1398 r"""Proxy of C++ IMP::em2d::RegistrationResult class."""
1400 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1402 def __init__(self, *args):
1404 __init__(RegistrationResult self) -> RegistrationResult
1405 __init__(RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0, int image_index=0, IMP::String name="") -> RegistrationResult
1406 __init__(RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0., 0.), int projection_index=0, int image_index=0, IMP::String name="") -> RegistrationResult
1408 _IMP_em2d.RegistrationResult_swiginit(self, _IMP_em2d.new_RegistrationResult(*args))
1411 r"""get_phi(RegistrationResult self) -> double"""
1412 return _IMP_em2d.RegistrationResult_get_phi(self)
1414 def get_theta(self):
1415 r"""get_theta(RegistrationResult self) -> double"""
1416 return _IMP_em2d.RegistrationResult_get_theta(self)
1419 r"""get_psi(RegistrationResult self) -> double"""
1420 return _IMP_em2d.RegistrationResult_get_psi(self)
1422 def get_shift(self):
1423 r"""get_shift(RegistrationResult self) -> Vector2D"""
1424 return _IMP_em2d.RegistrationResult_get_shift(self)
1426 def get_shift_3d(self):
1427 r"""get_shift_3d(RegistrationResult self) -> Vector3D"""
1428 return _IMP_em2d.RegistrationResult_get_shift_3d(self)
1430 def get_projection_index(self):
1431 r"""get_projection_index(RegistrationResult self) -> int"""
1432 return _IMP_em2d.RegistrationResult_get_projection_index(self)
1434 def set_projection_index(self, index):
1435 r"""set_projection_index(RegistrationResult self, int index)"""
1436 return _IMP_em2d.RegistrationResult_set_projection_index(self, index)
1438 def get_image_index(self):
1439 r"""get_image_index(RegistrationResult self) -> int"""
1440 return _IMP_em2d.RegistrationResult_get_image_index(self)
1442 def set_image_index(self, index):
1443 r"""set_image_index(RegistrationResult self, int index)"""
1444 return _IMP_em2d.RegistrationResult_set_image_index(self, index)
1447 r"""get_name(RegistrationResult self) -> IMP::String"""
1448 return _IMP_em2d.RegistrationResult_get_name(self)
1451 r"""get_ccc(RegistrationResult self) -> double"""
1452 return _IMP_em2d.RegistrationResult_get_ccc(self)
1454 def set_ccc(self, ccc):
1455 r"""set_ccc(RegistrationResult self, double ccc)"""
1456 return _IMP_em2d.RegistrationResult_set_ccc(self, ccc)
1458 def get_score(self):
1459 r"""get_score(RegistrationResult self) -> double"""
1460 return _IMP_em2d.RegistrationResult_get_score(self)
1462 def set_score(self, Score):
1463 r"""set_score(RegistrationResult self, double Score)"""
1464 return _IMP_em2d.RegistrationResult_set_score(self, Score)
1466 def set_rotation(self, *args):
1468 set_rotation(RegistrationResult self, double phi, double theta, double psi)
1469 set_rotation(RegistrationResult self, Rotation3D R)
1471 return _IMP_em2d.RegistrationResult_set_rotation(self, *args)
1473 def set_shift(self, shift):
1474 r"""set_shift(RegistrationResult self, Vector2D shift)"""
1475 return _IMP_em2d.RegistrationResult_set_shift(self, shift)
1477 def set_name(self, name):
1478 r"""set_name(RegistrationResult self, IMP::String name)"""
1479 return _IMP_em2d.RegistrationResult_set_name(self, name)
1481 def add_in_plane_transformation(self, t):
1482 r"""add_in_plane_transformation(RegistrationResult self, Transformation2D t)"""
1483 return _IMP_em2d.RegistrationResult_add_in_plane_transformation(self, t)
1485 def show(self, *args):
1486 r"""show(RegistrationResult self, _ostream out=std::cout)"""
1487 return _IMP_em2d.RegistrationResult_show(self, *args)
1489 def write(self, *args):
1490 r"""write(RegistrationResult self, _ostream out=std::cout)"""
1491 return _IMP_em2d.RegistrationResult_write(self, *args)
1493 def write_comment_line(self, *args):
1494 r"""write_comment_line(RegistrationResult self, _ostream out=std::cout)"""
1495 return _IMP_em2d.RegistrationResult_write_comment_line(self, *args)
1498 r"""read(RegistrationResult self, IMP::String const & s)"""
1499 return _IMP_em2d.RegistrationResult_read(self, s)
1501 def set_random_registration(self, index, maximum_shift):
1502 r"""set_random_registration(RegistrationResult self, unsigned int index, double maximum_shift)"""
1503 return _IMP_em2d.RegistrationResult_set_random_registration(self, index, maximum_shift)
1505 def get_rotation(self):
1506 r"""get_rotation(RegistrationResult self) -> Rotation3D"""
1507 return _IMP_em2d.RegistrationResult_get_rotation(self)
1509 def set_in_image(self, header):
1510 r"""set_in_image(RegistrationResult self, ImageHeader header)"""
1511 return _IMP_em2d.RegistrationResult_set_in_image(self, header)
1513 def read_from_image(self, header):
1514 r"""read_from_image(RegistrationResult self, ImageHeader header)"""
1515 return _IMP_em2d.RegistrationResult_read_from_image(self, header)
1517 def get_is_optimized_result(self):
1518 r"""get_is_optimized_result(RegistrationResult self) -> bool"""
1519 return _IMP_em2d.RegistrationResult_get_is_optimized_result(self)
1520 __swig_destroy__ = _IMP_em2d.delete_RegistrationResult
1523 r"""__str__(RegistrationResult self) -> std::string"""
1524 return _IMP_em2d.RegistrationResult___str__(self)
1527 r"""__repr__(RegistrationResult self) -> std::string"""
1528 return _IMP_em2d.RegistrationResult___repr__(self)
1530 def _get_as_binary(self):
1531 r"""_get_as_binary(RegistrationResult self) -> PyObject *"""
1532 return _IMP_em2d.RegistrationResult__get_as_binary(self)
1534 def _set_from_binary(self, p):
1535 r"""_set_from_binary(RegistrationResult self, PyObject * p)"""
1536 return _IMP_em2d.RegistrationResult__set_from_binary(self, p)
1538 def __getstate__(self):
1539 p = self._get_as_binary()
1540 if len(self.__dict__) > 1:
1541 d = self.__dict__.copy()
1546 def __setstate__(self, p):
1547 if not hasattr(self,
'this'):
1549 if isinstance(p, tuple):
1551 self.__dict__.update(d)
1552 return self._set_from_binary(p)
1556 _IMP_em2d.RegistrationResult_swigregister(RegistrationResult)
1559 r"""read_registration_results(IMP::String const & filename) -> IMP::em2d::RegistrationResults"""
1560 return _IMP_em2d.read_registration_results(filename)
1563 r"""write_registration_results(IMP::String filename, IMP::em2d::RegistrationResults const & results)"""
1564 return _IMP_em2d.write_registration_results(filename, results)
1567 r"""get_random_registration_results(unsigned int n, double maximum_shift=5.0) -> IMP::em2d::RegistrationResults"""
1568 return _IMP_em2d.get_random_registration_results(n, maximum_shift)
1571 r"""get_evenly_distributed_registration_results(unsigned int n_projections) -> IMP::em2d::RegistrationResults"""
1572 return _IMP_em2d.get_evenly_distributed_registration_results(n_projections)
1573 class SpiderImageReaderWriter(ImageReaderWriter):
1574 r"""Proxy of C++ IMP::em2d::SpiderImageReaderWriter class."""
1576 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1577 filename_ = property(_IMP_em2d.SpiderImageReaderWriter_filename__get, _IMP_em2d.SpiderImageReaderWriter_filename__set, doc=
r"""filename_ : IMP::String""")
1578 skip_type_check_ = property(_IMP_em2d.SpiderImageReaderWriter_skip_type_check__get, _IMP_em2d.SpiderImageReaderWriter_skip_type_check__set, doc=
r"""skip_type_check_ : bool""")
1579 force_reversed_ = property(_IMP_em2d.SpiderImageReaderWriter_force_reversed__get, _IMP_em2d.SpiderImageReaderWriter_force_reversed__set, doc=
r"""force_reversed_ : bool""")
1580 skip_extra_checkings_ = property(_IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__get, _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__set, doc=
r"""skip_extra_checkings_ : bool""")
1582 def __init__(self, *args):
1584 __init__(SpiderImageReaderWriter self) -> SpiderImageReaderWriter
1585 __init__(SpiderImageReaderWriter self, IMP::String const & filename, bool skip_type_check, bool force_reversed, bool skip_extra_checkings) -> SpiderImageReaderWriter
1587 _IMP_em2d.SpiderImageReaderWriter_swiginit(self, _IMP_em2d.new_SpiderImageReaderWriter(*args))
1588 __swig_destroy__ = _IMP_em2d.delete_SpiderImageReaderWriter
1591 r"""__str__(SpiderImageReaderWriter self) -> std::string"""
1592 return _IMP_em2d.SpiderImageReaderWriter___str__(self)
1595 r"""__repr__(SpiderImageReaderWriter self) -> std::string"""
1596 return _IMP_em2d.SpiderImageReaderWriter___repr__(self)
1600 return _object_cast_to_SpiderImageReaderWriter(o)
1604 _IMP_em2d.SpiderImageReaderWriter_swigregister(SpiderImageReaderWriter)
1605 class JPGImageReaderWriter(ImageReaderWriter):
1606 r"""Proxy of C++ IMP::em2d::JPGImageReaderWriter class."""
1608 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1611 r"""__init__(JPGImageReaderWriter self) -> JPGImageReaderWriter"""
1612 _IMP_em2d.JPGImageReaderWriter_swiginit(self, _IMP_em2d.new_JPGImageReaderWriter())
1613 __swig_destroy__ = _IMP_em2d.delete_JPGImageReaderWriter
1616 r"""__str__(JPGImageReaderWriter self) -> std::string"""
1617 return _IMP_em2d.JPGImageReaderWriter___str__(self)
1620 r"""__repr__(JPGImageReaderWriter self) -> std::string"""
1621 return _IMP_em2d.JPGImageReaderWriter___repr__(self)
1625 return _object_cast_to_JPGImageReaderWriter(o)
1629 _IMP_em2d.JPGImageReaderWriter_swigregister(JPGImageReaderWriter)
1630 class TIFFImageReaderWriter(ImageReaderWriter):
1631 r"""Proxy of C++ IMP::em2d::TIFFImageReaderWriter class."""
1633 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1636 r"""__init__(TIFFImageReaderWriter self) -> TIFFImageReaderWriter"""
1637 _IMP_em2d.TIFFImageReaderWriter_swiginit(self, _IMP_em2d.new_TIFFImageReaderWriter())
1638 __swig_destroy__ = _IMP_em2d.delete_TIFFImageReaderWriter
1641 r"""__str__(TIFFImageReaderWriter self) -> std::string"""
1642 return _IMP_em2d.TIFFImageReaderWriter___str__(self)
1645 r"""__repr__(TIFFImageReaderWriter self) -> std::string"""
1646 return _IMP_em2d.TIFFImageReaderWriter___repr__(self)
1650 return _object_cast_to_TIFFImageReaderWriter(o)
1654 _IMP_em2d.TIFFImageReaderWriter_swigregister(TIFFImageReaderWriter)
1657 r"""do_matrix_to_image_flip(cv::Mat & m)"""
1658 return _IMP_em2d.do_matrix_to_image_flip(m)
1661 r"""get_autocorrelation2d_no_preprocessing(cv::Mat const & M, cv::Mat & corr)"""
1662 return _IMP_em2d.get_autocorrelation2d_no_preprocessing(M, corr)
1666 get_autocorrelation2d(Image im1, Image im2)
1667 get_autocorrelation2d(cv::Mat const & m, cv::Mat & corr)
1669 return _IMP_em2d.get_autocorrelation2d(*args)
1673 get_correlation2d(Image im1, Image im2, Image corr)
1674 get_correlation2d(cv::Mat const & A, cv::Mat const & B, cv::Mat & corr)
1676 return _IMP_em2d.get_correlation2d(*args)
1679 r"""get_correlation2d_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2, cv::Mat & corr)"""
1680 return _IMP_em2d.get_correlation2d_no_preprocessing(M1, M2, corr)
1683 r"""get_fft_using_optimal_size(cv::Mat const & m, cv::Mat & M)"""
1684 return _IMP_em2d.get_fft_using_optimal_size(m, M)
1687 r"""get_spectrum(cv::Mat const & m, cv::Mat & real, cv::Mat & imag)"""
1688 return _IMP_em2d.get_spectrum(m, real, imag)
1691 r"""get_rotation_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
1692 return _IMP_em2d.get_rotation_error(rr1, rr2)
1695 r"""get_shift_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
1696 return _IMP_em2d.get_shift_error(rr1, rr2)
1698 def get_average_rotation_error(correct_RRs, computed_RRs):
1699 r"""get_average_rotation_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
1700 return _IMP_em2d.get_average_rotation_error(correct_RRs, computed_RRs)
1702 def get_average_shift_error(correct_RRs, computed_RRs):
1703 r"""get_average_shift_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
1704 return _IMP_em2d.get_average_shift_error(correct_RRs, computed_RRs)
1708 get_cross_correlation_coefficient(Image im1, Image im2) -> double
1709 get_cross_correlation_coefficient(cv::Mat const & m1, cv::Mat const & m2) -> double
1711 return _IMP_em2d.get_cross_correlation_coefficient(*args)
1714 r"""get_global_score(IMP::em2d::RegistrationResults const & RRs) -> double"""
1715 return _IMP_em2d.get_global_score(RRs)
1717 r"""Proxy of C++ IMP::em2d::ScoreFunction class."""
1719 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1721 def __init__(self, *args, **kwargs):
1722 raise AttributeError(
"No constructor defined - class is abstract")
1724 def get_score(self, image, projection):
1725 r"""get_score(ScoreFunction self, Image image, Image projection) -> double"""
1726 return _IMP_em2d.ScoreFunction_get_score(self, image, projection)
1728 def set_variance_image(self, var):
1729 r"""set_variance_image(ScoreFunction self, Image var)"""
1730 return _IMP_em2d.ScoreFunction_set_variance_image(self, var)
1732 def get_version_info(self):
1733 r"""get_version_info(ScoreFunction self) -> VersionInfo"""
1734 return _IMP_em2d.ScoreFunction_get_version_info(self)
1735 __swig_destroy__ = _IMP_em2d.delete_ScoreFunction
1738 r"""__str__(ScoreFunction self) -> std::string"""
1739 return _IMP_em2d.ScoreFunction___str__(self)
1742 r"""__repr__(ScoreFunction self) -> std::string"""
1743 return _IMP_em2d.ScoreFunction___repr__(self)
1747 return _object_cast_to_ScoreFunction(o)
1751 _IMP_em2d.ScoreFunction_swigregister(ScoreFunction)
1752 class ChiSquaredScore(ScoreFunction):
1753 r"""Proxy of C++ IMP::em2d::ChiSquaredScore class."""
1755 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1758 r"""__init__(ChiSquaredScore self) -> ChiSquaredScore"""
1759 _IMP_em2d.ChiSquaredScore_swiginit(self, _IMP_em2d.new_ChiSquaredScore())
1762 r"""__str__(ChiSquaredScore self) -> std::string"""
1763 return _IMP_em2d.ChiSquaredScore___str__(self)
1766 r"""__repr__(ChiSquaredScore self) -> std::string"""
1767 return _IMP_em2d.ChiSquaredScore___repr__(self)
1771 return _object_cast_to_ChiSquaredScore(o)
1773 __swig_destroy__ = _IMP_em2d.delete_ChiSquaredScore
1776 _IMP_em2d.ChiSquaredScore_swigregister(ChiSquaredScore)
1777 class EM2DScore(ScoreFunction):
1778 r"""Proxy of C++ IMP::em2d::EM2DScore class."""
1780 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1783 r"""__init__(EM2DScore self) -> EM2DScore"""
1784 _IMP_em2d.EM2DScore_swiginit(self, _IMP_em2d.new_EM2DScore())
1787 r"""__str__(EM2DScore self) -> std::string"""
1788 return _IMP_em2d.EM2DScore___str__(self)
1791 r"""__repr__(EM2DScore self) -> std::string"""
1792 return _IMP_em2d.EM2DScore___repr__(self)
1796 return _object_cast_to_EM2DScore(o)
1798 __swig_destroy__ = _IMP_em2d.delete_EM2DScore
1801 _IMP_em2d.EM2DScore_swigregister(EM2DScore)
1802 class MeanAbsoluteDifference(ScoreFunction):
1803 r"""Proxy of C++ IMP::em2d::MeanAbsoluteDifference class."""
1805 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1808 r"""__init__(MeanAbsoluteDifference self) -> MeanAbsoluteDifference"""
1809 _IMP_em2d.MeanAbsoluteDifference_swiginit(self, _IMP_em2d.new_MeanAbsoluteDifference())
1812 r"""__str__(MeanAbsoluteDifference self) -> std::string"""
1813 return _IMP_em2d.MeanAbsoluteDifference___str__(self)
1816 r"""__repr__(MeanAbsoluteDifference self) -> std::string"""
1817 return _IMP_em2d.MeanAbsoluteDifference___repr__(self)
1821 return _object_cast_to_MeanAbsoluteDifference(o)
1823 __swig_destroy__ = _IMP_em2d.delete_MeanAbsoluteDifference
1826 _IMP_em2d.MeanAbsoluteDifference_swigregister(MeanAbsoluteDifference)
1829 r"""read_selection_file(IMP::String fn) -> IMP::Strings"""
1830 return _IMP_em2d.read_selection_file(fn)
1833 r"""create_filenames(unsigned long number, IMP::String basic_name, IMP::String extension) -> IMP::Strings"""
1834 return _IMP_em2d.create_filenames(number, basic_name, extension)
1836 r"""Proxy of C++ IMP::em2d::ProjectionParameters class."""
1838 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
1840 def __init__(self, *args):
1842 __init__(ProjectionParameters self) -> ProjectionParameters
1843 __init__(ProjectionParameters self, Model m, ParticleIndex id) -> ProjectionParameters
1844 __init__(ProjectionParameters self, _ParticleAdaptor d) -> ProjectionParameters
1846 _IMP_em2d.ProjectionParameters_swiginit(self, _IMP_em2d.new_ProjectionParameters(*args))
1848 def show(self, *args):
1849 r"""show(ProjectionParameters self, _ostream out=std::cout)"""
1850 return _IMP_em2d.ProjectionParameters_show(self, *args)
1853 def setup_particle(*args):
1855 setup_particle(Model m, ParticleIndex pi) -> ProjectionParameters
1856 setup_particle(_ParticleAdaptor pa) -> ProjectionParameters
1858 return _IMP_em2d.ProjectionParameters_setup_particle(*args)
1859 __swig_destroy__ = _IMP_em2d.delete_ProjectionParameters
1863 r"""get_keys() -> IMP::FloatKeys const &"""
1864 return _IMP_em2d.ProjectionParameters_get_keys()
1866 def set_proper_ranges_for_keys(self, m, min_translation_values, max_translation_values):
1867 r"""set_proper_ranges_for_keys(ProjectionParameters self, Model m, Vector3D min_translation_values, Vector3D max_translation_values)"""
1868 return _IMP_em2d.ProjectionParameters_set_proper_ranges_for_keys(self, m, min_translation_values, max_translation_values)
1871 def get_is_setup(*args):
1873 get_is_setup(_ParticleAdaptor p) -> bool
1874 get_is_setup(Model m, ParticleIndex pi) -> bool
1876 return _IMP_em2d.ProjectionParameters_get_is_setup(*args)
1878 def get_parameters_optimized(self):
1879 r"""get_parameters_optimized(ProjectionParameters self) -> bool"""
1880 return _IMP_em2d.ProjectionParameters_get_parameters_optimized(self)
1882 def get_translation(self):
1883 r"""get_translation(ProjectionParameters self) -> Vector3D"""
1884 return _IMP_em2d.ProjectionParameters_get_translation(self)
1886 def set_translation(self, v):
1887 r"""set_translation(ProjectionParameters self, Vector3D v)"""
1888 return _IMP_em2d.ProjectionParameters_set_translation(self, v)
1890 def get_rotation(self):
1891 r"""get_rotation(ProjectionParameters self) -> Rotation3D"""
1892 return _IMP_em2d.ProjectionParameters_get_rotation(self)
1894 def set_rotation(self, R):
1895 r"""set_rotation(ProjectionParameters self, Rotation3D R)"""
1896 return _IMP_em2d.ProjectionParameters_set_rotation(self, R)
1898 def set_parameters_optimized(self, tf):
1899 r"""set_parameters_optimized(ProjectionParameters self, bool tf)"""
1900 return _IMP_em2d.ProjectionParameters_set_parameters_optimized(self, tf)
1902 def get_quaternion_1(self):
1903 r"""get_quaternion_1(ProjectionParameters self) -> double"""
1904 return _IMP_em2d.ProjectionParameters_get_quaternion_1(self)
1906 def set_quaternion_1(self, t):
1907 r"""set_quaternion_1(ProjectionParameters self, double t)"""
1908 return _IMP_em2d.ProjectionParameters_set_quaternion_1(self, t)
1910 def get_quaternion_2(self):
1911 r"""get_quaternion_2(ProjectionParameters self) -> double"""
1912 return _IMP_em2d.ProjectionParameters_get_quaternion_2(self)
1914 def set_quaternion_2(self, t):
1915 r"""set_quaternion_2(ProjectionParameters self, double t)"""
1916 return _IMP_em2d.ProjectionParameters_set_quaternion_2(self, t)
1918 def get_quaternion_3(self):
1919 r"""get_quaternion_3(ProjectionParameters self) -> double"""
1920 return _IMP_em2d.ProjectionParameters_get_quaternion_3(self)
1922 def set_quaternion_3(self, t):
1923 r"""set_quaternion_3(ProjectionParameters self, double t)"""
1924 return _IMP_em2d.ProjectionParameters_set_quaternion_3(self, t)
1926 def get_quaternion_4(self):
1927 r"""get_quaternion_4(ProjectionParameters self) -> double"""
1928 return _IMP_em2d.ProjectionParameters_get_quaternion_4(self)
1930 def set_quaternion_4(self, t):
1931 r"""set_quaternion_4(ProjectionParameters self, double t)"""
1932 return _IMP_em2d.ProjectionParameters_set_quaternion_4(self, t)
1934 def get_translation_x(self):
1935 r"""get_translation_x(ProjectionParameters self) -> double"""
1936 return _IMP_em2d.ProjectionParameters_get_translation_x(self)
1938 def set_translation_x(self, t):
1939 r"""set_translation_x(ProjectionParameters self, double t)"""
1940 return _IMP_em2d.ProjectionParameters_set_translation_x(self, t)
1942 def get_translation_y(self):
1943 r"""get_translation_y(ProjectionParameters self) -> double"""
1944 return _IMP_em2d.ProjectionParameters_get_translation_y(self)
1946 def set_translation_y(self, t):
1947 r"""set_translation_y(ProjectionParameters self, double t)"""
1948 return _IMP_em2d.ProjectionParameters_set_translation_y(self, t)
1950 def add_attribute(self, *args):
1952 add_attribute(ProjectionParameters self, FloatKey k, IMP::Float v, bool opt)
1953 add_attribute(ProjectionParameters self, FloatKey a0, IMP::Float a1)
1954 add_attribute(ProjectionParameters self, IntKey a0, IMP::Int a1)
1955 add_attribute(ProjectionParameters self, FloatsKey a0, IMP::Floats a1)
1956 add_attribute(ProjectionParameters self, IntsKey a0, IMP::Ints a1)
1957 add_attribute(ProjectionParameters self, StringKey a0, IMP::String a1)
1958 add_attribute(ProjectionParameters self, ParticleIndexKey a0, Particle a1)
1959 add_attribute(ProjectionParameters self, ObjectKey a0, Object a1)
1960 add_attribute(ProjectionParameters self, SparseFloatKey a0, IMP::Float a1)
1961 add_attribute(ProjectionParameters self, SparseIntKey a0, IMP::Int a1)
1962 add_attribute(ProjectionParameters self, SparseStringKey a0, IMP::String a1)
1963 add_attribute(ProjectionParameters self, SparseParticleIndexKey a0, ParticleIndex a1)
1965 return _IMP_em2d.ProjectionParameters_add_attribute(self, *args)
1967 def get_value(self, *args):
1969 get_value(ProjectionParameters self, FloatKey a0) -> IMP::Float
1970 get_value(ProjectionParameters self, IntKey a0) -> IMP::Int
1971 get_value(ProjectionParameters self, FloatsKey a0) -> IMP::Floats
1972 get_value(ProjectionParameters self, IntsKey a0) -> IMP::Ints
1973 get_value(ProjectionParameters self, StringKey a0) -> IMP::String
1974 get_value(ProjectionParameters self, ParticleIndexKey a0) -> Particle
1975 get_value(ProjectionParameters self, ObjectKey a0) -> Object
1976 get_value(ProjectionParameters self, SparseFloatKey a0) -> IMP::Float
1977 get_value(ProjectionParameters self, SparseIntKey a0) -> IMP::Int
1978 get_value(ProjectionParameters self, SparseStringKey a0) -> IMP::String
1979 get_value(ProjectionParameters self, SparseParticleIndexKey a0) -> ParticleIndex
1981 return _IMP_em2d.ProjectionParameters_get_value(self, *args)
1983 def set_value(self, *args):
1985 set_value(ProjectionParameters self, FloatKey a0, IMP::Float a1)
1986 set_value(ProjectionParameters self, IntKey a0, IMP::Int a1)
1987 set_value(ProjectionParameters self, FloatsKey a0, IMP::Floats a1)
1988 set_value(ProjectionParameters self, IntsKey a0, IMP::Ints a1)
1989 set_value(ProjectionParameters self, StringKey a0, IMP::String a1)
1990 set_value(ProjectionParameters self, ParticleIndexKey a0, Particle a1)
1991 set_value(ProjectionParameters self, ObjectKey a0, Object a1)
1992 set_value(ProjectionParameters self, SparseFloatKey a0, IMP::Float a1)
1993 set_value(ProjectionParameters self, SparseIntKey a0, IMP::Int a1)
1994 set_value(ProjectionParameters self, SparseStringKey a0, IMP::String a1)
1995 set_value(ProjectionParameters self, SparseParticleIndexKey a0, ParticleIndex a1)
1997 return _IMP_em2d.ProjectionParameters_set_value(self, *args)
1999 def remove_attribute(self, *args):
2001 remove_attribute(ProjectionParameters self, FloatKey a0)
2002 remove_attribute(ProjectionParameters self, IntKey a0)
2003 remove_attribute(ProjectionParameters self, FloatsKey a0)
2004 remove_attribute(ProjectionParameters self, IntsKey a0)
2005 remove_attribute(ProjectionParameters self, StringKey a0)
2006 remove_attribute(ProjectionParameters self, ParticleIndexKey a0)
2007 remove_attribute(ProjectionParameters self, ObjectKey a0)
2008 remove_attribute(ProjectionParameters self, SparseFloatKey a0)
2009 remove_attribute(ProjectionParameters self, SparseIntKey a0)
2010 remove_attribute(ProjectionParameters self, SparseStringKey a0)
2011 remove_attribute(ProjectionParameters self, SparseParticleIndexKey a0)
2013 return _IMP_em2d.ProjectionParameters_remove_attribute(self, *args)
2015 def has_attribute(self, *args):
2017 has_attribute(ProjectionParameters self, FloatKey a0) -> bool
2018 has_attribute(ProjectionParameters self, IntKey a0) -> bool
2019 has_attribute(ProjectionParameters self, FloatsKey a0) -> bool
2020 has_attribute(ProjectionParameters self, IntsKey a0) -> bool
2021 has_attribute(ProjectionParameters self, StringKey a0) -> bool
2022 has_attribute(ProjectionParameters self, ParticleIndexKey a0) -> bool
2023 has_attribute(ProjectionParameters self, ObjectKey a0) -> bool
2024 has_attribute(ProjectionParameters self, SparseFloatKey a0) -> bool
2025 has_attribute(ProjectionParameters self, SparseIntKey a0) -> bool
2026 has_attribute(ProjectionParameters self, SparseStringKey a0) -> bool
2027 has_attribute(ProjectionParameters self, SparseParticleIndexKey a0) -> bool
2029 return _IMP_em2d.ProjectionParameters_has_attribute(self, *args)
2031 def get_derivative(self, a0):
2032 r"""get_derivative(ProjectionParameters self, FloatKey a0) -> double"""
2033 return _IMP_em2d.ProjectionParameters_get_derivative(self, a0)
2036 r"""get_name(ProjectionParameters self) -> std::string"""
2037 return _IMP_em2d.ProjectionParameters_get_name(self)
2039 def clear_caches(self):
2040 r"""clear_caches(ProjectionParameters self)"""
2041 return _IMP_em2d.ProjectionParameters_clear_caches(self)
2043 def set_name(self, a0):
2044 r"""set_name(ProjectionParameters self, std::string a0)"""
2045 return _IMP_em2d.ProjectionParameters_set_name(self, a0)
2048 r"""set_check_level(ProjectionParameters self, IMP::CheckLevel a0)"""
2049 return _IMP_em2d.ProjectionParameters_set_check_level(self, a0)
2051 def add_to_derivative(self, a0, a1, a2):
2052 r"""add_to_derivative(ProjectionParameters self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
2053 return _IMP_em2d.ProjectionParameters_add_to_derivative(self, a0, a1, a2)
2055 def set_is_optimized(self, a0, a1):
2056 r"""set_is_optimized(ProjectionParameters self, FloatKey a0, bool a1)"""
2057 return _IMP_em2d.ProjectionParameters_set_is_optimized(self, a0, a1)
2059 def get_is_optimized(self, a0):
2060 r"""get_is_optimized(ProjectionParameters self, FloatKey a0) -> bool"""
2061 return _IMP_em2d.ProjectionParameters_get_is_optimized(self, a0)
2064 r"""get_check_level(ProjectionParameters self) -> IMP::CheckLevel"""
2065 return _IMP_em2d.ProjectionParameters_get_check_level(self)
2067 def __eq__(self, *args):
2069 __eq__(ProjectionParameters self, ProjectionParameters o) -> bool
2070 __eq__(ProjectionParameters self, Particle d) -> bool
2072 return _IMP_em2d.ProjectionParameters___eq__(self, *args)
2074 def __ne__(self, *args):
2076 __ne__(ProjectionParameters self, ProjectionParameters o) -> bool
2077 __ne__(ProjectionParameters self, Particle d) -> bool
2079 return _IMP_em2d.ProjectionParameters___ne__(self, *args)
2081 def __le__(self, *args):
2083 __le__(ProjectionParameters self, ProjectionParameters o) -> bool
2084 __le__(ProjectionParameters self, Particle d) -> bool
2086 return _IMP_em2d.ProjectionParameters___le__(self, *args)
2088 def __lt__(self, *args):
2090 __lt__(ProjectionParameters self, ProjectionParameters o) -> bool
2091 __lt__(ProjectionParameters self, Particle d) -> bool
2093 return _IMP_em2d.ProjectionParameters___lt__(self, *args)
2095 def __ge__(self, *args):
2097 __ge__(ProjectionParameters self, ProjectionParameters o) -> bool
2098 __ge__(ProjectionParameters self, Particle d) -> bool
2100 return _IMP_em2d.ProjectionParameters___ge__(self, *args)
2102 def __gt__(self, *args):
2104 __gt__(ProjectionParameters self, ProjectionParameters o) -> bool
2105 __gt__(ProjectionParameters self, Particle d) -> bool
2107 return _IMP_em2d.ProjectionParameters___gt__(self, *args)
2110 r"""__hash__(ProjectionParameters self) -> std::size_t"""
2111 return _IMP_em2d.ProjectionParameters___hash__(self)
2114 r"""__str__(ProjectionParameters self) -> std::string"""
2115 return _IMP_em2d.ProjectionParameters___str__(self)
2118 r"""__repr__(ProjectionParameters self) -> std::string"""
2119 return _IMP_em2d.ProjectionParameters___repr__(self)
2121 def _get_as_binary(self):
2122 r"""_get_as_binary(ProjectionParameters self) -> PyObject *"""
2123 return _IMP_em2d.ProjectionParameters__get_as_binary(self)
2125 def _set_from_binary(self, p):
2126 r"""_set_from_binary(ProjectionParameters self, PyObject * p)"""
2127 return _IMP_em2d.ProjectionParameters__set_from_binary(self, p)
2129 def __getstate__(self):
2130 p = self._get_as_binary()
2131 if len(self.__dict__) > 1:
2132 d = self.__dict__.copy()
2137 def __setstate__(self, p):
2138 if not hasattr(self,
'this'):
2140 if isinstance(p, tuple):
2142 self.__dict__.update(d)
2143 return self._set_from_binary(p)
2147 _IMP_em2d.ProjectionParameters_swigregister(ProjectionParameters)
2149 def __lshift__(out, n):
2150 r"""__lshift__(_ostream out, ProjectionParameters n) -> _ostream"""
2151 return _IMP_em2d.__lshift__(out, n)
2153 r"""Proxy of C++ IMP::em2d::ProjectionParametersScoreState class."""
2155 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2157 def __init__(self, p):
2158 r"""__init__(ProjectionParametersScoreState self, Particle p) -> ProjectionParametersScoreState"""
2159 _IMP_em2d.ProjectionParametersScoreState_swiginit(self, _IMP_em2d.new_ProjectionParametersScoreState(p))
2161 def do_before_evaluate(self):
2162 r"""do_before_evaluate(ProjectionParametersScoreState self)"""
2163 return _IMP_em2d.ProjectionParametersScoreState_do_before_evaluate(self)
2165 def do_after_evaluate(self, da):
2166 r"""do_after_evaluate(ProjectionParametersScoreState self, DerivativeAccumulator da)"""
2167 return _IMP_em2d.ProjectionParametersScoreState_do_after_evaluate(self, da)
2169 def do_get_inputs(self):
2170 r"""do_get_inputs(ProjectionParametersScoreState self) -> IMP::ModelObjectsTemp"""
2171 return _IMP_em2d.ProjectionParametersScoreState_do_get_inputs(self)
2173 def do_get_outputs(self):
2174 r"""do_get_outputs(ProjectionParametersScoreState self) -> IMP::ModelObjectsTemp"""
2175 return _IMP_em2d.ProjectionParametersScoreState_do_get_outputs(self)
2177 def get_version_info(self):
2178 r"""get_version_info(ProjectionParametersScoreState self) -> VersionInfo"""
2179 return _IMP_em2d.ProjectionParametersScoreState_get_version_info(self)
2180 __swig_destroy__ = _IMP_em2d.delete_ProjectionParametersScoreState
2183 r"""__str__(ProjectionParametersScoreState self) -> std::string"""
2184 return _IMP_em2d.ProjectionParametersScoreState___str__(self)
2187 r"""__repr__(ProjectionParametersScoreState self) -> std::string"""
2188 return _IMP_em2d.ProjectionParametersScoreState___repr__(self)
2192 return _object_cast_to_ProjectionParametersScoreState(o)
2196 _IMP_em2d.ProjectionParametersScoreState_swigregister(ProjectionParametersScoreState)
2197 class ProjectionMask(object):
2198 r"""Proxy of C++ IMP::em2d::ProjectionMask class."""
2200 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2203 r"""__init__(ProjectionMask self) -> ProjectionMask"""
2204 _IMP_em2d.ProjectionMask_swiginit(self, _IMP_em2d.new_ProjectionMask())
2206 def apply(self, m, v):
2207 r"""apply(ProjectionMask self, cv::Mat & m, Vector2D v)"""
2208 return _IMP_em2d.ProjectionMask_apply(self, m, v)
2210 def show(self, *args):
2211 r"""show(ProjectionMask self, _ostream out=std::cout)"""
2212 return _IMP_em2d.ProjectionMask_show(self, *args)
2213 __swig_destroy__ = _IMP_em2d.delete_ProjectionMask
2216 r"""__str__(ProjectionMask self) -> std::string"""
2217 return _IMP_em2d.ProjectionMask___str__(self)
2220 r"""__repr__(ProjectionMask self) -> std::string"""
2221 return _IMP_em2d.ProjectionMask___repr__(self)
2223 def _get_as_binary(self):
2224 r"""_get_as_binary(ProjectionMask self) -> PyObject *"""
2225 return _IMP_em2d.ProjectionMask__get_as_binary(self)
2227 def _set_from_binary(self, p):
2228 r"""_set_from_binary(ProjectionMask self, PyObject * p)"""
2229 return _IMP_em2d.ProjectionMask__set_from_binary(self, p)
2231 def __getstate__(self):
2232 p = self._get_as_binary()
2233 if len(self.__dict__) > 1:
2234 d = self.__dict__.copy()
2239 def __setstate__(self, p):
2240 if not hasattr(self,
'this'):
2242 if isinstance(p, tuple):
2244 self.__dict__.update(d)
2245 return self._set_from_binary(p)
2249 _IMP_em2d.ProjectionMask_swigregister(ProjectionMask)
2252 r"""do_place(cv::Mat & mask, cv::Mat & m, Vector2D v)"""
2253 return _IMP_em2d.do_place(mask, m, v)
2254 class MasksManager(object):
2255 r"""Proxy of C++ IMP::em2d::MasksManager class."""
2257 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2259 def __init__(self, *args):
2261 __init__(MasksManager self) -> MasksManager
2262 __init__(MasksManager self, double resolution, double pixelsize) -> MasksManager
2264 _IMP_em2d.MasksManager_swiginit(self, _IMP_em2d.new_MasksManager(*args))
2266 def setup_kernel(self, resolution, pixelsize):
2267 r"""setup_kernel(MasksManager self, double resolution, double pixelsize)"""
2268 return _IMP_em2d.MasksManager_setup_kernel(self, resolution, pixelsize)
2270 def create_masks(self, ps):
2271 r"""create_masks(MasksManager self, IMP::ParticlesTemp const & ps)"""
2272 return _IMP_em2d.MasksManager_create_masks(self, ps)
2274 def create_mask(self, mass):
2275 r"""create_mask(MasksManager self, double mass)"""
2276 return _IMP_em2d.MasksManager_create_mask(self, mass)
2278 def find_mask(self, mass):
2279 r"""find_mask(MasksManager self, double mass) -> IMP::em2d::ProjectionMaskPtr"""
2280 return _IMP_em2d.MasksManager_find_mask(self, mass)
2282 def show(self, *args):
2283 r"""show(MasksManager self, _ostream out=std::cout)"""
2284 return _IMP_em2d.MasksManager_show(self, *args)
2286 def get_number_of_masks(self):
2287 r"""get_number_of_masks(MasksManager self) -> unsigned int"""
2288 return _IMP_em2d.MasksManager_get_number_of_masks(self)
2289 __swig_destroy__ = _IMP_em2d.delete_MasksManager
2292 r"""__str__(MasksManager self) -> std::string"""
2293 return _IMP_em2d.MasksManager___str__(self)
2296 r"""__repr__(MasksManager self) -> std::string"""
2297 return _IMP_em2d.MasksManager___repr__(self)
2299 def _get_as_binary(self):
2300 r"""_get_as_binary(MasksManager self) -> PyObject *"""
2301 return _IMP_em2d.MasksManager__get_as_binary(self)
2303 def _set_from_binary(self, p):
2304 r"""_set_from_binary(MasksManager self, PyObject * p)"""
2305 return _IMP_em2d.MasksManager__set_from_binary(self, p)
2307 def __getstate__(self):
2308 p = self._get_as_binary()
2309 if len(self.__dict__) > 1:
2310 d = self.__dict__.copy()
2315 def __setstate__(self, p):
2316 if not hasattr(self,
'this'):
2318 if isinstance(p, tuple):
2320 self.__dict__.update(d)
2321 return self._set_from_binary(p)
2325 _IMP_em2d.MasksManager_swigregister(MasksManager)
2326 class ProjectingParameters(object):
2327 r"""Proxy of C++ IMP::em2d::ProjectingParameters class."""
2329 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2330 pixel_size = property(_IMP_em2d.ProjectingParameters_pixel_size_get, _IMP_em2d.ProjectingParameters_pixel_size_set, doc=
r"""pixel_size : double""")
2331 resolution = property(_IMP_em2d.ProjectingParameters_resolution_get, _IMP_em2d.ProjectingParameters_resolution_set, doc=
r"""resolution : double""")
2333 def __init__(self, *args):
2335 __init__(ProjectingParameters self) -> ProjectingParameters
2336 __init__(ProjectingParameters self, double ps, double res) -> ProjectingParameters
2338 _IMP_em2d.ProjectingParameters_swiginit(self, _IMP_em2d.new_ProjectingParameters(*args))
2340 def show(self, *args):
2341 r"""show(ProjectingParameters self, _ostream out=std::cout)"""
2342 return _IMP_em2d.ProjectingParameters_show(self, *args)
2345 r"""__str__(ProjectingParameters self) -> std::string"""
2346 return _IMP_em2d.ProjectingParameters___str__(self)
2349 r"""__repr__(ProjectingParameters self) -> std::string"""
2350 return _IMP_em2d.ProjectingParameters___repr__(self)
2352 def _get_as_binary(self):
2353 r"""_get_as_binary(ProjectingParameters self) -> PyObject *"""
2354 return _IMP_em2d.ProjectingParameters__get_as_binary(self)
2356 def _set_from_binary(self, p):
2357 r"""_set_from_binary(ProjectingParameters self, PyObject * p)"""
2358 return _IMP_em2d.ProjectingParameters__set_from_binary(self, p)
2360 def __getstate__(self):
2361 p = self._get_as_binary()
2362 if len(self.__dict__) > 1:
2363 d = self.__dict__.copy()
2368 def __setstate__(self, p):
2369 if not hasattr(self,
'this'):
2371 if isinstance(p, tuple):
2373 self.__dict__.update(d)
2374 return self._set_from_binary(p)
2376 __swig_destroy__ = _IMP_em2d.delete_ProjectingParameters
2379 _IMP_em2d.ProjectingParameters_swigregister(ProjectingParameters)
2380 class ProjectingOptions(ProjectingParameters):
2381 r"""Proxy of C++ IMP::em2d::ProjectingOptions class."""
2383 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2384 save_images = property(_IMP_em2d.ProjectingOptions_save_images_get, _IMP_em2d.ProjectingOptions_save_images_set, doc=
r"""save_images : bool""")
2385 normalize = property(_IMP_em2d.ProjectingOptions_normalize_get, _IMP_em2d.ProjectingOptions_normalize_set, doc=
r"""normalize : bool""")
2386 clear_matrix_before_projecting = property(_IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_get, _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_set, doc=
r"""clear_matrix_before_projecting : bool""")
2388 def __init__(self, *args):
2390 __init__(ProjectingOptions self) -> ProjectingOptions
2391 __init__(ProjectingOptions self, double ps, double res) -> ProjectingOptions
2392 __init__(ProjectingOptions self, double ps, double res, ImageReaderWriter irw) -> ProjectingOptions
2394 _IMP_em2d.ProjectingOptions_swiginit(self, _IMP_em2d.new_ProjectingOptions(*args))
2396 def show(self, *args):
2397 r"""show(ProjectingOptions self, _ostream out=std::cout)"""
2398 return _IMP_em2d.ProjectingOptions_show(self, *args)
2401 r"""__str__(ProjectingOptions self) -> std::string"""
2402 return _IMP_em2d.ProjectingOptions___str__(self)
2405 r"""__repr__(ProjectingOptions self) -> std::string"""
2406 return _IMP_em2d.ProjectingOptions___repr__(self)
2407 __swig_destroy__ = _IMP_em2d.delete_ProjectingOptions
2410 _IMP_em2d.ProjectingOptions_swigregister(ProjectingOptions)
2414 get_projections(IMP::ParticlesTemp const & ps, IMP::algebra::SphericalVector3Ds const & vs, int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
2415 get_projections(IMP::ParticlesTemp const & ps, IMP::em2d::RegistrationResults const & registration_values, int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
2417 return _IMP_em2d.get_projections(*args)
2420 r"""get_projection(Image img, IMP::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options, IMP::em2d::MasksManagerPtr masks=IMP::em2d::MasksManagerPtr(), IMP::String name="")"""
2421 return _IMP_em2d.get_projection(*args)
2424 r"""do_project_particles(IMP::ParticlesTemp const & ps, cv::Mat & m2, Rotation3D R, Vector3D translation, ProjectingOptions options, IMP::em2d::MasksManagerPtr masks)"""
2425 return _IMP_em2d.do_project_particles(ps, m2, R, translation, options, masks)
2428 r"""create_evenly_distributed_projections(IMP::ParticlesTemp const & ps, unsigned int n, ProjectingOptions options) -> IMP::em2d::Images"""
2429 return _IMP_em2d.create_evenly_distributed_projections(ps, n, options)
2433 do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation) -> IMP::algebra::Vector2Ds
2434 do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation, Vector3D center) -> IMP::algebra::Vector2Ds
2436 return _IMP_em2d.do_project_vectors(*args)
2439 r"""get_enclosing_image_size(IMP::ParticlesTemp const & ps, double pixel_size, unsigned int slack) -> unsigned int"""
2440 return _IMP_em2d.get_enclosing_image_size(ps, pixel_size, slack)
2443 r"""get_complete_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D"""
2444 return _IMP_em2d.get_complete_alignment(input, m_to_align, apply)
2447 r"""get_rotational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D"""
2448 return _IMP_em2d.get_rotational_alignment(input, m_to_align, apply)
2451 r"""get_translational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D"""
2452 return _IMP_em2d.get_translational_alignment(input, m_to_align, apply)
2455 r"""get_complete_alignment_no_preprocessing(cv::Mat const & input, cv::Mat const & INPUT, cv::Mat const & POLAR1, cv::Mat & m_to_align, cv::Mat const & POLAR2, bool apply=False) -> ResultAlign2D"""
2456 return _IMP_em2d.get_complete_alignment_no_preprocessing(input, INPUT, POLAR1, m_to_align, POLAR2, apply)
2459 r"""get_rotational_alignment_no_preprocessing(cv::Mat const & POLAR1, cv::Mat const & POLAR2) -> ResultAlign2D"""
2460 return _IMP_em2d.get_rotational_alignment_no_preprocessing(POLAR1, POLAR2)
2463 r"""get_translational_alignment_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2) -> ResultAlign2D"""
2464 return _IMP_em2d.get_translational_alignment_no_preprocessing(M1, M2)
2467 r"""get_complete_alignment_with_centers_no_preprocessing(Vector2D center1, Vector2D center2, cv::Mat const & AUTOC_POLAR1, cv::Mat const & AUTOC_POLAR2) -> ResultAlign2D"""
2468 return _IMP_em2d.get_complete_alignment_with_centers_no_preprocessing(center1, center2, AUTOC_POLAR1, AUTOC_POLAR2)
2472 write_vectors_as_pdb(IMP::algebra::Vector2Ds const vs, IMP::String const filename)
2473 write_vectors_as_pdb(IMP::algebra::Vector3Ds const vs, IMP::String const filename)
2475 return _IMP_em2d.write_vectors_as_pdb(*args)
2476 class Em2DRestraintParameters(ProjectingParameters):
2477 r"""Proxy of C++ IMP::em2d::Em2DRestraintParameters class."""
2479 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2480 n_projections = property(_IMP_em2d.Em2DRestraintParameters_n_projections_get, _IMP_em2d.Em2DRestraintParameters_n_projections_set, doc=
r"""n_projections : unsigned int""")
2481 coarse_registration_method = property(_IMP_em2d.Em2DRestraintParameters_coarse_registration_method_get, _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_set, doc=
r"""coarse_registration_method : unsigned int""")
2482 save_match_images = property(_IMP_em2d.Em2DRestraintParameters_save_match_images_get, _IMP_em2d.Em2DRestraintParameters_save_match_images_set, doc=
r"""save_match_images : bool""")
2483 optimization_steps = property(_IMP_em2d.Em2DRestraintParameters_optimization_steps_get, _IMP_em2d.Em2DRestraintParameters_optimization_steps_set, doc=
r"""optimization_steps : unsigned int""")
2484 simplex_initial_length = property(_IMP_em2d.Em2DRestraintParameters_simplex_initial_length_get, _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_set, doc=
r"""simplex_initial_length : double""")
2485 simplex_minimum_size = property(_IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_get, _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_set, doc=
r"""simplex_minimum_size : double""")
2487 def __init__(self, *args):
2489 __init__(Em2DRestraintParameters self) -> Em2DRestraintParameters
2490 __init__(Em2DRestraintParameters self, double ps, double res, unsigned int n_proj=20) -> Em2DRestraintParameters
2492 _IMP_em2d.Em2DRestraintParameters_swiginit(self, _IMP_em2d.new_Em2DRestraintParameters(*args))
2494 def show(self, *args):
2495 r"""show(Em2DRestraintParameters self, _ostream out=std::cout)"""
2496 return _IMP_em2d.Em2DRestraintParameters_show(self, *args)
2499 r"""__str__(Em2DRestraintParameters self) -> std::string"""
2500 return _IMP_em2d.Em2DRestraintParameters___str__(self)
2503 r"""__repr__(Em2DRestraintParameters self) -> std::string"""
2504 return _IMP_em2d.Em2DRestraintParameters___repr__(self)
2506 def _get_as_binary(self):
2507 r"""_get_as_binary(Em2DRestraintParameters self) -> PyObject *"""
2508 return _IMP_em2d.Em2DRestraintParameters__get_as_binary(self)
2510 def _set_from_binary(self, p):
2511 r"""_set_from_binary(Em2DRestraintParameters self, PyObject * p)"""
2512 return _IMP_em2d.Em2DRestraintParameters__set_from_binary(self, p)
2514 def __getstate__(self):
2515 p = self._get_as_binary()
2516 if len(self.__dict__) > 1:
2517 d = self.__dict__.copy()
2522 def __setstate__(self, p):
2523 if not hasattr(self,
'this'):
2525 if isinstance(p, tuple):
2527 self.__dict__.update(d)
2528 return self._set_from_binary(p)
2530 __swig_destroy__ = _IMP_em2d.delete_Em2DRestraintParameters
2533 _IMP_em2d.Em2DRestraintParameters_swigregister(Em2DRestraintParameters)
2534 cvar = _IMP_em2d.cvar
2535 ALIGN2D_NO_PREPROCESSING = cvar.ALIGN2D_NO_PREPROCESSING
2536 ALIGN2D_PREPROCESSING = cvar.ALIGN2D_PREPROCESSING
2537 ALIGN2D_WITH_CENTERS = cvar.ALIGN2D_WITH_CENTERS
2540 r"""Proxy of C++ IMP::em2d::ProjectionFinder class."""
2542 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2545 r"""__init__(ProjectionFinder self) -> ProjectionFinder"""
2546 _IMP_em2d.ProjectionFinder_swiginit(self, _IMP_em2d.new_ProjectionFinder())
2548 def setup(self, score_function, params):
2549 r"""setup(ProjectionFinder self, ScoreFunction score_function, Em2DRestraintParameters params)"""
2550 return _IMP_em2d.ProjectionFinder_setup(self, score_function, params)
2552 def set_subjects(self, subjects):
2553 r"""set_subjects(ProjectionFinder self, IMP::em2d::Images const & subjects)"""
2554 return _IMP_em2d.ProjectionFinder_set_subjects(self, subjects)
2556 def set_projections(self, projections):
2557 r"""set_projections(ProjectionFinder self, IMP::em2d::Images const & projections)"""
2558 return _IMP_em2d.ProjectionFinder_set_projections(self, projections)
2560 def set_variance_images(self, variances):
2561 r"""set_variance_images(ProjectionFinder self, IMP::em2d::Images const & variances)"""
2562 return _IMP_em2d.ProjectionFinder_set_variance_images(self, variances)
2564 def set_model_particles(self, ps):
2565 r"""set_model_particles(ProjectionFinder self, IMP::ParticlesTemp const & ps)"""
2566 return _IMP_em2d.ProjectionFinder_set_model_particles(self, ps)
2568 def set_save_match_images(self, x):
2569 r"""set_save_match_images(ProjectionFinder self, bool x)"""
2570 return _IMP_em2d.ProjectionFinder_set_save_match_images(self, x)
2572 def get_save_match_images(self):
2573 r"""get_save_match_images(ProjectionFinder self) -> bool"""
2574 return _IMP_em2d.ProjectionFinder_get_save_match_images(self)
2576 def set_fast_mode(self, n):
2577 r"""set_fast_mode(ProjectionFinder self, unsigned int n)"""
2578 return _IMP_em2d.ProjectionFinder_set_fast_mode(self, n)
2580 def get_registration_results(self):
2581 r"""get_registration_results(ProjectionFinder self) -> IMP::em2d::RegistrationResults"""
2582 return _IMP_em2d.ProjectionFinder_get_registration_results(self)
2584 def get_coarse_registration(self):
2585 r"""get_coarse_registration(ProjectionFinder self)"""
2586 return _IMP_em2d.ProjectionFinder_get_coarse_registration(self)
2588 def get_complete_registration(self):
2589 r"""get_complete_registration(ProjectionFinder self)"""
2590 return _IMP_em2d.ProjectionFinder_get_complete_registration(self)
2593 r"""get_global_score(ProjectionFinder self) -> double"""
2594 return _IMP_em2d.ProjectionFinder_get_global_score(self)
2596 def show(self, out):
2597 r"""show(ProjectionFinder self, _ostream out)"""
2598 return _IMP_em2d.ProjectionFinder_show(self, out)
2600 def get_preprocessing_time(self):
2601 r"""get_preprocessing_time(ProjectionFinder self) -> double"""
2602 return _IMP_em2d.ProjectionFinder_get_preprocessing_time(self)
2604 def get_coarse_registration_time(self):
2605 r"""get_coarse_registration_time(ProjectionFinder self) -> double"""
2606 return _IMP_em2d.ProjectionFinder_get_coarse_registration_time(self)
2608 def get_fine_registration_time(self):
2609 r"""get_fine_registration_time(ProjectionFinder self) -> double"""
2610 return _IMP_em2d.ProjectionFinder_get_fine_registration_time(self)
2612 def get_number_of_subjects(self):
2613 r"""get_number_of_subjects(ProjectionFinder self) -> unsigned int"""
2614 return _IMP_em2d.ProjectionFinder_get_number_of_subjects(self)
2616 def set_number_of_class_averages_members(self, n_members):
2617 r"""set_number_of_class_averages_members(ProjectionFinder self, IMP::Ints n_members)"""
2618 return _IMP_em2d.ProjectionFinder_set_number_of_class_averages_members(self, n_members)
2620 def get_number_of_projections(self):
2621 r"""get_number_of_projections(ProjectionFinder self) -> unsigned int"""
2622 return _IMP_em2d.ProjectionFinder_get_number_of_projections(self)
2624 def get_version_info(self):
2625 r"""get_version_info(ProjectionFinder self) -> VersionInfo"""
2626 return _IMP_em2d.ProjectionFinder_get_version_info(self)
2627 __swig_destroy__ = _IMP_em2d.delete_ProjectionFinder
2630 r"""__str__(ProjectionFinder self) -> std::string"""
2631 return _IMP_em2d.ProjectionFinder___str__(self)
2634 r"""__repr__(ProjectionFinder self) -> std::string"""
2635 return _IMP_em2d.ProjectionFinder___repr__(self)
2639 return _object_cast_to_ProjectionFinder(o)
2643 _IMP_em2d.ProjectionFinder_swigregister(ProjectionFinder)
2645 r"""Proxy of C++ IMP::em2d::Em2DRestraint class."""
2647 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2649 def __init__(self, m):
2650 r"""__init__(Em2DRestraint self, Model m) -> Em2DRestraint"""
2651 _IMP_em2d.Em2DRestraint_swiginit(self, _IMP_em2d.new_Em2DRestraint(m))
2653 def setup(self, score_function, params):
2654 r"""setup(Em2DRestraint self, ScoreFunction score_function, Em2DRestraintParameters params)"""
2655 return _IMP_em2d.Em2DRestraint_setup(self, score_function, params)
2657 def set_particles(self, particles_container):
2658 r"""set_particles(Em2DRestraint self, SingletonContainer particles_container)"""
2659 return _IMP_em2d.Em2DRestraint_set_particles(self, particles_container)
2661 def set_images(self, em_images):
2662 r"""set_images(Em2DRestraint self, IMP::em2d::Images const em_images)"""
2663 return _IMP_em2d.Em2DRestraint_set_images(self, em_images)
2665 def set_variance_images(self, variance_images):
2666 r"""set_variance_images(Em2DRestraint self, IMP::em2d::Images const variance_images)"""
2667 return _IMP_em2d.Em2DRestraint_set_variance_images(self, variance_images)
2669 def set_fast_mode(self, n):
2670 r"""set_fast_mode(Em2DRestraint self, unsigned int n)"""
2671 return _IMP_em2d.Em2DRestraint_set_fast_mode(self, n)
2673 def set_coarse_registration_mode(self, opt):
2674 r"""set_coarse_registration_mode(Em2DRestraint self, bool opt)"""
2675 return _IMP_em2d.Em2DRestraint_set_coarse_registration_mode(self, opt)
2677 def get_registration_results(self):
2678 r"""get_registration_results(Em2DRestraint self) -> IMP::em2d::RegistrationResults"""
2679 return _IMP_em2d.Em2DRestraint_get_registration_results(self)
2681 def do_get_inputs(self):
2682 r"""do_get_inputs(Em2DRestraint self) -> IMP::ModelObjectsTemp"""
2683 return _IMP_em2d.Em2DRestraint_do_get_inputs(self)
2685 def get_version_info(self):
2686 r"""get_version_info(Em2DRestraint self) -> VersionInfo"""
2687 return _IMP_em2d.Em2DRestraint_get_version_info(self)
2688 __swig_destroy__ = _IMP_em2d.delete_Em2DRestraint
2691 r"""__str__(Em2DRestraint self) -> std::string"""
2692 return _IMP_em2d.Em2DRestraint___str__(self)
2695 r"""__repr__(Em2DRestraint self) -> std::string"""
2696 return _IMP_em2d.Em2DRestraint___repr__(self)
2700 return _object_cast_to_Em2DRestraint(o)
2704 _IMP_em2d.Em2DRestraint_swigregister(Em2DRestraint)
2705 class ClusterSet(object):
2706 r"""Proxy of C++ IMP::em2d::ClusterSet class."""
2708 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2710 def __init__(self, *args):
2712 __init__(ClusterSet self) -> ClusterSet
2713 __init__(ClusterSet self, unsigned int N) -> ClusterSet
2715 _IMP_em2d.ClusterSet_swiginit(self, _IMP_em2d.new_ClusterSet(*args))
2717 def do_join_clusters(self, cluster_id1, cluster_id2, distance_between_clusters):
2718 r"""do_join_clusters(ClusterSet self, unsigned int cluster_id1, unsigned int cluster_id2, double distance_between_clusters)"""
2719 return _IMP_em2d.ClusterSet_do_join_clusters(self, cluster_id1, cluster_id2, distance_between_clusters)
2721 def get_cluster_elements(self, id):
2722 r"""get_cluster_elements(ClusterSet self, unsigned int id) -> IMP::Ints"""
2723 return _IMP_em2d.ClusterSet_get_cluster_elements(self, id)
2725 def get_clusters_below_cutoff(self, cutoff):
2726 r"""get_clusters_below_cutoff(ClusterSet self, double cutoff) -> IMP::Ints"""
2727 return _IMP_em2d.ClusterSet_get_clusters_below_cutoff(self, cutoff)
2729 def get_cluster_formed_at_step(self, step):
2730 r"""get_cluster_formed_at_step(ClusterSet self, unsigned int step) -> IMP::Ints"""
2731 return _IMP_em2d.ClusterSet_get_cluster_formed_at_step(self, step)
2733 def get_distance_at_step(self, step):
2734 r"""get_distance_at_step(ClusterSet self, unsigned int step) -> double"""
2735 return _IMP_em2d.ClusterSet_get_distance_at_step(self, step)
2737 def get_id_for_cluster_at_step(self, step):
2738 r"""get_id_for_cluster_at_step(ClusterSet self, unsigned int step) -> unsigned int"""
2739 return _IMP_em2d.ClusterSet_get_id_for_cluster_at_step(self, step)
2741 def get_linkage_matrix(self):
2742 r"""get_linkage_matrix(ClusterSet self) -> IMP::FloatsList"""
2743 return _IMP_em2d.ClusterSet_get_linkage_matrix(self)
2745 def get_linkage_matrix_in_matlab_format(self):
2746 r"""get_linkage_matrix_in_matlab_format(ClusterSet self) -> IMP::FloatsList"""
2747 return _IMP_em2d.ClusterSet_get_linkage_matrix_in_matlab_format(self)
2749 def get_number_of_steps(self):
2750 r"""get_number_of_steps(ClusterSet self) -> unsigned int"""
2751 return _IMP_em2d.ClusterSet_get_number_of_steps(self)
2753 def show(self, out):
2754 r"""show(ClusterSet self, _ostream out)"""
2755 return _IMP_em2d.ClusterSet_show(self, out)
2758 r"""__str__(ClusterSet self) -> std::string"""
2759 return _IMP_em2d.ClusterSet___str__(self)
2762 r"""__repr__(ClusterSet self) -> std::string"""
2763 return _IMP_em2d.ClusterSet___repr__(self)
2765 def _get_as_binary(self):
2766 r"""_get_as_binary(ClusterSet self) -> PyObject *"""
2767 return _IMP_em2d.ClusterSet__get_as_binary(self)
2769 def _set_from_binary(self, p):
2770 r"""_set_from_binary(ClusterSet self, PyObject * p)"""
2771 return _IMP_em2d.ClusterSet__set_from_binary(self, p)
2773 def __getstate__(self):
2774 p = self._get_as_binary()
2775 if len(self.__dict__) > 1:
2776 d = self.__dict__.copy()
2781 def __setstate__(self, p):
2782 if not hasattr(self,
'this'):
2784 if isinstance(p, tuple):
2786 self.__dict__.update(d)
2787 return self._set_from_binary(p)
2789 __swig_destroy__ = _IMP_em2d.delete_ClusterSet
2792 _IMP_em2d.ClusterSet_swigregister(ClusterSet)
2793 class SingleLinkage(object):
2794 r"""Proxy of C++ IMP::em2d::SingleLinkage class."""
2796 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2799 r"""__init__(SingleLinkage self) -> SingleLinkage"""
2800 _IMP_em2d.SingleLinkage_swiginit(self, _IMP_em2d.new_SingleLinkage())
2802 def __call__(self, id1, id2, cluster_set, distances):
2803 r"""__call__(SingleLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2804 return _IMP_em2d.SingleLinkage___call__(self, id1, id2, cluster_set, distances)
2806 def show(self, out):
2807 r"""show(SingleLinkage self, _ostream out)"""
2808 return _IMP_em2d.SingleLinkage_show(self, out)
2811 r"""__str__(SingleLinkage self) -> std::string"""
2812 return _IMP_em2d.SingleLinkage___str__(self)
2815 r"""__repr__(SingleLinkage self) -> std::string"""
2816 return _IMP_em2d.SingleLinkage___repr__(self)
2818 def _get_as_binary(self):
2819 r"""_get_as_binary(SingleLinkage self) -> PyObject *"""
2820 return _IMP_em2d.SingleLinkage__get_as_binary(self)
2822 def _set_from_binary(self, p):
2823 r"""_set_from_binary(SingleLinkage self, PyObject * p)"""
2824 return _IMP_em2d.SingleLinkage__set_from_binary(self, p)
2826 def __getstate__(self):
2827 p = self._get_as_binary()
2828 if len(self.__dict__) > 1:
2829 d = self.__dict__.copy()
2834 def __setstate__(self, p):
2835 if not hasattr(self,
'this'):
2837 if isinstance(p, tuple):
2839 self.__dict__.update(d)
2840 return self._set_from_binary(p)
2842 __swig_destroy__ = _IMP_em2d.delete_SingleLinkage
2845 _IMP_em2d.SingleLinkage_swigregister(SingleLinkage)
2846 class CompleteLinkage(object):
2847 r"""Proxy of C++ IMP::em2d::CompleteLinkage class."""
2849 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2852 r"""__init__(CompleteLinkage self) -> CompleteLinkage"""
2853 _IMP_em2d.CompleteLinkage_swiginit(self, _IMP_em2d.new_CompleteLinkage())
2855 def __call__(self, id1, id2, cluster_set, distances):
2856 r"""__call__(CompleteLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2857 return _IMP_em2d.CompleteLinkage___call__(self, id1, id2, cluster_set, distances)
2859 def show(self, out):
2860 r"""show(CompleteLinkage self, _ostream out)"""
2861 return _IMP_em2d.CompleteLinkage_show(self, out)
2864 r"""__str__(CompleteLinkage self) -> std::string"""
2865 return _IMP_em2d.CompleteLinkage___str__(self)
2868 r"""__repr__(CompleteLinkage self) -> std::string"""
2869 return _IMP_em2d.CompleteLinkage___repr__(self)
2871 def _get_as_binary(self):
2872 r"""_get_as_binary(CompleteLinkage self) -> PyObject *"""
2873 return _IMP_em2d.CompleteLinkage__get_as_binary(self)
2875 def _set_from_binary(self, p):
2876 r"""_set_from_binary(CompleteLinkage self, PyObject * p)"""
2877 return _IMP_em2d.CompleteLinkage__set_from_binary(self, p)
2879 def __getstate__(self):
2880 p = self._get_as_binary()
2881 if len(self.__dict__) > 1:
2882 d = self.__dict__.copy()
2887 def __setstate__(self, p):
2888 if not hasattr(self,
'this'):
2890 if isinstance(p, tuple):
2892 self.__dict__.update(d)
2893 return self._set_from_binary(p)
2895 __swig_destroy__ = _IMP_em2d.delete_CompleteLinkage
2898 _IMP_em2d.CompleteLinkage_swigregister(CompleteLinkage)
2899 class AverageDistanceLinkage(object):
2900 r"""Proxy of C++ IMP::em2d::AverageDistanceLinkage class."""
2902 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2905 r"""__init__(AverageDistanceLinkage self) -> AverageDistanceLinkage"""
2906 _IMP_em2d.AverageDistanceLinkage_swiginit(self, _IMP_em2d.new_AverageDistanceLinkage())
2908 def __call__(self, id1, id2, cluster_set, distances):
2909 r"""__call__(AverageDistanceLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2910 return _IMP_em2d.AverageDistanceLinkage___call__(self, id1, id2, cluster_set, distances)
2912 def show(self, out):
2913 r"""show(AverageDistanceLinkage self, _ostream out)"""
2914 return _IMP_em2d.AverageDistanceLinkage_show(self, out)
2917 r"""__str__(AverageDistanceLinkage self) -> std::string"""
2918 return _IMP_em2d.AverageDistanceLinkage___str__(self)
2921 r"""__repr__(AverageDistanceLinkage self) -> std::string"""
2922 return _IMP_em2d.AverageDistanceLinkage___repr__(self)
2924 def _get_as_binary(self):
2925 r"""_get_as_binary(AverageDistanceLinkage self) -> PyObject *"""
2926 return _IMP_em2d.AverageDistanceLinkage__get_as_binary(self)
2928 def _set_from_binary(self, p):
2929 r"""_set_from_binary(AverageDistanceLinkage self, PyObject * p)"""
2930 return _IMP_em2d.AverageDistanceLinkage__set_from_binary(self, p)
2932 def __getstate__(self):
2933 p = self._get_as_binary()
2934 if len(self.__dict__) > 1:
2935 d = self.__dict__.copy()
2940 def __setstate__(self, p):
2941 if not hasattr(self,
'this'):
2943 if isinstance(p, tuple):
2945 self.__dict__.update(d)
2946 return self._set_from_binary(p)
2948 __swig_destroy__ = _IMP_em2d.delete_AverageDistanceLinkage
2951 _IMP_em2d.AverageDistanceLinkage_swigregister(AverageDistanceLinkage)
2953 r"""Proxy of C++ IMP::em2d::CollisionCrossSection class."""
2955 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2957 def __init__(self, n_projections, resolution, pixel_size, projection_image_size):
2958 r"""__init__(CollisionCrossSection self, unsigned int n_projections, double resolution, double pixel_size, double projection_image_size) -> CollisionCrossSection"""
2959 _IMP_em2d.CollisionCrossSection_swiginit(self, _IMP_em2d.new_CollisionCrossSection(n_projections, resolution, pixel_size, projection_image_size))
2961 def set_model_particles(self, ps):
2962 r"""set_model_particles(CollisionCrossSection self, IMP::ParticlesTemp const & ps)"""
2963 return _IMP_em2d.CollisionCrossSection_set_model_particles(self, ps)
2966 r"""get_ccs(CollisionCrossSection self) -> double"""
2967 return _IMP_em2d.CollisionCrossSection_get_ccs(self)
2969 def show(self, out):
2970 r"""show(CollisionCrossSection self, _ostream out)"""
2971 return _IMP_em2d.CollisionCrossSection_show(self, out)
2973 def get_version_info(self):
2974 r"""get_version_info(CollisionCrossSection self) -> VersionInfo"""
2975 return _IMP_em2d.CollisionCrossSection_get_version_info(self)
2976 __swig_destroy__ = _IMP_em2d.delete_CollisionCrossSection
2979 r"""__str__(CollisionCrossSection self) -> std::string"""
2980 return _IMP_em2d.CollisionCrossSection___str__(self)
2983 r"""__repr__(CollisionCrossSection self) -> std::string"""
2984 return _IMP_em2d.CollisionCrossSection___repr__(self)
2988 return _object_cast_to_CollisionCrossSection(o)
2992 _IMP_em2d.CollisionCrossSection_swigregister(CollisionCrossSection)
2994 r"""Proxy of C++ IMP::em2d::GridStates class."""
2996 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
2998 def __init__(self, *args):
2999 r"""__init__(GridStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations, IMP::String const & name="GridStates") -> GridStates"""
3000 _IMP_em2d.GridStates_swiginit(self, _IMP_em2d.new_GridStates(*args))
3002 def get_position(self, i):
3003 r"""get_position(GridStates self, unsigned int i) -> Vector3D"""
3004 return _IMP_em2d.GridStates_get_position(self, i)
3006 def get_orientation(self, i):
3007 r"""get_orientation(GridStates self, unsigned int i) -> Rotation3D"""
3008 return _IMP_em2d.GridStates_get_orientation(self, i)
3010 def get_version_info(self):
3011 r"""get_version_info(GridStates self) -> VersionInfo"""
3012 return _IMP_em2d.GridStates_get_version_info(self)
3013 __swig_destroy__ = _IMP_em2d.delete_GridStates
3016 r"""__str__(GridStates self) -> std::string"""
3017 return _IMP_em2d.GridStates___str__(self)
3020 r"""__repr__(GridStates self) -> std::string"""
3021 return _IMP_em2d.GridStates___repr__(self)
3025 return _object_cast_to_GridStates(o)
3029 _IMP_em2d.GridStates_swigregister(GridStates)
3030 class ProjectionStates(GridStates):
3031 r"""Proxy of C++ IMP::em2d::ProjectionStates class."""
3033 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3035 def __init__(self, *args):
3036 r"""__init__(ProjectionStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations, IMP::em2d::Images const & projections, IMP::String const & name="ProjectionStates") -> ProjectionStates"""
3037 _IMP_em2d.ProjectionStates_swiginit(self, _IMP_em2d.new_ProjectionStates(*args))
3040 r"""get_projection(ProjectionStates self, unsigned int i) -> Image"""
3041 return _IMP_em2d.ProjectionStates_get_projection(self, i)
3042 __swig_destroy__ = _IMP_em2d.delete_ProjectionStates
3045 r"""__str__(ProjectionStates self) -> std::string"""
3046 return _IMP_em2d.ProjectionStates___str__(self)
3049 r"""__repr__(ProjectionStates self) -> std::string"""
3050 return _IMP_em2d.ProjectionStates___repr__(self)
3054 return _object_cast_to_ProjectionStates(o)
3058 _IMP_em2d.ProjectionStates_swigregister(ProjectionStates)
3060 r"""Proxy of C++ IMP::em2d::DistanceFilter class."""
3062 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3064 def __init__(self, subset_to_act_on, subset_to_restrain, ps_table, max_distance):
3065 r"""__init__(DistanceFilter self, Subset subset_to_act_on, Subset subset_to_restrain, ParticleStatesTable ps_table, double max_distance) -> DistanceFilter"""
3066 _IMP_em2d.DistanceFilter_swiginit(self, _IMP_em2d.new_DistanceFilter(subset_to_act_on, subset_to_restrain, ps_table, max_distance))
3068 def show(self, *args):
3069 r"""show(DistanceFilter self, _ostream out=std::cout)"""
3070 return _IMP_em2d.DistanceFilter_show(self, *args)
3072 def get_version_info(self):
3073 r"""get_version_info(DistanceFilter self) -> VersionInfo"""
3074 return _IMP_em2d.DistanceFilter_get_version_info(self)
3075 __swig_destroy__ = _IMP_em2d.delete_DistanceFilter
3078 r"""__str__(DistanceFilter self) -> std::string"""
3079 return _IMP_em2d.DistanceFilter___str__(self)
3082 r"""__repr__(DistanceFilter self) -> std::string"""
3083 return _IMP_em2d.DistanceFilter___repr__(self)
3087 return _object_cast_to_DistanceFilter(o)
3091 _IMP_em2d.DistanceFilter_swigregister(DistanceFilter)
3093 r"""Proxy of C++ IMP::em2d::DistanceFilterTable class."""
3095 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3097 def __init__(self, subset_to_act_on, ps_table, max_distance):
3098 r"""__init__(DistanceFilterTable self, Subset subset_to_act_on, ParticleStatesTable ps_table, double max_distance) -> DistanceFilterTable"""
3099 _IMP_em2d.DistanceFilterTable_swiginit(self, _IMP_em2d.new_DistanceFilterTable(subset_to_act_on, ps_table, max_distance))
3101 def show(self, *args):
3102 r"""show(DistanceFilterTable self, _ostream out=std::cout)"""
3103 return _IMP_em2d.DistanceFilterTable_show(self, *args)
3105 def get_version_info(self):
3106 r"""get_version_info(DistanceFilterTable self) -> VersionInfo"""
3107 return _IMP_em2d.DistanceFilterTable_get_version_info(self)
3108 __swig_destroy__ = _IMP_em2d.delete_DistanceFilterTable
3111 r"""__str__(DistanceFilterTable self) -> std::string"""
3112 return _IMP_em2d.DistanceFilterTable___str__(self)
3115 r"""__repr__(DistanceFilterTable self) -> std::string"""
3116 return _IMP_em2d.DistanceFilterTable___repr__(self)
3120 return _object_cast_to_DistanceFilterTable(o)
3124 _IMP_em2d.DistanceFilterTable_swigregister(DistanceFilterTable)
3125 class IntsOrder(object):
3126 r"""Proxy of C++ IMP::em2d::IntsOrder class."""
3128 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3129 __repr__ = _swig_repr
3131 def __call__(self, a, b):
3132 r"""__call__(IntsOrder self, IMP::Ints const & a, IMP::Ints const & b) -> bool"""
3133 return _IMP_em2d.IntsOrder___call__(self, a, b)
3136 r"""__init__(IntsOrder self) -> IntsOrder"""
3137 _IMP_em2d.IntsOrder_swiginit(self, _IMP_em2d.new_IntsOrder())
3138 __swig_destroy__ = _IMP_em2d.delete_IntsOrder
3141 _IMP_em2d.IntsOrder_swigregister(IntsOrder)
3143 r"""Proxy of C++ IMP::em2d::RigidBodiesImageFitRestraint class."""
3145 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3147 def get_version_info(self):
3148 r"""get_version_info(RigidBodiesImageFitRestraint self) -> VersionInfo"""
3149 return _IMP_em2d.RigidBodiesImageFitRestraint_get_version_info(self)
3150 __swig_destroy__ = _IMP_em2d.delete_RigidBodiesImageFitRestraint
3152 def __init__(self, scf, rbs, img):
3153 r"""__init__(RigidBodiesImageFitRestraint self, ScoreFunction scf, IMP::core::RigidBodies const & rbs, Image img) -> RigidBodiesImageFitRestraint"""
3154 _IMP_em2d.RigidBodiesImageFitRestraint_swiginit(self, _IMP_em2d.new_RigidBodiesImageFitRestraint(scf, rbs, img))
3156 def set_projecting_parameters(self, p):
3157 r"""set_projecting_parameters(RigidBodiesImageFitRestraint self, ProjectingParameters p)"""
3158 return _IMP_em2d.RigidBodiesImageFitRestraint_set_projecting_parameters(self, p)
3160 def set_orientations(self, rb, rots):
3161 r"""set_orientations(RigidBodiesImageFitRestraint self, RigidBody rb, IMP::algebra::Rotation3Ds const & rots)"""
3162 return _IMP_em2d.RigidBodiesImageFitRestraint_set_orientations(self, rb, rots)
3164 def get_number_of_masks(self, rb):
3165 r"""get_number_of_masks(RigidBodiesImageFitRestraint self, RigidBody rb) -> unsigned int"""
3166 return _IMP_em2d.RigidBodiesImageFitRestraint_get_number_of_masks(self, rb)
3169 r"""__str__(RigidBodiesImageFitRestraint self) -> std::string"""
3170 return _IMP_em2d.RigidBodiesImageFitRestraint___str__(self)
3173 r"""__repr__(RigidBodiesImageFitRestraint self) -> std::string"""
3174 return _IMP_em2d.RigidBodiesImageFitRestraint___repr__(self)
3178 return _object_cast_to_RigidBodiesImageFitRestraint(o)
3182 _IMP_em2d.RigidBodiesImageFitRestraint_swigregister(RigidBodiesImageFitRestraint)
3185 r"""get_unique_index(Rotation3D rot) -> IMP::Ints"""
3186 return _IMP_em2d.get_unique_index(rot)
3188 r"""Proxy of C++ IMP::em2d::RelativePositionMover class."""
3190 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3192 def __init__(self, d, max_translation, max_rotation):
3193 r"""__init__(RelativePositionMover self, RigidBody d, IMP::Float max_translation, IMP::Float max_rotation) -> RelativePositionMover"""
3194 _IMP_em2d.RelativePositionMover_swiginit(self, _IMP_em2d.new_RelativePositionMover(d, max_translation, max_rotation))
3196 def add_internal_transformations(self, d, transforms):
3197 r"""add_internal_transformations(RelativePositionMover self, RigidBody d, IMP::algebra::Transformation3Ds transforms)"""
3198 return _IMP_em2d.RelativePositionMover_add_internal_transformations(self, d, transforms)
3200 def set_random_move_probability(self, p):
3201 r"""set_random_move_probability(RelativePositionMover self, IMP::Float p)"""
3202 return _IMP_em2d.RelativePositionMover_set_random_move_probability(self, p)
3203 __swig_destroy__ = _IMP_em2d.delete_RelativePositionMover
3206 r"""__str__(RelativePositionMover self) -> std::string"""
3207 return _IMP_em2d.RelativePositionMover___str__(self)
3210 r"""__repr__(RelativePositionMover self) -> std::string"""
3211 return _IMP_em2d.RelativePositionMover___repr__(self)
3215 return _object_cast_to_RelativePositionMover(o)
3219 _IMP_em2d.RelativePositionMover_swigregister(RelativePositionMover)
3221 r"""Proxy of C++ IMP::em2d::DummyRestraint class."""
3223 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3225 def __init__(self, p, q):
3226 r"""__init__(DummyRestraint self, Particle p, Particle q) -> DummyRestraint"""
3227 _IMP_em2d.DummyRestraint_swiginit(self, _IMP_em2d.new_DummyRestraint(p, q))
3229 def show(self, *args):
3230 r"""show(DummyRestraint self, _ostream out=std::cout)"""
3231 return _IMP_em2d.DummyRestraint_show(self, *args)
3233 def do_get_inputs(self):
3234 r"""do_get_inputs(DummyRestraint self) -> IMP::ModelObjectsTemp"""
3235 return _IMP_em2d.DummyRestraint_do_get_inputs(self)
3237 def get_version_info(self):
3238 r"""get_version_info(DummyRestraint self) -> VersionInfo"""
3239 return _IMP_em2d.DummyRestraint_get_version_info(self)
3240 __swig_destroy__ = _IMP_em2d.delete_DummyRestraint
3243 r"""__str__(DummyRestraint self) -> std::string"""
3244 return _IMP_em2d.DummyRestraint___str__(self)
3247 r"""__repr__(DummyRestraint self) -> std::string"""
3248 return _IMP_em2d.DummyRestraint___repr__(self)
3252 return _object_cast_to_DummyRestraint(o)
3256 _IMP_em2d.DummyRestraint_swigregister(DummyRestraint)
3258 r"""Proxy of C++ IMP::em2d::ParticlesDummyRestraint class."""
3260 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3262 def __init__(self, sc):
3263 r"""__init__(ParticlesDummyRestraint self, SingletonContainer sc) -> ParticlesDummyRestraint"""
3264 _IMP_em2d.ParticlesDummyRestraint_swiginit(self, _IMP_em2d.new_ParticlesDummyRestraint(sc))
3266 def show(self, *args):
3267 r"""show(ParticlesDummyRestraint self, _ostream out=std::cout)"""
3268 return _IMP_em2d.ParticlesDummyRestraint_show(self, *args)
3270 def do_get_inputs(self):
3271 r"""do_get_inputs(ParticlesDummyRestraint self) -> IMP::ModelObjectsTemp"""
3272 return _IMP_em2d.ParticlesDummyRestraint_do_get_inputs(self)
3274 def get_version_info(self):
3275 r"""get_version_info(ParticlesDummyRestraint self) -> VersionInfo"""
3276 return _IMP_em2d.ParticlesDummyRestraint_get_version_info(self)
3277 __swig_destroy__ = _IMP_em2d.delete_ParticlesDummyRestraint
3280 r"""__str__(ParticlesDummyRestraint self) -> std::string"""
3281 return _IMP_em2d.ParticlesDummyRestraint___str__(self)
3284 r"""__repr__(ParticlesDummyRestraint self) -> std::string"""
3285 return _IMP_em2d.ParticlesDummyRestraint___repr__(self)
3289 return _object_cast_to_ParticlesDummyRestraint(o)
3293 _IMP_em2d.ParticlesDummyRestraint_swigregister(ParticlesDummyRestraint)
3295 r"""Proxy of C++ IMP::em2d::PCAFitRestraint class."""
3297 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3299 def __init__(self, particles, image_files, pixel_size, resolution=10.0, projection_number=100, reuse_direction=False, n_components=1, micrographs_number=0):
3300 r"""__init__(PCAFitRestraint self, IMP::Particles particles, Strings image_files, double pixel_size, double resolution=10.0, unsigned int projection_number=100, bool reuse_direction=False, unsigned int n_components=1, unsigned int micrographs_number=0) -> PCAFitRestraint"""
3301 _IMP_em2d.PCAFitRestraint_swiginit(self, _IMP_em2d.new_PCAFitRestraint(particles, image_files, pixel_size, resolution, projection_number, reuse_direction, n_components, micrographs_number))
3303 def get_projection_number(self):
3304 r"""get_projection_number(PCAFitRestraint self) -> unsigned int"""
3305 return _IMP_em2d.PCAFitRestraint_get_projection_number(self)
3307 def set_projection_number(self, n):
3308 r"""set_projection_number(PCAFitRestraint self, unsigned int n)"""
3309 return _IMP_em2d.PCAFitRestraint_set_projection_number(self, n)
3311 def get_micrographs_number(self):
3312 r"""get_micrographs_number(PCAFitRestraint self) -> unsigned int"""
3313 return _IMP_em2d.PCAFitRestraint_get_micrographs_number(self)
3315 def set_micrographs_number(self, n):
3316 r"""set_micrographs_number(PCAFitRestraint self, unsigned int n)"""
3317 return _IMP_em2d.PCAFitRestraint_set_micrographs_number(self, n)
3319 def get_transformation(self, image_number):
3320 r"""get_transformation(PCAFitRestraint self, unsigned int image_number) -> Transformation3D"""
3321 return _IMP_em2d.PCAFitRestraint_get_transformation(self, image_number)
3324 r"""get_cross_correlation_coefficient(PCAFitRestraint self, unsigned int image_number) -> double"""
3325 return _IMP_em2d.PCAFitRestraint_get_cross_correlation_coefficient(self, image_number)
3327 def write_best_projections(self, file_name, evaluate=False):
3328 r"""write_best_projections(PCAFitRestraint self, std::string file_name, bool evaluate=False)"""
3329 return _IMP_em2d.PCAFitRestraint_write_best_projections(self, file_name, evaluate)
3331 def do_get_inputs(self):
3332 r"""do_get_inputs(PCAFitRestraint self) -> IMP::ModelObjectsTemp"""
3333 return _IMP_em2d.PCAFitRestraint_do_get_inputs(self)
3335 def get_version_info(self):
3336 r"""get_version_info(PCAFitRestraint self) -> VersionInfo"""
3337 return _IMP_em2d.PCAFitRestraint_get_version_info(self)
3338 __swig_destroy__ = _IMP_em2d.delete_PCAFitRestraint
3341 r"""__str__(PCAFitRestraint self) -> std::string"""
3342 return _IMP_em2d.PCAFitRestraint___str__(self)
3345 r"""__repr__(PCAFitRestraint self) -> std::string"""
3346 return _IMP_em2d.PCAFitRestraint___repr__(self)
3350 return _object_cast_to_em2dPCAFitRestraint(o)
3354 _IMP_em2d.PCAFitRestraint_swigregister(PCAFitRestraint)
3356 r"""Proxy of C++ std::pair< IMP::algebra::Transformation2D,double > class."""
3358 thisown = property(
lambda x: x.this.own(),
lambda x, v: x.this.own(v), doc=
"The membership flag")
3359 __repr__ = _swig_repr
3361 def __init__(self, *args):
3363 __init__(ResultAlign2D self) -> ResultAlign2D
3364 __init__(ResultAlign2D self, Transformation2D first, double second) -> ResultAlign2D
3365 __init__(ResultAlign2D self, ResultAlign2D other) -> ResultAlign2D
3367 _IMP_em2d.ResultAlign2D_swiginit(self, _IMP_em2d.new_ResultAlign2D(*args))
3368 first = property(_IMP_em2d.ResultAlign2D_first_get, _IMP_em2d.ResultAlign2D_first_set, doc=
r"""first : IMP::algebra::Transformation2D""")
3369 second = property(_IMP_em2d.ResultAlign2D_second_get, _IMP_em2d.ResultAlign2D_second_set, doc=
r"""second : double""")
3373 return str((self.first, self.second))
3374 def __getitem__(self, index):
3379 def __setitem__(self, index, val):
3384 __swig_destroy__ = _IMP_em2d.delete_ResultAlign2D
3387 _IMP_em2d.ResultAlign2D_swigregister(ResultAlign2D)
3389 def _do_hierarchical_clustering_single_linkage(distances):
3390 r"""_do_hierarchical_clustering_single_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3391 return _IMP_em2d._do_hierarchical_clustering_single_linkage(distances)
3393 def _do_hierarchical_clustering_complete_linkage(distances):
3394 r"""_do_hierarchical_clustering_complete_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3395 return _IMP_em2d._do_hierarchical_clustering_complete_linkage(distances)
3397 def _do_hierarchical_clustering_average_distance_linkage(distances):
3398 r"""_do_hierarchical_clustering_average_distance_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3399 return _IMP_em2d._do_hierarchical_clustering_average_distance_linkage(distances)
3401 do_hierarchical_clustering_single_linkage = _do_hierarchical_clustering_single_linkage
3402 do_hierarchical_clustering_complete_linkage = _do_hierarchical_clustering_complete_linkage
3403 do_hierarchical_clustering_average_distance_linkage = _do_hierarchical_clustering_average_distance_linkage
3407 r"""get_module_version() -> std::string const"""
3408 return _IMP_em2d.get_module_version()
3411 r"""get_example_path(std::string fname) -> std::string"""
3412 return _IMP_em2d.get_example_path(fname)
3415 r"""get_data_path(std::string fname) -> std::string"""
3416 return _IMP_em2d.get_data_path(fname)
3418 from .
import _version_check
double get_shift_error(const RegistrationResult &rr1, const RegistrationResult &rr2)
Distance between the two in-plane translations.
Images create_evenly_distributed_projections(const ParticlesTemp &ps, unsigned int n, const ProjectingOptions &options)
void get_autocorrelation2d_no_preprocessing(const cv::Mat &M, cv::Mat &corr)
Autocorrelation without preprocessing.
void do_morphologic_contrast_enhancement(const cv::Mat &m, cv::Mat &result, const cv::Mat &kernel, unsigned int iterations)
double get_mean(const cv::Mat &mat, const cvIntMat &mask)
CheckLevel get_check_level()
Get the current audit mode.
void apply_threshold(cv::Mat &m, cv::Mat &result, double threshold=0.0)
em2d::Images get_projections(const ParticlesTemp &ps, const algebra::SphericalVector3Ds &vs, int rows, int cols, const ProjectingOptions &options, Strings names=Strings())
Generates projections from particles.
std::string get_module_version()
Return the version of this module, as a string.
IMPEM2D_BEGIN_NAMESPACE Strings read_selection_file(String fn)
Reads a selection file.
ResultAlign2D get_complete_alignment_with_centers_no_preprocessing(const algebra::Vector2D ¢er1, const algebra::Vector2D ¢er2, const cv::Mat &AUTOC_POLAR1, const cv::Mat &AUTOC_POLAR2)
Strings create_filenames(unsigned long number, String basic_name, String extension)
Various classes to hold sets of particles.
ResultAlign2D get_translational_alignment(const cv::Mat &input, cv::Mat &m_to_align, bool apply=false)
Aligns two matrices translationally.
void get_correlation2d(const cv::Mat &A, const cv::Mat &B, cv::Mat &corr)
Correlation matrix between two 2D matrices using FFT.
cvIntMat create_circular_mask(int rows, int cols, int radius)
ResultAlign2D get_complete_alignment(const cv::Mat &input, cv::Mat &m_to_align, bool apply=false)
void do_dilate_and_shrink_warp(cv::Mat &m, const cv::Mat &grayscale, cv::Mat &kernel)
(U. Adiga, 2005)
em2d::ResultAlign2D get_rotational_alignment(const cv::Mat &input, cv::Mat &m_to_align, bool apply=false)
RegistrationResults get_evenly_distributed_registration_results(unsigned int n_projections)
void apply_variance_filter(Image *input, Image *filtered, int kernelsize)
void apply_diffusion_filter(Image *input, Image *filtered, double beta, double pixelsize, int time_steps)
int do_labeling(const cvIntMat &m, cvIntMat &mat_to_label)
Labeling function for a matrix.
Make CGAL functionality available to IMP.
MatchTemplateResults get_best_template_matches(const cv::Mat &m, const cv::Mat &templ, unsigned int n)
Modify the transformation of a rigid body.
void do_project_particles(const ParticlesTemp &ps, cv::Mat &m2, const algebra::Rotation3D &R, const algebra::Vector3D &translation, const ProjectingOptions &options, MasksManagerPtr masks)
Projects a set of particles. This is the core function that others call.
void get_autocorrelation2d(const cv::Mat &m, cv::Mat &corr)
Computes the autocorrelation matrix.
std::string get_data_path(std::string file_name)
Return the full path to one of this module's data files.
void apply_mean_outside_mask(Image *img, double radius)
Several general purpose optimizers from the GNU Scientific Library (GSL).
double get_rotation_error(const RegistrationResult &rr1, const RegistrationResult &rr2)
Composable functors to implement scores via compile-time composition.
ResultAlign2D get_rotational_alignment_no_preprocessing(const cv::Mat &POLAR1, const cv::Mat &POLAR2)
void get_fft_using_optimal_size(const cv::Mat &m, cv::Mat &M)
Floats get_histogram(Image *img, int bins)
void write_matrix(cv::Mat &m, std::string name)
Quick and dirty way of writing a OpenCV matrix to a Spider image.
void do_subtract_images(Image *first, Image *second, Image *result)
Code to compute statistical measures.
RegistrationResults get_random_registration_results(unsigned int n, double maximum_shift=5.0)
Provides a set of random registration results (or parameters)
algebra::Vector2Ds do_project_vectors(const algebra::Vector3Ds &ps, const algebra::Rotation3D &R, const algebra::Vector3D &translation)
Project the points contained in Vector3Ds to gen vectors in 2D.
void write_vectors_as_pdb(const algebra::Vector2Ds vs, const String filename)
Common base class for heavy weight IMP objects.
ScoreStates maintain invariants in the Model.
void apply_circular_mask(const cv::Mat &mat, cv::Mat &result, int radius, double value=0.0)
Images read_images(const Strings &names, const ImageReaderWriter *rw)
void write_registration_results(String filename, const RegistrationResults &results)
Writes a set of registration results.
Basic utilities for handling cryo-electron microscopy 3D density maps.
void crop(Image *img, const IntPair ¢er, int size)
void get_morphologic_gradient(const cv::Mat &m, cv::Mat &result, const cv::Mat &kernel)
void apply_mask(const cv::Mat &m, cv::Mat &result, const cvIntMat &mask, double val)
Applies a binary mask to an image.
double get_cross_correlation_coefficient(Image *im1, Image *im2)
Cross correlation between two images.
void save_images(Images images, const Strings &names, const ImageReaderWriter *rw)
void get_domes(cv::Mat &m, cv::Mat &result, double h)
Gets the domes of m with height h.
void do_normalize(Image *im, bool force=false)
Interface to specialized Particle types (e.g. atoms)
void do_matrix_to_image_flip(cv::Mat &m)
std::ostream & show(Hierarchy h, std::ostream &out=std::cout)
Print the hierarchy using a given decorator to display each node.
ResultAlign2D get_translational_alignment_no_preprocessing(const cv::Mat &M1, const cv::Mat &M2)
void get_correlation2d_no_preprocessing(const cv::Mat &M1, const cv::Mat &M2, cv::Mat &corr)
Correlation without preprocessing.
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.
unsigned int get_enclosing_image_size(const ParticlesTemp &ps, double pixel_size, unsigned int slack)
Get an automatic size for an image that contains the particles.
std::pair< algebra::Transformation2D, double > ResultAlign2D
void do_resample_polar(Image *im1, Image *im2, const PolarResamplingParameters &polar_params)
Basic functionality that is expected to be used by a wide variety of IMP users.
General purpose algebraic and geometric methods that are expected to be used by a wide variety of IMP...
em2d::ResultAlign2D get_complete_alignment_no_preprocessing(const cv::Mat &input, const cv::Mat &INPUT, const cv::Mat &POLAR1, cv::Mat &m_to_align, const cv::Mat &POLAR2, bool apply=false)
double get_overlap_percentage(cv::Mat &m1, cv::Mat &m2, const IntPair ¢er)
RegistrationResults read_registration_results(const String &filename)
Reads a set of registration results.
void get_diffusion_filtering_partial_derivative(const cv::Mat &m, cv::Mat &der, double dx, double dy, double ang)
Ints get_unique_index(const algebra::Rotation3D &rot)
Map a rotation to a list of 4 "unique" integers.
double get_global_score(const RegistrationResults &RRs)
void do_place(cv::Mat &mask, cv::Mat &m, const algebra::Vector2D &v)
void do_morphologic_reconstruction(const cv::Mat &mask, cv::Mat &marker, int neighbors_mode=4)
morphologic grayscale reconstruction (L Vincent, 1993)
Output IMP model data in various file formats.
Functionality for loading, creating, manipulating and scoring atomic structures.
Support for the RMF file format for storing hierarchical molecular data and markup.
Divide-and-conquer inferential optimization in discrete space.
Support for small angle X-ray scattering (SAXS) data.
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
void get_projection(em2d::Image *img, const ParticlesTemp &ps, const RegistrationResult ®, const ProjectingOptions &options, MasksManagerPtr masks=MasksManagerPtr(), String name="")
Generates a projection from particles.
Inferential scoring building on methods developed as part of the Inferential Structure Determination ...
A restraint is a term in an IMP ScoringFunction.
void get_spectrum(const cv::Mat &m, cv::Mat &real, cv::Mat &imag)
Computes the fft of a matrix and returns the real and imaginary matrices.