11 from sys
import version_info
12 if version_info >= (2,6,0):
13 def swig_import_helper():
14 from os.path
import dirname
18 fp, pathname, description = imp.find_module(
'_IMP_em2d', [dirname(__file__)])
24 _mod = imp.load_module(
'_IMP_em2d', fp, pathname, description)
28 _IMP_em2d = swig_import_helper()
29 del swig_import_helper
34 _swig_property = property
37 def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
38 if (name ==
"thisown"):
return self.this.own(value)
40 if type(value).__name__ ==
'SwigPyObject':
41 self.__dict__[name] = value
43 method = class_type.__swig_setmethods__.get(name,
None)
44 if method:
return method(self,value)
46 self.__dict__[name] = value
48 raise AttributeError(
"You cannot add attributes to %s" % self)
50 def _swig_setattr(self,class_type,name,value):
51 return _swig_setattr_nondynamic(self,class_type,name,value,0)
53 def _swig_getattr(self,class_type,name):
54 if (name ==
"thisown"):
return self.this.own()
55 method = class_type.__swig_getmethods__.get(name,
None)
56 if method:
return method(self)
57 raise AttributeError(name)
60 try: strthis =
"proxy of " + self.this.__repr__()
62 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
67 except AttributeError:
74 weakref_proxy = weakref.proxy
76 weakref_proxy =
lambda x: x
79 class IMP_EM2D_SwigPyIterator(_object):
80 """Proxy of C++ swig::IMP_EM2D_SwigPyIterator class"""
81 __swig_setmethods__ = {}
82 __setattr__ =
lambda self, name, value: _swig_setattr(self, IMP_EM2D_SwigPyIterator, name, value)
83 __swig_getmethods__ = {}
84 __getattr__ =
lambda self, name: _swig_getattr(self, IMP_EM2D_SwigPyIterator, name)
85 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
87 __swig_destroy__ = _IMP_em2d.delete_IMP_EM2D_SwigPyIterator
88 __del__ =
lambda self :
None;
90 """value(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
91 return _IMP_em2d.IMP_EM2D_SwigPyIterator_value(self)
95 incr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator
96 incr(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator
98 return _IMP_em2d.IMP_EM2D_SwigPyIterator_incr(self, n)
102 decr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator
103 decr(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator
105 return _IMP_em2d.IMP_EM2D_SwigPyIterator_decr(self, n)
107 def distance(self, *args):
108 """distance(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t"""
109 return _IMP_em2d.IMP_EM2D_SwigPyIterator_distance(self, *args)
111 def equal(self, *args):
112 """equal(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
113 return _IMP_em2d.IMP_EM2D_SwigPyIterator_equal(self, *args)
116 """copy(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator"""
117 return _IMP_em2d.IMP_EM2D_SwigPyIterator_copy(self)
120 """next(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
121 return _IMP_em2d.IMP_EM2D_SwigPyIterator_next(self)
124 """__next__(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
125 return _IMP_em2d.IMP_EM2D_SwigPyIterator___next__(self)
128 """previous(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
129 return _IMP_em2d.IMP_EM2D_SwigPyIterator_previous(self)
131 def advance(self, *args):
132 """advance(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
133 return _IMP_em2d.IMP_EM2D_SwigPyIterator_advance(self, *args)
135 def __eq__(self, *args):
136 """__eq__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
137 return _IMP_em2d.IMP_EM2D_SwigPyIterator___eq__(self, *args)
139 def __ne__(self, *args):
140 """__ne__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
141 return _IMP_em2d.IMP_EM2D_SwigPyIterator___ne__(self, *args)
143 def __iadd__(self, *args):
144 """__iadd__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
145 return _IMP_em2d.IMP_EM2D_SwigPyIterator___iadd__(self, *args)
147 def __isub__(self, *args):
148 """__isub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
149 return _IMP_em2d.IMP_EM2D_SwigPyIterator___isub__(self, *args)
151 def __add__(self, *args):
152 """__add__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
153 return _IMP_em2d.IMP_EM2D_SwigPyIterator___add__(self, *args)
155 def __sub__(self, *args):
157 __sub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator
158 __sub__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t
160 return _IMP_em2d.IMP_EM2D_SwigPyIterator___sub__(self, *args)
162 def __iter__(self):
return self
163 IMP_EM2D_SwigPyIterator_swigregister = _IMP_em2d.IMP_EM2D_SwigPyIterator_swigregister
164 IMP_EM2D_SwigPyIterator_swigregister(IMP_EM2D_SwigPyIterator)
171 IMP_DEBUG = _IMP_em2d.IMP_DEBUG
172 IMP_RELEASE = _IMP_em2d.IMP_RELEASE
173 IMP_SILENT = _IMP_em2d.IMP_SILENT
174 IMP_PROGRESS = _IMP_em2d.IMP_PROGRESS
175 IMP_TERSE = _IMP_em2d.IMP_TERSE
176 IMP_VERBOSE = _IMP_em2d.IMP_VERBOSE
177 IMP_MEMORY = _IMP_em2d.IMP_MEMORY
178 IMP_NONE = _IMP_em2d.IMP_NONE
179 IMP_USAGE = _IMP_em2d.IMP_USAGE
180 IMP_INTERNAL = _IMP_em2d.IMP_INTERNAL
181 IMP_BASE_HAS_LOG4CXX = _IMP_em2d.IMP_BASE_HAS_LOG4CXX
182 IMP_COMPILER_HAS_AUTO = _IMP_em2d.IMP_COMPILER_HAS_AUTO
183 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_em2d.IMP_COMPILER_HAS_DEBUG_VECTOR
184 IMP_BASE_HAS_BOOST_RANDOM = _IMP_em2d.IMP_BASE_HAS_BOOST_RANDOM
185 IMP_BASE_HAS_GPERFTOOLS = _IMP_em2d.IMP_BASE_HAS_GPERFTOOLS
186 IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_em2d.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
187 IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_em2d.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
188 IMPBASE_SHOW_WARNINGS = _IMP_em2d.IMPBASE_SHOW_WARNINGS
190 class _DirectorObjects(object):
191 """@internal Simple class to keep references to director objects
192 to prevent premature deletion."""
195 def register(self, obj):
196 """Take a reference to a director object; will only work for
197 refcounted C++ classes"""
198 if hasattr(obj,
'get_ref_count'):
199 self._objects.append(obj)
201 """Only drop our reference and allow cleanup by Python if no other
202 Python references exist (we hold 3 references: one in self._objects,
203 one in x, and one in the argument list for getrefcount) *and* no
204 other C++ references exist (the Python object always holds one)"""
205 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
206 or x.get_ref_count() > 1]
210 def get_object_count(self):
211 """Get number of director objects (useful for testing only)"""
212 return len(self._objects)
213 _director_objects = _DirectorObjects()
215 DEFAULT_CHECK = _IMP_em2d.DEFAULT_CHECK
216 NONE = _IMP_em2d.NONE
217 USAGE = _IMP_em2d.USAGE
218 USAGE_AND_INTERNAL = _IMP_em2d.USAGE_AND_INTERNAL
221 """set_check_level(IMP::base::CheckLevel tf)"""
222 return _IMP_em2d.set_check_level(*args)
225 """get_check_level() -> IMP::base::CheckLevel"""
226 return _IMP_em2d.get_check_level()
227 class _ostream(_object):
228 """Proxy of C++ std::ostream class"""
229 __swig_setmethods__ = {}
230 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ostream, name, value)
231 __swig_getmethods__ = {}
232 __getattr__ =
lambda self, name: _swig_getattr(self, _ostream, name)
233 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined")
234 __repr__ = _swig_repr
235 def write(self, *args):
236 """write(_ostream self, char const * osa_buf)"""
237 return _IMP_em2d._ostream_write(self, *args)
239 _ostream_swigregister = _IMP_em2d._ostream_swigregister
240 _ostream_swigregister(_ostream)
242 IMP_COMPILER_HAS_OVERRIDE = _IMP_em2d.IMP_COMPILER_HAS_OVERRIDE
243 IMP_COMPILER_HAS_FINAL = _IMP_em2d.IMP_COMPILER_HAS_FINAL
244 IMP_HAS_NOEXCEPT = _IMP_em2d.IMP_HAS_NOEXCEPT
246 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_FILESYSTEM
247 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
248 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CGAL_HAS_BOOST_RANDOM
249 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_SYSTEM
250 IMPCGAL_SHOW_WARNINGS = _IMP_em2d.IMPCGAL_SHOW_WARNINGS
252 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_IMP_CGAL
253 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
254 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
255 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_RANDOM
256 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_SYSTEM
257 IMP_ALGEBRA_HAS_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_CGAL
258 IMP_ALGEBRA_HAS_ANN = _IMP_em2d.IMP_ALGEBRA_HAS_ANN
259 IMPALGEBRA_SHOW_WARNINGS = _IMP_em2d.IMPALGEBRA_SHOW_WARNINGS
261 IMP_KERNEL_HAS_IMP_CGAL = _IMP_em2d.IMP_KERNEL_HAS_IMP_CGAL
262 IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
263 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_KERNEL_HAS_BOOST_RANDOM
264 IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_KERNEL_HAS_BOOST_SYSTEM
265 IMP_KERNEL_HAS_CGAL = _IMP_em2d.IMP_KERNEL_HAS_CGAL
266 IMPKERNEL_SHOW_WARNINGS = _IMP_em2d.IMPKERNEL_SHOW_WARNINGS
268 IMP_DISPLAY_HAS_IMP_BASE = _IMP_em2d.IMP_DISPLAY_HAS_IMP_BASE
269 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_IMP_CGAL
270 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
271 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
272 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_RANDOM
273 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_SYSTEM
274 IMP_DISPLAY_HAS_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_CGAL
275 IMPDISPLAY_SHOW_WARNINGS = _IMP_em2d.IMPDISPLAY_SHOW_WARNINGS
277 IMP_GSL_HAS_IMP_BASE = _IMP_em2d.IMP_GSL_HAS_IMP_BASE
278 IMP_GSL_HAS_IMP_CGAL = _IMP_em2d.IMP_GSL_HAS_IMP_CGAL
279 IMP_GSL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_FILESYSTEM
280 IMP_GSL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_GSL_HAS_BOOST_PROGRAMOPTIONS
281 IMP_GSL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_GSL_HAS_BOOST_RANDOM
282 IMP_GSL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_SYSTEM
283 IMP_GSL_HAS_CGAL = _IMP_em2d.IMP_GSL_HAS_CGAL
284 IMPGSL_SHOW_WARNINGS = _IMP_em2d.IMPGSL_SHOW_WARNINGS
286 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
287 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
288 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
289 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
290 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
291 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_CGAL
292 IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_HDF5
293 IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_em2d.IMPSCOREFUNCTOR_SHOW_WARNINGS
295 IMP_STATISTICS_HAS_IMP_BASE = _IMP_em2d.IMP_STATISTICS_HAS_IMP_BASE
296 IMP_STATISTICS_HAS_IMP_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_IMP_CGAL
297 IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
298 IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
299 IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_RANDOM
300 IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_SYSTEM
301 IMP_STATISTICS_HAS_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_CGAL
302 IMPSTATISTICS_SHOW_WARNINGS = _IMP_em2d.IMPSTATISTICS_SHOW_WARNINGS
304 IMP_CORE_HAS_IMP_BASE = _IMP_em2d.IMP_CORE_HAS_IMP_BASE
305 IMP_CORE_HAS_IMP_CGAL = _IMP_em2d.IMP_CORE_HAS_IMP_CGAL
306 IMP_CORE_HAS_IMP_KERNEL = _IMP_em2d.IMP_CORE_HAS_IMP_KERNEL
307 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_FILESYSTEM
308 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
309 IMP_CORE_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CORE_HAS_BOOST_RANDOM
310 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_SYSTEM
311 IMP_CORE_HAS_CGAL = _IMP_em2d.IMP_CORE_HAS_CGAL
312 IMP_CORE_HAS_HDF5 = _IMP_em2d.IMP_CORE_HAS_HDF5
313 IMPCORE_SHOW_WARNINGS = _IMP_em2d.IMPCORE_SHOW_WARNINGS
315 IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_em2d.IMP_CONTAINER_HAS_IMP_ALGEBRA
316 IMP_CONTAINER_HAS_IMP_BASE = _IMP_em2d.IMP_CONTAINER_HAS_IMP_BASE
317 IMP_CONTAINER_HAS_IMP_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_CGAL
318 IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_em2d.IMP_CONTAINER_HAS_IMP_DISPLAY
319 IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_KERNEL
320 IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
321 IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
322 IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
323 IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_RANDOM
324 IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_SYSTEM
325 IMP_CONTAINER_HAS_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_CGAL
326 IMP_CONTAINER_HAS_HDF5 = _IMP_em2d.IMP_CONTAINER_HAS_HDF5
327 IMPCONTAINER_SHOW_WARNINGS = _IMP_em2d.IMPCONTAINER_SHOW_WARNINGS
329 IMP_ATOM_HAS_IMP_BASE = _IMP_em2d.IMP_ATOM_HAS_IMP_BASE
330 IMP_ATOM_HAS_IMP_CGAL = _IMP_em2d.IMP_ATOM_HAS_IMP_CGAL
331 IMP_ATOM_HAS_IMP_KERNEL = _IMP_em2d.IMP_ATOM_HAS_IMP_KERNEL
332 IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
333 IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
334 IMP_ATOM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ATOM_HAS_BOOST_RANDOM
335 IMP_ATOM_HAS_BOOST_REGEX = _IMP_em2d.IMP_ATOM_HAS_BOOST_REGEX
336 IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ATOM_HAS_BOOST_SYSTEM
337 IMP_ATOM_HAS_CGAL = _IMP_em2d.IMP_ATOM_HAS_CGAL
338 IMP_ATOM_HAS_HDF5 = _IMP_em2d.IMP_ATOM_HAS_HDF5
339 IMPATOM_SHOW_WARNINGS = _IMP_em2d.IMPATOM_SHOW_WARNINGS
340 IMP_ATOM_TYPE_INDEX = _IMP_em2d.IMP_ATOM_TYPE_INDEX
341 IMP_RESIDUE_TYPE_INDEX = _IMP_em2d.IMP_RESIDUE_TYPE_INDEX
342 IMP_HIERARCHY_TYPE_INDEX = _IMP_em2d.IMP_HIERARCHY_TYPE_INDEX
344 IMP_EM_HAS_IMP_CGAL = _IMP_em2d.IMP_EM_HAS_IMP_CGAL
345 IMP_EM_HAS_IMP_CONTAINER = _IMP_em2d.IMP_EM_HAS_IMP_CONTAINER
346 IMP_EM_HAS_IMP_DISPLAY = _IMP_em2d.IMP_EM_HAS_IMP_DISPLAY
347 IMP_EM_HAS_IMP_KERNEL = _IMP_em2d.IMP_EM_HAS_IMP_KERNEL
348 IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM_HAS_IMP_SCORE_FUNCTOR
349 IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_FILESYSTEM
350 IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_EM_HAS_BOOST_PROGRAMOPTIONS
351 IMP_EM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM_HAS_BOOST_RANDOM
352 IMP_EM_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM_HAS_BOOST_REGEX
353 IMP_EM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_SYSTEM
354 IMP_EM_HAS_CGAL = _IMP_em2d.IMP_EM_HAS_CGAL
355 IMP_EM_HAS_HDF5 = _IMP_em2d.IMP_EM_HAS_HDF5
356 IMPEM_SHOW_WARNINGS = _IMP_em2d.IMPEM_SHOW_WARNINGS
358 IMP_RMF_HAS_IMP_BASE = _IMP_em2d.IMP_RMF_HAS_IMP_BASE
359 IMP_RMF_HAS_IMP_CGAL = _IMP_em2d.IMP_RMF_HAS_IMP_CGAL
360 IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
361 IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_FILESYSTEM
362 IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
363 IMP_RMF_HAS_BOOST_RANDOM = _IMP_em2d.IMP_RMF_HAS_BOOST_RANDOM
364 IMP_RMF_HAS_BOOST_REGEX = _IMP_em2d.IMP_RMF_HAS_BOOST_REGEX
365 IMP_RMF_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_SYSTEM
366 IMP_RMF_HAS_CGAL = _IMP_em2d.IMP_RMF_HAS_CGAL
367 IMP_RMF_HAS_HDF5 = _IMP_em2d.IMP_RMF_HAS_HDF5
368 IMPRMF_SHOW_WARNINGS = _IMP_em2d.IMPRMF_SHOW_WARNINGS
371 IMP_DOMINO_HAS_IMP_ATOM = _IMP_em2d.IMP_DOMINO_HAS_IMP_ATOM
372 IMP_DOMINO_HAS_IMP_BASE = _IMP_em2d.IMP_DOMINO_HAS_IMP_BASE
373 IMP_DOMINO_HAS_IMP_CGAL = _IMP_em2d.IMP_DOMINO_HAS_IMP_CGAL
374 IMP_DOMINO_HAS_IMP_KERNEL = _IMP_em2d.IMP_DOMINO_HAS_IMP_KERNEL
375 IMP_DOMINO_HAS_IMP_RMF = _IMP_em2d.IMP_DOMINO_HAS_IMP_RMF
376 IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR
377 IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_FILESYSTEM
378 IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS
379 IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_RANDOM
380 IMP_DOMINO_HAS_BOOST_REGEX = _IMP_em2d.IMP_DOMINO_HAS_BOOST_REGEX
381 IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_SYSTEM
382 IMP_DOMINO_HAS_CGAL = _IMP_em2d.IMP_DOMINO_HAS_CGAL
383 IMP_DOMINO_HAS_HDF5 = _IMP_em2d.IMP_DOMINO_HAS_HDF5
384 IMP_DOMINO_HAS_RMF = _IMP_em2d.IMP_DOMINO_HAS_RMF
385 IMPDOMINO_SHOW_WARNINGS = _IMP_em2d.IMPDOMINO_SHOW_WARNINGS
388 IMP_EM2D_HAS_IMP_BASE = _IMP_em2d.IMP_EM2D_HAS_IMP_BASE
389 IMP_EM2D_HAS_IMP_CGAL = _IMP_em2d.IMP_EM2D_HAS_IMP_CGAL
390 IMP_EM2D_HAS_IMP_KERNEL = _IMP_em2d.IMP_EM2D_HAS_IMP_KERNEL
391 IMP_EM2D_HAS_IMP_RMF = _IMP_em2d.IMP_EM2D_HAS_IMP_RMF
392 IMP_EM2D_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM2D_HAS_IMP_SCORE_FUNCTOR
393 IMP_EM2D_HAS_IMP_STATISTICS = _IMP_em2d.IMP_EM2D_HAS_IMP_STATISTICS
394 IMP_EM2D_HAS_BOOST_GRAPH = _IMP_em2d.IMP_EM2D_HAS_BOOST_GRAPH
395 IMP_EM2D_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM2D_HAS_BOOST_RANDOM
396 IMP_EM2D_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM2D_HAS_BOOST_REGEX
397 IMP_EM2D_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM2D_HAS_BOOST_SYSTEM
398 IMP_EM2D_HAS_CGAL = _IMP_em2d.IMP_EM2D_HAS_CGAL
399 IMP_EM2D_HAS_GSL = _IMP_em2d.IMP_EM2D_HAS_GSL
400 IMP_EM2D_HAS_HDF5 = _IMP_em2d.IMP_EM2D_HAS_HDF5
401 IMP_EM2D_HAS_OPENCV22 = _IMP_em2d.IMP_EM2D_HAS_OPENCV22
402 IMP_EM2D_HAS_RMF = _IMP_em2d.IMP_EM2D_HAS_RMF
403 IMP_EM2D_HAS_OPENCV21 = _IMP_em2d.IMP_EM2D_HAS_OPENCV21
404 IMPEM2D_SHOW_WARNINGS = _IMP_em2d.IMPEM2D_SHOW_WARNINGS
405 PolarResamplingParametersList=list
406 _plural_types.append(
"PolarResamplingParametersList")
407 _value_types.append(
"PolarResamplingParameters")
410 _plural_types.append(
"ProjectionMasks")
411 _value_types.append(
"ProjectionMask")
414 _plural_types.append(
"MasksManagers")
415 _value_types.append(
"MasksManager")
417 RegistrationResults=list
418 _plural_types.append(
"RegistrationResults")
419 _value_types.append(
"RegistrationResult")
422 _plural_types.append(
"ClusterSets")
423 _value_types.append(
"ClusterSet")
426 _plural_types.append(
"SingleLinkages")
427 _value_types.append(
"SingleLinkage")
429 CompleteLinkages=list
430 _plural_types.append(
"CompleteLinkages")
431 _value_types.append(
"CompleteLinkage")
433 AverageDistanceLinkages=list
434 _plural_types.append(
"AverageDistanceLinkages")
435 _value_types.append(
"AverageDistanceLinkage")
437 SegmentationParametersList=list
438 _plural_types.append(
"SegmentationParametersList")
439 _value_types.append(
"SegmentationParameters")
441 MatchTemplateResults=list
442 _plural_types.append(
"MatchTemplateResults")
443 _value_types.append(
"MatchTemplateResult")
445 ProjectingParametersList=list
446 _plural_types.append(
"ProjectingParametersList")
447 _value_types.append(
"ProjectingParameters")
449 ProjectingOptionsList=list
450 _plural_types.append(
"ProjectingOptionsList")
451 _value_types.append(
"ProjectingOptions")
453 Em2DRestraintParametersList=list
454 _plural_types.append(
"Em2DRestraintParametersList")
455 _value_types.append(
"Em2DRestraintParameters")
457 _object_types.append(
"ProjectionFinder")
460 def _object_cast_to_ProjectionFinder(*args):
461 """_object_cast_to_ProjectionFinder(Object o) -> ProjectionFinder"""
462 return _IMP_em2d._object_cast_to_ProjectionFinder(*args)
463 _object_types.append(
"ScoreFunction")
466 def _object_cast_to_ScoreFunction(*args):
467 """_object_cast_to_ScoreFunction(Object o) -> ScoreFunction"""
468 return _IMP_em2d._object_cast_to_ScoreFunction(*args)
469 _object_types.append(
"ChiSquaredScore")
472 def _object_cast_to_ChiSquaredScore(*args):
473 """_object_cast_to_ChiSquaredScore(Object o) -> ChiSquaredScore"""
474 return _IMP_em2d._object_cast_to_ChiSquaredScore(*args)
475 _object_types.append(
"EM2DScore")
478 def _object_cast_to_EM2DScore(*args):
479 """_object_cast_to_EM2DScore(Object o) -> EM2DScore"""
480 return _IMP_em2d._object_cast_to_EM2DScore(*args)
481 _object_types.append(
"MeanAbsoluteDifference")
484 def _object_cast_to_MeanAbsoluteDifference(*args):
485 """_object_cast_to_MeanAbsoluteDifference(Object o) -> MeanAbsoluteDifference"""
486 return _IMP_em2d._object_cast_to_MeanAbsoluteDifference(*args)
487 _object_types.append(
"ProjectionParametersScoreState")
490 def _object_cast_to_ProjectionParametersScoreState(*args):
491 """_object_cast_to_ProjectionParametersScoreState(Object o) -> ProjectionParametersScoreState"""
492 return _IMP_em2d._object_cast_to_ProjectionParametersScoreState(*args)
493 _object_types.append(
"Em2DRestraint")
496 def _object_cast_to_Em2DRestraint(*args):
497 """_object_cast_to_Em2DRestraint(Object o) -> Em2DRestraint"""
498 return _IMP_em2d._object_cast_to_Em2DRestraint(*args)
499 _object_types.append(
"Image")
502 def _object_cast_to_Image(*args):
503 """_object_cast_to_Image(Object o) -> Image"""
504 return _IMP_em2d._object_cast_to_Image(*args)
505 _object_types.append(
"ImageReaderWriter")
508 def _object_cast_to_ImageReaderWriter(*args):
509 """_object_cast_to_ImageReaderWriter(Object o) -> ImageReaderWriter"""
510 return _IMP_em2d._object_cast_to_ImageReaderWriter(*args)
511 _object_types.append(
"JPGImageReaderWriter")
514 def _object_cast_to_JPGImageReaderWriter(*args):
515 """_object_cast_to_JPGImageReaderWriter(Object o) -> JPGImageReaderWriter"""
516 return _IMP_em2d._object_cast_to_JPGImageReaderWriter(*args)
517 _object_types.append(
"TIFFImageReaderWriter")
520 def _object_cast_to_TIFFImageReaderWriter(*args):
521 """_object_cast_to_TIFFImageReaderWriter(Object o) -> TIFFImageReaderWriter"""
522 return _IMP_em2d._object_cast_to_TIFFImageReaderWriter(*args)
523 _object_types.append(
"SpiderImageReaderWriter")
526 def _object_cast_to_SpiderImageReaderWriter(*args):
527 """_object_cast_to_SpiderImageReaderWriter(Object o) -> SpiderImageReaderWriter"""
528 return _IMP_em2d._object_cast_to_SpiderImageReaderWriter(*args)
529 _object_types.append(
"CollisionCrossSection")
532 def _object_cast_to_CollisionCrossSection(*args):
533 """_object_cast_to_CollisionCrossSection(Object o) -> CollisionCrossSection"""
534 return _IMP_em2d._object_cast_to_CollisionCrossSection(*args)
535 _object_types.append(
"GridStates")
538 def _object_cast_to_GridStates(*args):
539 """_object_cast_to_GridStates(Object o) -> GridStates"""
540 return _IMP_em2d._object_cast_to_GridStates(*args)
541 _object_types.append(
"ProjectionStates")
544 def _object_cast_to_ProjectionStates(*args):
545 """_object_cast_to_ProjectionStates(Object o) -> ProjectionStates"""
546 return _IMP_em2d._object_cast_to_ProjectionStates(*args)
547 _object_types.append(
"DistanceFilter")
550 def _object_cast_to_DistanceFilter(*args):
551 """_object_cast_to_DistanceFilter(Object o) -> DistanceFilter"""
552 return _IMP_em2d._object_cast_to_DistanceFilter(*args)
553 _object_types.append(
"DistanceFilterTable")
556 def _object_cast_to_DistanceFilterTable(*args):
557 """_object_cast_to_DistanceFilterTable(Object o) -> DistanceFilterTable"""
558 return _IMP_em2d._object_cast_to_DistanceFilterTable(*args)
559 _object_types.append(
"RigidBodiesImageFitRestraint")
562 def _object_cast_to_RigidBodiesImageFitRestraint(*args):
563 """_object_cast_to_RigidBodiesImageFitRestraint(Object o) -> RigidBodiesImageFitRestraint"""
564 return _IMP_em2d._object_cast_to_RigidBodiesImageFitRestraint(*args)
565 _object_types.append(
"DummyRestraint")
568 def _object_cast_to_DummyRestraint(*args):
569 """_object_cast_to_DummyRestraint(Object o) -> DummyRestraint"""
570 return _IMP_em2d._object_cast_to_DummyRestraint(*args)
571 _object_types.append(
"ParticlesDummyRestraint")
574 def _object_cast_to_ParticlesDummyRestraint(*args):
575 """_object_cast_to_ParticlesDummyRestraint(Object o) -> ParticlesDummyRestraint"""
576 return _IMP_em2d._object_cast_to_ParticlesDummyRestraint(*args)
577 _object_types.append(
"RelativePositionMover")
580 def _object_cast_to_RelativePositionMover(*args):
581 """_object_cast_to_RelativePositionMover(Object o) -> RelativePositionMover"""
582 return _IMP_em2d._object_cast_to_RelativePositionMover(*args)
583 def ProjectionParametersList(l=[]):
584 return [ProjectionParameters(x)
for x
in l]
585 _plural_types.append(
"ProjectionParametersList")
587 _value_types.append(
"ProjectionParameters")
592 show(cv::Mat const & m, _ostream out=std::cout)
593 show(cv::Mat const & m)
595 return _IMP_em2d.show(*args)
598 """write_matrix(cv::Mat & m, std::string name)"""
599 return _IMP_em2d.write_matrix(*args)
601 """Proxy of C++ IMP::em2d::ImageReaderWriter class"""
602 __swig_setmethods__ = {}
603 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
604 __setattr__ =
lambda self, name, value: _swig_setattr(self, ImageReaderWriter, name, value)
605 __swig_getmethods__ = {}
606 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
607 __getattr__ =
lambda self, name: _swig_getattr(self, ImageReaderWriter, name)
608 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
609 def read(self, *args):
610 """read(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
611 return _IMP_em2d.ImageReaderWriter_read(self, *args)
613 def read_from_floats(self, *args):
614 """read_from_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
615 return _IMP_em2d.ImageReaderWriter_read_from_floats(self, *args)
617 def read_from_ints(self, *args):
618 """read_from_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
619 return _IMP_em2d.ImageReaderWriter_read_from_ints(self, *args)
621 def write(self, *args):
622 """write(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
623 return _IMP_em2d.ImageReaderWriter_write(self, *args)
625 def write_to_floats(self, *args):
626 """write_to_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
627 return _IMP_em2d.ImageReaderWriter_write_to_floats(self, *args)
629 def write_to_ints(self, *args):
630 """write_to_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
631 return _IMP_em2d.ImageReaderWriter_write_to_ints(self, *args)
633 def get_version_info(self):
634 """get_version_info(ImageReaderWriter self) -> VersionInfo"""
635 return _IMP_em2d.ImageReaderWriter_get_version_info(self)
638 """__str__(ImageReaderWriter self) -> std::string"""
639 return _IMP_em2d.ImageReaderWriter___str__(self)
642 """__repr__(ImageReaderWriter self) -> std::string"""
643 return _IMP_em2d.ImageReaderWriter___repr__(self)
646 return _object_cast_to_ImageReaderWriter(o)
647 get_from = staticmethod(get_from)
649 ImageReaderWriter_swigregister = _IMP_em2d.ImageReaderWriter_swigregister
650 ImageReaderWriter_swigregister(ImageReaderWriter)
652 class PolarResamplingParameters(_object):
653 """Proxy of C++ IMP::em2d::PolarResamplingParameters class"""
654 __swig_setmethods__ = {}
655 __setattr__ =
lambda self, name, value: _swig_setattr(self, PolarResamplingParameters, name, value)
656 __swig_getmethods__ = {}
657 __getattr__ =
lambda self, name: _swig_getattr(self, PolarResamplingParameters, name)
658 def __init__(self, *args):
660 __init__(IMP::em2d::PolarResamplingParameters self) -> PolarResamplingParameters
661 __init__(IMP::em2d::PolarResamplingParameters self, unsigned int rows, unsigned int cols) -> PolarResamplingParameters
662 __init__(IMP::em2d::PolarResamplingParameters self, cv::Mat const & m) -> PolarResamplingParameters
664 this = _IMP_em2d.new_PolarResamplingParameters(*args)
665 try: self.this.append(this)
666 except: self.this = this
667 __swig_destroy__ = _IMP_em2d.delete_PolarResamplingParameters
668 __del__ =
lambda self :
None;
669 def setup(self, *args):
670 """setup(PolarResamplingParameters self, unsigned int rows, unsigned int cols)"""
671 return _IMP_em2d.PolarResamplingParameters_setup(self, *args)
673 def get_starting_radius(self):
674 """get_starting_radius(PolarResamplingParameters self) -> double"""
675 return _IMP_em2d.PolarResamplingParameters_get_starting_radius(self)
677 def get_ending_radius(self):
678 """get_ending_radius(PolarResamplingParameters self) -> double"""
679 return _IMP_em2d.PolarResamplingParameters_get_ending_radius(self)
681 def get_radius(self, *args):
682 """get_radius(PolarResamplingParameters self, unsigned int n_ring) -> double"""
683 return _IMP_em2d.PolarResamplingParameters_get_radius(self, *args)
685 def get_number_of_rings(self):
686 """get_number_of_rings(PolarResamplingParameters self) -> unsigned int"""
687 return _IMP_em2d.PolarResamplingParameters_get_number_of_rings(self)
689 def set_estimated_number_of_angles(self, *args):
690 """set_estimated_number_of_angles(PolarResamplingParameters self, unsigned int aprox_value)"""
691 return _IMP_em2d.PolarResamplingParameters_set_estimated_number_of_angles(self, *args)
693 def get_number_of_angles(self):
694 """get_number_of_angles(PolarResamplingParameters self) -> unsigned int"""
695 return _IMP_em2d.PolarResamplingParameters_get_number_of_angles(self)
697 def get_angle_step(self):
698 """get_angle_step(PolarResamplingParameters self) -> double"""
699 return _IMP_em2d.PolarResamplingParameters_get_angle_step(self)
701 def get_radius_step(self):
702 """get_radius_step(PolarResamplingParameters self) -> double"""
703 return _IMP_em2d.PolarResamplingParameters_get_radius_step(self)
705 def create_maps_for_resampling(self):
706 """create_maps_for_resampling(PolarResamplingParameters self)"""
707 return _IMP_em2d.PolarResamplingParameters_create_maps_for_resampling(self)
709 def get_resampling_maps(self, *args):
710 """get_resampling_maps(PolarResamplingParameters self, cv::Mat & m1, cv::Mat & m2)"""
711 return _IMP_em2d.PolarResamplingParameters_get_resampling_maps(self, *args)
713 def get_resampling_map(self, *args):
714 """get_resampling_map(PolarResamplingParameters self, cv::Mat & m1)"""
715 return _IMP_em2d.PolarResamplingParameters_get_resampling_map(self, *args)
717 def show(self, *args):
718 """show(PolarResamplingParameters self, _ostream out)"""
719 return _IMP_em2d.PolarResamplingParameters_show(self, *args)
721 def get_is_setup(self):
722 """get_is_setup(PolarResamplingParameters self) -> bool"""
723 return _IMP_em2d.PolarResamplingParameters_get_is_setup(self)
726 """__str__(PolarResamplingParameters self) -> std::string"""
727 return _IMP_em2d.PolarResamplingParameters___str__(self)
730 """__repr__(PolarResamplingParameters self) -> std::string"""
731 return _IMP_em2d.PolarResamplingParameters___repr__(self)
733 PolarResamplingParameters_swigregister = _IMP_em2d.PolarResamplingParameters_swigregister
734 PolarResamplingParameters_swigregister(PolarResamplingParameters)
736 class SegmentationParameters(_object):
737 """Proxy of C++ IMP::em2d::SegmentationParameters class"""
738 __swig_setmethods__ = {}
739 __setattr__ =
lambda self, name, value: _swig_setattr(self, SegmentationParameters, name, value)
740 __swig_getmethods__ = {}
741 __getattr__ =
lambda self, name: _swig_getattr(self, SegmentationParameters, name)
742 __swig_setmethods__[
"image_pixel_size"] = _IMP_em2d.SegmentationParameters_image_pixel_size_set
743 __swig_getmethods__[
"image_pixel_size"] = _IMP_em2d.SegmentationParameters_image_pixel_size_get
744 if _newclass:image_pixel_size = _swig_property(_IMP_em2d.SegmentationParameters_image_pixel_size_get, _IMP_em2d.SegmentationParameters_image_pixel_size_set)
745 __swig_setmethods__[
"diffusion_beta"] = _IMP_em2d.SegmentationParameters_diffusion_beta_set
746 __swig_getmethods__[
"diffusion_beta"] = _IMP_em2d.SegmentationParameters_diffusion_beta_get
747 if _newclass:diffusion_beta = _swig_property(_IMP_em2d.SegmentationParameters_diffusion_beta_get, _IMP_em2d.SegmentationParameters_diffusion_beta_set)
748 __swig_setmethods__[
"diffusion_timesteps"] = _IMP_em2d.SegmentationParameters_diffusion_timesteps_set
749 __swig_getmethods__[
"diffusion_timesteps"] = _IMP_em2d.SegmentationParameters_diffusion_timesteps_get
750 if _newclass:diffusion_timesteps = _swig_property(_IMP_em2d.SegmentationParameters_diffusion_timesteps_get, _IMP_em2d.SegmentationParameters_diffusion_timesteps_set)
751 __swig_setmethods__[
"fill_holes_stddevs"] = _IMP_em2d.SegmentationParameters_fill_holes_stddevs_set
752 __swig_getmethods__[
"fill_holes_stddevs"] = _IMP_em2d.SegmentationParameters_fill_holes_stddevs_get
753 if _newclass:fill_holes_stddevs = _swig_property(_IMP_em2d.SegmentationParameters_fill_holes_stddevs_get, _IMP_em2d.SegmentationParameters_fill_holes_stddevs_set)
754 __swig_setmethods__[
"opening_kernel"] = _IMP_em2d.SegmentationParameters_opening_kernel_set
755 __swig_getmethods__[
"opening_kernel"] = _IMP_em2d.SegmentationParameters_opening_kernel_get
756 if _newclass:opening_kernel = _swig_property(_IMP_em2d.SegmentationParameters_opening_kernel_get, _IMP_em2d.SegmentationParameters_opening_kernel_set)
757 __swig_setmethods__[
"remove_sizing_percentage"] = _IMP_em2d.SegmentationParameters_remove_sizing_percentage_set
758 __swig_getmethods__[
"remove_sizing_percentage"] = _IMP_em2d.SegmentationParameters_remove_sizing_percentage_get
759 if _newclass:remove_sizing_percentage = _swig_property(_IMP_em2d.SegmentationParameters_remove_sizing_percentage_get, _IMP_em2d.SegmentationParameters_remove_sizing_percentage_set)
760 __swig_setmethods__[
"binary_background"] = _IMP_em2d.SegmentationParameters_binary_background_set
761 __swig_getmethods__[
"binary_background"] = _IMP_em2d.SegmentationParameters_binary_background_get
762 if _newclass:binary_background = _swig_property(_IMP_em2d.SegmentationParameters_binary_background_get, _IMP_em2d.SegmentationParameters_binary_background_set)
763 __swig_setmethods__[
"binary_foreground"] = _IMP_em2d.SegmentationParameters_binary_foreground_set
764 __swig_getmethods__[
"binary_foreground"] = _IMP_em2d.SegmentationParameters_binary_foreground_get
765 if _newclass:binary_foreground = _swig_property(_IMP_em2d.SegmentationParameters_binary_foreground_get, _IMP_em2d.SegmentationParameters_binary_foreground_set)
766 __swig_setmethods__[
"threshold"] = _IMP_em2d.SegmentationParameters_threshold_set
767 __swig_getmethods__[
"threshold"] = _IMP_em2d.SegmentationParameters_threshold_get
768 if _newclass:threshold = _swig_property(_IMP_em2d.SegmentationParameters_threshold_get, _IMP_em2d.SegmentationParameters_threshold_set)
769 def __init__(self, *args):
771 __init__(IMP::em2d::SegmentationParameters self) -> SegmentationParameters
772 __init__(IMP::em2d::SegmentationParameters self, double apix, double diff_beta, unsigned int diff_timesteps, double fh_stddevs, cv::Mat const & kr,
773 int background, int foreground) -> SegmentationParameters
775 this = _IMP_em2d.new_SegmentationParameters(*args)
776 try: self.this.append(this)
777 except: self.this = this
778 def show(self, *args):
780 show(SegmentationParameters self, _ostream out=std::cout)
781 show(SegmentationParameters self)
783 return _IMP_em2d.SegmentationParameters_show(self, *args)
786 """__str__(SegmentationParameters self) -> std::string"""
787 return _IMP_em2d.SegmentationParameters___str__(self)
790 """__repr__(SegmentationParameters self) -> std::string"""
791 return _IMP_em2d.SegmentationParameters___repr__(self)
793 __swig_destroy__ = _IMP_em2d.delete_SegmentationParameters
794 __del__ =
lambda self :
None;
795 SegmentationParameters_swigregister = _IMP_em2d.SegmentationParameters_swigregister
796 SegmentationParameters_swigregister(SegmentationParameters)
798 class MatchTemplateResult(_object):
799 """Proxy of C++ IMP::em2d::MatchTemplateResult class"""
800 __swig_setmethods__ = {}
801 __setattr__ =
lambda self, name, value: _swig_setattr(self, MatchTemplateResult, name, value)
802 __swig_getmethods__ = {}
803 __getattr__ =
lambda self, name: _swig_getattr(self, MatchTemplateResult, name)
804 __swig_setmethods__[
"pair"] = _IMP_em2d.MatchTemplateResult_pair_set
805 __swig_getmethods__[
"pair"] = _IMP_em2d.MatchTemplateResult_pair_get
806 if _newclass:pair = _swig_property(_IMP_em2d.MatchTemplateResult_pair_get, _IMP_em2d.MatchTemplateResult_pair_set)
807 __swig_setmethods__[
"cross_correlation"] = _IMP_em2d.MatchTemplateResult_cross_correlation_set
808 __swig_getmethods__[
"cross_correlation"] = _IMP_em2d.MatchTemplateResult_cross_correlation_get
809 if _newclass:cross_correlation = _swig_property(_IMP_em2d.MatchTemplateResult_cross_correlation_get, _IMP_em2d.MatchTemplateResult_cross_correlation_set)
810 def __init__(self, *args):
811 """__init__(IMP::em2d::MatchTemplateResult self, IMP::IntPair p, double cc) -> MatchTemplateResult"""
812 this = _IMP_em2d.new_MatchTemplateResult(*args)
813 try: self.this.append(this)
814 except: self.this = this
815 def show(self, *args):
817 show(MatchTemplateResult self, _ostream out=std::cout)
818 show(MatchTemplateResult self)
820 return _IMP_em2d.MatchTemplateResult_show(self, *args)
823 """__str__(MatchTemplateResult self) -> std::string"""
824 return _IMP_em2d.MatchTemplateResult___str__(self)
827 """__repr__(MatchTemplateResult self) -> std::string"""
828 return _IMP_em2d.MatchTemplateResult___repr__(self)
830 __swig_destroy__ = _IMP_em2d.delete_MatchTemplateResult
831 __del__ =
lambda self :
None;
832 MatchTemplateResult_swigregister = _IMP_em2d.MatchTemplateResult_swigregister
833 MatchTemplateResult_swigregister(MatchTemplateResult)
837 """apply_mask(cv::Mat const & m, cv::Mat & result, IMP::em2d::cvIntMat const & mask, double val)"""
838 return _IMP_em2d.apply_mask(*args)
842 apply_circular_mask(cv::Mat const & mat, cv::Mat & result, int radius, double value=0.0)
843 apply_circular_mask(cv::Mat const & mat, cv::Mat & result, int radius)
845 return _IMP_em2d.apply_circular_mask(*args)
848 """get_mean(cv::Mat const & mat, IMP::em2d::cvIntMat const & mask) -> double"""
849 return _IMP_em2d.get_mean(*args)
852 """create_circular_mask(int rows, int cols, int radius) -> IMP::em2d::cvIntMat"""
853 return _IMP_em2d.create_circular_mask(*args)
855 def do_histogram_stretching(*args):
856 """do_histogram_stretching(cv::Mat & m, int boxes, int offset)"""
857 return _IMP_em2d.do_histogram_stretching(*args)
860 """do_dilate_and_shrink_warp(cv::Mat & m, cv::Mat const & greyscale, cv::Mat & kernel)"""
861 return _IMP_em2d.do_dilate_and_shrink_warp(*args)
865 do_morphologic_reconstruction(cv::Mat const & mask, cv::Mat & marker, int neighbors_mode=4)
866 do_morphologic_reconstruction(cv::Mat const & mask, cv::Mat & marker)
868 return _IMP_em2d.do_morphologic_reconstruction(*args)
871 """do_labeling(IMP::em2d::cvIntMat const & m, IMP::em2d::cvIntMat & mat_to_label) -> int"""
872 return _IMP_em2d.do_labeling(*args)
875 """get_diffusion_filtering_partial_derivative(cv::Mat const & m, cv::Mat & der, double dx, double dy, double ang)"""
876 return _IMP_em2d.get_diffusion_filtering_partial_derivative(*args)
879 """get_domes(cv::Mat & m, cv::Mat & result, double h)"""
880 return _IMP_em2d.get_domes(*args)
882 def my_meanStdDev(*args):
883 """my_meanStdDev(cv::Mat const & m, cv::Scalar & mean, cv::Scalar & stddev)"""
884 return _IMP_em2d.my_meanStdDev(*args)
887 """get_transformed(cv::Mat const & input, cv::Mat & transformed, Transformation2D T)"""
888 return _IMP_em2d.get_transformed(*args)
892 apply_threshold(cv::Mat & m, cv::Mat & result, double threshold=0.0)
893 apply_threshold(cv::Mat & m, cv::Mat & result)
895 return _IMP_em2d.apply_threshold(*args)
898 """do_morphologic_contrast_enhancement(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel, unsigned int iterations)"""
899 return _IMP_em2d.do_morphologic_contrast_enhancement(*args)
902 """get_morphologic_gradient(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel)"""
903 return _IMP_em2d.get_morphologic_gradient(*args)
906 """get_overlap_percentage(cv::Mat & m1, cv::Mat & m2, IMP::IntPair const & center) -> double"""
907 return _IMP_em2d.get_overlap_percentage(*args)
910 """get_best_template_matches(cv::Mat const & m, cv::Mat const & templ, unsigned int n) -> IMP::em2d::MatchTemplateResults"""
911 return _IMP_em2d.get_best_template_matches(*args)
913 """Proxy of C++ IMP::em2d::Image class"""
914 __swig_setmethods__ = {}
915 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
916 __setattr__ =
lambda self, name, value: _swig_setattr(self, Image, name, value)
917 __swig_getmethods__ = {}
918 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
919 __getattr__ =
lambda self, name: _swig_getattr(self, Image, name)
920 def __init__(self, *args):
922 __init__(IMP::em2d::Image self) -> Image
923 __init__(IMP::em2d::Image self, int rows, int cols) -> Image
924 __init__(IMP::em2d::Image self, IMP::String filename, ImageReaderWriter reader) -> Image
926 this = _IMP_em2d.new_Image(*args)
927 try: self.this.append(this)
928 except: self.this = this
930 """get_data(Image self) -> cv::Mat &"""
931 return _IMP_em2d.Image_get_data(self)
933 def set_data(self, *args):
934 """set_data(Image self, cv::Mat const & mat)"""
935 return _IMP_em2d.Image_set_data(self, *args)
938 """set_zeros(Image self)"""
939 return _IMP_em2d.Image_set_zeros(self)
941 def set_value(self, *args):
943 set_value(Image self, double val)
944 set_value(Image self, int i, int j, double val)
946 return _IMP_em2d.Image_set_value(self, *args)
948 def __call__(self, *args):
949 """__call__(Image self, int i, int j) -> double"""
950 return _IMP_em2d.Image___call__(self, *args)
952 def get_header(self):
953 """get_header(Image self) -> ImageHeader"""
954 return _IMP_em2d.Image_get_header(self)
956 def set_size(self, *args):
958 set_size(Image self, int rows, int cols)
959 set_size(Image self, Image img)
961 return _IMP_em2d.Image_set_size(self, *args)
963 def update_header(self):
964 """update_header(Image self)"""
965 return _IMP_em2d.Image_update_header(self)
967 def read(self, *args):
968 """read(Image self, IMP::String filename, ImageReaderWriter reader)"""
969 return _IMP_em2d.Image_read(self, *args)
971 def write(self, *args):
972 """write(Image self, IMP::String const & filename, ImageReaderWriter writer)"""
973 return _IMP_em2d.Image_write(self, *args)
975 def show(self, *args):
976 """show(Image self, _ostream out)"""
977 return _IMP_em2d.Image_show(self, *args)
979 def get_version_info(self):
980 """get_version_info(Image self) -> VersionInfo"""
981 return _IMP_em2d.Image_get_version_info(self)
983 def set_name(self, *args):
984 """set_name(Image self, IMP::String const & name)"""
985 return _IMP_em2d.Image_set_name(self, *args)
988 """get_name(Image self) -> IMP::String"""
989 return _IMP_em2d.Image_get_name(self)
991 def get_min_and_max_values(self):
992 """get_min_and_max_values(Image self) -> IMP::FloatRange"""
993 return _IMP_em2d.Image_get_min_and_max_values(self)
996 """__str__(Image self) -> std::string"""
997 return _IMP_em2d.Image___str__(self)
1000 """__repr__(Image self) -> std::string"""
1001 return _IMP_em2d.Image___repr__(self)
1004 return _object_cast_to_Image(o)
1005 get_from = staticmethod(get_from)
1007 Image_swigregister = _IMP_em2d.Image_swigregister
1008 Image_swigregister(Image)
1012 """read_images(IMP::Strings const & names, ImageReaderWriter rw) -> IMP::em2d::Images"""
1013 return _IMP_em2d.read_images(*args)
1016 """save_images(IMP::em2d::Images images, IMP::Strings const & names, ImageReaderWriter rw)"""
1017 return _IMP_em2d.save_images(*args)
1021 do_normalize(cv::Mat & m)
1022 do_normalize(Image im, bool force=False)
1023 do_normalize(Image im)
1025 return _IMP_em2d.do_normalize(*args)
1029 get_histogram(cv::Mat const & m, int bins) -> IMP::Floats
1030 get_histogram(Image img, int bins) -> IMP::Floats
1032 return _IMP_em2d.get_histogram(*args)
1036 apply_variance_filter(cv::Mat const & input, cv::Mat & filtered, int kernelsize)
1037 apply_variance_filter(Image input, Image filtered, int kernelsize)
1039 return _IMP_em2d.apply_variance_filter(*args)
1043 apply_diffusion_filter(cv::Mat const & m, cv::Mat & result, double beta, double pixelsize, unsigned int time_steps)
1044 apply_diffusion_filter(Image input, Image filtered, double beta, double pixelsize, int time_steps)
1046 return _IMP_em2d.apply_diffusion_filter(*args)
1048 def do_fill_holes(*args):
1050 do_fill_holes(cv::Mat const & m, cv::Mat & result, double h)
1051 do_fill_holes(Image input, Image result, double n_stddevs)
1053 return _IMP_em2d.do_fill_holes(*args)
1055 def do_combined_fill_holes_and_threshold(*args):
1057 do_combined_fill_holes_and_threshold(cv::Mat & m, cv::Mat & result, double n_stddevs, double threshold=0.0)
1058 do_combined_fill_holes_and_threshold(cv::Mat & m, cv::Mat & result, double n_stddevs)
1059 do_combined_fill_holes_and_threshold(Image input, Image result, double n_stddevs)
1061 return _IMP_em2d.do_combined_fill_holes_and_threshold(*args)
1063 def do_extend_borders(*args):
1065 do_extend_borders(cv::Mat & orig, cv::Mat & dst, unsigned int pix)
1066 do_extend_borders(Image im1, Image im2, unsigned int pix)
1068 return _IMP_em2d.do_extend_borders(*args)
1070 def do_segmentation(*args):
1072 do_segmentation(cv::Mat const & m, cv::Mat & result, SegmentationParameters params)
1073 do_segmentation(Image input, Image result, SegmentationParameters params)
1075 return _IMP_em2d.do_segmentation(*args)
1077 def do_remove_small_objects(*args):
1079 do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage, int background=0, int foreground=1)
1080 do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage, int background=0)
1081 do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage)
1082 do_remove_small_objects(Image input, double percentage, int background=0, int foreground=1)
1083 do_remove_small_objects(Image input, double percentage, int background=0)
1084 do_remove_small_objects(Image input, double percentage)
1086 return _IMP_em2d.do_remove_small_objects(*args)
1089 """do_subtract_images(Image first, Image second, Image result)"""
1090 return _IMP_em2d.do_subtract_images(*args)
1092 def add_noise(*args):
1094 add_noise(cv::Mat & v, double op1, double op2, IMP::String const & mode="uniform", double df=3)
1095 add_noise(cv::Mat & v, double op1, double op2, IMP::String const & mode="uniform")
1096 add_noise(cv::Mat & v, double op1, double op2)
1097 add_noise(Image im1, double op1, double op2, IMP::String const & mode="uniform", double df=3)
1098 add_noise(Image im1, double op1, double op2, IMP::String const & mode="uniform")
1099 add_noise(Image im1, double op1, double op2)
1101 return _IMP_em2d.add_noise(*args)
1105 do_resample_polar(cv::Mat const & input, cv::Mat & resampled, PolarResamplingParameters polar_params)
1106 do_resample_polar(Image im1, Image im2, PolarResamplingParameters polar_params)
1108 return _IMP_em2d.do_resample_polar(*args)
1112 crop(cv::Mat const & m, IMP::IntPair const & center, int size) -> cv::Mat
1113 crop(Image img, IMP::IntPair const & center, int size)
1115 return _IMP_em2d.crop(*args)
1118 """apply_mean_outside_mask(Image img, double radius)"""
1119 return _IMP_em2d.apply_mean_outside_mask(*args)
1120 class RegistrationResult(_object):
1121 """Proxy of C++ IMP::em2d::RegistrationResult class"""
1122 __swig_setmethods__ = {}
1123 __setattr__ =
lambda self, name, value: _swig_setattr(self, RegistrationResult, name, value)
1124 __swig_getmethods__ = {}
1125 __getattr__ =
lambda self, name: _swig_getattr(self, RegistrationResult, name)
1126 def __init__(self, *args):
1128 __init__(IMP::em2d::RegistrationResult self) -> RegistrationResult
1129 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0, int image_index=0,
1130 IMP::String name="") -> RegistrationResult
1131 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0, int image_index=0) -> RegistrationResult
1132 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0) -> RegistrationResult
1133 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift) -> RegistrationResult
1134 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0., 0.), int projection_index=0,
1135 int image_index=0, IMP::String name="") -> RegistrationResult
1136 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0., 0.), int projection_index=0,
1137 int image_index=0) -> RegistrationResult
1138 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0., 0.), int projection_index=0) -> RegistrationResult
1139 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0., 0.)) -> RegistrationResult
1140 __init__(IMP::em2d::RegistrationResult self, Rotation3D R) -> RegistrationResult
1142 this = _IMP_em2d.new_RegistrationResult(*args)
1143 try: self.this.append(this)
1144 except: self.this = this
1146 """get_phi(RegistrationResult self) -> double"""
1147 return _IMP_em2d.RegistrationResult_get_phi(self)
1149 def get_theta(self):
1150 """get_theta(RegistrationResult self) -> double"""
1151 return _IMP_em2d.RegistrationResult_get_theta(self)
1154 """get_psi(RegistrationResult self) -> double"""
1155 return _IMP_em2d.RegistrationResult_get_psi(self)
1157 def get_shift(self):
1158 """get_shift(RegistrationResult self) -> Vector2D"""
1159 return _IMP_em2d.RegistrationResult_get_shift(self)
1161 def get_shift_3d(self):
1162 """get_shift_3d(RegistrationResult self) -> Vector3D"""
1163 return _IMP_em2d.RegistrationResult_get_shift_3d(self)
1165 def get_projection_index(self):
1166 """get_projection_index(RegistrationResult self) -> int"""
1167 return _IMP_em2d.RegistrationResult_get_projection_index(self)
1169 def set_projection_index(self, *args):
1170 """set_projection_index(RegistrationResult self, int index)"""
1171 return _IMP_em2d.RegistrationResult_set_projection_index(self, *args)
1173 def get_image_index(self):
1174 """get_image_index(RegistrationResult self) -> int"""
1175 return _IMP_em2d.RegistrationResult_get_image_index(self)
1177 def set_image_index(self, *args):
1178 """set_image_index(RegistrationResult self, int index)"""
1179 return _IMP_em2d.RegistrationResult_set_image_index(self, *args)
1182 """get_name(RegistrationResult self) -> IMP::String"""
1183 return _IMP_em2d.RegistrationResult_get_name(self)
1186 """get_ccc(RegistrationResult self) -> double"""
1187 return _IMP_em2d.RegistrationResult_get_ccc(self)
1189 def set_ccc(self, *args):
1190 """set_ccc(RegistrationResult self, double ccc)"""
1191 return _IMP_em2d.RegistrationResult_set_ccc(self, *args)
1193 def get_score(self):
1194 """get_score(RegistrationResult self) -> double"""
1195 return _IMP_em2d.RegistrationResult_get_score(self)
1197 def set_score(self, *args):
1198 """set_score(RegistrationResult self, double Score)"""
1199 return _IMP_em2d.RegistrationResult_set_score(self, *args)
1201 def set_rotation(self, *args):
1203 set_rotation(RegistrationResult self, double phi, double theta, double psi)
1204 set_rotation(RegistrationResult self, Rotation3D R)
1206 return _IMP_em2d.RegistrationResult_set_rotation(self, *args)
1208 def set_shift(self, *args):
1209 """set_shift(RegistrationResult self, Vector2D shift)"""
1210 return _IMP_em2d.RegistrationResult_set_shift(self, *args)
1212 def set_name(self, *args):
1213 """set_name(RegistrationResult self, IMP::String name)"""
1214 return _IMP_em2d.RegistrationResult_set_name(self, *args)
1216 def add_in_plane_transformation(self, *args):
1217 """add_in_plane_transformation(RegistrationResult self, Transformation2D t)"""
1218 return _IMP_em2d.RegistrationResult_add_in_plane_transformation(self, *args)
1220 def show(self, *args):
1222 show(RegistrationResult self, _ostream out=std::cout)
1223 show(RegistrationResult self)
1225 return _IMP_em2d.RegistrationResult_show(self, *args)
1227 def write(self, *args):
1229 write(RegistrationResult self, _ostream out=std::cout)
1230 write(RegistrationResult self)
1232 return _IMP_em2d.RegistrationResult_write(self, *args)
1234 def write_comment_line(self, *args):
1236 write_comment_line(RegistrationResult self, _ostream out=std::cout)
1237 write_comment_line(RegistrationResult self)
1239 return _IMP_em2d.RegistrationResult_write_comment_line(self, *args)
1241 def read(self, *args):
1242 """read(RegistrationResult self, IMP::String const & s)"""
1243 return _IMP_em2d.RegistrationResult_read(self, *args)
1245 def set_random_registration(self, *args):
1246 """set_random_registration(RegistrationResult self, unsigned int index, double maximum_shift)"""
1247 return _IMP_em2d.RegistrationResult_set_random_registration(self, *args)
1249 def get_rotation(self):
1250 """get_rotation(RegistrationResult self) -> Rotation3D"""
1251 return _IMP_em2d.RegistrationResult_get_rotation(self)
1253 def set_in_image(self, *args):
1254 """set_in_image(RegistrationResult self, ImageHeader header)"""
1255 return _IMP_em2d.RegistrationResult_set_in_image(self, *args)
1257 def read_from_image(self, *args):
1258 """read_from_image(RegistrationResult self, ImageHeader header)"""
1259 return _IMP_em2d.RegistrationResult_read_from_image(self, *args)
1261 def get_is_optimized_result(self):
1262 """get_is_optimized_result(RegistrationResult self) -> bool"""
1263 return _IMP_em2d.RegistrationResult_get_is_optimized_result(self)
1265 __swig_destroy__ = _IMP_em2d.delete_RegistrationResult
1266 __del__ =
lambda self :
None;
1268 """__str__(RegistrationResult self) -> std::string"""
1269 return _IMP_em2d.RegistrationResult___str__(self)
1272 """__repr__(RegistrationResult self) -> std::string"""
1273 return _IMP_em2d.RegistrationResult___repr__(self)
1275 RegistrationResult_swigregister = _IMP_em2d.RegistrationResult_swigregister
1276 RegistrationResult_swigregister(RegistrationResult)
1280 """read_registration_results(IMP::String const & filename) -> IMP::em2d::RegistrationResults"""
1281 return _IMP_em2d.read_registration_results(*args)
1284 """write_registration_results(IMP::String filename, IMP::em2d::RegistrationResults const & results)"""
1285 return _IMP_em2d.write_registration_results(*args)
1289 get_random_registration_results(unsigned int n, double maximum_shift=5.0) -> IMP::em2d::RegistrationResults
1290 get_random_registration_results(unsigned int n) -> IMP::em2d::RegistrationResults
1292 return _IMP_em2d.get_random_registration_results(*args)
1295 """get_evenly_distributed_registration_results(unsigned int n_projections) -> IMP::em2d::RegistrationResults"""
1296 return _IMP_em2d.get_evenly_distributed_registration_results(*args)
1298 def get_random_between_zero_and_one():
1299 """get_random_between_zero_and_one() -> double"""
1300 return _IMP_em2d.get_random_between_zero_and_one()
1301 class SpiderImageReaderWriter(ImageReaderWriter):
1302 """Proxy of C++ IMP::em2d::SpiderImageReaderWriter class"""
1303 __swig_setmethods__ = {}
1304 for _s
in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1305 __setattr__ =
lambda self, name, value: _swig_setattr(self, SpiderImageReaderWriter, name, value)
1306 __swig_getmethods__ = {}
1307 for _s
in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1308 __getattr__ =
lambda self, name: _swig_getattr(self, SpiderImageReaderWriter, name)
1309 __swig_setmethods__[
"filename_"] = _IMP_em2d.SpiderImageReaderWriter_filename__set
1310 __swig_getmethods__[
"filename_"] = _IMP_em2d.SpiderImageReaderWriter_filename__get
1311 if _newclass:filename_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_filename__get, _IMP_em2d.SpiderImageReaderWriter_filename__set)
1312 __swig_setmethods__[
"skip_type_check_"] = _IMP_em2d.SpiderImageReaderWriter_skip_type_check__set
1313 __swig_getmethods__[
"skip_type_check_"] = _IMP_em2d.SpiderImageReaderWriter_skip_type_check__get
1314 if _newclass:skip_type_check_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_skip_type_check__get, _IMP_em2d.SpiderImageReaderWriter_skip_type_check__set)
1315 __swig_setmethods__[
"force_reversed_"] = _IMP_em2d.SpiderImageReaderWriter_force_reversed__set
1316 __swig_getmethods__[
"force_reversed_"] = _IMP_em2d.SpiderImageReaderWriter_force_reversed__get
1317 if _newclass:force_reversed_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_force_reversed__get, _IMP_em2d.SpiderImageReaderWriter_force_reversed__set)
1318 __swig_setmethods__[
"skip_extra_checkings_"] = _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__set
1319 __swig_getmethods__[
"skip_extra_checkings_"] = _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__get
1320 if _newclass:skip_extra_checkings_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__get, _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__set)
1321 def __init__(self, *args):
1323 __init__(IMP::em2d::SpiderImageReaderWriter self) -> SpiderImageReaderWriter
1324 __init__(IMP::em2d::SpiderImageReaderWriter self, IMP::String const & filename, bool skip_type_check, bool force_reversed, bool skip_extra_checkings) -> SpiderImageReaderWriter
1326 this = _IMP_em2d.new_SpiderImageReaderWriter(*args)
1327 try: self.this.append(this)
1328 except: self.this = this
1330 """__str__(SpiderImageReaderWriter self) -> std::string"""
1331 return _IMP_em2d.SpiderImageReaderWriter___str__(self)
1334 """__repr__(SpiderImageReaderWriter self) -> std::string"""
1335 return _IMP_em2d.SpiderImageReaderWriter___repr__(self)
1338 return _object_cast_to_SpiderImageReaderWriter(o)
1339 get_from = staticmethod(get_from)
1341 SpiderImageReaderWriter_swigregister = _IMP_em2d.SpiderImageReaderWriter_swigregister
1342 SpiderImageReaderWriter_swigregister(SpiderImageReaderWriter)
1344 class JPGImageReaderWriter(ImageReaderWriter):
1345 """Proxy of C++ IMP::em2d::JPGImageReaderWriter class"""
1346 __swig_setmethods__ = {}
1347 for _s
in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1348 __setattr__ =
lambda self, name, value: _swig_setattr(self, JPGImageReaderWriter, name, value)
1349 __swig_getmethods__ = {}
1350 for _s
in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1351 __getattr__ =
lambda self, name: _swig_getattr(self, JPGImageReaderWriter, name)
1353 """__init__(IMP::em2d::JPGImageReaderWriter self) -> JPGImageReaderWriter"""
1354 this = _IMP_em2d.new_JPGImageReaderWriter()
1355 try: self.this.append(this)
1356 except: self.this = this
1358 """__str__(JPGImageReaderWriter self) -> std::string"""
1359 return _IMP_em2d.JPGImageReaderWriter___str__(self)
1362 """__repr__(JPGImageReaderWriter self) -> std::string"""
1363 return _IMP_em2d.JPGImageReaderWriter___repr__(self)
1366 return _object_cast_to_JPGImageReaderWriter(o)
1367 get_from = staticmethod(get_from)
1369 JPGImageReaderWriter_swigregister = _IMP_em2d.JPGImageReaderWriter_swigregister
1370 JPGImageReaderWriter_swigregister(JPGImageReaderWriter)
1372 class TIFFImageReaderWriter(ImageReaderWriter):
1373 """Proxy of C++ IMP::em2d::TIFFImageReaderWriter class"""
1374 __swig_setmethods__ = {}
1375 for _s
in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1376 __setattr__ =
lambda self, name, value: _swig_setattr(self, TIFFImageReaderWriter, name, value)
1377 __swig_getmethods__ = {}
1378 for _s
in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1379 __getattr__ =
lambda self, name: _swig_getattr(self, TIFFImageReaderWriter, name)
1381 """__init__(IMP::em2d::TIFFImageReaderWriter self) -> TIFFImageReaderWriter"""
1382 this = _IMP_em2d.new_TIFFImageReaderWriter()
1383 try: self.this.append(this)
1384 except: self.this = this
1386 """__str__(TIFFImageReaderWriter self) -> std::string"""
1387 return _IMP_em2d.TIFFImageReaderWriter___str__(self)
1390 """__repr__(TIFFImageReaderWriter self) -> std::string"""
1391 return _IMP_em2d.TIFFImageReaderWriter___repr__(self)
1394 return _object_cast_to_TIFFImageReaderWriter(o)
1395 get_from = staticmethod(get_from)
1397 TIFFImageReaderWriter_swigregister = _IMP_em2d.TIFFImageReaderWriter_swigregister
1398 TIFFImageReaderWriter_swigregister(TIFFImageReaderWriter)
1402 """do_matrix_to_image_flip(cv::Mat & m)"""
1403 return _IMP_em2d.do_matrix_to_image_flip(*args)
1406 """get_autocorrelation2d_no_preprocessing(cv::Mat const & M, cv::Mat & corr)"""
1407 return _IMP_em2d.get_autocorrelation2d_no_preprocessing(*args)
1411 get_autocorrelation2d(Image im1, Image im2)
1412 get_autocorrelation2d(cv::Mat const & m, cv::Mat & corr)
1414 return _IMP_em2d.get_autocorrelation2d(*args)
1418 get_correlation2d(Image im1, Image im2, Image corr)
1419 get_correlation2d(cv::Mat const & A, cv::Mat const & B, cv::Mat & corr)
1421 return _IMP_em2d.get_correlation2d(*args)
1424 """get_correlation2d_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2, cv::Mat & corr)"""
1425 return _IMP_em2d.get_correlation2d_no_preprocessing(*args)
1428 """get_fft_using_optimal_size(cv::Mat const & m, cv::Mat & M)"""
1429 return _IMP_em2d.get_fft_using_optimal_size(*args)
1432 """get_spectrum(cv::Mat const & m, cv::Mat & real, cv::Mat & imag)"""
1433 return _IMP_em2d.get_spectrum(*args)
1436 """get_rotation_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
1437 return _IMP_em2d.get_rotation_error(*args)
1440 """get_shift_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
1441 return _IMP_em2d.get_shift_error(*args)
1443 def get_average_rotation_error(*args):
1444 """get_average_rotation_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
1445 return _IMP_em2d.get_average_rotation_error(*args)
1447 def get_average_shift_error(*args):
1448 """get_average_shift_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
1449 return _IMP_em2d.get_average_shift_error(*args)
1453 get_cross_correlation_coefficient(Image im1, Image im2) -> double
1454 get_cross_correlation_coefficient(cv::Mat const & m1, cv::Mat const & m2) -> double
1456 return _IMP_em2d.get_cross_correlation_coefficient(*args)
1459 """get_global_score(IMP::em2d::RegistrationResults const & RRs) -> double"""
1460 return _IMP_em2d.get_global_score(*args)
1462 """Proxy of C++ IMP::em2d::ScoreFunction class"""
1463 __swig_setmethods__ = {}
1464 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1465 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScoreFunction, name, value)
1466 __swig_getmethods__ = {}
1467 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1468 __getattr__ =
lambda self, name: _swig_getattr(self, ScoreFunction, name)
1469 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
1470 def get_score(self, *args):
1471 """get_score(ScoreFunction self, Image image, Image projection) -> double"""
1472 return _IMP_em2d.ScoreFunction_get_score(self, *args)
1474 def set_variance_image(self, *args):
1475 """set_variance_image(ScoreFunction self, Image var)"""
1476 return _IMP_em2d.ScoreFunction_set_variance_image(self, *args)
1478 def get_version_info(self):
1479 """get_version_info(ScoreFunction self) -> VersionInfo"""
1480 return _IMP_em2d.ScoreFunction_get_version_info(self)
1483 """__str__(ScoreFunction self) -> std::string"""
1484 return _IMP_em2d.ScoreFunction___str__(self)
1487 """__repr__(ScoreFunction self) -> std::string"""
1488 return _IMP_em2d.ScoreFunction___repr__(self)
1491 return _object_cast_to_ScoreFunction(o)
1492 get_from = staticmethod(get_from)
1494 ScoreFunction_swigregister = _IMP_em2d.ScoreFunction_swigregister
1495 ScoreFunction_swigregister(ScoreFunction)
1497 class ChiSquaredScore(ScoreFunction):
1498 """Proxy of C++ IMP::em2d::ChiSquaredScore class"""
1499 __swig_setmethods__ = {}
1500 for _s
in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1501 __setattr__ =
lambda self, name, value: _swig_setattr(self, ChiSquaredScore, name, value)
1502 __swig_getmethods__ = {}
1503 for _s
in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1504 __getattr__ =
lambda self, name: _swig_getattr(self, ChiSquaredScore, name)
1506 """__init__(IMP::em2d::ChiSquaredScore self) -> ChiSquaredScore"""
1507 this = _IMP_em2d.new_ChiSquaredScore()
1508 try: self.this.append(this)
1509 except: self.this = this
1511 """__str__(ChiSquaredScore self) -> std::string"""
1512 return _IMP_em2d.ChiSquaredScore___str__(self)
1515 """__repr__(ChiSquaredScore self) -> std::string"""
1516 return _IMP_em2d.ChiSquaredScore___repr__(self)
1519 return _object_cast_to_ChiSquaredScore(o)
1520 get_from = staticmethod(get_from)
1522 __swig_destroy__ = _IMP_em2d.delete_ChiSquaredScore
1523 __del__ =
lambda self :
None;
1524 ChiSquaredScore_swigregister = _IMP_em2d.ChiSquaredScore_swigregister
1525 ChiSquaredScore_swigregister(ChiSquaredScore)
1527 class EM2DScore(ScoreFunction):
1528 """Proxy of C++ IMP::em2d::EM2DScore class"""
1529 __swig_setmethods__ = {}
1530 for _s
in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1531 __setattr__ =
lambda self, name, value: _swig_setattr(self, EM2DScore, name, value)
1532 __swig_getmethods__ = {}
1533 for _s
in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1534 __getattr__ =
lambda self, name: _swig_getattr(self, EM2DScore, name)
1536 """__init__(IMP::em2d::EM2DScore self) -> EM2DScore"""
1537 this = _IMP_em2d.new_EM2DScore()
1538 try: self.this.append(this)
1539 except: self.this = this
1541 """__str__(EM2DScore self) -> std::string"""
1542 return _IMP_em2d.EM2DScore___str__(self)
1545 """__repr__(EM2DScore self) -> std::string"""
1546 return _IMP_em2d.EM2DScore___repr__(self)
1549 return _object_cast_to_EM2DScore(o)
1550 get_from = staticmethod(get_from)
1552 __swig_destroy__ = _IMP_em2d.delete_EM2DScore
1553 __del__ =
lambda self :
None;
1554 EM2DScore_swigregister = _IMP_em2d.EM2DScore_swigregister
1555 EM2DScore_swigregister(EM2DScore)
1557 class MeanAbsoluteDifference(ScoreFunction):
1558 """Proxy of C++ IMP::em2d::MeanAbsoluteDifference class"""
1559 __swig_setmethods__ = {}
1560 for _s
in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1561 __setattr__ =
lambda self, name, value: _swig_setattr(self, MeanAbsoluteDifference, name, value)
1562 __swig_getmethods__ = {}
1563 for _s
in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1564 __getattr__ =
lambda self, name: _swig_getattr(self, MeanAbsoluteDifference, name)
1566 """__init__(IMP::em2d::MeanAbsoluteDifference self) -> MeanAbsoluteDifference"""
1567 this = _IMP_em2d.new_MeanAbsoluteDifference()
1568 try: self.this.append(this)
1569 except: self.this = this
1571 """__str__(MeanAbsoluteDifference self) -> std::string"""
1572 return _IMP_em2d.MeanAbsoluteDifference___str__(self)
1575 """__repr__(MeanAbsoluteDifference self) -> std::string"""
1576 return _IMP_em2d.MeanAbsoluteDifference___repr__(self)
1579 return _object_cast_to_MeanAbsoluteDifference(o)
1580 get_from = staticmethod(get_from)
1582 __swig_destroy__ = _IMP_em2d.delete_MeanAbsoluteDifference
1583 __del__ =
lambda self :
None;
1584 MeanAbsoluteDifference_swigregister = _IMP_em2d.MeanAbsoluteDifference_swigregister
1585 MeanAbsoluteDifference_swigregister(MeanAbsoluteDifference)
1589 """read_selection_file(IMP::String fn) -> IMP::Strings"""
1590 return _IMP_em2d.read_selection_file(*args)
1593 """create_filenames(unsigned long number, IMP::String basic_name, IMP::String extension) -> IMP::Strings"""
1594 return _IMP_em2d.create_filenames(*args)
1596 """Proxy of C++ IMP::em2d::ProjectionParameters class"""
1597 __swig_setmethods__ = {}
1598 for _s
in [
IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1599 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionParameters, name, value)
1600 __swig_getmethods__ = {}
1601 for _s
in [
IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1602 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionParameters, name)
1603 def __init__(self, *args):
1605 __init__(IMP::em2d::ProjectionParameters self) -> ProjectionParameters
1606 __init__(IMP::em2d::ProjectionParameters self, Model m, ::IMP::kernel::ParticleIndex id) -> ProjectionParameters
1607 __init__(IMP::em2d::ProjectionParameters self, _ParticleAdaptor d) -> ProjectionParameters
1609 this = _IMP_em2d.new_ProjectionParameters(*args)
1610 try: self.this.append(this)
1611 except: self.this = this
1612 def decorate_particle(*args):
1613 """decorate_particle(Particle p) -> ProjectionParameters"""
1614 return _IMP_em2d.ProjectionParameters_decorate_particle(*args)
1616 if _newclass:decorate_particle = staticmethod(decorate_particle)
1617 __swig_getmethods__[
"decorate_particle"] =
lambda x: decorate_particle
1618 def show(self, *args):
1620 show(ProjectionParameters self, _ostream out=std::cout)
1621 show(ProjectionParameters self)
1623 return _IMP_em2d.ProjectionParameters_show(self, *args)
1625 def setup_particle(*args):
1627 setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> ProjectionParameters
1628 setup_particle(_ParticleAdaptor decorator) -> ProjectionParameters
1630 return _IMP_em2d.ProjectionParameters_setup_particle(*args)
1632 if _newclass:setup_particle = staticmethod(setup_particle)
1633 __swig_getmethods__[
"setup_particle"] =
lambda x: setup_particle
1634 __swig_destroy__ = _IMP_em2d.delete_ProjectionParameters
1635 __del__ =
lambda self :
None;
1637 """get_keys() -> IMP::kernel::FloatKeys const &"""
1638 return _IMP_em2d.ProjectionParameters_get_keys()
1640 if _newclass:get_keys = staticmethod(get_keys)
1641 __swig_getmethods__[
"get_keys"] =
lambda x: get_keys
1642 def set_proper_ranges_for_keys(self, *args):
1643 """set_proper_ranges_for_keys(ProjectionParameters self, Model m, Vector3D min_translation_values, Vector3D max_translation_values)"""
1644 return _IMP_em2d.ProjectionParameters_set_proper_ranges_for_keys(self, *args)
1646 def get_is_setup(*args):
1648 get_is_setup(_ParticleAdaptor p) -> bool
1649 get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
1651 return _IMP_em2d.ProjectionParameters_get_is_setup(*args)
1653 if _newclass:get_is_setup = staticmethod(get_is_setup)
1654 __swig_getmethods__[
"get_is_setup"] =
lambda x: get_is_setup
1655 def get_parameters_optimized(self):
1656 """get_parameters_optimized(ProjectionParameters self) -> bool"""
1657 return _IMP_em2d.ProjectionParameters_get_parameters_optimized(self)
1659 def get_translation(self):
1660 """get_translation(ProjectionParameters self) -> Vector3D"""
1661 return _IMP_em2d.ProjectionParameters_get_translation(self)
1663 def set_translation(self, *args):
1664 """set_translation(ProjectionParameters self, Vector3D v)"""
1665 return _IMP_em2d.ProjectionParameters_set_translation(self, *args)
1667 def get_rotation(self):
1668 """get_rotation(ProjectionParameters self) -> Rotation3D"""
1669 return _IMP_em2d.ProjectionParameters_get_rotation(self)
1671 def set_rotation(self, *args):
1672 """set_rotation(ProjectionParameters self, Rotation3D R)"""
1673 return _IMP_em2d.ProjectionParameters_set_rotation(self, *args)
1675 def set_parameters_optimized(self, *args):
1676 """set_parameters_optimized(ProjectionParameters self, bool tf)"""
1677 return _IMP_em2d.ProjectionParameters_set_parameters_optimized(self, *args)
1679 def get_quaternion_1(self):
1680 """get_quaternion_1(ProjectionParameters self) -> double"""
1681 return _IMP_em2d.ProjectionParameters_get_quaternion_1(self)
1683 def set_quaternion_1(self, *args):
1684 """set_quaternion_1(ProjectionParameters self, double t)"""
1685 return _IMP_em2d.ProjectionParameters_set_quaternion_1(self, *args)
1687 def get_quaternion_2(self):
1688 """get_quaternion_2(ProjectionParameters self) -> double"""
1689 return _IMP_em2d.ProjectionParameters_get_quaternion_2(self)
1691 def set_quaternion_2(self, *args):
1692 """set_quaternion_2(ProjectionParameters self, double t)"""
1693 return _IMP_em2d.ProjectionParameters_set_quaternion_2(self, *args)
1695 def get_quaternion_3(self):
1696 """get_quaternion_3(ProjectionParameters self) -> double"""
1697 return _IMP_em2d.ProjectionParameters_get_quaternion_3(self)
1699 def set_quaternion_3(self, *args):
1700 """set_quaternion_3(ProjectionParameters self, double t)"""
1701 return _IMP_em2d.ProjectionParameters_set_quaternion_3(self, *args)
1703 def get_quaternion_4(self):
1704 """get_quaternion_4(ProjectionParameters self) -> double"""
1705 return _IMP_em2d.ProjectionParameters_get_quaternion_4(self)
1707 def set_quaternion_4(self, *args):
1708 """set_quaternion_4(ProjectionParameters self, double t)"""
1709 return _IMP_em2d.ProjectionParameters_set_quaternion_4(self, *args)
1711 def get_translation_x(self):
1712 """get_translation_x(ProjectionParameters self) -> double"""
1713 return _IMP_em2d.ProjectionParameters_get_translation_x(self)
1715 def set_translation_x(self, *args):
1716 """set_translation_x(ProjectionParameters self, double t)"""
1717 return _IMP_em2d.ProjectionParameters_set_translation_x(self, *args)
1719 def get_translation_y(self):
1720 """get_translation_y(ProjectionParameters self) -> double"""
1721 return _IMP_em2d.ProjectionParameters_get_translation_y(self)
1723 def set_translation_y(self, *args):
1724 """set_translation_y(ProjectionParameters self, double t)"""
1725 return _IMP_em2d.ProjectionParameters_set_translation_y(self, *args)
1727 def add_attribute(self, *args):
1729 add_attribute(ProjectionParameters self, FloatKey k, IMP::Float v, bool opt)
1730 add_attribute(ProjectionParameters self, FloatKey a0, IMP::Float a1)
1731 add_attribute(ProjectionParameters self, IntKey a0, IMP::Int a1)
1732 add_attribute(ProjectionParameters self, StringKey a0, IMP::String a1)
1733 add_attribute(ProjectionParameters self, ParticleIndexKey a0, Particle a1)
1734 add_attribute(ProjectionParameters self, ObjectKey a0, Object a1)
1736 return _IMP_em2d.ProjectionParameters_add_attribute(self, *args)
1738 def get_value(self, *args):
1740 get_value(ProjectionParameters self, FloatKey a0) -> IMP::Float
1741 get_value(ProjectionParameters self, IntKey a0) -> IMP::Int
1742 get_value(ProjectionParameters self, StringKey a0) -> IMP::String
1743 get_value(ProjectionParameters self, ParticleIndexKey a0) -> Particle
1744 get_value(ProjectionParameters self, ObjectKey a0) -> Object
1746 return _IMP_em2d.ProjectionParameters_get_value(self, *args)
1748 def set_value(self, *args):
1750 set_value(ProjectionParameters self, FloatKey a0, IMP::Float a1)
1751 set_value(ProjectionParameters self, IntKey a0, IMP::Int a1)
1752 set_value(ProjectionParameters self, StringKey a0, IMP::String a1)
1753 set_value(ProjectionParameters self, ParticleIndexKey a0, Particle a1)
1754 set_value(ProjectionParameters self, ObjectKey a0, Object a1)
1756 return _IMP_em2d.ProjectionParameters_set_value(self, *args)
1758 def remove_attribute(self, *args):
1760 remove_attribute(ProjectionParameters self, FloatKey a0)
1761 remove_attribute(ProjectionParameters self, IntKey a0)
1762 remove_attribute(ProjectionParameters self, StringKey a0)
1763 remove_attribute(ProjectionParameters self, ParticleIndexKey a0)
1764 remove_attribute(ProjectionParameters self, ObjectKey a0)
1766 return _IMP_em2d.ProjectionParameters_remove_attribute(self, *args)
1768 def has_attribute(self, *args):
1770 has_attribute(ProjectionParameters self, FloatKey a0) -> bool
1771 has_attribute(ProjectionParameters self, IntKey a0) -> bool
1772 has_attribute(ProjectionParameters self, StringKey a0) -> bool
1773 has_attribute(ProjectionParameters self, ParticleIndexKey a0) -> bool
1774 has_attribute(ProjectionParameters self, ObjectKey a0) -> bool
1776 return _IMP_em2d.ProjectionParameters_has_attribute(self, *args)
1778 def get_derivative(self, *args):
1779 """get_derivative(ProjectionParameters self, FloatKey a0) -> double"""
1780 return _IMP_em2d.ProjectionParameters_get_derivative(self, *args)
1783 """get_name(ProjectionParameters self) -> std::string"""
1784 return _IMP_em2d.ProjectionParameters_get_name(self)
1786 def clear_caches(self):
1787 """clear_caches(ProjectionParameters self)"""
1788 return _IMP_em2d.ProjectionParameters_clear_caches(self)
1790 def set_name(self, *args):
1791 """set_name(ProjectionParameters self, std::string a0)"""
1792 return _IMP_em2d.ProjectionParameters_set_name(self, *args)
1795 """set_check_level(ProjectionParameters self, IMP::base::CheckLevel a0)"""
1796 return _IMP_em2d.ProjectionParameters_set_check_level(self, *args)
1798 def add_to_derivative(self, *args):
1799 """add_to_derivative(ProjectionParameters self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
1800 return _IMP_em2d.ProjectionParameters_add_to_derivative(self, *args)
1802 def set_is_optimized(self, *args):
1803 """set_is_optimized(ProjectionParameters self, FloatKey a0, bool a1)"""
1804 return _IMP_em2d.ProjectionParameters_set_is_optimized(self, *args)
1806 def get_is_optimized(self, *args):
1807 """get_is_optimized(ProjectionParameters self, FloatKey a0) -> bool"""
1808 return _IMP_em2d.ProjectionParameters_get_is_optimized(self, *args)
1811 """get_check_level(ProjectionParameters self) -> IMP::base::CheckLevel"""
1812 return _IMP_em2d.ProjectionParameters_get_check_level(self)
1814 def __eq__(self, *args):
1816 __eq__(ProjectionParameters self, ProjectionParameters o) -> bool
1817 __eq__(ProjectionParameters self, Particle d) -> bool
1819 return _IMP_em2d.ProjectionParameters___eq__(self, *args)
1821 def __ne__(self, *args):
1823 __ne__(ProjectionParameters self, ProjectionParameters o) -> bool
1824 __ne__(ProjectionParameters self, Particle d) -> bool
1826 return _IMP_em2d.ProjectionParameters___ne__(self, *args)
1828 def __le__(self, *args):
1830 __le__(ProjectionParameters self, ProjectionParameters o) -> bool
1831 __le__(ProjectionParameters self, Particle d) -> bool
1833 return _IMP_em2d.ProjectionParameters___le__(self, *args)
1835 def __lt__(self, *args):
1837 __lt__(ProjectionParameters self, ProjectionParameters o) -> bool
1838 __lt__(ProjectionParameters self, Particle d) -> bool
1840 return _IMP_em2d.ProjectionParameters___lt__(self, *args)
1842 def __ge__(self, *args):
1844 __ge__(ProjectionParameters self, ProjectionParameters o) -> bool
1845 __ge__(ProjectionParameters self, Particle d) -> bool
1847 return _IMP_em2d.ProjectionParameters___ge__(self, *args)
1849 def __gt__(self, *args):
1851 __gt__(ProjectionParameters self, ProjectionParameters o) -> bool
1852 __gt__(ProjectionParameters self, Particle d) -> bool
1854 return _IMP_em2d.ProjectionParameters___gt__(self, *args)
1857 """__str__(ProjectionParameters self) -> std::string"""
1858 return _IMP_em2d.ProjectionParameters___str__(self)
1861 """__repr__(ProjectionParameters self) -> std::string"""
1862 return _IMP_em2d.ProjectionParameters___repr__(self)
1864 ProjectionParameters_swigregister = _IMP_em2d.ProjectionParameters_swigregister
1865 ProjectionParameters_swigregister(ProjectionParameters)
1867 def ProjectionParameters_decorate_particle(*args):
1868 """ProjectionParameters_decorate_particle(Particle p) -> ProjectionParameters"""
1869 return _IMP_em2d.ProjectionParameters_decorate_particle(*args)
1871 def ProjectionParameters_setup_particle(*args):
1873 setup_particle(Model m, IMP::kernel::ParticleIndex pi) -> ProjectionParameters
1874 ProjectionParameters_setup_particle(_ParticleAdaptor decorator) -> ProjectionParameters
1876 return _IMP_em2d.ProjectionParameters_setup_particle(*args)
1878 def ProjectionParameters_get_keys():
1879 """ProjectionParameters_get_keys() -> IMP::kernel::FloatKeys const &"""
1880 return _IMP_em2d.ProjectionParameters_get_keys()
1882 def ProjectionParameters_get_is_setup(*args):
1884 get_is_setup(_ParticleAdaptor p) -> bool
1885 ProjectionParameters_get_is_setup(Model m, IMP::kernel::ParticleIndex pi) -> bool
1887 return _IMP_em2d.ProjectionParameters_get_is_setup(*args)
1890 def __lshift__(*args):
1891 """__lshift__(_ostream out, ProjectionParameters n) -> _ostream"""
1892 return _IMP_em2d.__lshift__(*args)
1894 """Proxy of C++ IMP::em2d::ProjectionParametersScoreState class"""
1895 __swig_setmethods__ = {}
1897 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionParametersScoreState, name, value)
1898 __swig_getmethods__ = {}
1900 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionParametersScoreState, name)
1901 def __init__(self, *args):
1902 """__init__(IMP::em2d::ProjectionParametersScoreState self, Particle p) -> ProjectionParametersScoreState"""
1903 this = _IMP_em2d.new_ProjectionParametersScoreState(*args)
1904 try: self.this.append(this)
1905 except: self.this = this
1906 def do_before_evaluate(self):
1907 """do_before_evaluate(ProjectionParametersScoreState self)"""
1908 return _IMP_em2d.ProjectionParametersScoreState_do_before_evaluate(self)
1910 def do_after_evaluate(self, *args):
1911 """do_after_evaluate(ProjectionParametersScoreState self, DerivativeAccumulator da)"""
1912 return _IMP_em2d.ProjectionParametersScoreState_do_after_evaluate(self, *args)
1914 def do_get_inputs(self):
1915 """do_get_inputs(ProjectionParametersScoreState self) -> IMP::kernel::ModelObjectsTemp"""
1916 return _IMP_em2d.ProjectionParametersScoreState_do_get_inputs(self)
1918 def do_get_outputs(self):
1919 """do_get_outputs(ProjectionParametersScoreState self) -> IMP::kernel::ModelObjectsTemp"""
1920 return _IMP_em2d.ProjectionParametersScoreState_do_get_outputs(self)
1922 def get_version_info(self):
1923 """get_version_info(ProjectionParametersScoreState self) -> VersionInfo"""
1924 return _IMP_em2d.ProjectionParametersScoreState_get_version_info(self)
1927 """__str__(ProjectionParametersScoreState self) -> std::string"""
1928 return _IMP_em2d.ProjectionParametersScoreState___str__(self)
1931 """__repr__(ProjectionParametersScoreState self) -> std::string"""
1932 return _IMP_em2d.ProjectionParametersScoreState___repr__(self)
1935 return _object_cast_to_ProjectionParametersScoreState(o)
1936 get_from = staticmethod(get_from)
1938 ProjectionParametersScoreState_swigregister = _IMP_em2d.ProjectionParametersScoreState_swigregister
1939 ProjectionParametersScoreState_swigregister(ProjectionParametersScoreState)
1941 class ProjectionMask(_object):
1942 """Proxy of C++ IMP::em2d::ProjectionMask class"""
1943 __swig_setmethods__ = {}
1944 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionMask, name, value)
1945 __swig_getmethods__ = {}
1946 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionMask, name)
1947 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined")
1948 def apply(self, *args):
1949 """apply(ProjectionMask self, cv::Mat & m, Vector2D v)"""
1950 return _IMP_em2d.ProjectionMask_apply(self, *args)
1952 def show(self, *args):
1954 show(ProjectionMask self, _ostream out=std::cout)
1955 show(ProjectionMask self)
1957 return _IMP_em2d.ProjectionMask_show(self, *args)
1959 __swig_destroy__ = _IMP_em2d.delete_ProjectionMask
1960 __del__ =
lambda self :
None;
1962 """__str__(ProjectionMask self) -> std::string"""
1963 return _IMP_em2d.ProjectionMask___str__(self)
1966 """__repr__(ProjectionMask self) -> std::string"""
1967 return _IMP_em2d.ProjectionMask___repr__(self)
1969 ProjectionMask_swigregister = _IMP_em2d.ProjectionMask_swigregister
1970 ProjectionMask_swigregister(ProjectionMask)
1974 """do_place(cv::Mat & mask, cv::Mat & m, Vector2D v)"""
1975 return _IMP_em2d.do_place(*args)
1976 class MasksManager(_object):
1977 """Proxy of C++ IMP::em2d::MasksManager class"""
1978 __swig_setmethods__ = {}
1979 __setattr__ =
lambda self, name, value: _swig_setattr(self, MasksManager, name, value)
1980 __swig_getmethods__ = {}
1981 __getattr__ =
lambda self, name: _swig_getattr(self, MasksManager, name)
1982 def __init__(self, *args):
1984 __init__(IMP::em2d::MasksManager self) -> MasksManager
1985 __init__(IMP::em2d::MasksManager self, double resolution, double pixelsize) -> MasksManager
1987 this = _IMP_em2d.new_MasksManager(*args)
1988 try: self.this.append(this)
1989 except: self.this = this
1990 def setup_kernel(self, *args):
1991 """setup_kernel(MasksManager self, double resolution, double pixelsize)"""
1992 return _IMP_em2d.MasksManager_setup_kernel(self, *args)
1994 def create_masks(self, *args):
1995 """create_masks(MasksManager self, IMP::kernel::ParticlesTemp const & ps)"""
1996 return _IMP_em2d.MasksManager_create_masks(self, *args)
1998 def create_mask(self, *args):
1999 """create_mask(MasksManager self, double radius, double mass)"""
2000 return _IMP_em2d.MasksManager_create_mask(self, *args)
2002 def find_mask(self, *args):
2003 """find_mask(MasksManager self, double radius) -> IMP::em2d::ProjectionMaskPtr"""
2004 return _IMP_em2d.MasksManager_find_mask(self, *args)
2006 def show(self, *args):
2008 show(MasksManager self, _ostream out=std::cout)
2009 show(MasksManager self)
2011 return _IMP_em2d.MasksManager_show(self, *args)
2013 def get_number_of_masks(self):
2014 """get_number_of_masks(MasksManager self) -> unsigned int"""
2015 return _IMP_em2d.MasksManager_get_number_of_masks(self)
2017 __swig_destroy__ = _IMP_em2d.delete_MasksManager
2018 __del__ =
lambda self :
None;
2020 """__str__(MasksManager self) -> std::string"""
2021 return _IMP_em2d.MasksManager___str__(self)
2024 """__repr__(MasksManager self) -> std::string"""
2025 return _IMP_em2d.MasksManager___repr__(self)
2027 MasksManager_swigregister = _IMP_em2d.MasksManager_swigregister
2028 MasksManager_swigregister(MasksManager)
2030 class ProjectingParameters(_object):
2031 """Proxy of C++ IMP::em2d::ProjectingParameters class"""
2032 __swig_setmethods__ = {}
2033 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectingParameters, name, value)
2034 __swig_getmethods__ = {}
2035 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectingParameters, name)
2036 __swig_setmethods__[
"pixel_size"] = _IMP_em2d.ProjectingParameters_pixel_size_set
2037 __swig_getmethods__[
"pixel_size"] = _IMP_em2d.ProjectingParameters_pixel_size_get
2038 if _newclass:pixel_size = _swig_property(_IMP_em2d.ProjectingParameters_pixel_size_get, _IMP_em2d.ProjectingParameters_pixel_size_set)
2039 __swig_setmethods__[
"resolution"] = _IMP_em2d.ProjectingParameters_resolution_set
2040 __swig_getmethods__[
"resolution"] = _IMP_em2d.ProjectingParameters_resolution_get
2041 if _newclass:resolution = _swig_property(_IMP_em2d.ProjectingParameters_resolution_get, _IMP_em2d.ProjectingParameters_resolution_set)
2042 def __init__(self, *args):
2044 __init__(IMP::em2d::ProjectingParameters self) -> ProjectingParameters
2045 __init__(IMP::em2d::ProjectingParameters self, double ps, double res) -> ProjectingParameters
2047 this = _IMP_em2d.new_ProjectingParameters(*args)
2048 try: self.this.append(this)
2049 except: self.this = this
2050 def show(self, *args):
2052 show(ProjectingParameters self, _ostream out=std::cout)
2053 show(ProjectingParameters self)
2055 return _IMP_em2d.ProjectingParameters_show(self, *args)
2058 """__str__(ProjectingParameters self) -> std::string"""
2059 return _IMP_em2d.ProjectingParameters___str__(self)
2062 """__repr__(ProjectingParameters self) -> std::string"""
2063 return _IMP_em2d.ProjectingParameters___repr__(self)
2065 __swig_destroy__ = _IMP_em2d.delete_ProjectingParameters
2066 __del__ =
lambda self :
None;
2067 ProjectingParameters_swigregister = _IMP_em2d.ProjectingParameters_swigregister
2068 ProjectingParameters_swigregister(ProjectingParameters)
2070 class ProjectingOptions(ProjectingParameters):
2071 """Proxy of C++ IMP::em2d::ProjectingOptions class"""
2072 __swig_setmethods__ = {}
2073 for _s
in [ProjectingParameters]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2074 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectingOptions, name, value)
2075 __swig_getmethods__ = {}
2076 for _s
in [ProjectingParameters]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2077 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectingOptions, name)
2078 __swig_setmethods__[
"save_images"] = _IMP_em2d.ProjectingOptions_save_images_set
2079 __swig_getmethods__[
"save_images"] = _IMP_em2d.ProjectingOptions_save_images_get
2080 if _newclass:save_images = _swig_property(_IMP_em2d.ProjectingOptions_save_images_get, _IMP_em2d.ProjectingOptions_save_images_set)
2081 __swig_setmethods__[
"normalize"] = _IMP_em2d.ProjectingOptions_normalize_set
2082 __swig_getmethods__[
"normalize"] = _IMP_em2d.ProjectingOptions_normalize_get
2083 if _newclass:normalize = _swig_property(_IMP_em2d.ProjectingOptions_normalize_get, _IMP_em2d.ProjectingOptions_normalize_set)
2084 __swig_setmethods__[
"clear_matrix_before_projecting"] = _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_set
2085 __swig_getmethods__[
"clear_matrix_before_projecting"] = _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_get
2086 if _newclass:clear_matrix_before_projecting = _swig_property(_IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_get, _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_set)
2087 def __init__(self, *args):
2089 __init__(IMP::em2d::ProjectingOptions self) -> ProjectingOptions
2090 __init__(IMP::em2d::ProjectingOptions self, double ps, double res) -> ProjectingOptions
2091 __init__(IMP::em2d::ProjectingOptions self, double ps, double res, ImageReaderWriter irw) -> ProjectingOptions
2093 this = _IMP_em2d.new_ProjectingOptions(*args)
2094 try: self.this.append(this)
2095 except: self.this = this
2096 def show(self, *args):
2098 show(ProjectingOptions self, _ostream out=std::cout)
2099 show(ProjectingOptions self)
2101 return _IMP_em2d.ProjectingOptions_show(self, *args)
2104 """__str__(ProjectingOptions self) -> std::string"""
2105 return _IMP_em2d.ProjectingOptions___str__(self)
2108 """__repr__(ProjectingOptions self) -> std::string"""
2109 return _IMP_em2d.ProjectingOptions___repr__(self)
2111 __swig_destroy__ = _IMP_em2d.delete_ProjectingOptions
2112 __del__ =
lambda self :
None;
2113 ProjectingOptions_swigregister = _IMP_em2d.ProjectingOptions_swigregister
2114 ProjectingOptions_swigregister(ProjectingOptions)
2119 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::algebra::SphericalVector3Ds const & vs,
2120 int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
2121 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::algebra::SphericalVector3Ds const & vs,
2122 int rows, int cols, ProjectingOptions options) -> IMP::em2d::Images
2123 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::em2d::RegistrationResults const & registration_values,
2124 int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
2125 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::em2d::RegistrationResults const & registration_values,
2126 int rows, int cols, ProjectingOptions options) -> IMP::em2d::Images
2128 return _IMP_em2d.get_projections(*args)
2132 get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options,
2133 IMP::em2d::MasksManagerPtr masks=IMP::em2d::MasksManagerPtr(),
2134 IMP::String name="")
2135 get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options,
2136 IMP::em2d::MasksManagerPtr masks=IMP::em2d::MasksManagerPtr())
2137 get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options)
2139 return _IMP_em2d.get_projection(*args)
2143 do_project_particles(IMP::kernel::ParticlesTemp const & ps, cv::Mat & m2, Rotation3D R, Vector3D translation,
2144 ProjectingOptions options, IMP::em2d::MasksManagerPtr masks)
2146 return _IMP_em2d.do_project_particles(*args)
2149 """create_evenly_distributed_projections(IMP::kernel::ParticlesTemp const & ps, unsigned int n, ProjectingOptions options) -> IMP::em2d::Images"""
2150 return _IMP_em2d.create_evenly_distributed_projections(*args)
2154 do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation) -> IMP::algebra::Vector2Ds
2155 do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation, Vector3D center) -> IMP::algebra::Vector2Ds
2157 return _IMP_em2d.do_project_vectors(*args)
2160 """get_enclosing_image_size(IMP::kernel::ParticlesTemp const & ps, double pixel_size, unsigned int slack) -> unsigned int"""
2161 return _IMP_em2d.get_enclosing_image_size(*args)
2165 get_complete_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
2166 get_complete_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
2168 return _IMP_em2d.get_complete_alignment(*args)
2172 get_rotational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
2173 get_rotational_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
2175 return _IMP_em2d.get_rotational_alignment(*args)
2179 get_translational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
2180 get_translational_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
2182 return _IMP_em2d.get_translational_alignment(*args)
2186 get_complete_alignment_no_preprocessing(cv::Mat const & input, cv::Mat const & INPUT, cv::Mat const & POLAR1, cv::Mat & m_to_align,
2187 cv::Mat const & POLAR2, bool apply=False) -> ResultAlign2D
2188 get_complete_alignment_no_preprocessing(cv::Mat const & input, cv::Mat const & INPUT, cv::Mat const & POLAR1, cv::Mat & m_to_align,
2189 cv::Mat const & POLAR2) -> ResultAlign2D
2191 return _IMP_em2d.get_complete_alignment_no_preprocessing(*args)
2194 """get_rotational_alignment_no_preprocessing(cv::Mat const & POLAR1, cv::Mat const & POLAR2) -> ResultAlign2D"""
2195 return _IMP_em2d.get_rotational_alignment_no_preprocessing(*args)
2198 """get_translational_alignment_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2) -> ResultAlign2D"""
2199 return _IMP_em2d.get_translational_alignment_no_preprocessing(*args)
2202 """get_complete_alignment_with_centers_no_preprocessing(Vector2D center1, Vector2D center2, cv::Mat const & AUTOC_POLAR1, cv::Mat const & AUTOC_POLAR2) -> ResultAlign2D"""
2203 return _IMP_em2d.get_complete_alignment_with_centers_no_preprocessing(*args)
2207 write_vectors_as_pdb(IMP::algebra::Vector2Ds const vs, IMP::String const filename)
2208 write_vectors_as_pdb(IMP::algebra::Vector3Ds const vs, IMP::String const filename)
2210 return _IMP_em2d.write_vectors_as_pdb(*args)
2211 class Em2DRestraintParameters(ProjectingParameters):
2212 """Proxy of C++ IMP::em2d::Em2DRestraintParameters class"""
2213 __swig_setmethods__ = {}
2214 for _s
in [ProjectingParameters]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2215 __setattr__ =
lambda self, name, value: _swig_setattr(self, Em2DRestraintParameters, name, value)
2216 __swig_getmethods__ = {}
2217 for _s
in [ProjectingParameters]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2218 __getattr__ =
lambda self, name: _swig_getattr(self, Em2DRestraintParameters, name)
2219 __swig_setmethods__[
"n_projections"] = _IMP_em2d.Em2DRestraintParameters_n_projections_set
2220 __swig_getmethods__[
"n_projections"] = _IMP_em2d.Em2DRestraintParameters_n_projections_get
2221 if _newclass:n_projections = _swig_property(_IMP_em2d.Em2DRestraintParameters_n_projections_get, _IMP_em2d.Em2DRestraintParameters_n_projections_set)
2222 __swig_setmethods__[
"coarse_registration_method"] = _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_set
2223 __swig_getmethods__[
"coarse_registration_method"] = _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_get
2224 if _newclass:coarse_registration_method = _swig_property(_IMP_em2d.Em2DRestraintParameters_coarse_registration_method_get, _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_set)
2225 __swig_setmethods__[
"save_match_images"] = _IMP_em2d.Em2DRestraintParameters_save_match_images_set
2226 __swig_getmethods__[
"save_match_images"] = _IMP_em2d.Em2DRestraintParameters_save_match_images_get
2227 if _newclass:save_match_images = _swig_property(_IMP_em2d.Em2DRestraintParameters_save_match_images_get, _IMP_em2d.Em2DRestraintParameters_save_match_images_set)
2228 __swig_setmethods__[
"optimization_steps"] = _IMP_em2d.Em2DRestraintParameters_optimization_steps_set
2229 __swig_getmethods__[
"optimization_steps"] = _IMP_em2d.Em2DRestraintParameters_optimization_steps_get
2230 if _newclass:optimization_steps = _swig_property(_IMP_em2d.Em2DRestraintParameters_optimization_steps_get, _IMP_em2d.Em2DRestraintParameters_optimization_steps_set)
2231 __swig_setmethods__[
"simplex_initial_length"] = _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_set
2232 __swig_getmethods__[
"simplex_initial_length"] = _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_get
2233 if _newclass:simplex_initial_length = _swig_property(_IMP_em2d.Em2DRestraintParameters_simplex_initial_length_get, _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_set)
2234 __swig_setmethods__[
"simplex_minimum_size"] = _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_set
2235 __swig_getmethods__[
"simplex_minimum_size"] = _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_get
2236 if _newclass:simplex_minimum_size = _swig_property(_IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_get, _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_set)
2237 def __init__(self, *args):
2239 __init__(IMP::em2d::Em2DRestraintParameters self) -> Em2DRestraintParameters
2240 __init__(IMP::em2d::Em2DRestraintParameters self, double ps, double res, unsigned int n_proj=20) -> Em2DRestraintParameters
2241 __init__(IMP::em2d::Em2DRestraintParameters self, double ps, double res) -> Em2DRestraintParameters
2243 this = _IMP_em2d.new_Em2DRestraintParameters(*args)
2244 try: self.this.append(this)
2245 except: self.this = this
2246 def show(self, *args):
2248 show(Em2DRestraintParameters self, _ostream out=std::cout)
2249 show(Em2DRestraintParameters self)
2251 return _IMP_em2d.Em2DRestraintParameters_show(self, *args)
2254 """__str__(Em2DRestraintParameters self) -> std::string"""
2255 return _IMP_em2d.Em2DRestraintParameters___str__(self)
2258 """__repr__(Em2DRestraintParameters self) -> std::string"""
2259 return _IMP_em2d.Em2DRestraintParameters___repr__(self)
2261 __swig_destroy__ = _IMP_em2d.delete_Em2DRestraintParameters
2262 __del__ =
lambda self :
None;
2263 Em2DRestraintParameters_swigregister = _IMP_em2d.Em2DRestraintParameters_swigregister
2264 Em2DRestraintParameters_swigregister(Em2DRestraintParameters)
2265 cvar = _IMP_em2d.cvar
2266 ALIGN2D_NO_PREPROCESSING = cvar.ALIGN2D_NO_PREPROCESSING
2267 ALIGN2D_PREPROCESSING = cvar.ALIGN2D_PREPROCESSING
2268 ALIGN2D_WITH_CENTERS = cvar.ALIGN2D_WITH_CENTERS
2271 """Proxy of C++ IMP::em2d::ProjectionFinder class"""
2272 __swig_setmethods__ = {}
2273 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2274 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionFinder, name, value)
2275 __swig_getmethods__ = {}
2276 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2277 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionFinder, name)
2279 """__init__(IMP::em2d::ProjectionFinder self) -> ProjectionFinder"""
2280 this = _IMP_em2d.new_ProjectionFinder()
2281 try: self.this.append(this)
2282 except: self.this = this
2283 def setup(self, *args):
2284 """setup(ProjectionFinder self, ScoreFunction score_function, Em2DRestraintParameters params)"""
2285 return _IMP_em2d.ProjectionFinder_setup(self, *args)
2287 def set_subjects(self, *args):
2288 """set_subjects(ProjectionFinder self, IMP::em2d::Images const & subjects)"""
2289 return _IMP_em2d.ProjectionFinder_set_subjects(self, *args)
2291 def set_projections(self, *args):
2292 """set_projections(ProjectionFinder self, IMP::em2d::Images const & projections)"""
2293 return _IMP_em2d.ProjectionFinder_set_projections(self, *args)
2295 def set_variance_images(self, *args):
2296 """set_variance_images(ProjectionFinder self, IMP::em2d::Images const & variances)"""
2297 return _IMP_em2d.ProjectionFinder_set_variance_images(self, *args)
2299 def set_model_particles(self, *args):
2300 """set_model_particles(ProjectionFinder self, IMP::kernel::ParticlesTemp const & ps)"""
2301 return _IMP_em2d.ProjectionFinder_set_model_particles(self, *args)
2303 def set_save_match_images(self, *args):
2304 """set_save_match_images(ProjectionFinder self, bool x)"""
2305 return _IMP_em2d.ProjectionFinder_set_save_match_images(self, *args)
2307 def get_save_match_images(self):
2308 """get_save_match_images(ProjectionFinder self) -> bool"""
2309 return _IMP_em2d.ProjectionFinder_get_save_match_images(self)
2311 def set_fast_mode(self, *args):
2312 """set_fast_mode(ProjectionFinder self, unsigned int n)"""
2313 return _IMP_em2d.ProjectionFinder_set_fast_mode(self, *args)
2315 def get_registration_results(self):
2316 """get_registration_results(ProjectionFinder self) -> IMP::em2d::RegistrationResults"""
2317 return _IMP_em2d.ProjectionFinder_get_registration_results(self)
2319 def get_coarse_registration(self):
2320 """get_coarse_registration(ProjectionFinder self)"""
2321 return _IMP_em2d.ProjectionFinder_get_coarse_registration(self)
2323 def get_complete_registration(self):
2324 """get_complete_registration(ProjectionFinder self)"""
2325 return _IMP_em2d.ProjectionFinder_get_complete_registration(self)
2328 """get_global_score(ProjectionFinder self) -> double"""
2329 return _IMP_em2d.ProjectionFinder_get_global_score(self)
2331 def show(self, *args):
2332 """show(ProjectionFinder self, _ostream out)"""
2333 return _IMP_em2d.ProjectionFinder_show(self, *args)
2335 def get_preprocessing_time(self):
2336 """get_preprocessing_time(ProjectionFinder self) -> double"""
2337 return _IMP_em2d.ProjectionFinder_get_preprocessing_time(self)
2339 def get_coarse_registration_time(self):
2340 """get_coarse_registration_time(ProjectionFinder self) -> double"""
2341 return _IMP_em2d.ProjectionFinder_get_coarse_registration_time(self)
2343 def get_fine_registration_time(self):
2344 """get_fine_registration_time(ProjectionFinder self) -> double"""
2345 return _IMP_em2d.ProjectionFinder_get_fine_registration_time(self)
2347 def get_number_of_subjects(self):
2348 """get_number_of_subjects(ProjectionFinder self) -> unsigned int"""
2349 return _IMP_em2d.ProjectionFinder_get_number_of_subjects(self)
2351 def set_number_of_class_averages_members(self, *args):
2352 """set_number_of_class_averages_members(ProjectionFinder self, IMP::Ints n_members)"""
2353 return _IMP_em2d.ProjectionFinder_set_number_of_class_averages_members(self, *args)
2355 def get_number_of_projections(self):
2356 """get_number_of_projections(ProjectionFinder self) -> unsigned int"""
2357 return _IMP_em2d.ProjectionFinder_get_number_of_projections(self)
2359 def get_version_info(self):
2360 """get_version_info(ProjectionFinder self) -> VersionInfo"""
2361 return _IMP_em2d.ProjectionFinder_get_version_info(self)
2364 """__str__(ProjectionFinder self) -> std::string"""
2365 return _IMP_em2d.ProjectionFinder___str__(self)
2368 """__repr__(ProjectionFinder self) -> std::string"""
2369 return _IMP_em2d.ProjectionFinder___repr__(self)
2372 return _object_cast_to_ProjectionFinder(o)
2373 get_from = staticmethod(get_from)
2375 ProjectionFinder_swigregister = _IMP_em2d.ProjectionFinder_swigregister
2376 ProjectionFinder_swigregister(ProjectionFinder)
2379 """Proxy of C++ IMP::em2d::Em2DRestraint class"""
2380 __swig_setmethods__ = {}
2381 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2382 __setattr__ =
lambda self, name, value: _swig_setattr(self, Em2DRestraint, name, value)
2383 __swig_getmethods__ = {}
2384 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2385 __getattr__ =
lambda self, name: _swig_getattr(self, Em2DRestraint, name)
2386 def __init__(self, *args):
2387 """__init__(IMP::em2d::Em2DRestraint self, Model m) -> Em2DRestraint"""
2388 this = _IMP_em2d.new_Em2DRestraint(*args)
2389 try: self.this.append(this)
2390 except: self.this = this
2391 def setup(self, *args):
2392 """setup(Em2DRestraint self, ScoreFunction score_function, Em2DRestraintParameters params)"""
2393 return _IMP_em2d.Em2DRestraint_setup(self, *args)
2395 def set_particles(self, *args):
2396 """set_particles(Em2DRestraint self, SingletonContainer particles_container)"""
2397 return _IMP_em2d.Em2DRestraint_set_particles(self, *args)
2399 def set_images(self, *args):
2400 """set_images(Em2DRestraint self, IMP::em2d::Images const em_images)"""
2401 return _IMP_em2d.Em2DRestraint_set_images(self, *args)
2403 def set_variance_images(self, *args):
2404 """set_variance_images(Em2DRestraint self, IMP::em2d::Images const variance_images)"""
2405 return _IMP_em2d.Em2DRestraint_set_variance_images(self, *args)
2407 def set_fast_mode(self, *args):
2408 """set_fast_mode(Em2DRestraint self, unsigned int n)"""
2409 return _IMP_em2d.Em2DRestraint_set_fast_mode(self, *args)
2411 def set_coarse_registration_mode(self, *args):
2412 """set_coarse_registration_mode(Em2DRestraint self, bool opt)"""
2413 return _IMP_em2d.Em2DRestraint_set_coarse_registration_mode(self, *args)
2415 def get_registration_results(self):
2416 """get_registration_results(Em2DRestraint self) -> IMP::em2d::RegistrationResults"""
2417 return _IMP_em2d.Em2DRestraint_get_registration_results(self)
2419 def do_get_inputs(self):
2420 """do_get_inputs(Em2DRestraint self) -> IMP::kernel::ModelObjectsTemp"""
2421 return _IMP_em2d.Em2DRestraint_do_get_inputs(self)
2423 def get_version_info(self):
2424 """get_version_info(Em2DRestraint self) -> VersionInfo"""
2425 return _IMP_em2d.Em2DRestraint_get_version_info(self)
2428 """__str__(Em2DRestraint self) -> std::string"""
2429 return _IMP_em2d.Em2DRestraint___str__(self)
2432 """__repr__(Em2DRestraint self) -> std::string"""
2433 return _IMP_em2d.Em2DRestraint___repr__(self)
2436 return _object_cast_to_Em2DRestraint(o)
2437 get_from = staticmethod(get_from)
2439 Em2DRestraint_swigregister = _IMP_em2d.Em2DRestraint_swigregister
2440 Em2DRestraint_swigregister(Em2DRestraint)
2442 class ClusterSet(_object):
2443 """Proxy of C++ IMP::em2d::ClusterSet class"""
2444 __swig_setmethods__ = {}
2445 __setattr__ =
lambda self, name, value: _swig_setattr(self, ClusterSet, name, value)
2446 __swig_getmethods__ = {}
2447 __getattr__ =
lambda self, name: _swig_getattr(self, ClusterSet, name)
2448 def __init__(self, *args):
2449 """__init__(IMP::em2d::ClusterSet self, unsigned int N) -> ClusterSet"""
2450 this = _IMP_em2d.new_ClusterSet(*args)
2451 try: self.this.append(this)
2452 except: self.this = this
2453 def do_join_clusters(self, *args):
2454 """do_join_clusters(ClusterSet self, unsigned int cluster_id1, unsigned int cluster_id2, double distance_between_clusters)"""
2455 return _IMP_em2d.ClusterSet_do_join_clusters(self, *args)
2457 def get_cluster_elements(self, *args):
2458 """get_cluster_elements(ClusterSet self, unsigned int id) -> IMP::Ints"""
2459 return _IMP_em2d.ClusterSet_get_cluster_elements(self, *args)
2461 def get_clusters_below_cutoff(self, *args):
2462 """get_clusters_below_cutoff(ClusterSet self, double cutoff) -> IMP::Ints"""
2463 return _IMP_em2d.ClusterSet_get_clusters_below_cutoff(self, *args)
2465 def get_cluster_formed_at_step(self, *args):
2466 """get_cluster_formed_at_step(ClusterSet self, unsigned int step) -> IMP::Ints"""
2467 return _IMP_em2d.ClusterSet_get_cluster_formed_at_step(self, *args)
2469 def get_distance_at_step(self, *args):
2470 """get_distance_at_step(ClusterSet self, unsigned int step) -> double"""
2471 return _IMP_em2d.ClusterSet_get_distance_at_step(self, *args)
2473 def get_id_for_cluster_at_step(self, *args):
2474 """get_id_for_cluster_at_step(ClusterSet self, unsigned int step) -> unsigned int"""
2475 return _IMP_em2d.ClusterSet_get_id_for_cluster_at_step(self, *args)
2477 def get_linkage_matrix(self):
2478 """get_linkage_matrix(ClusterSet self) -> IMP::FloatsList"""
2479 return _IMP_em2d.ClusterSet_get_linkage_matrix(self)
2481 def get_linkage_matrix_in_matlab_format(self):
2482 """get_linkage_matrix_in_matlab_format(ClusterSet self) -> IMP::FloatsList"""
2483 return _IMP_em2d.ClusterSet_get_linkage_matrix_in_matlab_format(self)
2485 def get_number_of_steps(self):
2486 """get_number_of_steps(ClusterSet self) -> unsigned int"""
2487 return _IMP_em2d.ClusterSet_get_number_of_steps(self)
2489 def show(self, *args):
2490 """show(ClusterSet self, _ostream out)"""
2491 return _IMP_em2d.ClusterSet_show(self, *args)
2494 """__str__(ClusterSet self) -> std::string"""
2495 return _IMP_em2d.ClusterSet___str__(self)
2498 """__repr__(ClusterSet self) -> std::string"""
2499 return _IMP_em2d.ClusterSet___repr__(self)
2501 __swig_destroy__ = _IMP_em2d.delete_ClusterSet
2502 __del__ =
lambda self :
None;
2503 ClusterSet_swigregister = _IMP_em2d.ClusterSet_swigregister
2504 ClusterSet_swigregister(ClusterSet)
2506 class SingleLinkage(_object):
2507 """Proxy of C++ IMP::em2d::SingleLinkage class"""
2508 __swig_setmethods__ = {}
2509 __setattr__ =
lambda self, name, value: _swig_setattr(self, SingleLinkage, name, value)
2510 __swig_getmethods__ = {}
2511 __getattr__ =
lambda self, name: _swig_getattr(self, SingleLinkage, name)
2513 """__init__(IMP::em2d::SingleLinkage self) -> SingleLinkage"""
2514 this = _IMP_em2d.new_SingleLinkage()
2515 try: self.this.append(this)
2516 except: self.this = this
2517 def __call__(self, *args):
2518 """__call__(SingleLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2519 return _IMP_em2d.SingleLinkage___call__(self, *args)
2521 def show(self, *args):
2522 """show(SingleLinkage self, _ostream out)"""
2523 return _IMP_em2d.SingleLinkage_show(self, *args)
2526 """__str__(SingleLinkage self) -> std::string"""
2527 return _IMP_em2d.SingleLinkage___str__(self)
2530 """__repr__(SingleLinkage self) -> std::string"""
2531 return _IMP_em2d.SingleLinkage___repr__(self)
2533 __swig_destroy__ = _IMP_em2d.delete_SingleLinkage
2534 __del__ =
lambda self :
None;
2535 SingleLinkage_swigregister = _IMP_em2d.SingleLinkage_swigregister
2536 SingleLinkage_swigregister(SingleLinkage)
2538 class CompleteLinkage(_object):
2539 """Proxy of C++ IMP::em2d::CompleteLinkage class"""
2540 __swig_setmethods__ = {}
2541 __setattr__ =
lambda self, name, value: _swig_setattr(self, CompleteLinkage, name, value)
2542 __swig_getmethods__ = {}
2543 __getattr__ =
lambda self, name: _swig_getattr(self, CompleteLinkage, name)
2545 """__init__(IMP::em2d::CompleteLinkage self) -> CompleteLinkage"""
2546 this = _IMP_em2d.new_CompleteLinkage()
2547 try: self.this.append(this)
2548 except: self.this = this
2549 def __call__(self, *args):
2550 """__call__(CompleteLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2551 return _IMP_em2d.CompleteLinkage___call__(self, *args)
2553 def show(self, *args):
2554 """show(CompleteLinkage self, _ostream out)"""
2555 return _IMP_em2d.CompleteLinkage_show(self, *args)
2558 """__str__(CompleteLinkage self) -> std::string"""
2559 return _IMP_em2d.CompleteLinkage___str__(self)
2562 """__repr__(CompleteLinkage self) -> std::string"""
2563 return _IMP_em2d.CompleteLinkage___repr__(self)
2565 __swig_destroy__ = _IMP_em2d.delete_CompleteLinkage
2566 __del__ =
lambda self :
None;
2567 CompleteLinkage_swigregister = _IMP_em2d.CompleteLinkage_swigregister
2568 CompleteLinkage_swigregister(CompleteLinkage)
2570 class AverageDistanceLinkage(_object):
2571 """Proxy of C++ IMP::em2d::AverageDistanceLinkage class"""
2572 __swig_setmethods__ = {}
2573 __setattr__ =
lambda self, name, value: _swig_setattr(self, AverageDistanceLinkage, name, value)
2574 __swig_getmethods__ = {}
2575 __getattr__ =
lambda self, name: _swig_getattr(self, AverageDistanceLinkage, name)
2577 """__init__(IMP::em2d::AverageDistanceLinkage self) -> AverageDistanceLinkage"""
2578 this = _IMP_em2d.new_AverageDistanceLinkage()
2579 try: self.this.append(this)
2580 except: self.this = this
2581 def __call__(self, *args):
2582 """__call__(AverageDistanceLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2583 return _IMP_em2d.AverageDistanceLinkage___call__(self, *args)
2585 def show(self, *args):
2586 """show(AverageDistanceLinkage self, _ostream out)"""
2587 return _IMP_em2d.AverageDistanceLinkage_show(self, *args)
2590 """__str__(AverageDistanceLinkage self) -> std::string"""
2591 return _IMP_em2d.AverageDistanceLinkage___str__(self)
2594 """__repr__(AverageDistanceLinkage self) -> std::string"""
2595 return _IMP_em2d.AverageDistanceLinkage___repr__(self)
2597 __swig_destroy__ = _IMP_em2d.delete_AverageDistanceLinkage
2598 __del__ =
lambda self :
None;
2599 AverageDistanceLinkage_swigregister = _IMP_em2d.AverageDistanceLinkage_swigregister
2600 AverageDistanceLinkage_swigregister(AverageDistanceLinkage)
2603 """Proxy of C++ IMP::em2d::CollisionCrossSection class"""
2604 __swig_setmethods__ = {}
2605 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2606 __setattr__ =
lambda self, name, value: _swig_setattr(self, CollisionCrossSection, name, value)
2607 __swig_getmethods__ = {}
2608 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2609 __getattr__ =
lambda self, name: _swig_getattr(self, CollisionCrossSection, name)
2610 def __init__(self, *args):
2611 """__init__(IMP::em2d::CollisionCrossSection self, unsigned int n_projections, double resolution, double pixel_size, double projection_image_size) -> CollisionCrossSection"""
2612 this = _IMP_em2d.new_CollisionCrossSection(*args)
2613 try: self.this.append(this)
2614 except: self.this = this
2615 def set_model_particles(self, *args):
2616 """set_model_particles(CollisionCrossSection self, IMP::kernel::ParticlesTemp const & ps)"""
2617 return _IMP_em2d.CollisionCrossSection_set_model_particles(self, *args)
2620 """get_ccs(CollisionCrossSection self) -> double"""
2621 return _IMP_em2d.CollisionCrossSection_get_ccs(self)
2623 def show(self, *args):
2624 """show(CollisionCrossSection self, _ostream out)"""
2625 return _IMP_em2d.CollisionCrossSection_show(self, *args)
2627 def get_version_info(self):
2628 """get_version_info(CollisionCrossSection self) -> VersionInfo"""
2629 return _IMP_em2d.CollisionCrossSection_get_version_info(self)
2632 """__str__(CollisionCrossSection self) -> std::string"""
2633 return _IMP_em2d.CollisionCrossSection___str__(self)
2636 """__repr__(CollisionCrossSection self) -> std::string"""
2637 return _IMP_em2d.CollisionCrossSection___repr__(self)
2640 return _object_cast_to_CollisionCrossSection(o)
2641 get_from = staticmethod(get_from)
2643 CollisionCrossSection_swigregister = _IMP_em2d.CollisionCrossSection_swigregister
2644 CollisionCrossSection_swigregister(CollisionCrossSection)
2647 """Proxy of C++ IMP::em2d::GridStates class"""
2648 __swig_setmethods__ = {}
2650 __setattr__ =
lambda self, name, value: _swig_setattr(self, GridStates, name, value)
2651 __swig_getmethods__ = {}
2653 __getattr__ =
lambda self, name: _swig_getattr(self, GridStates, name)
2654 def __init__(self, *args):
2656 __init__(IMP::em2d::GridStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations,
2657 IMP::String const & name="GridStates") -> GridStates
2658 __init__(IMP::em2d::GridStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations) -> GridStates
2660 this = _IMP_em2d.new_GridStates(*args)
2661 try: self.this.append(this)
2662 except: self.this = this
2663 def get_position(self, *args):
2664 """get_position(GridStates self, unsigned int i) -> Vector3D"""
2665 return _IMP_em2d.GridStates_get_position(self, *args)
2667 def get_orientation(self, *args):
2668 """get_orientation(GridStates self, unsigned int i) -> Rotation3D"""
2669 return _IMP_em2d.GridStates_get_orientation(self, *args)
2671 def get_version_info(self):
2672 """get_version_info(GridStates self) -> VersionInfo"""
2673 return _IMP_em2d.GridStates_get_version_info(self)
2675 def do_show(self, *args):
2676 """do_show(GridStates self, _ostream out)"""
2677 return _IMP_em2d.GridStates_do_show(self, *args)
2679 __swig_destroy__ = _IMP_em2d.delete_GridStates
2680 __del__ =
lambda self :
None;
2682 """__str__(GridStates self) -> std::string"""
2683 return _IMP_em2d.GridStates___str__(self)
2686 """__repr__(GridStates self) -> std::string"""
2687 return _IMP_em2d.GridStates___repr__(self)
2690 return _object_cast_to_GridStates(o)
2691 get_from = staticmethod(get_from)
2693 GridStates_swigregister = _IMP_em2d.GridStates_swigregister
2694 GridStates_swigregister(GridStates)
2696 class ProjectionStates(GridStates):
2697 """Proxy of C++ IMP::em2d::ProjectionStates class"""
2698 __swig_setmethods__ = {}
2699 for _s
in [GridStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2700 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionStates, name, value)
2701 __swig_getmethods__ = {}
2702 for _s
in [GridStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2703 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionStates, name)
2704 def __init__(self, *args):
2706 __init__(IMP::em2d::ProjectionStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations,
2707 IMP::em2d::Images const & projections, IMP::String const & name="ProjectionStates") -> ProjectionStates
2708 __init__(IMP::em2d::ProjectionStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations,
2709 IMP::em2d::Images const & projections) -> ProjectionStates
2711 this = _IMP_em2d.new_ProjectionStates(*args)
2712 try: self.this.append(this)
2713 except: self.this = this
2715 """get_projection(ProjectionStates self, unsigned int i) -> Image"""
2716 return _IMP_em2d.ProjectionStates_get_projection(self, *args)
2718 def do_show(self, *args):
2719 """do_show(ProjectionStates self, _ostream out)"""
2720 return _IMP_em2d.ProjectionStates_do_show(self, *args)
2722 __swig_destroy__ = _IMP_em2d.delete_ProjectionStates
2723 __del__ =
lambda self :
None;
2725 """__str__(ProjectionStates self) -> std::string"""
2726 return _IMP_em2d.ProjectionStates___str__(self)
2729 """__repr__(ProjectionStates self) -> std::string"""
2730 return _IMP_em2d.ProjectionStates___repr__(self)
2733 return _object_cast_to_ProjectionStates(o)
2734 get_from = staticmethod(get_from)
2736 ProjectionStates_swigregister = _IMP_em2d.ProjectionStates_swigregister
2737 ProjectionStates_swigregister(ProjectionStates)
2740 """Proxy of C++ IMP::em2d::DistanceFilter class"""
2741 __swig_setmethods__ = {}
2743 __setattr__ =
lambda self, name, value: _swig_setattr(self, DistanceFilter, name, value)
2744 __swig_getmethods__ = {}
2746 __getattr__ =
lambda self, name: _swig_getattr(self, DistanceFilter, name)
2747 def __init__(self, *args):
2749 __init__(IMP::em2d::DistanceFilter self, Subset subset_to_act_on, Subset subset_to_restrain, ParticleStatesTable ps_table,
2750 double max_distance) -> DistanceFilter
2752 this = _IMP_em2d.new_DistanceFilter(*args)
2753 try: self.this.append(this)
2754 except: self.this = this
2755 def show(self, *args):
2757 show(DistanceFilter self, _ostream out=std::cout)
2758 show(DistanceFilter self)
2760 return _IMP_em2d.DistanceFilter_show(self, *args)
2762 def get_version_info(self):
2763 """get_version_info(DistanceFilter self) -> VersionInfo"""
2764 return _IMP_em2d.DistanceFilter_get_version_info(self)
2766 def do_show(self, *args):
2767 """do_show(DistanceFilter self, _ostream out)"""
2768 return _IMP_em2d.DistanceFilter_do_show(self, *args)
2770 __swig_destroy__ = _IMP_em2d.delete_DistanceFilter
2771 __del__ =
lambda self :
None;
2773 """__str__(DistanceFilter self) -> std::string"""
2774 return _IMP_em2d.DistanceFilter___str__(self)
2777 """__repr__(DistanceFilter self) -> std::string"""
2778 return _IMP_em2d.DistanceFilter___repr__(self)
2781 return _object_cast_to_DistanceFilter(o)
2782 get_from = staticmethod(get_from)
2784 DistanceFilter_swigregister = _IMP_em2d.DistanceFilter_swigregister
2785 DistanceFilter_swigregister(DistanceFilter)
2788 """Proxy of C++ IMP::em2d::DistanceFilterTable class"""
2789 __swig_setmethods__ = {}
2791 __setattr__ =
lambda self, name, value: _swig_setattr(self, DistanceFilterTable, name, value)
2792 __swig_getmethods__ = {}
2794 __getattr__ =
lambda self, name: _swig_getattr(self, DistanceFilterTable, name)
2795 def __init__(self, *args):
2796 """__init__(IMP::em2d::DistanceFilterTable self, Subset subset_to_act_on, ParticleStatesTable ps_table, double max_distance) -> DistanceFilterTable"""
2797 this = _IMP_em2d.new_DistanceFilterTable(*args)
2798 try: self.this.append(this)
2799 except: self.this = this
2800 def show(self, *args):
2802 show(DistanceFilterTable self, _ostream out=std::cout)
2803 show(DistanceFilterTable self)
2805 return _IMP_em2d.DistanceFilterTable_show(self, *args)
2807 def get_version_info(self):
2808 """get_version_info(DistanceFilterTable self) -> VersionInfo"""
2809 return _IMP_em2d.DistanceFilterTable_get_version_info(self)
2811 def do_show(self, *args):
2812 """do_show(DistanceFilterTable self, _ostream out)"""
2813 return _IMP_em2d.DistanceFilterTable_do_show(self, *args)
2815 __swig_destroy__ = _IMP_em2d.delete_DistanceFilterTable
2816 __del__ =
lambda self :
None;
2818 """__str__(DistanceFilterTable self) -> std::string"""
2819 return _IMP_em2d.DistanceFilterTable___str__(self)
2822 """__repr__(DistanceFilterTable self) -> std::string"""
2823 return _IMP_em2d.DistanceFilterTable___repr__(self)
2826 return _object_cast_to_DistanceFilterTable(o)
2827 get_from = staticmethod(get_from)
2829 DistanceFilterTable_swigregister = _IMP_em2d.DistanceFilterTable_swigregister
2830 DistanceFilterTable_swigregister(DistanceFilterTable)
2832 class IntsOrder(_object):
2833 """Proxy of C++ IMP::em2d::IntsOrder class"""
2834 __swig_setmethods__ = {}
2835 __setattr__ =
lambda self, name, value: _swig_setattr(self, IntsOrder, name, value)
2836 __swig_getmethods__ = {}
2837 __getattr__ =
lambda self, name: _swig_getattr(self, IntsOrder, name)
2838 __repr__ = _swig_repr
2839 def __call__(self, *args):
2840 """__call__(IntsOrder self, IMP::Ints const & a, IMP::Ints const & b) -> bool"""
2841 return _IMP_em2d.IntsOrder___call__(self, *args)
2844 """__init__(IMP::em2d::IntsOrder self) -> IntsOrder"""
2845 this = _IMP_em2d.new_IntsOrder()
2846 try: self.this.append(this)
2847 except: self.this = this
2848 __swig_destroy__ = _IMP_em2d.delete_IntsOrder
2849 __del__ =
lambda self :
None;
2850 IntsOrder_swigregister = _IMP_em2d.IntsOrder_swigregister
2851 IntsOrder_swigregister(IntsOrder)
2854 """Proxy of C++ IMP::em2d::RigidBodiesImageFitRestraint class"""
2855 __swig_setmethods__ = {}
2856 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2857 __setattr__ =
lambda self, name, value: _swig_setattr(self, RigidBodiesImageFitRestraint, name, value)
2858 __swig_getmethods__ = {}
2859 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2860 __getattr__ =
lambda self, name: _swig_getattr(self, RigidBodiesImageFitRestraint, name)
2861 def get_version_info(self):
2862 """get_version_info(RigidBodiesImageFitRestraint self) -> VersionInfo"""
2863 return _IMP_em2d.RigidBodiesImageFitRestraint_get_version_info(self)
2865 def __init__(self, *args):
2866 """__init__(IMP::em2d::RigidBodiesImageFitRestraint self, ScoreFunction scf, IMP::core::RigidBodies const & rbs, Image img) -> RigidBodiesImageFitRestraint"""
2867 this = _IMP_em2d.new_RigidBodiesImageFitRestraint(*args)
2868 try: self.this.append(this)
2869 except: self.this = this
2870 def set_projecting_parameters(self, *args):
2871 """set_projecting_parameters(RigidBodiesImageFitRestraint self, ProjectingParameters p)"""
2872 return _IMP_em2d.RigidBodiesImageFitRestraint_set_projecting_parameters(self, *args)
2874 def set_orientations(self, *args):
2875 """set_orientations(RigidBodiesImageFitRestraint self, RigidBody rb, IMP::algebra::Rotation3Ds const & rots)"""
2876 return _IMP_em2d.RigidBodiesImageFitRestraint_set_orientations(self, *args)
2878 def get_number_of_masks(self, *args):
2879 """get_number_of_masks(RigidBodiesImageFitRestraint self, RigidBody rb) -> unsigned int"""
2880 return _IMP_em2d.RigidBodiesImageFitRestraint_get_number_of_masks(self, *args)
2883 """__str__(RigidBodiesImageFitRestraint self) -> std::string"""
2884 return _IMP_em2d.RigidBodiesImageFitRestraint___str__(self)
2887 """__repr__(RigidBodiesImageFitRestraint self) -> std::string"""
2888 return _IMP_em2d.RigidBodiesImageFitRestraint___repr__(self)
2891 return _object_cast_to_RigidBodiesImageFitRestraint(o)
2892 get_from = staticmethod(get_from)
2894 RigidBodiesImageFitRestraint_swigregister = _IMP_em2d.RigidBodiesImageFitRestraint_swigregister
2895 RigidBodiesImageFitRestraint_swigregister(RigidBodiesImageFitRestraint)
2898 def get_unique_index(*args):
2899 """get_unique_index(Rotation3D rot) -> IMP::Ints"""
2900 return _IMP_em2d.get_unique_index(*args)
2902 """Proxy of C++ IMP::em2d::RelativePositionMover class"""
2903 __swig_setmethods__ = {}
2905 __setattr__ =
lambda self, name, value: _swig_setattr(self, RelativePositionMover, name, value)
2906 __swig_getmethods__ = {}
2908 __getattr__ =
lambda self, name: _swig_getattr(self, RelativePositionMover, name)
2909 def __init__(self, *args):
2910 """__init__(IMP::em2d::RelativePositionMover self, RigidBody d, IMP::Float max_translation, IMP::Float max_rotation) -> RelativePositionMover"""
2911 this = _IMP_em2d.new_RelativePositionMover(*args)
2912 try: self.this.append(this)
2913 except: self.this = this
2914 def add_internal_transformations(self, *args):
2915 """add_internal_transformations(RelativePositionMover self, RigidBody d, IMP::algebra::Transformation3Ds transforms)"""
2916 return _IMP_em2d.RelativePositionMover_add_internal_transformations(self, *args)
2918 def set_random_move_probability(self, *args):
2919 """set_random_move_probability(RelativePositionMover self, IMP::Float p)"""
2920 return _IMP_em2d.RelativePositionMover_set_random_move_probability(self, *args)
2923 """__str__(RelativePositionMover self) -> std::string"""
2924 return _IMP_em2d.RelativePositionMover___str__(self)
2927 """__repr__(RelativePositionMover self) -> std::string"""
2928 return _IMP_em2d.RelativePositionMover___repr__(self)
2931 return _object_cast_to_RelativePositionMover(o)
2932 get_from = staticmethod(get_from)
2934 RelativePositionMover_swigregister = _IMP_em2d.RelativePositionMover_swigregister
2935 RelativePositionMover_swigregister(RelativePositionMover)
2938 """Proxy of C++ IMP::em2d::DummyRestraint class"""
2939 __swig_setmethods__ = {}
2940 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2941 __setattr__ =
lambda self, name, value: _swig_setattr(self, DummyRestraint, name, value)
2942 __swig_getmethods__ = {}
2943 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2944 __getattr__ =
lambda self, name: _swig_getattr(self, DummyRestraint, name)
2945 def __init__(self, *args):
2946 """__init__(IMP::em2d::DummyRestraint self, Particle p, Particle q) -> DummyRestraint"""
2947 this = _IMP_em2d.new_DummyRestraint(*args)
2948 try: self.this.append(this)
2949 except: self.this = this
2950 def show(self, *args):
2952 show(DummyRestraint self, _ostream out=std::cout)
2953 show(DummyRestraint self)
2955 return _IMP_em2d.DummyRestraint_show(self, *args)
2957 def do_get_inputs(self):
2958 """do_get_inputs(DummyRestraint self) -> IMP::kernel::ModelObjectsTemp"""
2959 return _IMP_em2d.DummyRestraint_do_get_inputs(self)
2961 def get_version_info(self):
2962 """get_version_info(DummyRestraint self) -> VersionInfo"""
2963 return _IMP_em2d.DummyRestraint_get_version_info(self)
2966 """__str__(DummyRestraint self) -> std::string"""
2967 return _IMP_em2d.DummyRestraint___str__(self)
2970 """__repr__(DummyRestraint self) -> std::string"""
2971 return _IMP_em2d.DummyRestraint___repr__(self)
2974 return _object_cast_to_DummyRestraint(o)
2975 get_from = staticmethod(get_from)
2977 DummyRestraint_swigregister = _IMP_em2d.DummyRestraint_swigregister
2978 DummyRestraint_swigregister(DummyRestraint)
2981 """Proxy of C++ IMP::em2d::ParticlesDummyRestraint class"""
2982 __swig_setmethods__ = {}
2983 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2984 __setattr__ =
lambda self, name, value: _swig_setattr(self, ParticlesDummyRestraint, name, value)
2985 __swig_getmethods__ = {}
2986 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2987 __getattr__ =
lambda self, name: _swig_getattr(self, ParticlesDummyRestraint, name)
2988 def __init__(self, *args):
2989 """__init__(IMP::em2d::ParticlesDummyRestraint self, SingletonContainer sc) -> ParticlesDummyRestraint"""
2990 this = _IMP_em2d.new_ParticlesDummyRestraint(*args)
2991 try: self.this.append(this)
2992 except: self.this = this
2993 def show(self, *args):
2995 show(ParticlesDummyRestraint self, _ostream out=std::cout)
2996 show(ParticlesDummyRestraint self)
2998 return _IMP_em2d.ParticlesDummyRestraint_show(self, *args)
3000 def do_get_inputs(self):
3001 """do_get_inputs(ParticlesDummyRestraint self) -> IMP::kernel::ModelObjectsTemp"""
3002 return _IMP_em2d.ParticlesDummyRestraint_do_get_inputs(self)
3004 def get_version_info(self):
3005 """get_version_info(ParticlesDummyRestraint self) -> VersionInfo"""
3006 return _IMP_em2d.ParticlesDummyRestraint_get_version_info(self)
3009 """__str__(ParticlesDummyRestraint self) -> std::string"""
3010 return _IMP_em2d.ParticlesDummyRestraint___str__(self)
3013 """__repr__(ParticlesDummyRestraint self) -> std::string"""
3014 return _IMP_em2d.ParticlesDummyRestraint___repr__(self)
3017 return _object_cast_to_ParticlesDummyRestraint(o)
3018 get_from = staticmethod(get_from)
3020 ParticlesDummyRestraint_swigregister = _IMP_em2d.ParticlesDummyRestraint_swigregister
3021 ParticlesDummyRestraint_swigregister(ParticlesDummyRestraint)
3024 """Proxy of C++ std::pair<(IMP::algebra::Transformation2D,double)> class"""
3025 __swig_setmethods__ = {}
3026 __setattr__ =
lambda self, name, value: _swig_setattr(self, ResultAlign2D, name, value)
3027 __swig_getmethods__ = {}
3028 __getattr__ =
lambda self, name: _swig_getattr(self, ResultAlign2D, name)
3029 __repr__ = _swig_repr
3030 def __init__(self, *args):
3032 __init__(std::pair<(IMP::algebra::Transformation2D,double)> self) -> ResultAlign2D
3033 __init__(std::pair<(IMP::algebra::Transformation2D,double)> self, Transformation2D first, double second) -> ResultAlign2D
3034 __init__(std::pair<(IMP::algebra::Transformation2D,double)> self, ResultAlign2D p) -> ResultAlign2D
3036 this = _IMP_em2d.new_ResultAlign2D(*args)
3037 try: self.this.append(this)
3038 except: self.this = this
3039 __swig_setmethods__[
"first"] = _IMP_em2d.ResultAlign2D_first_set
3040 __swig_getmethods__[
"first"] = _IMP_em2d.ResultAlign2D_first_get
3041 if _newclass:first = _swig_property(_IMP_em2d.ResultAlign2D_first_get, _IMP_em2d.ResultAlign2D_first_set)
3042 __swig_setmethods__[
"second"] = _IMP_em2d.ResultAlign2D_second_set
3043 __swig_getmethods__[
"second"] = _IMP_em2d.ResultAlign2D_second_get
3044 if _newclass:second = _swig_property(_IMP_em2d.ResultAlign2D_second_get, _IMP_em2d.ResultAlign2D_second_set)
3045 def __len__(self):
return 2
3046 def __repr__(self):
return str((self.first, self.second))
3047 def __getitem__(self, index):
3052 def __setitem__(self, index, val):
3057 __swig_destroy__ = _IMP_em2d.delete_ResultAlign2D
3058 __del__ =
lambda self :
None;
3059 ResultAlign2D_swigregister = _IMP_em2d.ResultAlign2D_swigregister
3060 ResultAlign2D_swigregister(ResultAlign2D)
3063 def _do_hierarchical_clustering_single_linkage(*args):
3064 """_do_hierarchical_clustering_single_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3065 return _IMP_em2d._do_hierarchical_clustering_single_linkage(*args)
3067 def _do_hierarchical_clustering_complete_linkage(*args):
3068 """_do_hierarchical_clustering_complete_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3069 return _IMP_em2d._do_hierarchical_clustering_complete_linkage(*args)
3071 def _do_hierarchical_clustering_average_distance_linkage(*args):
3072 """_do_hierarchical_clustering_average_distance_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3073 return _IMP_em2d._do_hierarchical_clustering_average_distance_linkage(*args)
3074 do_hierarchical_clustering_single_linkage = _do_hierarchical_clustering_single_linkage
3075 do_hierarchical_clustering_complete_linkage = _do_hierarchical_clustering_complete_linkage
3076 do_hierarchical_clustering_average_distance_linkage = _do_hierarchical_clustering_average_distance_linkage
3079 def get_module_version():
3080 """get_module_version() -> std::string const"""
3081 return _IMP_em2d.get_module_version()
3084 """get_example_path(std::string fname) -> std::string"""
3085 return _IMP_em2d.get_example_path(*args)
3088 """get_data_path(std::string fname) -> std::string"""
3089 return _IMP_em2d.get_data_path(*args)
3090 import _version_check
3091 _version_check.check_version(get_module_version())
double get_shift_error(const RegistrationResult &rr1, const RegistrationResult &rr2)
Distance between the two in-plane translations.
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)
void do_project_particles(const kernel::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.
double get_mean(const cv::Mat &mat, const cvIntMat &mask)
void apply_threshold(cv::Mat &m, cv::Mat &result, double threshold=0.0)
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)
See IMP.container for more information.
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.
unsigned int get_enclosing_image_size(const kernel::ParticlesTemp &ps, double pixel_size, unsigned int slack)
Get an automatic size for an image that contains the particles.
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)
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 get_projection(em2d::Image *img, const kernel::ParticlesTemp &ps, const RegistrationResult ®, const ProjectingOptions &options, MasksManagerPtr masks=MasksManagerPtr(), String name="")
Generates a projection from particles.
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.
See IMP.cgal for more information.
void set_check_level(CheckLevel tf)
Control runtime checks in the code.
MatchTemplateResults get_best_template_matches(const cv::Mat &m, const cv::Mat &templ, unsigned int n)
Modify the transformation of a rigid body.
See IMP.base for more information.
void get_autocorrelation2d(const cv::Mat &m, cv::Mat &corr)
std::string get_data_path(std::string file_name)
Return the full path to installed data.
void apply_mean_outside_mask(Image *img, double radius)
See IMP.gsl for more information.
double get_rotation_error(const RegistrationResult &rr1, const RegistrationResult &rr2)
ScoreStates maintian invariants in the Model.
See IMP.score_functor for more information.
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)
See IMP.statistics for more information.
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)
void apply_circular_mask(const cv::Mat &mat, cv::Mat &result, int radius, double value=0.0)
See IMP.kernel for more information.
Images read_images(const Strings &names, const ImageReaderWriter *rw)
A restraint is a term in an IMP ScoringFunction.
void write_registration_results(String filename, const RegistrationResults &results)
Writes a set of registration results.
See IMP.em for more information.
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)
Common base class for heavy weight IMP objects.
Images create_evenly_distributed_projections(const kernel::ParticlesTemp &ps, unsigned int n, const ProjectingOptions &options)
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)
DensityMap * get_transformed(const DensityMap *input, const algebra::Transformation3D &tr, double threshold)
void do_matrix_to_image_flip(cv::Mat &m)
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)
std::string get_example_path(std::string file_name)
Return the path to installed example data for this module.
void do_dilate_and_shrink_warp(cv::Mat &m, const cv::Mat &greyscale, cv::Mat &kernel)
(U. Adiga, 2005)
std::pair< algebra::Transformation2D, double > ResultAlign2D
em2d::Images get_projections(const kernel::ParticlesTemp &ps, const algebra::SphericalVector3Ds &vs, int rows, int cols, const ProjectingOptions &options, Strings names=Strings())
Generates projections from particles.
void do_resample_polar(Image *im1, Image *im2, const PolarResamplingParameters &polar_params)
See IMP.core for more information.
See IMP.algebra for more information.
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)
void show(Hierarchy h, std::ostream &out=std::cout)
Print out a molecular hierarchy.
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)
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)
See IMP.display for more information.
CheckLevel get_check_level()
Get the current audit mode.
See IMP.atom for more information.
See IMP.rmf for more information.
See IMP.domino for more information.
void get_spectrum(const cv::Mat &m, cv::Mat &real, cv::Mat &imag)