9 from sys
import version_info
10 if version_info >= (2,6,0):
11 def swig_import_helper():
12 from os.path
import dirname
16 fp, pathname, description = imp.find_module(
'_IMP_em2d', [dirname(__file__)])
22 _mod = imp.load_module(
'_IMP_em2d', fp, pathname, description)
26 _IMP_em2d = swig_import_helper()
27 del swig_import_helper
32 _swig_property = property
35 def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
36 if (name ==
"thisown"):
return self.this.own(value)
38 if type(value).__name__ ==
'SwigPyObject':
39 self.__dict__[name] = value
41 method = class_type.__swig_setmethods__.get(name,
None)
42 if method:
return method(self,value)
44 self.__dict__[name] = value
46 raise AttributeError(
"You cannot add attributes to %s" % self)
48 def _swig_setattr(self,class_type,name,value):
49 return _swig_setattr_nondynamic(self,class_type,name,value,0)
51 def _swig_getattr(self,class_type,name):
52 if (name ==
"thisown"):
return self.this.own()
53 method = class_type.__swig_getmethods__.get(name,
None)
54 if method:
return method(self)
55 raise AttributeError(name)
58 try: strthis =
"proxy of " + self.this.__repr__()
60 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
65 except AttributeError:
72 weakref_proxy = weakref.proxy
74 weakref_proxy =
lambda x: x
77 class IMP_EM2D_SwigPyIterator(_object):
78 """Proxy of C++ swig::IMP_EM2D_SwigPyIterator class"""
79 __swig_setmethods__ = {}
80 __setattr__ =
lambda self, name, value: _swig_setattr(self, IMP_EM2D_SwigPyIterator, name, value)
81 __swig_getmethods__ = {}
82 __getattr__ =
lambda self, name: _swig_getattr(self, IMP_EM2D_SwigPyIterator, name)
83 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
85 __swig_destroy__ = _IMP_em2d.delete_IMP_EM2D_SwigPyIterator
86 __del__ =
lambda self :
None;
88 """value(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
89 return _IMP_em2d.IMP_EM2D_SwigPyIterator_value(self)
93 incr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator
94 incr(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator
96 return _IMP_em2d.IMP_EM2D_SwigPyIterator_incr(self, n)
100 decr(IMP_EM2D_SwigPyIterator self, size_t n=1) -> IMP_EM2D_SwigPyIterator
101 decr(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator
103 return _IMP_em2d.IMP_EM2D_SwigPyIterator_decr(self, n)
105 def distance(self, *args):
106 """distance(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t"""
107 return _IMP_em2d.IMP_EM2D_SwigPyIterator_distance(self, *args)
109 def equal(self, *args):
110 """equal(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
111 return _IMP_em2d.IMP_EM2D_SwigPyIterator_equal(self, *args)
114 """copy(IMP_EM2D_SwigPyIterator self) -> IMP_EM2D_SwigPyIterator"""
115 return _IMP_em2d.IMP_EM2D_SwigPyIterator_copy(self)
118 """next(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
119 return _IMP_em2d.IMP_EM2D_SwigPyIterator_next(self)
122 """__next__(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
123 return _IMP_em2d.IMP_EM2D_SwigPyIterator___next__(self)
126 """previous(IMP_EM2D_SwigPyIterator self) -> PyObject *"""
127 return _IMP_em2d.IMP_EM2D_SwigPyIterator_previous(self)
129 def advance(self, *args):
130 """advance(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
131 return _IMP_em2d.IMP_EM2D_SwigPyIterator_advance(self, *args)
133 def __eq__(self, *args):
134 """__eq__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
135 return _IMP_em2d.IMP_EM2D_SwigPyIterator___eq__(self, *args)
137 def __ne__(self, *args):
138 """__ne__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> bool"""
139 return _IMP_em2d.IMP_EM2D_SwigPyIterator___ne__(self, *args)
141 def __iadd__(self, *args):
142 """__iadd__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
143 return _IMP_em2d.IMP_EM2D_SwigPyIterator___iadd__(self, *args)
145 def __isub__(self, *args):
146 """__isub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
147 return _IMP_em2d.IMP_EM2D_SwigPyIterator___isub__(self, *args)
149 def __add__(self, *args):
150 """__add__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator"""
151 return _IMP_em2d.IMP_EM2D_SwigPyIterator___add__(self, *args)
153 def __sub__(self, *args):
155 __sub__(IMP_EM2D_SwigPyIterator self, ptrdiff_t n) -> IMP_EM2D_SwigPyIterator
156 __sub__(IMP_EM2D_SwigPyIterator self, IMP_EM2D_SwigPyIterator x) -> ptrdiff_t
158 return _IMP_em2d.IMP_EM2D_SwigPyIterator___sub__(self, *args)
160 def __iter__(self):
return self
161 IMP_EM2D_SwigPyIterator_swigregister = _IMP_em2d.IMP_EM2D_SwigPyIterator_swigregister
162 IMP_EM2D_SwigPyIterator_swigregister(IMP_EM2D_SwigPyIterator)
169 IMP_HAS_DEPRECATED = _IMP_em2d.IMP_HAS_DEPRECATED
170 IMP_DEBUG = _IMP_em2d.IMP_DEBUG
171 IMP_RELEASE = _IMP_em2d.IMP_RELEASE
172 IMP_SILENT = _IMP_em2d.IMP_SILENT
173 IMP_PROGRESS = _IMP_em2d.IMP_PROGRESS
174 IMP_TERSE = _IMP_em2d.IMP_TERSE
175 IMP_VERBOSE = _IMP_em2d.IMP_VERBOSE
176 IMP_NONE = _IMP_em2d.IMP_NONE
177 IMP_USAGE = _IMP_em2d.IMP_USAGE
178 IMP_INTERNAL = _IMP_em2d.IMP_INTERNAL
179 IMP_COMPILER_HAS_AUTO = _IMP_em2d.IMP_COMPILER_HAS_AUTO
180 IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_em2d.IMP_COMPILER_HAS_DEBUG_VECTOR
181 IMP_COMPILER_HAS_NULLPTR = _IMP_em2d.IMP_COMPILER_HAS_NULLPTR
182 IMP_BASE_HAS_BOOST_RANDOM = _IMP_em2d.IMP_BASE_HAS_BOOST_RANDOM
183 IMP_BASE_HAS_GPERFTOOLS = _IMP_em2d.IMP_BASE_HAS_GPERFTOOLS
184 IMP_BASE_HAS_LOG4CXX = _IMP_em2d.IMP_BASE_HAS_LOG4CXX
185 IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_em2d.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
186 IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_em2d.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
188 class _DirectorObjects(object):
189 """@internal Simple class to keep references to director objects
190 to prevent premature deletion."""
193 def register(self, obj):
194 """Take a reference to a director object; will only work for
195 refcounted C++ classes"""
196 if hasattr(obj,
'get_ref_count'):
197 self._objects.append(obj)
199 """Only drop our reference and allow cleanup by Python if no other
200 Python references exist (we hold 3 references: one in self._objects,
201 one in x, and one in the argument list for getrefcount) *and* no
202 other C++ references exist (the Python object always holds one)"""
203 objs = [x
for x
in self._objects
if sys.getrefcount(x) > 3 \
204 or x.get_ref_count() > 1]
208 def get_object_count(self):
209 """Get number of director objects (useful for testing only)"""
210 return len(self._objects)
211 _director_objects = _DirectorObjects()
213 DEFAULT_CHECK = _IMP_em2d.DEFAULT_CHECK
214 NONE = _IMP_em2d.NONE
215 USAGE = _IMP_em2d.USAGE
216 USAGE_AND_INTERNAL = _IMP_em2d.USAGE_AND_INTERNAL
219 """set_check_level(IMP::base::CheckLevel tf)"""
220 return _IMP_em2d.set_check_level(*args)
223 """get_check_level() -> IMP::base::CheckLevel"""
224 return _IMP_em2d.get_check_level()
225 class _ostream(_object):
226 """Proxy of C++ std::ostream class"""
227 __swig_setmethods__ = {}
228 __setattr__ =
lambda self, name, value: _swig_setattr(self, _ostream, name, value)
229 __swig_getmethods__ = {}
230 __getattr__ =
lambda self, name: _swig_getattr(self, _ostream, name)
231 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined")
232 __repr__ = _swig_repr
233 def write(self, *args):
234 """write(_ostream self, char const * osa_buf)"""
235 return _IMP_em2d._ostream_write(self, *args)
237 _ostream_swigregister = _IMP_em2d._ostream_swigregister
238 _ostream_swigregister(_ostream)
240 IMP_COMPILER_HAS_OVERRIDE = _IMP_em2d.IMP_COMPILER_HAS_OVERRIDE
241 IMP_COMPILER_HAS_FINAL = _IMP_em2d.IMP_COMPILER_HAS_FINAL
243 IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_FILESYSTEM
244 IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
245 IMP_CGAL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CGAL_HAS_BOOST_RANDOM
246 IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CGAL_HAS_BOOST_SYSTEM
248 IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_IMP_CGAL
249 IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
250 IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
251 IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_RANDOM
252 IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ALGEBRA_HAS_BOOST_SYSTEM
253 IMP_ALGEBRA_HAS_CGAL = _IMP_em2d.IMP_ALGEBRA_HAS_CGAL
254 IMP_ALGEBRA_HAS_ANN = _IMP_em2d.IMP_ALGEBRA_HAS_ANN
256 IMP_KERNEL_HAS_IMP_CGAL = _IMP_em2d.IMP_KERNEL_HAS_IMP_CGAL
257 IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
258 IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_KERNEL_HAS_BOOST_RANDOM
259 IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_KERNEL_HAS_BOOST_SYSTEM
260 IMP_KERNEL_HAS_CGAL = _IMP_em2d.IMP_KERNEL_HAS_CGAL
262 IMP_DISPLAY_HAS_IMP_BASE = _IMP_em2d.IMP_DISPLAY_HAS_IMP_BASE
263 IMP_DISPLAY_HAS_IMP_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_IMP_CGAL
264 IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
265 IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
266 IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_RANDOM
267 IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DISPLAY_HAS_BOOST_SYSTEM
268 IMP_DISPLAY_HAS_CGAL = _IMP_em2d.IMP_DISPLAY_HAS_CGAL
270 IMP_GSL_HAS_IMP_BASE = _IMP_em2d.IMP_GSL_HAS_IMP_BASE
271 IMP_GSL_HAS_IMP_CGAL = _IMP_em2d.IMP_GSL_HAS_IMP_CGAL
272 IMP_GSL_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_FILESYSTEM
273 IMP_GSL_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_GSL_HAS_BOOST_PROGRAMOPTIONS
274 IMP_GSL_HAS_BOOST_RANDOM = _IMP_em2d.IMP_GSL_HAS_BOOST_RANDOM
275 IMP_GSL_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_GSL_HAS_BOOST_SYSTEM
276 IMP_GSL_HAS_CGAL = _IMP_em2d.IMP_GSL_HAS_CGAL
278 IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
279 IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
280 IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
281 IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
282 IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
283 IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_em2d.IMP_SCORE_FUNCTOR_HAS_CGAL
285 IMP_STATISTICS_HAS_IMP_BASE = _IMP_em2d.IMP_STATISTICS_HAS_IMP_BASE
286 IMP_STATISTICS_HAS_IMP_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_IMP_CGAL
287 IMP_STATISTICS_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_FILESYSTEM
288 IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_PROGRAMOPTIONS
289 IMP_STATISTICS_HAS_BOOST_RANDOM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_RANDOM
290 IMP_STATISTICS_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_STATISTICS_HAS_BOOST_SYSTEM
291 IMP_STATISTICS_HAS_CGAL = _IMP_em2d.IMP_STATISTICS_HAS_CGAL
293 IMP_CORE_HAS_IMP_BASE = _IMP_em2d.IMP_CORE_HAS_IMP_BASE
294 IMP_CORE_HAS_IMP_CGAL = _IMP_em2d.IMP_CORE_HAS_IMP_CGAL
295 IMP_CORE_HAS_IMP_KERNEL = _IMP_em2d.IMP_CORE_HAS_IMP_KERNEL
296 IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_FILESYSTEM
297 IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
298 IMP_CORE_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CORE_HAS_BOOST_RANDOM
299 IMP_CORE_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CORE_HAS_BOOST_SYSTEM
300 IMP_CORE_HAS_CGAL = _IMP_em2d.IMP_CORE_HAS_CGAL
302 IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_em2d.IMP_CONTAINER_HAS_IMP_ALGEBRA
303 IMP_CONTAINER_HAS_IMP_BASE = _IMP_em2d.IMP_CONTAINER_HAS_IMP_BASE
304 IMP_CONTAINER_HAS_IMP_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_CGAL
305 IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_em2d.IMP_CONTAINER_HAS_IMP_DISPLAY
306 IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_em2d.IMP_CONTAINER_HAS_IMP_KERNEL
307 IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
308 IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
309 IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
310 IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_RANDOM
311 IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_CONTAINER_HAS_BOOST_SYSTEM
312 IMP_CONTAINER_HAS_CGAL = _IMP_em2d.IMP_CONTAINER_HAS_CGAL
314 IMP_ATOM_HAS_IMP_BASE = _IMP_em2d.IMP_ATOM_HAS_IMP_BASE
315 IMP_ATOM_HAS_IMP_CGAL = _IMP_em2d.IMP_ATOM_HAS_IMP_CGAL
316 IMP_ATOM_HAS_IMP_KERNEL = _IMP_em2d.IMP_ATOM_HAS_IMP_KERNEL
317 IMP_ATOM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_ATOM_HAS_IMP_SCORE_FUNCTOR
318 IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_ATOM_HAS_BOOST_PROGRAMOPTIONS
319 IMP_ATOM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_ATOM_HAS_BOOST_RANDOM
320 IMP_ATOM_HAS_BOOST_REGEX = _IMP_em2d.IMP_ATOM_HAS_BOOST_REGEX
321 IMP_ATOM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_ATOM_HAS_BOOST_SYSTEM
322 IMP_ATOM_HAS_CGAL = _IMP_em2d.IMP_ATOM_HAS_CGAL
323 IMP_ATOM_TYPE_INDEX = _IMP_em2d.IMP_ATOM_TYPE_INDEX
324 IMP_RESIDUE_TYPE_INDEX = _IMP_em2d.IMP_RESIDUE_TYPE_INDEX
325 IMP_HIERARCHY_TYPE_INDEX = _IMP_em2d.IMP_HIERARCHY_TYPE_INDEX
327 IMP_EM_HAS_IMP_CGAL = _IMP_em2d.IMP_EM_HAS_IMP_CGAL
328 IMP_EM_HAS_IMP_CONTAINER = _IMP_em2d.IMP_EM_HAS_IMP_CONTAINER
329 IMP_EM_HAS_IMP_DISPLAY = _IMP_em2d.IMP_EM_HAS_IMP_DISPLAY
330 IMP_EM_HAS_IMP_KERNEL = _IMP_em2d.IMP_EM_HAS_IMP_KERNEL
331 IMP_EM_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM_HAS_IMP_SCORE_FUNCTOR
332 IMP_EM_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_FILESYSTEM
333 IMP_EM_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_EM_HAS_BOOST_PROGRAMOPTIONS
334 IMP_EM_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM_HAS_BOOST_RANDOM
335 IMP_EM_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM_HAS_BOOST_REGEX
336 IMP_EM_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM_HAS_BOOST_SYSTEM
337 IMP_EM_HAS_CGAL = _IMP_em2d.IMP_EM_HAS_CGAL
339 IMP_RMF_HAS_IMP_BASE = _IMP_em2d.IMP_RMF_HAS_IMP_BASE
340 IMP_RMF_HAS_IMP_CGAL = _IMP_em2d.IMP_RMF_HAS_IMP_CGAL
341 IMP_RMF_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_RMF_HAS_IMP_SCORE_FUNCTOR
342 IMP_RMF_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_FILESYSTEM
343 IMP_RMF_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_RMF_HAS_BOOST_PROGRAMOPTIONS
344 IMP_RMF_HAS_BOOST_RANDOM = _IMP_em2d.IMP_RMF_HAS_BOOST_RANDOM
345 IMP_RMF_HAS_BOOST_REGEX = _IMP_em2d.IMP_RMF_HAS_BOOST_REGEX
346 IMP_RMF_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_RMF_HAS_BOOST_SYSTEM
347 IMP_RMF_HAS_CGAL = _IMP_em2d.IMP_RMF_HAS_CGAL
350 IMP_DOMINO_HAS_IMP_ATOM = _IMP_em2d.IMP_DOMINO_HAS_IMP_ATOM
351 IMP_DOMINO_HAS_IMP_BASE = _IMP_em2d.IMP_DOMINO_HAS_IMP_BASE
352 IMP_DOMINO_HAS_IMP_CGAL = _IMP_em2d.IMP_DOMINO_HAS_IMP_CGAL
353 IMP_DOMINO_HAS_IMP_KERNEL = _IMP_em2d.IMP_DOMINO_HAS_IMP_KERNEL
354 IMP_DOMINO_HAS_IMP_RMF = _IMP_em2d.IMP_DOMINO_HAS_IMP_RMF
355 IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_DOMINO_HAS_IMP_SCORE_FUNCTOR
356 IMP_DOMINO_HAS_BOOST_FILESYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_FILESYSTEM
357 IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS = _IMP_em2d.IMP_DOMINO_HAS_BOOST_PROGRAMOPTIONS
358 IMP_DOMINO_HAS_BOOST_RANDOM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_RANDOM
359 IMP_DOMINO_HAS_BOOST_REGEX = _IMP_em2d.IMP_DOMINO_HAS_BOOST_REGEX
360 IMP_DOMINO_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_DOMINO_HAS_BOOST_SYSTEM
361 IMP_DOMINO_HAS_CGAL = _IMP_em2d.IMP_DOMINO_HAS_CGAL
362 IMP_DOMINO_HAS_HDF5 = _IMP_em2d.IMP_DOMINO_HAS_HDF5
363 IMP_DOMINO_HAS_RMF = _IMP_em2d.IMP_DOMINO_HAS_RMF
366 IMP_EM2D_HAS_IMP_BASE = _IMP_em2d.IMP_EM2D_HAS_IMP_BASE
367 IMP_EM2D_HAS_IMP_CGAL = _IMP_em2d.IMP_EM2D_HAS_IMP_CGAL
368 IMP_EM2D_HAS_IMP_KERNEL = _IMP_em2d.IMP_EM2D_HAS_IMP_KERNEL
369 IMP_EM2D_HAS_IMP_RMF = _IMP_em2d.IMP_EM2D_HAS_IMP_RMF
370 IMP_EM2D_HAS_IMP_SCORE_FUNCTOR = _IMP_em2d.IMP_EM2D_HAS_IMP_SCORE_FUNCTOR
371 IMP_EM2D_HAS_IMP_STATISTICS = _IMP_em2d.IMP_EM2D_HAS_IMP_STATISTICS
372 IMP_EM2D_HAS_BOOST_GRAPH = _IMP_em2d.IMP_EM2D_HAS_BOOST_GRAPH
373 IMP_EM2D_HAS_BOOST_RANDOM = _IMP_em2d.IMP_EM2D_HAS_BOOST_RANDOM
374 IMP_EM2D_HAS_BOOST_REGEX = _IMP_em2d.IMP_EM2D_HAS_BOOST_REGEX
375 IMP_EM2D_HAS_BOOST_SYSTEM = _IMP_em2d.IMP_EM2D_HAS_BOOST_SYSTEM
376 IMP_EM2D_HAS_CGAL = _IMP_em2d.IMP_EM2D_HAS_CGAL
377 IMP_EM2D_HAS_GSL = _IMP_em2d.IMP_EM2D_HAS_GSL
378 IMP_EM2D_HAS_HDF5 = _IMP_em2d.IMP_EM2D_HAS_HDF5
379 IMP_EM2D_HAS_OPENCV22 = _IMP_em2d.IMP_EM2D_HAS_OPENCV22
380 IMP_EM2D_HAS_RMF = _IMP_em2d.IMP_EM2D_HAS_RMF
381 IMP_EM2D_HAS_OPENCV21 = _IMP_em2d.IMP_EM2D_HAS_OPENCV21
382 PolarResamplingParametersList=list
383 _plural_types.append(
"PolarResamplingParametersList")
384 _value_types.append(
"PolarResamplingParameters")
387 _plural_types.append(
"ProjectionMasks")
388 _value_types.append(
"ProjectionMask")
391 _plural_types.append(
"MasksManagers")
392 _value_types.append(
"MasksManager")
394 RegistrationResults=list
395 _plural_types.append(
"RegistrationResults")
396 _value_types.append(
"RegistrationResult")
399 _plural_types.append(
"ClusterSets")
400 _value_types.append(
"ClusterSet")
403 _plural_types.append(
"SingleLinkages")
404 _value_types.append(
"SingleLinkage")
406 CompleteLinkages=list
407 _plural_types.append(
"CompleteLinkages")
408 _value_types.append(
"CompleteLinkage")
410 AverageDistanceLinkages=list
411 _plural_types.append(
"AverageDistanceLinkages")
412 _value_types.append(
"AverageDistanceLinkage")
414 SegmentationParametersList=list
415 _plural_types.append(
"SegmentationParametersList")
416 _value_types.append(
"SegmentationParameters")
418 MatchTemplateResults=list
419 _plural_types.append(
"MatchTemplateResults")
420 _value_types.append(
"MatchTemplateResult")
422 ProjectingParametersList=list
423 _plural_types.append(
"ProjectingParametersList")
424 _value_types.append(
"ProjectingParameters")
426 ProjectingOptionsList=list
427 _plural_types.append(
"ProjectingOptionsList")
428 _value_types.append(
"ProjectingOptions")
430 Em2DRestraintParametersList=list
431 _plural_types.append(
"Em2DRestraintParametersList")
432 _value_types.append(
"Em2DRestraintParameters")
434 _object_types.append(
"ProjectionFinder")
437 def _object_cast_to_ProjectionFinder(*args):
438 """_object_cast_to_ProjectionFinder(Object o) -> ProjectionFinder"""
439 return _IMP_em2d._object_cast_to_ProjectionFinder(*args)
440 _object_types.append(
"ScoreFunction")
443 def _object_cast_to_ScoreFunction(*args):
444 """_object_cast_to_ScoreFunction(Object o) -> ScoreFunction"""
445 return _IMP_em2d._object_cast_to_ScoreFunction(*args)
446 _object_types.append(
"ChiSquaredScore")
449 def _object_cast_to_ChiSquaredScore(*args):
450 """_object_cast_to_ChiSquaredScore(Object o) -> ChiSquaredScore"""
451 return _IMP_em2d._object_cast_to_ChiSquaredScore(*args)
452 _object_types.append(
"EM2DScore")
455 def _object_cast_to_EM2DScore(*args):
456 """_object_cast_to_EM2DScore(Object o) -> EM2DScore"""
457 return _IMP_em2d._object_cast_to_EM2DScore(*args)
458 _object_types.append(
"MeanAbsoluteDifference")
461 def _object_cast_to_MeanAbsoluteDifference(*args):
462 """_object_cast_to_MeanAbsoluteDifference(Object o) -> MeanAbsoluteDifference"""
463 return _IMP_em2d._object_cast_to_MeanAbsoluteDifference(*args)
464 _object_types.append(
"ProjectionParametersScoreState")
467 def _object_cast_to_ProjectionParametersScoreState(*args):
468 """_object_cast_to_ProjectionParametersScoreState(Object o) -> ProjectionParametersScoreState"""
469 return _IMP_em2d._object_cast_to_ProjectionParametersScoreState(*args)
470 _object_types.append(
"Em2DRestraint")
473 def _object_cast_to_Em2DRestraint(*args):
474 """_object_cast_to_Em2DRestraint(Object o) -> Em2DRestraint"""
475 return _IMP_em2d._object_cast_to_Em2DRestraint(*args)
476 _object_types.append(
"Image")
479 def _object_cast_to_Image(*args):
480 """_object_cast_to_Image(Object o) -> Image"""
481 return _IMP_em2d._object_cast_to_Image(*args)
482 _object_types.append(
"ImageReaderWriter")
485 def _object_cast_to_ImageReaderWriter(*args):
486 """_object_cast_to_ImageReaderWriter(Object o) -> ImageReaderWriter"""
487 return _IMP_em2d._object_cast_to_ImageReaderWriter(*args)
488 _object_types.append(
"JPGImageReaderWriter")
491 def _object_cast_to_JPGImageReaderWriter(*args):
492 """_object_cast_to_JPGImageReaderWriter(Object o) -> JPGImageReaderWriter"""
493 return _IMP_em2d._object_cast_to_JPGImageReaderWriter(*args)
494 _object_types.append(
"TIFFImageReaderWriter")
497 def _object_cast_to_TIFFImageReaderWriter(*args):
498 """_object_cast_to_TIFFImageReaderWriter(Object o) -> TIFFImageReaderWriter"""
499 return _IMP_em2d._object_cast_to_TIFFImageReaderWriter(*args)
500 _object_types.append(
"SpiderImageReaderWriter")
503 def _object_cast_to_SpiderImageReaderWriter(*args):
504 """_object_cast_to_SpiderImageReaderWriter(Object o) -> SpiderImageReaderWriter"""
505 return _IMP_em2d._object_cast_to_SpiderImageReaderWriter(*args)
506 _object_types.append(
"CollisionCrossSection")
509 def _object_cast_to_CollisionCrossSection(*args):
510 """_object_cast_to_CollisionCrossSection(Object o) -> CollisionCrossSection"""
511 return _IMP_em2d._object_cast_to_CollisionCrossSection(*args)
512 _object_types.append(
"GridStates")
515 def _object_cast_to_GridStates(*args):
516 """_object_cast_to_GridStates(Object o) -> GridStates"""
517 return _IMP_em2d._object_cast_to_GridStates(*args)
518 _object_types.append(
"ProjectionStates")
521 def _object_cast_to_ProjectionStates(*args):
522 """_object_cast_to_ProjectionStates(Object o) -> ProjectionStates"""
523 return _IMP_em2d._object_cast_to_ProjectionStates(*args)
524 _object_types.append(
"DistanceFilter")
527 def _object_cast_to_DistanceFilter(*args):
528 """_object_cast_to_DistanceFilter(Object o) -> DistanceFilter"""
529 return _IMP_em2d._object_cast_to_DistanceFilter(*args)
530 _object_types.append(
"DistanceFilterTable")
533 def _object_cast_to_DistanceFilterTable(*args):
534 """_object_cast_to_DistanceFilterTable(Object o) -> DistanceFilterTable"""
535 return _IMP_em2d._object_cast_to_DistanceFilterTable(*args)
536 _object_types.append(
"RigidBodiesImageFitRestraint")
539 def _object_cast_to_RigidBodiesImageFitRestraint(*args):
540 """_object_cast_to_RigidBodiesImageFitRestraint(Object o) -> RigidBodiesImageFitRestraint"""
541 return _IMP_em2d._object_cast_to_RigidBodiesImageFitRestraint(*args)
542 _object_types.append(
"DummyRestraint")
545 def _object_cast_to_DummyRestraint(*args):
546 """_object_cast_to_DummyRestraint(Object o) -> DummyRestraint"""
547 return _IMP_em2d._object_cast_to_DummyRestraint(*args)
548 _object_types.append(
"ParticlesDummyRestraint")
551 def _object_cast_to_ParticlesDummyRestraint(*args):
552 """_object_cast_to_ParticlesDummyRestraint(Object o) -> ParticlesDummyRestraint"""
553 return _IMP_em2d._object_cast_to_ParticlesDummyRestraint(*args)
554 _object_types.append(
"RelativePositionMover")
557 def _object_cast_to_RelativePositionMover(*args):
558 """_object_cast_to_RelativePositionMover(Object o) -> RelativePositionMover"""
559 return _IMP_em2d._object_cast_to_RelativePositionMover(*args)
560 def ProjectionParametersList(l=[]):
561 return [ProjectionParameters(x)
for x
in l]
562 _plural_types.append(
"ProjectionParametersList")
564 _value_types.append(
"ProjectionParameters")
569 show(cv::Mat const & m, _ostream out=std::cout)
570 show(cv::Mat const & m)
572 return _IMP_em2d.show(*args)
575 """write_matrix(cv::Mat & m, std::string name)"""
576 return _IMP_em2d.write_matrix(*args)
578 """Proxy of C++ IMP::em2d::ImageReaderWriter class"""
579 __swig_setmethods__ = {}
580 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
581 __setattr__ =
lambda self, name, value: _swig_setattr(self, ImageReaderWriter, name, value)
582 __swig_getmethods__ = {}
583 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
584 __getattr__ =
lambda self, name: _swig_getattr(self, ImageReaderWriter, name)
585 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
586 def read(self, *args):
587 """read(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
588 return _IMP_em2d.ImageReaderWriter_read(self, *args)
590 def read_from_floats(self, *args):
591 """read_from_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
592 return _IMP_em2d.ImageReaderWriter_read_from_floats(self, *args)
594 def read_from_ints(self, *args):
595 """read_from_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat & data)"""
596 return _IMP_em2d.ImageReaderWriter_read_from_ints(self, *args)
598 def write(self, *args):
599 """write(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
600 return _IMP_em2d.ImageReaderWriter_write(self, *args)
602 def write_to_floats(self, *args):
603 """write_to_floats(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
604 return _IMP_em2d.ImageReaderWriter_write_to_floats(self, *args)
606 def write_to_ints(self, *args):
607 """write_to_ints(ImageReaderWriter self, IMP::String const & filename, ImageHeader header, cv::Mat const & data)"""
608 return _IMP_em2d.ImageReaderWriter_write_to_ints(self, *args)
610 def get_version_info(self):
611 """get_version_info(ImageReaderWriter self) -> VersionInfo"""
612 return _IMP_em2d.ImageReaderWriter_get_version_info(self)
614 __swig_destroy__ = _IMP_em2d.delete_ImageReaderWriter
615 __del__ =
lambda self :
None;
617 """__str__(ImageReaderWriter self) -> std::string"""
618 return _IMP_em2d.ImageReaderWriter___str__(self)
621 """__repr__(ImageReaderWriter self) -> std::string"""
622 return _IMP_em2d.ImageReaderWriter___repr__(self)
625 return _object_cast_to_ImageReaderWriter(o)
626 get_from = staticmethod(get_from)
628 ImageReaderWriter_swigregister = _IMP_em2d.ImageReaderWriter_swigregister
629 ImageReaderWriter_swigregister(ImageReaderWriter)
631 class PolarResamplingParameters(_object):
632 """Proxy of C++ IMP::em2d::PolarResamplingParameters class"""
633 __swig_setmethods__ = {}
634 __setattr__ =
lambda self, name, value: _swig_setattr(self, PolarResamplingParameters, name, value)
635 __swig_getmethods__ = {}
636 __getattr__ =
lambda self, name: _swig_getattr(self, PolarResamplingParameters, name)
637 def __init__(self, *args):
639 __init__(IMP::em2d::PolarResamplingParameters self) -> PolarResamplingParameters
640 __init__(IMP::em2d::PolarResamplingParameters self, unsigned int rows, unsigned int cols) -> PolarResamplingParameters
641 __init__(IMP::em2d::PolarResamplingParameters self, cv::Mat const & m) -> PolarResamplingParameters
643 this = _IMP_em2d.new_PolarResamplingParameters(*args)
644 try: self.this.append(this)
645 except: self.this = this
646 __swig_destroy__ = _IMP_em2d.delete_PolarResamplingParameters
647 __del__ =
lambda self :
None;
648 def setup(self, *args):
649 """setup(PolarResamplingParameters self, unsigned int rows, unsigned int cols)"""
650 return _IMP_em2d.PolarResamplingParameters_setup(self, *args)
652 def get_starting_radius(self):
653 """get_starting_radius(PolarResamplingParameters self) -> double"""
654 return _IMP_em2d.PolarResamplingParameters_get_starting_radius(self)
656 def get_ending_radius(self):
657 """get_ending_radius(PolarResamplingParameters self) -> double"""
658 return _IMP_em2d.PolarResamplingParameters_get_ending_radius(self)
660 def get_radius(self, *args):
661 """get_radius(PolarResamplingParameters self, unsigned int n_ring) -> double"""
662 return _IMP_em2d.PolarResamplingParameters_get_radius(self, *args)
664 def get_number_of_rings(self):
665 """get_number_of_rings(PolarResamplingParameters self) -> unsigned int"""
666 return _IMP_em2d.PolarResamplingParameters_get_number_of_rings(self)
668 def set_estimated_number_of_angles(self, *args):
669 """set_estimated_number_of_angles(PolarResamplingParameters self, unsigned int aprox_value)"""
670 return _IMP_em2d.PolarResamplingParameters_set_estimated_number_of_angles(self, *args)
672 def get_number_of_angles(self):
673 """get_number_of_angles(PolarResamplingParameters self) -> unsigned int"""
674 return _IMP_em2d.PolarResamplingParameters_get_number_of_angles(self)
676 def get_angle_step(self):
677 """get_angle_step(PolarResamplingParameters self) -> double"""
678 return _IMP_em2d.PolarResamplingParameters_get_angle_step(self)
680 def get_radius_step(self):
681 """get_radius_step(PolarResamplingParameters self) -> double"""
682 return _IMP_em2d.PolarResamplingParameters_get_radius_step(self)
684 def create_maps_for_resampling(self):
685 """create_maps_for_resampling(PolarResamplingParameters self)"""
686 return _IMP_em2d.PolarResamplingParameters_create_maps_for_resampling(self)
688 def get_resampling_maps(self, *args):
689 """get_resampling_maps(PolarResamplingParameters self, cv::Mat & m1, cv::Mat & m2)"""
690 return _IMP_em2d.PolarResamplingParameters_get_resampling_maps(self, *args)
692 def get_resampling_map(self, *args):
693 """get_resampling_map(PolarResamplingParameters self, cv::Mat & m1)"""
694 return _IMP_em2d.PolarResamplingParameters_get_resampling_map(self, *args)
696 def show(self, *args):
697 """show(PolarResamplingParameters self, _ostream out)"""
698 return _IMP_em2d.PolarResamplingParameters_show(self, *args)
700 def get_is_setup(self):
701 """get_is_setup(PolarResamplingParameters self) -> bool"""
702 return _IMP_em2d.PolarResamplingParameters_get_is_setup(self)
705 """__str__(PolarResamplingParameters self) -> std::string"""
706 return _IMP_em2d.PolarResamplingParameters___str__(self)
709 """__repr__(PolarResamplingParameters self) -> std::string"""
710 return _IMP_em2d.PolarResamplingParameters___repr__(self)
712 PolarResamplingParameters_swigregister = _IMP_em2d.PolarResamplingParameters_swigregister
713 PolarResamplingParameters_swigregister(PolarResamplingParameters)
715 class SegmentationParameters(_object):
716 """Proxy of C++ IMP::em2d::SegmentationParameters class"""
717 __swig_setmethods__ = {}
718 __setattr__ =
lambda self, name, value: _swig_setattr(self, SegmentationParameters, name, value)
719 __swig_getmethods__ = {}
720 __getattr__ =
lambda self, name: _swig_getattr(self, SegmentationParameters, name)
721 __swig_setmethods__[
"image_pixel_size"] = _IMP_em2d.SegmentationParameters_image_pixel_size_set
722 __swig_getmethods__[
"image_pixel_size"] = _IMP_em2d.SegmentationParameters_image_pixel_size_get
723 if _newclass:image_pixel_size = _swig_property(_IMP_em2d.SegmentationParameters_image_pixel_size_get, _IMP_em2d.SegmentationParameters_image_pixel_size_set)
724 __swig_setmethods__[
"diffusion_beta"] = _IMP_em2d.SegmentationParameters_diffusion_beta_set
725 __swig_getmethods__[
"diffusion_beta"] = _IMP_em2d.SegmentationParameters_diffusion_beta_get
726 if _newclass:diffusion_beta = _swig_property(_IMP_em2d.SegmentationParameters_diffusion_beta_get, _IMP_em2d.SegmentationParameters_diffusion_beta_set)
727 __swig_setmethods__[
"diffusion_timesteps"] = _IMP_em2d.SegmentationParameters_diffusion_timesteps_set
728 __swig_getmethods__[
"diffusion_timesteps"] = _IMP_em2d.SegmentationParameters_diffusion_timesteps_get
729 if _newclass:diffusion_timesteps = _swig_property(_IMP_em2d.SegmentationParameters_diffusion_timesteps_get, _IMP_em2d.SegmentationParameters_diffusion_timesteps_set)
730 __swig_setmethods__[
"fill_holes_stddevs"] = _IMP_em2d.SegmentationParameters_fill_holes_stddevs_set
731 __swig_getmethods__[
"fill_holes_stddevs"] = _IMP_em2d.SegmentationParameters_fill_holes_stddevs_get
732 if _newclass:fill_holes_stddevs = _swig_property(_IMP_em2d.SegmentationParameters_fill_holes_stddevs_get, _IMP_em2d.SegmentationParameters_fill_holes_stddevs_set)
733 __swig_setmethods__[
"opening_kernel"] = _IMP_em2d.SegmentationParameters_opening_kernel_set
734 __swig_getmethods__[
"opening_kernel"] = _IMP_em2d.SegmentationParameters_opening_kernel_get
735 if _newclass:opening_kernel = _swig_property(_IMP_em2d.SegmentationParameters_opening_kernel_get, _IMP_em2d.SegmentationParameters_opening_kernel_set)
736 __swig_setmethods__[
"remove_sizing_percentage"] = _IMP_em2d.SegmentationParameters_remove_sizing_percentage_set
737 __swig_getmethods__[
"remove_sizing_percentage"] = _IMP_em2d.SegmentationParameters_remove_sizing_percentage_get
738 if _newclass:remove_sizing_percentage = _swig_property(_IMP_em2d.SegmentationParameters_remove_sizing_percentage_get, _IMP_em2d.SegmentationParameters_remove_sizing_percentage_set)
739 __swig_setmethods__[
"binary_background"] = _IMP_em2d.SegmentationParameters_binary_background_set
740 __swig_getmethods__[
"binary_background"] = _IMP_em2d.SegmentationParameters_binary_background_get
741 if _newclass:binary_background = _swig_property(_IMP_em2d.SegmentationParameters_binary_background_get, _IMP_em2d.SegmentationParameters_binary_background_set)
742 __swig_setmethods__[
"binary_foreground"] = _IMP_em2d.SegmentationParameters_binary_foreground_set
743 __swig_getmethods__[
"binary_foreground"] = _IMP_em2d.SegmentationParameters_binary_foreground_get
744 if _newclass:binary_foreground = _swig_property(_IMP_em2d.SegmentationParameters_binary_foreground_get, _IMP_em2d.SegmentationParameters_binary_foreground_set)
745 __swig_setmethods__[
"threshold"] = _IMP_em2d.SegmentationParameters_threshold_set
746 __swig_getmethods__[
"threshold"] = _IMP_em2d.SegmentationParameters_threshold_get
747 if _newclass:threshold = _swig_property(_IMP_em2d.SegmentationParameters_threshold_get, _IMP_em2d.SegmentationParameters_threshold_set)
748 def __init__(self, *args):
750 __init__(IMP::em2d::SegmentationParameters self) -> SegmentationParameters
751 __init__(IMP::em2d::SegmentationParameters self, double apix, double diff_beta, unsigned int diff_timesteps, double fh_stddevs, cv::Mat const & kr,
752 int background, int foreground) -> SegmentationParameters
754 this = _IMP_em2d.new_SegmentationParameters(*args)
755 try: self.this.append(this)
756 except: self.this = this
757 def show(self, *args):
759 show(SegmentationParameters self, _ostream out=std::cout)
760 show(SegmentationParameters self)
762 return _IMP_em2d.SegmentationParameters_show(self, *args)
765 """__str__(SegmentationParameters self) -> std::string"""
766 return _IMP_em2d.SegmentationParameters___str__(self)
769 """__repr__(SegmentationParameters self) -> std::string"""
770 return _IMP_em2d.SegmentationParameters___repr__(self)
772 __swig_destroy__ = _IMP_em2d.delete_SegmentationParameters
773 __del__ =
lambda self :
None;
774 SegmentationParameters_swigregister = _IMP_em2d.SegmentationParameters_swigregister
775 SegmentationParameters_swigregister(SegmentationParameters)
777 class MatchTemplateResult(_object):
778 """Proxy of C++ IMP::em2d::MatchTemplateResult class"""
779 __swig_setmethods__ = {}
780 __setattr__ =
lambda self, name, value: _swig_setattr(self, MatchTemplateResult, name, value)
781 __swig_getmethods__ = {}
782 __getattr__ =
lambda self, name: _swig_getattr(self, MatchTemplateResult, name)
783 __swig_setmethods__[
"pair"] = _IMP_em2d.MatchTemplateResult_pair_set
784 __swig_getmethods__[
"pair"] = _IMP_em2d.MatchTemplateResult_pair_get
785 if _newclass:pair = _swig_property(_IMP_em2d.MatchTemplateResult_pair_get, _IMP_em2d.MatchTemplateResult_pair_set)
786 __swig_setmethods__[
"cross_correlation"] = _IMP_em2d.MatchTemplateResult_cross_correlation_set
787 __swig_getmethods__[
"cross_correlation"] = _IMP_em2d.MatchTemplateResult_cross_correlation_get
788 if _newclass:cross_correlation = _swig_property(_IMP_em2d.MatchTemplateResult_cross_correlation_get, _IMP_em2d.MatchTemplateResult_cross_correlation_set)
789 def __init__(self, *args):
790 """__init__(IMP::em2d::MatchTemplateResult self, IMP::IntPair p, double cc) -> MatchTemplateResult"""
791 this = _IMP_em2d.new_MatchTemplateResult(*args)
792 try: self.this.append(this)
793 except: self.this = this
794 def show(self, *args):
796 show(MatchTemplateResult self, _ostream out=std::cout)
797 show(MatchTemplateResult self)
799 return _IMP_em2d.MatchTemplateResult_show(self, *args)
802 """__str__(MatchTemplateResult self) -> std::string"""
803 return _IMP_em2d.MatchTemplateResult___str__(self)
806 """__repr__(MatchTemplateResult self) -> std::string"""
807 return _IMP_em2d.MatchTemplateResult___repr__(self)
809 __swig_destroy__ = _IMP_em2d.delete_MatchTemplateResult
810 __del__ =
lambda self :
None;
811 MatchTemplateResult_swigregister = _IMP_em2d.MatchTemplateResult_swigregister
812 MatchTemplateResult_swigregister(MatchTemplateResult)
816 """apply_mask(cv::Mat const & m, cv::Mat & result, IMP::em2d::cvIntMat const & mask, double val)"""
817 return _IMP_em2d.apply_mask(*args)
821 apply_circular_mask(cv::Mat const & mat, cv::Mat & result, int radius, double value=0.0)
822 apply_circular_mask(cv::Mat const & mat, cv::Mat & result, int radius)
824 return _IMP_em2d.apply_circular_mask(*args)
827 """get_mean(cv::Mat const & mat, IMP::em2d::cvIntMat const & mask) -> double"""
828 return _IMP_em2d.get_mean(*args)
831 """create_circular_mask(int rows, int cols, int radius) -> IMP::em2d::cvIntMat"""
832 return _IMP_em2d.create_circular_mask(*args)
834 def do_histogram_stretching(*args):
835 """do_histogram_stretching(cv::Mat & m, int boxes, int offset)"""
836 return _IMP_em2d.do_histogram_stretching(*args)
839 """do_dilate_and_shrink_warp(cv::Mat & m, cv::Mat const & greyscale, cv::Mat & kernel)"""
840 return _IMP_em2d.do_dilate_and_shrink_warp(*args)
844 do_morphologic_reconstruction(cv::Mat const & mask, cv::Mat & marker, int neighbors_mode=4)
845 do_morphologic_reconstruction(cv::Mat const & mask, cv::Mat & marker)
847 return _IMP_em2d.do_morphologic_reconstruction(*args)
850 """do_labeling(IMP::em2d::cvIntMat const & m, IMP::em2d::cvIntMat & mat_to_label) -> int"""
851 return _IMP_em2d.do_labeling(*args)
854 """get_diffusion_filtering_partial_derivative(cv::Mat const & m, cv::Mat & der, double dx, double dy, double ang)"""
855 return _IMP_em2d.get_diffusion_filtering_partial_derivative(*args)
858 """get_domes(cv::Mat & m, cv::Mat & result, double h)"""
859 return _IMP_em2d.get_domes(*args)
861 def my_meanStdDev(*args):
862 """my_meanStdDev(cv::Mat const & m, cv::Scalar & mean, cv::Scalar & stddev)"""
863 return _IMP_em2d.my_meanStdDev(*args)
866 """get_transformed(cv::Mat const & input, cv::Mat & transformed, Transformation2D T)"""
867 return _IMP_em2d.get_transformed(*args)
871 apply_threshold(cv::Mat & m, cv::Mat & result, double threshold=0.0)
872 apply_threshold(cv::Mat & m, cv::Mat & result)
874 return _IMP_em2d.apply_threshold(*args)
877 """do_morphologic_contrast_enhancement(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel, unsigned int iterations)"""
878 return _IMP_em2d.do_morphologic_contrast_enhancement(*args)
881 """get_morphologic_gradient(cv::Mat const & m, cv::Mat & result, cv::Mat const & kernel)"""
882 return _IMP_em2d.get_morphologic_gradient(*args)
885 """get_overlap_percentage(cv::Mat & m1, cv::Mat & m2, IMP::IntPair const & center) -> double"""
886 return _IMP_em2d.get_overlap_percentage(*args)
889 """get_best_template_matches(cv::Mat const & m, cv::Mat const & templ, unsigned int n) -> IMP::em2d::MatchTemplateResults"""
890 return _IMP_em2d.get_best_template_matches(*args)
892 """Proxy of C++ IMP::em2d::Image class"""
893 __swig_setmethods__ = {}
894 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
895 __setattr__ =
lambda self, name, value: _swig_setattr(self, Image, name, value)
896 __swig_getmethods__ = {}
897 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
898 __getattr__ =
lambda self, name: _swig_getattr(self, Image, name)
899 def __init__(self, *args):
901 __init__(IMP::em2d::Image self) -> Image
902 __init__(IMP::em2d::Image self, int rows, int cols) -> Image
903 __init__(IMP::em2d::Image self, IMP::String filename, ImageReaderWriter reader) -> Image
905 this = _IMP_em2d.new_Image(*args)
906 try: self.this.append(this)
907 except: self.this = this
909 """get_data(Image self) -> cv::Mat &"""
910 return _IMP_em2d.Image_get_data(self)
912 def set_data(self, *args):
913 """set_data(Image self, cv::Mat const & mat)"""
914 return _IMP_em2d.Image_set_data(self, *args)
917 """set_zeros(Image self)"""
918 return _IMP_em2d.Image_set_zeros(self)
920 def set_value(self, *args):
922 set_value(Image self, double val)
923 set_value(Image self, int i, int j, double val)
925 return _IMP_em2d.Image_set_value(self, *args)
927 def __call__(self, *args):
928 """__call__(Image self, int i, int j) -> double"""
929 return _IMP_em2d.Image___call__(self, *args)
931 def get_header(self):
932 """get_header(Image self) -> ImageHeader"""
933 return _IMP_em2d.Image_get_header(self)
935 def set_size(self, *args):
937 set_size(Image self, int rows, int cols)
938 set_size(Image self, Image img)
940 return _IMP_em2d.Image_set_size(self, *args)
942 def update_header(self):
943 """update_header(Image self)"""
944 return _IMP_em2d.Image_update_header(self)
946 def read(self, *args):
947 """read(Image self, IMP::String filename, ImageReaderWriter reader)"""
948 return _IMP_em2d.Image_read(self, *args)
950 def write(self, *args):
951 """write(Image self, IMP::String const & filename, ImageReaderWriter writer)"""
952 return _IMP_em2d.Image_write(self, *args)
954 def show(self, *args):
955 """show(Image self, _ostream out)"""
956 return _IMP_em2d.Image_show(self, *args)
958 def get_version_info(self):
959 """get_version_info(Image self) -> VersionInfo"""
960 return _IMP_em2d.Image_get_version_info(self)
962 __swig_destroy__ = _IMP_em2d.delete_Image
963 __del__ =
lambda self :
None;
964 def destroyed_msg(self):
965 """destroyed_msg(Image self)"""
966 return _IMP_em2d.Image_destroyed_msg(self)
968 def set_name(self, *args):
969 """set_name(Image self, IMP::String const & name)"""
970 return _IMP_em2d.Image_set_name(self, *args)
973 """get_name(Image self) -> IMP::String"""
974 return _IMP_em2d.Image_get_name(self)
976 def get_min_and_max_values(self):
977 """get_min_and_max_values(Image self) -> IMP::FloatRange"""
978 return _IMP_em2d.Image_get_min_and_max_values(self)
981 """__str__(Image self) -> std::string"""
982 return _IMP_em2d.Image___str__(self)
985 """__repr__(Image self) -> std::string"""
986 return _IMP_em2d.Image___repr__(self)
989 return _object_cast_to_Image(o)
990 get_from = staticmethod(get_from)
992 Image_swigregister = _IMP_em2d.Image_swigregister
993 Image_swigregister(Image)
997 """read_images(IMP::Strings const & names, ImageReaderWriter rw) -> IMP::em2d::Images"""
998 return _IMP_em2d.read_images(*args)
1001 """save_images(IMP::em2d::Images images, IMP::Strings const & names, ImageReaderWriter rw)"""
1002 return _IMP_em2d.save_images(*args)
1006 do_normalize(cv::Mat & m)
1007 do_normalize(Image im, bool force=False)
1008 do_normalize(Image im)
1010 return _IMP_em2d.do_normalize(*args)
1014 get_histogram(cv::Mat const & m, int bins) -> IMP::Floats
1015 get_histogram(Image img, int bins) -> IMP::Floats
1017 return _IMP_em2d.get_histogram(*args)
1021 apply_variance_filter(cv::Mat const & input, cv::Mat & filtered, int kernelsize)
1022 apply_variance_filter(Image input, Image filtered, int kernelsize)
1024 return _IMP_em2d.apply_variance_filter(*args)
1028 apply_diffusion_filter(cv::Mat const & m, cv::Mat & result, double beta, double pixelsize, unsigned int time_steps)
1029 apply_diffusion_filter(Image input, Image filtered, double beta, double pixelsize, int time_steps)
1031 return _IMP_em2d.apply_diffusion_filter(*args)
1033 def do_fill_holes(*args):
1035 do_fill_holes(cv::Mat const & m, cv::Mat & result, double h)
1036 do_fill_holes(Image input, Image result, double n_stddevs)
1038 return _IMP_em2d.do_fill_holes(*args)
1040 def do_combined_fill_holes_and_threshold(*args):
1042 do_combined_fill_holes_and_threshold(cv::Mat & m, cv::Mat & result, double n_stddevs, double threshold=0.0)
1043 do_combined_fill_holes_and_threshold(cv::Mat & m, cv::Mat & result, double n_stddevs)
1044 do_combined_fill_holes_and_threshold(Image input, Image result, double n_stddevs)
1046 return _IMP_em2d.do_combined_fill_holes_and_threshold(*args)
1048 def do_extend_borders(*args):
1050 do_extend_borders(cv::Mat & orig, cv::Mat & dst, unsigned int pix)
1051 do_extend_borders(Image im1, Image im2, unsigned int pix)
1053 return _IMP_em2d.do_extend_borders(*args)
1055 def do_segmentation(*args):
1057 do_segmentation(cv::Mat const & m, cv::Mat & result, SegmentationParameters params)
1058 do_segmentation(Image input, Image result, SegmentationParameters params)
1060 return _IMP_em2d.do_segmentation(*args)
1062 def do_remove_small_objects(*args):
1064 do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage, int background=0, int foreground=1)
1065 do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage, int background=0)
1066 do_remove_small_objects(IMP::em2d::cvIntMat & m, double percentage)
1067 do_remove_small_objects(Image input, double percentage, int background=0, int foreground=1)
1068 do_remove_small_objects(Image input, double percentage, int background=0)
1069 do_remove_small_objects(Image input, double percentage)
1071 return _IMP_em2d.do_remove_small_objects(*args)
1074 """do_subtract_images(Image first, Image second, Image result)"""
1075 return _IMP_em2d.do_subtract_images(*args)
1077 def add_noise(*args):
1079 add_noise(cv::Mat & v, double op1, double op2, IMP::String const & mode="uniform", double df=3)
1080 add_noise(cv::Mat & v, double op1, double op2, IMP::String const & mode="uniform")
1081 add_noise(cv::Mat & v, double op1, double op2)
1082 add_noise(Image im1, double op1, double op2, IMP::String const & mode="uniform", double df=3)
1083 add_noise(Image im1, double op1, double op2, IMP::String const & mode="uniform")
1084 add_noise(Image im1, double op1, double op2)
1086 return _IMP_em2d.add_noise(*args)
1090 do_resample_polar(cv::Mat const & input, cv::Mat & resampled, PolarResamplingParameters polar_params)
1091 do_resample_polar(Image im1, Image im2, PolarResamplingParameters polar_params)
1093 return _IMP_em2d.do_resample_polar(*args)
1097 crop(cv::Mat const & m, IMP::IntPair const & center, int size) -> cv::Mat
1098 crop(Image img, IMP::IntPair const & center, int size)
1100 return _IMP_em2d.crop(*args)
1103 """apply_mean_outside_mask(Image img, double radius)"""
1104 return _IMP_em2d.apply_mean_outside_mask(*args)
1105 class RegistrationResult(_object):
1106 """Proxy of C++ IMP::em2d::RegistrationResult class"""
1107 __swig_setmethods__ = {}
1108 __setattr__ =
lambda self, name, value: _swig_setattr(self, RegistrationResult, name, value)
1109 __swig_getmethods__ = {}
1110 __getattr__ =
lambda self, name: _swig_getattr(self, RegistrationResult, name)
1111 def __init__(self, *args):
1113 __init__(IMP::em2d::RegistrationResult self) -> RegistrationResult
1114 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0, int image_index=0,
1115 IMP::String name="") -> RegistrationResult
1116 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0, int image_index=0) -> RegistrationResult
1117 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift, int projection_index=0) -> RegistrationResult
1118 __init__(IMP::em2d::RegistrationResult self, double phi, double theta, double psi, Vector2D shift) -> RegistrationResult
1119 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.), int projection_index=0,
1120 int image_index=0, IMP::String name="") -> RegistrationResult
1121 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.), int projection_index=0,
1122 int image_index=0) -> RegistrationResult
1123 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.), int projection_index=0) -> RegistrationResult
1124 __init__(IMP::em2d::RegistrationResult self, Rotation3D R, Vector2D shift=IMP::algebra::Vector2D(0.,0.)) -> RegistrationResult
1125 __init__(IMP::em2d::RegistrationResult self, Rotation3D R) -> RegistrationResult
1127 this = _IMP_em2d.new_RegistrationResult(*args)
1128 try: self.this.append(this)
1129 except: self.this = this
1131 """get_phi(RegistrationResult self) -> double"""
1132 return _IMP_em2d.RegistrationResult_get_phi(self)
1134 def get_theta(self):
1135 """get_theta(RegistrationResult self) -> double"""
1136 return _IMP_em2d.RegistrationResult_get_theta(self)
1139 """get_psi(RegistrationResult self) -> double"""
1140 return _IMP_em2d.RegistrationResult_get_psi(self)
1142 def get_shift(self):
1143 """get_shift(RegistrationResult self) -> Vector2D"""
1144 return _IMP_em2d.RegistrationResult_get_shift(self)
1146 def get_shift_3d(self):
1147 """get_shift_3d(RegistrationResult self) -> Vector3D"""
1148 return _IMP_em2d.RegistrationResult_get_shift_3d(self)
1150 def get_projection_index(self):
1151 """get_projection_index(RegistrationResult self) -> int"""
1152 return _IMP_em2d.RegistrationResult_get_projection_index(self)
1154 def set_projection_index(self, *args):
1155 """set_projection_index(RegistrationResult self, int index)"""
1156 return _IMP_em2d.RegistrationResult_set_projection_index(self, *args)
1158 def get_image_index(self):
1159 """get_image_index(RegistrationResult self) -> int"""
1160 return _IMP_em2d.RegistrationResult_get_image_index(self)
1162 def set_image_index(self, *args):
1163 """set_image_index(RegistrationResult self, int index)"""
1164 return _IMP_em2d.RegistrationResult_set_image_index(self, *args)
1167 """get_name(RegistrationResult self) -> IMP::String"""
1168 return _IMP_em2d.RegistrationResult_get_name(self)
1171 """get_ccc(RegistrationResult self) -> double"""
1172 return _IMP_em2d.RegistrationResult_get_ccc(self)
1174 def set_ccc(self, *args):
1175 """set_ccc(RegistrationResult self, double ccc)"""
1176 return _IMP_em2d.RegistrationResult_set_ccc(self, *args)
1178 def get_score(self):
1179 """get_score(RegistrationResult self) -> double"""
1180 return _IMP_em2d.RegistrationResult_get_score(self)
1182 def set_score(self, *args):
1183 """set_score(RegistrationResult self, double Score)"""
1184 return _IMP_em2d.RegistrationResult_set_score(self, *args)
1186 def set_rotation(self, *args):
1188 set_rotation(RegistrationResult self, double phi, double theta, double psi)
1189 set_rotation(RegistrationResult self, Rotation3D R)
1191 return _IMP_em2d.RegistrationResult_set_rotation(self, *args)
1193 def set_shift(self, *args):
1194 """set_shift(RegistrationResult self, Vector2D shift)"""
1195 return _IMP_em2d.RegistrationResult_set_shift(self, *args)
1197 def set_name(self, *args):
1198 """set_name(RegistrationResult self, IMP::String name)"""
1199 return _IMP_em2d.RegistrationResult_set_name(self, *args)
1201 def add_in_plane_transformation(self, *args):
1202 """add_in_plane_transformation(RegistrationResult self, Transformation2D t)"""
1203 return _IMP_em2d.RegistrationResult_add_in_plane_transformation(self, *args)
1205 def show(self, *args):
1207 show(RegistrationResult self, _ostream out=std::cout)
1208 show(RegistrationResult self)
1210 return _IMP_em2d.RegistrationResult_show(self, *args)
1212 def write(self, *args):
1214 write(RegistrationResult self, _ostream out=std::cout)
1215 write(RegistrationResult self)
1217 return _IMP_em2d.RegistrationResult_write(self, *args)
1219 def write_comment_line(self, *args):
1221 write_comment_line(RegistrationResult self, _ostream out=std::cout)
1222 write_comment_line(RegistrationResult self)
1224 return _IMP_em2d.RegistrationResult_write_comment_line(self, *args)
1226 def read(self, *args):
1227 """read(RegistrationResult self, IMP::String const & s)"""
1228 return _IMP_em2d.RegistrationResult_read(self, *args)
1230 def set_random_registration(self, *args):
1231 """set_random_registration(RegistrationResult self, unsigned int index, double maximum_shift)"""
1232 return _IMP_em2d.RegistrationResult_set_random_registration(self, *args)
1234 def get_rotation(self):
1235 """get_rotation(RegistrationResult self) -> Rotation3D"""
1236 return _IMP_em2d.RegistrationResult_get_rotation(self)
1238 def set_in_image(self, *args):
1239 """set_in_image(RegistrationResult self, ImageHeader header)"""
1240 return _IMP_em2d.RegistrationResult_set_in_image(self, *args)
1242 def read_from_image(self, *args):
1243 """read_from_image(RegistrationResult self, ImageHeader header)"""
1244 return _IMP_em2d.RegistrationResult_read_from_image(self, *args)
1246 def get_is_optimized_result(self):
1247 """get_is_optimized_result(RegistrationResult self) -> bool"""
1248 return _IMP_em2d.RegistrationResult_get_is_optimized_result(self)
1250 __swig_destroy__ = _IMP_em2d.delete_RegistrationResult
1251 __del__ =
lambda self :
None;
1253 """__str__(RegistrationResult self) -> std::string"""
1254 return _IMP_em2d.RegistrationResult___str__(self)
1257 """__repr__(RegistrationResult self) -> std::string"""
1258 return _IMP_em2d.RegistrationResult___repr__(self)
1260 RegistrationResult_swigregister = _IMP_em2d.RegistrationResult_swigregister
1261 RegistrationResult_swigregister(RegistrationResult)
1265 """read_registration_results(IMP::String const & filename) -> IMP::em2d::RegistrationResults"""
1266 return _IMP_em2d.read_registration_results(*args)
1269 """write_registration_results(IMP::String filename, IMP::em2d::RegistrationResults const & results)"""
1270 return _IMP_em2d.write_registration_results(*args)
1274 get_random_registration_results(unsigned int n, double maximum_shift=5.0) -> IMP::em2d::RegistrationResults
1275 get_random_registration_results(unsigned int n) -> IMP::em2d::RegistrationResults
1277 return _IMP_em2d.get_random_registration_results(*args)
1280 """get_evenly_distributed_registration_results(unsigned int n_projections) -> IMP::em2d::RegistrationResults"""
1281 return _IMP_em2d.get_evenly_distributed_registration_results(*args)
1283 def get_random_between_zero_and_one():
1284 """get_random_between_zero_and_one() -> double"""
1285 return _IMP_em2d.get_random_between_zero_and_one()
1286 class SpiderImageReaderWriter(ImageReaderWriter):
1287 """Proxy of C++ IMP::em2d::SpiderImageReaderWriter class"""
1288 __swig_setmethods__ = {}
1289 for _s
in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1290 __setattr__ =
lambda self, name, value: _swig_setattr(self, SpiderImageReaderWriter, name, value)
1291 __swig_getmethods__ = {}
1292 for _s
in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1293 __getattr__ =
lambda self, name: _swig_getattr(self, SpiderImageReaderWriter, name)
1294 __swig_setmethods__[
"filename_"] = _IMP_em2d.SpiderImageReaderWriter_filename__set
1295 __swig_getmethods__[
"filename_"] = _IMP_em2d.SpiderImageReaderWriter_filename__get
1296 if _newclass:filename_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_filename__get, _IMP_em2d.SpiderImageReaderWriter_filename__set)
1297 __swig_setmethods__[
"skip_type_check_"] = _IMP_em2d.SpiderImageReaderWriter_skip_type_check__set
1298 __swig_getmethods__[
"skip_type_check_"] = _IMP_em2d.SpiderImageReaderWriter_skip_type_check__get
1299 if _newclass:skip_type_check_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_skip_type_check__get, _IMP_em2d.SpiderImageReaderWriter_skip_type_check__set)
1300 __swig_setmethods__[
"force_reversed_"] = _IMP_em2d.SpiderImageReaderWriter_force_reversed__set
1301 __swig_getmethods__[
"force_reversed_"] = _IMP_em2d.SpiderImageReaderWriter_force_reversed__get
1302 if _newclass:force_reversed_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_force_reversed__get, _IMP_em2d.SpiderImageReaderWriter_force_reversed__set)
1303 __swig_setmethods__[
"skip_extra_checkings_"] = _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__set
1304 __swig_getmethods__[
"skip_extra_checkings_"] = _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__get
1305 if _newclass:skip_extra_checkings_ = _swig_property(_IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__get, _IMP_em2d.SpiderImageReaderWriter_skip_extra_checkings__set)
1306 def __init__(self, *args):
1308 __init__(IMP::em2d::SpiderImageReaderWriter self) -> SpiderImageReaderWriter
1309 __init__(IMP::em2d::SpiderImageReaderWriter self, IMP::String const & filename, bool skip_type_check, bool force_reversed, bool skip_extra_checkings) -> SpiderImageReaderWriter
1311 this = _IMP_em2d.new_SpiderImageReaderWriter(*args)
1312 try: self.this.append(this)
1313 except: self.this = this
1314 __swig_destroy__ = _IMP_em2d.delete_SpiderImageReaderWriter
1315 __del__ =
lambda self :
None;
1317 """__str__(SpiderImageReaderWriter self) -> std::string"""
1318 return _IMP_em2d.SpiderImageReaderWriter___str__(self)
1321 """__repr__(SpiderImageReaderWriter self) -> std::string"""
1322 return _IMP_em2d.SpiderImageReaderWriter___repr__(self)
1325 return _object_cast_to_SpiderImageReaderWriter(o)
1326 get_from = staticmethod(get_from)
1328 SpiderImageReaderWriter_swigregister = _IMP_em2d.SpiderImageReaderWriter_swigregister
1329 SpiderImageReaderWriter_swigregister(SpiderImageReaderWriter)
1331 class JPGImageReaderWriter(ImageReaderWriter):
1332 """Proxy of C++ IMP::em2d::JPGImageReaderWriter class"""
1333 __swig_setmethods__ = {}
1334 for _s
in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1335 __setattr__ =
lambda self, name, value: _swig_setattr(self, JPGImageReaderWriter, name, value)
1336 __swig_getmethods__ = {}
1337 for _s
in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1338 __getattr__ =
lambda self, name: _swig_getattr(self, JPGImageReaderWriter, name)
1340 """__init__(IMP::em2d::JPGImageReaderWriter self) -> JPGImageReaderWriter"""
1341 this = _IMP_em2d.new_JPGImageReaderWriter()
1342 try: self.this.append(this)
1343 except: self.this = this
1344 __swig_destroy__ = _IMP_em2d.delete_JPGImageReaderWriter
1345 __del__ =
lambda self :
None;
1347 """__str__(JPGImageReaderWriter self) -> std::string"""
1348 return _IMP_em2d.JPGImageReaderWriter___str__(self)
1351 """__repr__(JPGImageReaderWriter self) -> std::string"""
1352 return _IMP_em2d.JPGImageReaderWriter___repr__(self)
1355 return _object_cast_to_JPGImageReaderWriter(o)
1356 get_from = staticmethod(get_from)
1358 JPGImageReaderWriter_swigregister = _IMP_em2d.JPGImageReaderWriter_swigregister
1359 JPGImageReaderWriter_swigregister(JPGImageReaderWriter)
1361 class TIFFImageReaderWriter(ImageReaderWriter):
1362 """Proxy of C++ IMP::em2d::TIFFImageReaderWriter class"""
1363 __swig_setmethods__ = {}
1364 for _s
in [ImageReaderWriter]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1365 __setattr__ =
lambda self, name, value: _swig_setattr(self, TIFFImageReaderWriter, name, value)
1366 __swig_getmethods__ = {}
1367 for _s
in [ImageReaderWriter]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1368 __getattr__ =
lambda self, name: _swig_getattr(self, TIFFImageReaderWriter, name)
1370 """__init__(IMP::em2d::TIFFImageReaderWriter self) -> TIFFImageReaderWriter"""
1371 this = _IMP_em2d.new_TIFFImageReaderWriter()
1372 try: self.this.append(this)
1373 except: self.this = this
1374 __swig_destroy__ = _IMP_em2d.delete_TIFFImageReaderWriter
1375 __del__ =
lambda self :
None;
1377 """__str__(TIFFImageReaderWriter self) -> std::string"""
1378 return _IMP_em2d.TIFFImageReaderWriter___str__(self)
1381 """__repr__(TIFFImageReaderWriter self) -> std::string"""
1382 return _IMP_em2d.TIFFImageReaderWriter___repr__(self)
1385 return _object_cast_to_TIFFImageReaderWriter(o)
1386 get_from = staticmethod(get_from)
1388 TIFFImageReaderWriter_swigregister = _IMP_em2d.TIFFImageReaderWriter_swigregister
1389 TIFFImageReaderWriter_swigregister(TIFFImageReaderWriter)
1393 """do_matrix_to_image_flip(cv::Mat & m)"""
1394 return _IMP_em2d.do_matrix_to_image_flip(*args)
1397 """get_autocorrelation2d_no_preprocessing(cv::Mat const & M, cv::Mat & corr)"""
1398 return _IMP_em2d.get_autocorrelation2d_no_preprocessing(*args)
1402 get_autocorrelation2d(Image im1, Image im2)
1403 get_autocorrelation2d(cv::Mat const & m, cv::Mat & corr)
1405 return _IMP_em2d.get_autocorrelation2d(*args)
1409 get_correlation2d(Image im1, Image im2, Image corr)
1410 get_correlation2d(cv::Mat const & A, cv::Mat const & B, cv::Mat & corr)
1412 return _IMP_em2d.get_correlation2d(*args)
1415 """get_correlation2d_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2, cv::Mat & corr)"""
1416 return _IMP_em2d.get_correlation2d_no_preprocessing(*args)
1419 """get_fft_using_optimal_size(cv::Mat const & m, cv::Mat & M)"""
1420 return _IMP_em2d.get_fft_using_optimal_size(*args)
1423 """get_spectrum(cv::Mat const & m, cv::Mat & real, cv::Mat & imag)"""
1424 return _IMP_em2d.get_spectrum(*args)
1427 """get_rotation_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
1428 return _IMP_em2d.get_rotation_error(*args)
1431 """get_shift_error(RegistrationResult rr1, RegistrationResult rr2) -> double"""
1432 return _IMP_em2d.get_shift_error(*args)
1434 def get_average_rotation_error(*args):
1435 """get_average_rotation_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
1436 return _IMP_em2d.get_average_rotation_error(*args)
1438 def get_average_shift_error(*args):
1439 """get_average_shift_error(IMP::em2d::RegistrationResults const & correct_RRs, IMP::em2d::RegistrationResults const & computed_RRs) -> double"""
1440 return _IMP_em2d.get_average_shift_error(*args)
1444 get_cross_correlation_coefficient(Image im1, Image im2) -> double
1445 get_cross_correlation_coefficient(cv::Mat const & m1, cv::Mat const & m2) -> double
1447 return _IMP_em2d.get_cross_correlation_coefficient(*args)
1450 """get_global_score(IMP::em2d::RegistrationResults const & RRs) -> double"""
1451 return _IMP_em2d.get_global_score(*args)
1453 """Proxy of C++ IMP::em2d::ScoreFunction class"""
1454 __swig_setmethods__ = {}
1455 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1456 __setattr__ =
lambda self, name, value: _swig_setattr(self, ScoreFunction, name, value)
1457 __swig_getmethods__ = {}
1458 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1459 __getattr__ =
lambda self, name: _swig_getattr(self, ScoreFunction, name)
1460 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined - class is abstract")
1461 def get_score(self, *args):
1462 """get_score(ScoreFunction self, Image image, Image projection) -> double"""
1463 return _IMP_em2d.ScoreFunction_get_score(self, *args)
1465 def set_variance_image(self, *args):
1466 """set_variance_image(ScoreFunction self, Image var)"""
1467 return _IMP_em2d.ScoreFunction_set_variance_image(self, *args)
1469 def get_version_info(self):
1470 """get_version_info(ScoreFunction self) -> VersionInfo"""
1471 return _IMP_em2d.ScoreFunction_get_version_info(self)
1473 __swig_destroy__ = _IMP_em2d.delete_ScoreFunction
1474 __del__ =
lambda self :
None;
1476 """__str__(ScoreFunction self) -> std::string"""
1477 return _IMP_em2d.ScoreFunction___str__(self)
1480 """__repr__(ScoreFunction self) -> std::string"""
1481 return _IMP_em2d.ScoreFunction___repr__(self)
1484 return _object_cast_to_ScoreFunction(o)
1485 get_from = staticmethod(get_from)
1487 ScoreFunction_swigregister = _IMP_em2d.ScoreFunction_swigregister
1488 ScoreFunction_swigregister(ScoreFunction)
1490 class ChiSquaredScore(ScoreFunction):
1491 """Proxy of C++ IMP::em2d::ChiSquaredScore class"""
1492 __swig_setmethods__ = {}
1493 for _s
in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1494 __setattr__ =
lambda self, name, value: _swig_setattr(self, ChiSquaredScore, name, value)
1495 __swig_getmethods__ = {}
1496 for _s
in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1497 __getattr__ =
lambda self, name: _swig_getattr(self, ChiSquaredScore, name)
1499 """__init__(IMP::em2d::ChiSquaredScore self) -> ChiSquaredScore"""
1500 this = _IMP_em2d.new_ChiSquaredScore()
1501 try: self.this.append(this)
1502 except: self.this = this
1504 """__str__(ChiSquaredScore self) -> std::string"""
1505 return _IMP_em2d.ChiSquaredScore___str__(self)
1508 """__repr__(ChiSquaredScore self) -> std::string"""
1509 return _IMP_em2d.ChiSquaredScore___repr__(self)
1512 return _object_cast_to_ChiSquaredScore(o)
1513 get_from = staticmethod(get_from)
1515 __swig_destroy__ = _IMP_em2d.delete_ChiSquaredScore
1516 __del__ =
lambda self :
None;
1517 ChiSquaredScore_swigregister = _IMP_em2d.ChiSquaredScore_swigregister
1518 ChiSquaredScore_swigregister(ChiSquaredScore)
1520 class EM2DScore(ScoreFunction):
1521 """Proxy of C++ IMP::em2d::EM2DScore class"""
1522 __swig_setmethods__ = {}
1523 for _s
in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1524 __setattr__ =
lambda self, name, value: _swig_setattr(self, EM2DScore, name, value)
1525 __swig_getmethods__ = {}
1526 for _s
in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1527 __getattr__ =
lambda self, name: _swig_getattr(self, EM2DScore, name)
1529 """__init__(IMP::em2d::EM2DScore self) -> EM2DScore"""
1530 this = _IMP_em2d.new_EM2DScore()
1531 try: self.this.append(this)
1532 except: self.this = this
1534 """__str__(EM2DScore self) -> std::string"""
1535 return _IMP_em2d.EM2DScore___str__(self)
1538 """__repr__(EM2DScore self) -> std::string"""
1539 return _IMP_em2d.EM2DScore___repr__(self)
1542 return _object_cast_to_EM2DScore(o)
1543 get_from = staticmethod(get_from)
1545 __swig_destroy__ = _IMP_em2d.delete_EM2DScore
1546 __del__ =
lambda self :
None;
1547 EM2DScore_swigregister = _IMP_em2d.EM2DScore_swigregister
1548 EM2DScore_swigregister(EM2DScore)
1550 class MeanAbsoluteDifference(ScoreFunction):
1551 """Proxy of C++ IMP::em2d::MeanAbsoluteDifference class"""
1552 __swig_setmethods__ = {}
1553 for _s
in [ScoreFunction]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1554 __setattr__ =
lambda self, name, value: _swig_setattr(self, MeanAbsoluteDifference, name, value)
1555 __swig_getmethods__ = {}
1556 for _s
in [ScoreFunction]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1557 __getattr__ =
lambda self, name: _swig_getattr(self, MeanAbsoluteDifference, name)
1559 """__init__(IMP::em2d::MeanAbsoluteDifference self) -> MeanAbsoluteDifference"""
1560 this = _IMP_em2d.new_MeanAbsoluteDifference()
1561 try: self.this.append(this)
1562 except: self.this = this
1564 """__str__(MeanAbsoluteDifference self) -> std::string"""
1565 return _IMP_em2d.MeanAbsoluteDifference___str__(self)
1568 """__repr__(MeanAbsoluteDifference self) -> std::string"""
1569 return _IMP_em2d.MeanAbsoluteDifference___repr__(self)
1572 return _object_cast_to_MeanAbsoluteDifference(o)
1573 get_from = staticmethod(get_from)
1575 __swig_destroy__ = _IMP_em2d.delete_MeanAbsoluteDifference
1576 __del__ =
lambda self :
None;
1577 MeanAbsoluteDifference_swigregister = _IMP_em2d.MeanAbsoluteDifference_swigregister
1578 MeanAbsoluteDifference_swigregister(MeanAbsoluteDifference)
1582 """read_selection_file(IMP::String fn) -> IMP::Strings"""
1583 return _IMP_em2d.read_selection_file(*args)
1586 """create_filenames(unsigned long number, IMP::String basic_name, IMP::String extension) -> IMP::Strings"""
1587 return _IMP_em2d.create_filenames(*args)
1589 """Proxy of C++ IMP::em2d::ProjectionParameters class"""
1590 __swig_setmethods__ = {}
1591 for _s
in [
IMP.kernel.Decorator]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
1592 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionParameters, name, value)
1593 __swig_getmethods__ = {}
1594 for _s
in [
IMP.kernel.Decorator]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
1595 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionParameters, name)
1596 def __init__(self, *args):
1598 __init__(IMP::em2d::ProjectionParameters self) -> ProjectionParameters
1599 __init__(IMP::em2d::ProjectionParameters self, Model m, IMP::kernel::ParticleIndex id) -> ProjectionParameters
1600 __init__(IMP::em2d::ProjectionParameters self, Particle p) -> ProjectionParameters
1602 this = _IMP_em2d.new_ProjectionParameters(*args)
1603 try: self.this.append(this)
1604 except: self.this = this
1605 def decorate_particle(*args):
1606 """decorate_particle(Particle p) -> ProjectionParameters"""
1607 return _IMP_em2d.ProjectionParameters_decorate_particle(*args)
1609 if _newclass:decorate_particle = staticmethod(decorate_particle)
1610 __swig_getmethods__[
"decorate_particle"] =
lambda x: decorate_particle
1611 def show(self, *args):
1613 show(ProjectionParameters self, _ostream out=std::cout)
1614 show(ProjectionParameters self)
1616 return _IMP_em2d.ProjectionParameters_show(self, *args)
1618 __swig_destroy__ = _IMP_em2d.delete_ProjectionParameters
1619 __del__ =
lambda self :
None;
1621 """get_keys() -> IMP::kernel::FloatKeys const &"""
1622 return _IMP_em2d.ProjectionParameters_get_keys()
1624 if _newclass:get_keys = staticmethod(get_keys)
1625 __swig_getmethods__[
"get_keys"] =
lambda x: get_keys
1626 def set_proper_ranges_for_keys(self, *args):
1627 """set_proper_ranges_for_keys(ProjectionParameters self, Model m, Vector3D min_translation_values, Vector3D max_translation_values)"""
1628 return _IMP_em2d.ProjectionParameters_set_proper_ranges_for_keys(self, *args)
1630 def setup_particle(*args):
1631 """setup_particle(Particle p) -> ProjectionParameters"""
1632 return _IMP_em2d.ProjectionParameters_setup_particle(*args)
1634 if _newclass:setup_particle = staticmethod(setup_particle)
1635 __swig_getmethods__[
"setup_particle"] =
lambda x: setup_particle
1636 def particle_is_instance(*args):
1637 """particle_is_instance(Particle p) -> bool"""
1638 return _IMP_em2d.ProjectionParameters_particle_is_instance(*args)
1640 if _newclass:particle_is_instance = staticmethod(particle_is_instance)
1641 __swig_getmethods__[
"particle_is_instance"] =
lambda x: particle_is_instance
1642 def get_parameters_optimized(self):
1643 """get_parameters_optimized(ProjectionParameters self) -> bool"""
1644 return _IMP_em2d.ProjectionParameters_get_parameters_optimized(self)
1646 def get_translation(self):
1647 """get_translation(ProjectionParameters self) -> Vector3D"""
1648 return _IMP_em2d.ProjectionParameters_get_translation(self)
1650 def set_translation(self, *args):
1651 """set_translation(ProjectionParameters self, Vector3D v)"""
1652 return _IMP_em2d.ProjectionParameters_set_translation(self, *args)
1654 def get_rotation(self):
1655 """get_rotation(ProjectionParameters self) -> Rotation3D"""
1656 return _IMP_em2d.ProjectionParameters_get_rotation(self)
1658 def set_rotation(self, *args):
1659 """set_rotation(ProjectionParameters self, Rotation3D R)"""
1660 return _IMP_em2d.ProjectionParameters_set_rotation(self, *args)
1662 def set_parameters_optimized(self, *args):
1663 """set_parameters_optimized(ProjectionParameters self, bool tf)"""
1664 return _IMP_em2d.ProjectionParameters_set_parameters_optimized(self, *args)
1666 def get_quaternion_1(self):
1667 """get_quaternion_1(ProjectionParameters self) -> double"""
1668 return _IMP_em2d.ProjectionParameters_get_quaternion_1(self)
1670 def set_quaternion_1(self, *args):
1671 """set_quaternion_1(ProjectionParameters self, double t)"""
1672 return _IMP_em2d.ProjectionParameters_set_quaternion_1(self, *args)
1674 def get_quaternion_2(self):
1675 """get_quaternion_2(ProjectionParameters self) -> double"""
1676 return _IMP_em2d.ProjectionParameters_get_quaternion_2(self)
1678 def set_quaternion_2(self, *args):
1679 """set_quaternion_2(ProjectionParameters self, double t)"""
1680 return _IMP_em2d.ProjectionParameters_set_quaternion_2(self, *args)
1682 def get_quaternion_3(self):
1683 """get_quaternion_3(ProjectionParameters self) -> double"""
1684 return _IMP_em2d.ProjectionParameters_get_quaternion_3(self)
1686 def set_quaternion_3(self, *args):
1687 """set_quaternion_3(ProjectionParameters self, double t)"""
1688 return _IMP_em2d.ProjectionParameters_set_quaternion_3(self, *args)
1690 def get_quaternion_4(self):
1691 """get_quaternion_4(ProjectionParameters self) -> double"""
1692 return _IMP_em2d.ProjectionParameters_get_quaternion_4(self)
1694 def set_quaternion_4(self, *args):
1695 """set_quaternion_4(ProjectionParameters self, double t)"""
1696 return _IMP_em2d.ProjectionParameters_set_quaternion_4(self, *args)
1698 def get_translation_x(self):
1699 """get_translation_x(ProjectionParameters self) -> double"""
1700 return _IMP_em2d.ProjectionParameters_get_translation_x(self)
1702 def set_translation_x(self, *args):
1703 """set_translation_x(ProjectionParameters self, double t)"""
1704 return _IMP_em2d.ProjectionParameters_set_translation_x(self, *args)
1706 def get_translation_y(self):
1707 """get_translation_y(ProjectionParameters self) -> double"""
1708 return _IMP_em2d.ProjectionParameters_get_translation_y(self)
1710 def set_translation_y(self, *args):
1711 """set_translation_y(ProjectionParameters self, double t)"""
1712 return _IMP_em2d.ProjectionParameters_set_translation_y(self, *args)
1714 def add_attribute(self, *args):
1716 add_attribute(ProjectionParameters self, FloatKey k, IMP::Float v, bool opt)
1717 add_attribute(ProjectionParameters self, FloatKey a0, IMP::Float a1)
1718 add_attribute(ProjectionParameters self, IntKey a0, IMP::Int a1)
1719 add_attribute(ProjectionParameters self, StringKey a0, IMP::String a1)
1720 add_attribute(ProjectionParameters self, ParticleIndexKey a0, Particle a1)
1721 add_attribute(ProjectionParameters self, ObjectKey a0, IMP::Object * a1)
1723 return _IMP_em2d.ProjectionParameters_add_attribute(self, *args)
1725 def get_value(self, *args):
1727 get_value(ProjectionParameters self, FloatKey a0) -> IMP::Float
1728 get_value(ProjectionParameters self, IntKey a0) -> IMP::Int
1729 get_value(ProjectionParameters self, StringKey a0) -> IMP::String
1730 get_value(ProjectionParameters self, ParticleIndexKey a0) -> Particle
1731 get_value(ProjectionParameters self, ObjectKey a0) -> IMP::Object *
1733 return _IMP_em2d.ProjectionParameters_get_value(self, *args)
1735 def set_value(self, *args):
1737 set_value(ProjectionParameters self, FloatKey a0, IMP::Float a1)
1738 set_value(ProjectionParameters self, IntKey a0, IMP::Int a1)
1739 set_value(ProjectionParameters self, StringKey a0, IMP::String a1)
1740 set_value(ProjectionParameters self, ParticleIndexKey a0, Particle a1)
1741 set_value(ProjectionParameters self, ObjectKey a0, IMP::Object * a1)
1743 return _IMP_em2d.ProjectionParameters_set_value(self, *args)
1745 def remove_attribute(self, *args):
1747 remove_attribute(ProjectionParameters self, FloatKey a0)
1748 remove_attribute(ProjectionParameters self, IntKey a0)
1749 remove_attribute(ProjectionParameters self, StringKey a0)
1750 remove_attribute(ProjectionParameters self, ParticleIndexKey a0)
1751 remove_attribute(ProjectionParameters self, ObjectKey a0)
1753 return _IMP_em2d.ProjectionParameters_remove_attribute(self, *args)
1755 def has_attribute(self, *args):
1757 has_attribute(ProjectionParameters self, FloatKey a0) -> bool
1758 has_attribute(ProjectionParameters self, IntKey a0) -> bool
1759 has_attribute(ProjectionParameters self, StringKey a0) -> bool
1760 has_attribute(ProjectionParameters self, ParticleIndexKey a0) -> bool
1761 has_attribute(ProjectionParameters self, ObjectKey a0) -> bool
1763 return _IMP_em2d.ProjectionParameters_has_attribute(self, *args)
1765 def get_derivative(self, *args):
1766 """get_derivative(ProjectionParameters self, FloatKey a0) -> double"""
1767 return _IMP_em2d.ProjectionParameters_get_derivative(self, *args)
1770 """get_name(ProjectionParameters self) -> std::string"""
1771 return _IMP_em2d.ProjectionParameters_get_name(self)
1773 def clear_caches(self):
1774 """clear_caches(ProjectionParameters self)"""
1775 return _IMP_em2d.ProjectionParameters_clear_caches(self)
1777 def set_name(self, *args):
1778 """set_name(ProjectionParameters self, std::string a0)"""
1779 return _IMP_em2d.ProjectionParameters_set_name(self, *args)
1782 """set_check_level(ProjectionParameters self, IMP::base::CheckLevel a0)"""
1783 return _IMP_em2d.ProjectionParameters_set_check_level(self, *args)
1785 def add_to_derivative(self, *args):
1786 """add_to_derivative(ProjectionParameters self, FloatKey a0, double a1, DerivativeAccumulator a2)"""
1787 return _IMP_em2d.ProjectionParameters_add_to_derivative(self, *args)
1789 def set_is_optimized(self, *args):
1790 """set_is_optimized(ProjectionParameters self, FloatKey a0, bool a1)"""
1791 return _IMP_em2d.ProjectionParameters_set_is_optimized(self, *args)
1793 def get_is_optimized(self, *args):
1794 """get_is_optimized(ProjectionParameters self, FloatKey a0) -> bool"""
1795 return _IMP_em2d.ProjectionParameters_get_is_optimized(self, *args)
1798 """get_check_level(ProjectionParameters self) -> IMP::base::CheckLevel"""
1799 return _IMP_em2d.ProjectionParameters_get_check_level(self)
1801 def __eq__(self, *args):
1803 __eq__(ProjectionParameters self, ProjectionParameters o) -> bool
1804 __eq__(ProjectionParameters self, Particle d) -> bool
1806 return _IMP_em2d.ProjectionParameters___eq__(self, *args)
1808 def __ne__(self, *args):
1810 __ne__(ProjectionParameters self, ProjectionParameters o) -> bool
1811 __ne__(ProjectionParameters self, Particle d) -> bool
1813 return _IMP_em2d.ProjectionParameters___ne__(self, *args)
1815 def __le__(self, *args):
1817 __le__(ProjectionParameters self, ProjectionParameters o) -> bool
1818 __le__(ProjectionParameters self, Particle d) -> bool
1820 return _IMP_em2d.ProjectionParameters___le__(self, *args)
1822 def __lt__(self, *args):
1824 __lt__(ProjectionParameters self, ProjectionParameters o) -> bool
1825 __lt__(ProjectionParameters self, Particle d) -> bool
1827 return _IMP_em2d.ProjectionParameters___lt__(self, *args)
1829 def __ge__(self, *args):
1831 __ge__(ProjectionParameters self, ProjectionParameters o) -> bool
1832 __ge__(ProjectionParameters self, Particle d) -> bool
1834 return _IMP_em2d.ProjectionParameters___ge__(self, *args)
1836 def __gt__(self, *args):
1838 __gt__(ProjectionParameters self, ProjectionParameters o) -> bool
1839 __gt__(ProjectionParameters self, Particle d) -> bool
1841 return _IMP_em2d.ProjectionParameters___gt__(self, *args)
1844 """__str__(ProjectionParameters self) -> std::string"""
1845 return _IMP_em2d.ProjectionParameters___str__(self)
1848 """__repr__(ProjectionParameters self) -> std::string"""
1849 return _IMP_em2d.ProjectionParameters___repr__(self)
1851 ProjectionParameters_swigregister = _IMP_em2d.ProjectionParameters_swigregister
1852 ProjectionParameters_swigregister(ProjectionParameters)
1854 def ProjectionParameters_decorate_particle(*args):
1855 """ProjectionParameters_decorate_particle(Particle p) -> ProjectionParameters"""
1856 return _IMP_em2d.ProjectionParameters_decorate_particle(*args)
1858 def ProjectionParameters_get_keys():
1859 """ProjectionParameters_get_keys() -> IMP::kernel::FloatKeys const &"""
1860 return _IMP_em2d.ProjectionParameters_get_keys()
1862 def ProjectionParameters_setup_particle(*args):
1863 """ProjectionParameters_setup_particle(Particle p) -> ProjectionParameters"""
1864 return _IMP_em2d.ProjectionParameters_setup_particle(*args)
1866 def ProjectionParameters_particle_is_instance(*args):
1867 """ProjectionParameters_particle_is_instance(Particle p) -> bool"""
1868 return _IMP_em2d.ProjectionParameters_particle_is_instance(*args)
1871 def __lshift__(*args):
1872 """__lshift__(_ostream out, ProjectionParameters n) -> _ostream"""
1873 return _IMP_em2d.__lshift__(*args)
1875 """Proxy of C++ IMP::em2d::ProjectionParametersScoreState class"""
1876 __swig_setmethods__ = {}
1878 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionParametersScoreState, name, value)
1879 __swig_getmethods__ = {}
1881 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionParametersScoreState, name)
1882 def __init__(self, *args):
1883 """__init__(IMP::em2d::ProjectionParametersScoreState self, Particle p) -> ProjectionParametersScoreState"""
1884 this = _IMP_em2d.new_ProjectionParametersScoreState(*args)
1885 try: self.this.append(this)
1886 except: self.this = this
1888 """get_input_particles(ProjectionParametersScoreState self) -> IMP::kernel::ParticlesTemp"""
1889 return _IMP_em2d.ProjectionParametersScoreState_get_input_particles(self)
1892 """get_input_containers(ProjectionParametersScoreState self) -> IMP::kernel::ContainersTemp"""
1893 return _IMP_em2d.ProjectionParametersScoreState_get_input_containers(self)
1895 def do_get_inputs(self):
1896 """do_get_inputs(ProjectionParametersScoreState self) -> IMP::kernel::ModelObjectsTemp"""
1897 return _IMP_em2d.ProjectionParametersScoreState_do_get_inputs(self)
1900 """get_output_particles(ProjectionParametersScoreState self) -> IMP::kernel::ParticlesTemp"""
1901 return _IMP_em2d.ProjectionParametersScoreState_get_output_particles(self)
1904 """get_output_containers(ProjectionParametersScoreState self) -> IMP::kernel::ContainersTemp"""
1905 return _IMP_em2d.ProjectionParametersScoreState_get_output_containers(self)
1907 def do_get_outputs(self):
1908 """do_get_outputs(ProjectionParametersScoreState self) -> IMP::kernel::ModelObjectsTemp"""
1909 return _IMP_em2d.ProjectionParametersScoreState_do_get_outputs(self)
1911 def get_version_info(self):
1912 """get_version_info(ProjectionParametersScoreState self) -> VersionInfo"""
1913 return _IMP_em2d.ProjectionParametersScoreState_get_version_info(self)
1915 def do_show(self, *args):
1916 """do_show(ProjectionParametersScoreState self, _ostream out)"""
1917 return _IMP_em2d.ProjectionParametersScoreState_do_show(self, *args)
1919 __swig_destroy__ = _IMP_em2d.delete_ProjectionParametersScoreState
1920 __del__ =
lambda self :
None;
1922 """__str__(ProjectionParametersScoreState self) -> std::string"""
1923 return _IMP_em2d.ProjectionParametersScoreState___str__(self)
1926 """__repr__(ProjectionParametersScoreState self) -> std::string"""
1927 return _IMP_em2d.ProjectionParametersScoreState___repr__(self)
1930 return _object_cast_to_ProjectionParametersScoreState(o)
1931 get_from = staticmethod(get_from)
1933 ProjectionParametersScoreState_swigregister = _IMP_em2d.ProjectionParametersScoreState_swigregister
1934 ProjectionParametersScoreState_swigregister(ProjectionParametersScoreState)
1936 class ProjectionMask(_object):
1937 """Proxy of C++ IMP::em2d::ProjectionMask class"""
1938 __swig_setmethods__ = {}
1939 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionMask, name, value)
1940 __swig_getmethods__ = {}
1941 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionMask, name)
1942 def __init__(self, *args, **kwargs):
raise AttributeError(
"No constructor defined")
1943 def apply(self, *args):
1944 """apply(ProjectionMask self, cv::Mat & m, Vector2D v)"""
1945 return _IMP_em2d.ProjectionMask_apply(self, *args)
1947 def show(self, *args):
1949 show(ProjectionMask self, _ostream out=std::cout)
1950 show(ProjectionMask self)
1952 return _IMP_em2d.ProjectionMask_show(self, *args)
1954 __swig_destroy__ = _IMP_em2d.delete_ProjectionMask
1955 __del__ =
lambda self :
None;
1957 """__str__(ProjectionMask self) -> std::string"""
1958 return _IMP_em2d.ProjectionMask___str__(self)
1961 """__repr__(ProjectionMask self) -> std::string"""
1962 return _IMP_em2d.ProjectionMask___repr__(self)
1964 ProjectionMask_swigregister = _IMP_em2d.ProjectionMask_swigregister
1965 ProjectionMask_swigregister(ProjectionMask)
1969 """do_place(cv::Mat & mask, cv::Mat & m, Vector2D v)"""
1970 return _IMP_em2d.do_place(*args)
1971 class MasksManager(_object):
1972 """Proxy of C++ IMP::em2d::MasksManager class"""
1973 __swig_setmethods__ = {}
1974 __setattr__ =
lambda self, name, value: _swig_setattr(self, MasksManager, name, value)
1975 __swig_getmethods__ = {}
1976 __getattr__ =
lambda self, name: _swig_getattr(self, MasksManager, name)
1977 def __init__(self, *args):
1979 __init__(IMP::em2d::MasksManager self) -> MasksManager
1980 __init__(IMP::em2d::MasksManager self, double resolution, double pixelsize) -> MasksManager
1982 this = _IMP_em2d.new_MasksManager(*args)
1983 try: self.this.append(this)
1984 except: self.this = this
1985 def setup_kernel(self, *args):
1986 """setup_kernel(MasksManager self, double resolution, double pixelsize)"""
1987 return _IMP_em2d.MasksManager_setup_kernel(self, *args)
1989 def create_masks(self, *args):
1990 """create_masks(MasksManager self, IMP::kernel::ParticlesTemp const & ps)"""
1991 return _IMP_em2d.MasksManager_create_masks(self, *args)
1993 def create_mask(self, *args):
1994 """create_mask(MasksManager self, double radius, double mass)"""
1995 return _IMP_em2d.MasksManager_create_mask(self, *args)
1997 def find_mask(self, *args):
1998 """find_mask(MasksManager self, double radius) -> IMP::em2d::ProjectionMaskPtr"""
1999 return _IMP_em2d.MasksManager_find_mask(self, *args)
2001 def show(self, *args):
2003 show(MasksManager self, _ostream out=std::cout)
2004 show(MasksManager self)
2006 return _IMP_em2d.MasksManager_show(self, *args)
2008 def get_number_of_masks(self):
2009 """get_number_of_masks(MasksManager self) -> unsigned int"""
2010 return _IMP_em2d.MasksManager_get_number_of_masks(self)
2012 __swig_destroy__ = _IMP_em2d.delete_MasksManager
2013 __del__ =
lambda self :
None;
2015 """__str__(MasksManager self) -> std::string"""
2016 return _IMP_em2d.MasksManager___str__(self)
2019 """__repr__(MasksManager self) -> std::string"""
2020 return _IMP_em2d.MasksManager___repr__(self)
2022 MasksManager_swigregister = _IMP_em2d.MasksManager_swigregister
2023 MasksManager_swigregister(MasksManager)
2025 class ProjectingParameters(_object):
2026 """Proxy of C++ IMP::em2d::ProjectingParameters class"""
2027 __swig_setmethods__ = {}
2028 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectingParameters, name, value)
2029 __swig_getmethods__ = {}
2030 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectingParameters, name)
2031 __swig_setmethods__[
"pixel_size"] = _IMP_em2d.ProjectingParameters_pixel_size_set
2032 __swig_getmethods__[
"pixel_size"] = _IMP_em2d.ProjectingParameters_pixel_size_get
2033 if _newclass:pixel_size = _swig_property(_IMP_em2d.ProjectingParameters_pixel_size_get, _IMP_em2d.ProjectingParameters_pixel_size_set)
2034 __swig_setmethods__[
"resolution"] = _IMP_em2d.ProjectingParameters_resolution_set
2035 __swig_getmethods__[
"resolution"] = _IMP_em2d.ProjectingParameters_resolution_get
2036 if _newclass:resolution = _swig_property(_IMP_em2d.ProjectingParameters_resolution_get, _IMP_em2d.ProjectingParameters_resolution_set)
2037 def __init__(self, *args):
2039 __init__(IMP::em2d::ProjectingParameters self) -> ProjectingParameters
2040 __init__(IMP::em2d::ProjectingParameters self, double ps, double res) -> ProjectingParameters
2042 this = _IMP_em2d.new_ProjectingParameters(*args)
2043 try: self.this.append(this)
2044 except: self.this = this
2045 def show(self, *args):
2047 show(ProjectingParameters self, _ostream out=std::cout)
2048 show(ProjectingParameters self)
2050 return _IMP_em2d.ProjectingParameters_show(self, *args)
2053 """__str__(ProjectingParameters self) -> std::string"""
2054 return _IMP_em2d.ProjectingParameters___str__(self)
2057 """__repr__(ProjectingParameters self) -> std::string"""
2058 return _IMP_em2d.ProjectingParameters___repr__(self)
2060 __swig_destroy__ = _IMP_em2d.delete_ProjectingParameters
2061 __del__ =
lambda self :
None;
2062 ProjectingParameters_swigregister = _IMP_em2d.ProjectingParameters_swigregister
2063 ProjectingParameters_swigregister(ProjectingParameters)
2065 class ProjectingOptions(ProjectingParameters):
2066 """Proxy of C++ IMP::em2d::ProjectingOptions class"""
2067 __swig_setmethods__ = {}
2068 for _s
in [ProjectingParameters]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2069 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectingOptions, name, value)
2070 __swig_getmethods__ = {}
2071 for _s
in [ProjectingParameters]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2072 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectingOptions, name)
2073 __swig_setmethods__[
"save_images"] = _IMP_em2d.ProjectingOptions_save_images_set
2074 __swig_getmethods__[
"save_images"] = _IMP_em2d.ProjectingOptions_save_images_get
2075 if _newclass:save_images = _swig_property(_IMP_em2d.ProjectingOptions_save_images_get, _IMP_em2d.ProjectingOptions_save_images_set)
2076 __swig_setmethods__[
"normalize"] = _IMP_em2d.ProjectingOptions_normalize_set
2077 __swig_getmethods__[
"normalize"] = _IMP_em2d.ProjectingOptions_normalize_get
2078 if _newclass:normalize = _swig_property(_IMP_em2d.ProjectingOptions_normalize_get, _IMP_em2d.ProjectingOptions_normalize_set)
2079 __swig_setmethods__[
"clear_matrix_before_projecting"] = _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_set
2080 __swig_getmethods__[
"clear_matrix_before_projecting"] = _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_get
2081 if _newclass:clear_matrix_before_projecting = _swig_property(_IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_get, _IMP_em2d.ProjectingOptions_clear_matrix_before_projecting_set)
2082 def __init__(self, *args):
2084 __init__(IMP::em2d::ProjectingOptions self) -> ProjectingOptions
2085 __init__(IMP::em2d::ProjectingOptions self, double ps, double res) -> ProjectingOptions
2086 __init__(IMP::em2d::ProjectingOptions self, double ps, double res, ImageReaderWriter irw) -> ProjectingOptions
2088 this = _IMP_em2d.new_ProjectingOptions(*args)
2089 try: self.this.append(this)
2090 except: self.this = this
2091 def show(self, *args):
2093 show(ProjectingOptions self, _ostream out=std::cout)
2094 show(ProjectingOptions self)
2096 return _IMP_em2d.ProjectingOptions_show(self, *args)
2099 """__str__(ProjectingOptions self) -> std::string"""
2100 return _IMP_em2d.ProjectingOptions___str__(self)
2103 """__repr__(ProjectingOptions self) -> std::string"""
2104 return _IMP_em2d.ProjectingOptions___repr__(self)
2106 __swig_destroy__ = _IMP_em2d.delete_ProjectingOptions
2107 __del__ =
lambda self :
None;
2108 ProjectingOptions_swigregister = _IMP_em2d.ProjectingOptions_swigregister
2109 ProjectingOptions_swigregister(ProjectingOptions)
2114 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::algebra::SphericalVector3Ds const & vs,
2115 int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
2116 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::algebra::SphericalVector3Ds const & vs,
2117 int rows, int cols, ProjectingOptions options) -> IMP::em2d::Images
2118 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::em2d::RegistrationResults const & registration_values,
2119 int rows, int cols, ProjectingOptions options, IMP::Strings names=IMP::Strings()) -> IMP::em2d::Images
2120 get_projections(IMP::kernel::ParticlesTemp const & ps, IMP::em2d::RegistrationResults const & registration_values,
2121 int rows, int cols, ProjectingOptions options) -> IMP::em2d::Images
2123 return _IMP_em2d.get_projections(*args)
2127 get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options,
2128 IMP::em2d::MasksManagerPtr masks=IMP::em2d::MasksManagerPtr(),
2129 IMP::String name="")
2130 get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options,
2131 IMP::em2d::MasksManagerPtr masks=IMP::em2d::MasksManagerPtr())
2132 get_projection(Image img, IMP::kernel::ParticlesTemp const & ps, RegistrationResult reg, ProjectingOptions options)
2134 return _IMP_em2d.get_projection(*args)
2138 do_project_particles(IMP::kernel::ParticlesTemp const & ps, cv::Mat & m2, Rotation3D R, Vector3D translation,
2139 ProjectingOptions options, IMP::em2d::MasksManagerPtr masks)
2141 return _IMP_em2d.do_project_particles(*args)
2144 """create_evenly_distributed_projections(IMP::kernel::ParticlesTemp const & ps, unsigned int n, ProjectingOptions options) -> IMP::em2d::Images"""
2145 return _IMP_em2d.create_evenly_distributed_projections(*args)
2149 do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation) -> IMP::algebra::Vector2Ds
2150 do_project_vectors(IMP::algebra::Vector3Ds const & ps, Rotation3D R, Vector3D translation, Vector3D center) -> IMP::algebra::Vector2Ds
2152 return _IMP_em2d.do_project_vectors(*args)
2155 """get_enclosing_image_size(IMP::kernel::ParticlesTemp const & ps, double pixel_size, unsigned int slack) -> unsigned int"""
2156 return _IMP_em2d.get_enclosing_image_size(*args)
2160 get_complete_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
2161 get_complete_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
2163 return _IMP_em2d.get_complete_alignment(*args)
2167 get_rotational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
2168 get_rotational_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
2170 return _IMP_em2d.get_rotational_alignment(*args)
2174 get_translational_alignment(cv::Mat const & input, cv::Mat & m_to_align, bool apply=False) -> ResultAlign2D
2175 get_translational_alignment(cv::Mat const & input, cv::Mat & m_to_align) -> ResultAlign2D
2177 return _IMP_em2d.get_translational_alignment(*args)
2181 get_complete_alignment_no_preprocessing(cv::Mat const & input, cv::Mat const & INPUT, cv::Mat const & POLAR1, cv::Mat & m_to_align,
2182 cv::Mat const & POLAR2, bool apply=False) -> ResultAlign2D
2183 get_complete_alignment_no_preprocessing(cv::Mat const & input, cv::Mat const & INPUT, cv::Mat const & POLAR1, cv::Mat & m_to_align,
2184 cv::Mat const & POLAR2) -> ResultAlign2D
2186 return _IMP_em2d.get_complete_alignment_no_preprocessing(*args)
2189 """get_rotational_alignment_no_preprocessing(cv::Mat const & POLAR1, cv::Mat const & POLAR2) -> ResultAlign2D"""
2190 return _IMP_em2d.get_rotational_alignment_no_preprocessing(*args)
2193 """get_translational_alignment_no_preprocessing(cv::Mat const & M1, cv::Mat const & M2) -> ResultAlign2D"""
2194 return _IMP_em2d.get_translational_alignment_no_preprocessing(*args)
2197 """get_complete_alignment_with_centers_no_preprocessing(Vector2D center1, Vector2D center2, cv::Mat const & AUTOC_POLAR1, cv::Mat const & AUTOC_POLAR2) -> ResultAlign2D"""
2198 return _IMP_em2d.get_complete_alignment_with_centers_no_preprocessing(*args)
2202 write_vectors_as_pdb(IMP::algebra::Vector2Ds const vs, IMP::String const filename)
2203 write_vectors_as_pdb(IMP::algebra::Vector3Ds const vs, IMP::String const filename)
2205 return _IMP_em2d.write_vectors_as_pdb(*args)
2206 class Em2DRestraintParameters(ProjectingParameters):
2207 """Proxy of C++ IMP::em2d::Em2DRestraintParameters class"""
2208 __swig_setmethods__ = {}
2209 for _s
in [ProjectingParameters]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2210 __setattr__ =
lambda self, name, value: _swig_setattr(self, Em2DRestraintParameters, name, value)
2211 __swig_getmethods__ = {}
2212 for _s
in [ProjectingParameters]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2213 __getattr__ =
lambda self, name: _swig_getattr(self, Em2DRestraintParameters, name)
2214 __swig_setmethods__[
"n_projections"] = _IMP_em2d.Em2DRestraintParameters_n_projections_set
2215 __swig_getmethods__[
"n_projections"] = _IMP_em2d.Em2DRestraintParameters_n_projections_get
2216 if _newclass:n_projections = _swig_property(_IMP_em2d.Em2DRestraintParameters_n_projections_get, _IMP_em2d.Em2DRestraintParameters_n_projections_set)
2217 __swig_setmethods__[
"coarse_registration_method"] = _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_set
2218 __swig_getmethods__[
"coarse_registration_method"] = _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_get
2219 if _newclass:coarse_registration_method = _swig_property(_IMP_em2d.Em2DRestraintParameters_coarse_registration_method_get, _IMP_em2d.Em2DRestraintParameters_coarse_registration_method_set)
2220 __swig_setmethods__[
"save_match_images"] = _IMP_em2d.Em2DRestraintParameters_save_match_images_set
2221 __swig_getmethods__[
"save_match_images"] = _IMP_em2d.Em2DRestraintParameters_save_match_images_get
2222 if _newclass:save_match_images = _swig_property(_IMP_em2d.Em2DRestraintParameters_save_match_images_get, _IMP_em2d.Em2DRestraintParameters_save_match_images_set)
2223 __swig_setmethods__[
"optimization_steps"] = _IMP_em2d.Em2DRestraintParameters_optimization_steps_set
2224 __swig_getmethods__[
"optimization_steps"] = _IMP_em2d.Em2DRestraintParameters_optimization_steps_get
2225 if _newclass:optimization_steps = _swig_property(_IMP_em2d.Em2DRestraintParameters_optimization_steps_get, _IMP_em2d.Em2DRestraintParameters_optimization_steps_set)
2226 __swig_setmethods__[
"simplex_initial_length"] = _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_set
2227 __swig_getmethods__[
"simplex_initial_length"] = _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_get
2228 if _newclass:simplex_initial_length = _swig_property(_IMP_em2d.Em2DRestraintParameters_simplex_initial_length_get, _IMP_em2d.Em2DRestraintParameters_simplex_initial_length_set)
2229 __swig_setmethods__[
"simplex_minimum_size"] = _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_set
2230 __swig_getmethods__[
"simplex_minimum_size"] = _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_get
2231 if _newclass:simplex_minimum_size = _swig_property(_IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_get, _IMP_em2d.Em2DRestraintParameters_simplex_minimum_size_set)
2232 def __init__(self, *args):
2234 __init__(IMP::em2d::Em2DRestraintParameters self) -> Em2DRestraintParameters
2235 __init__(IMP::em2d::Em2DRestraintParameters self, double ps, double res, unsigned int n_proj=20) -> Em2DRestraintParameters
2236 __init__(IMP::em2d::Em2DRestraintParameters self, double ps, double res) -> Em2DRestraintParameters
2238 this = _IMP_em2d.new_Em2DRestraintParameters(*args)
2239 try: self.this.append(this)
2240 except: self.this = this
2241 def show(self, *args):
2243 show(Em2DRestraintParameters self, _ostream out=std::cout)
2244 show(Em2DRestraintParameters self)
2246 return _IMP_em2d.Em2DRestraintParameters_show(self, *args)
2249 """__str__(Em2DRestraintParameters self) -> std::string"""
2250 return _IMP_em2d.Em2DRestraintParameters___str__(self)
2253 """__repr__(Em2DRestraintParameters self) -> std::string"""
2254 return _IMP_em2d.Em2DRestraintParameters___repr__(self)
2256 __swig_destroy__ = _IMP_em2d.delete_Em2DRestraintParameters
2257 __del__ =
lambda self :
None;
2258 Em2DRestraintParameters_swigregister = _IMP_em2d.Em2DRestraintParameters_swigregister
2259 Em2DRestraintParameters_swigregister(Em2DRestraintParameters)
2260 cvar = _IMP_em2d.cvar
2261 ALIGN2D_NO_PREPROCESSING = cvar.ALIGN2D_NO_PREPROCESSING
2262 ALIGN2D_PREPROCESSING = cvar.ALIGN2D_PREPROCESSING
2263 ALIGN2D_WITH_CENTERS = cvar.ALIGN2D_WITH_CENTERS
2266 """Proxy of C++ IMP::em2d::ProjectionFinder class"""
2267 __swig_setmethods__ = {}
2268 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2269 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionFinder, name, value)
2270 __swig_getmethods__ = {}
2271 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2272 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionFinder, name)
2274 """__init__(IMP::em2d::ProjectionFinder self) -> ProjectionFinder"""
2275 this = _IMP_em2d.new_ProjectionFinder()
2276 try: self.this.append(this)
2277 except: self.this = this
2278 def setup(self, *args):
2279 """setup(ProjectionFinder self, ScoreFunction score_function, Em2DRestraintParameters params)"""
2280 return _IMP_em2d.ProjectionFinder_setup(self, *args)
2282 def set_subjects(self, *args):
2283 """set_subjects(ProjectionFinder self, IMP::em2d::Images const & subjects)"""
2284 return _IMP_em2d.ProjectionFinder_set_subjects(self, *args)
2286 def set_projections(self, *args):
2287 """set_projections(ProjectionFinder self, IMP::em2d::Images const & projections)"""
2288 return _IMP_em2d.ProjectionFinder_set_projections(self, *args)
2290 def set_variance_images(self, *args):
2291 """set_variance_images(ProjectionFinder self, IMP::em2d::Images const & variances)"""
2292 return _IMP_em2d.ProjectionFinder_set_variance_images(self, *args)
2294 def set_model_particles(self, *args):
2295 """set_model_particles(ProjectionFinder self, IMP::kernel::ParticlesTemp const & ps)"""
2296 return _IMP_em2d.ProjectionFinder_set_model_particles(self, *args)
2298 def set_save_match_images(self, *args):
2299 """set_save_match_images(ProjectionFinder self, bool x)"""
2300 return _IMP_em2d.ProjectionFinder_set_save_match_images(self, *args)
2302 def get_save_match_images(self):
2303 """get_save_match_images(ProjectionFinder self) -> bool"""
2304 return _IMP_em2d.ProjectionFinder_get_save_match_images(self)
2306 def set_fast_mode(self, *args):
2307 """set_fast_mode(ProjectionFinder self, unsigned int n)"""
2308 return _IMP_em2d.ProjectionFinder_set_fast_mode(self, *args)
2310 def get_registration_results(self):
2311 """get_registration_results(ProjectionFinder self) -> IMP::em2d::RegistrationResults"""
2312 return _IMP_em2d.ProjectionFinder_get_registration_results(self)
2314 def get_coarse_registration(self):
2315 """get_coarse_registration(ProjectionFinder self)"""
2316 return _IMP_em2d.ProjectionFinder_get_coarse_registration(self)
2318 def get_complete_registration(self):
2319 """get_complete_registration(ProjectionFinder self)"""
2320 return _IMP_em2d.ProjectionFinder_get_complete_registration(self)
2323 """get_global_score(ProjectionFinder self) -> double"""
2324 return _IMP_em2d.ProjectionFinder_get_global_score(self)
2326 def show(self, *args):
2327 """show(ProjectionFinder self, _ostream out)"""
2328 return _IMP_em2d.ProjectionFinder_show(self, *args)
2330 def get_preprocessing_time(self):
2331 """get_preprocessing_time(ProjectionFinder self) -> double"""
2332 return _IMP_em2d.ProjectionFinder_get_preprocessing_time(self)
2334 def get_coarse_registration_time(self):
2335 """get_coarse_registration_time(ProjectionFinder self) -> double"""
2336 return _IMP_em2d.ProjectionFinder_get_coarse_registration_time(self)
2338 def get_fine_registration_time(self):
2339 """get_fine_registration_time(ProjectionFinder self) -> double"""
2340 return _IMP_em2d.ProjectionFinder_get_fine_registration_time(self)
2342 def get_number_of_subjects(self):
2343 """get_number_of_subjects(ProjectionFinder self) -> unsigned int"""
2344 return _IMP_em2d.ProjectionFinder_get_number_of_subjects(self)
2346 def set_number_of_class_averages_members(self, *args):
2347 """set_number_of_class_averages_members(ProjectionFinder self, IMP::Ints n_members)"""
2348 return _IMP_em2d.ProjectionFinder_set_number_of_class_averages_members(self, *args)
2350 def get_number_of_projections(self):
2351 """get_number_of_projections(ProjectionFinder self) -> unsigned int"""
2352 return _IMP_em2d.ProjectionFinder_get_number_of_projections(self)
2354 def get_version_info(self):
2355 """get_version_info(ProjectionFinder self) -> VersionInfo"""
2356 return _IMP_em2d.ProjectionFinder_get_version_info(self)
2358 __swig_destroy__ = _IMP_em2d.delete_ProjectionFinder
2359 __del__ =
lambda self :
None;
2361 """__str__(ProjectionFinder self) -> std::string"""
2362 return _IMP_em2d.ProjectionFinder___str__(self)
2365 """__repr__(ProjectionFinder self) -> std::string"""
2366 return _IMP_em2d.ProjectionFinder___repr__(self)
2369 return _object_cast_to_ProjectionFinder(o)
2370 get_from = staticmethod(get_from)
2372 ProjectionFinder_swigregister = _IMP_em2d.ProjectionFinder_swigregister
2373 ProjectionFinder_swigregister(ProjectionFinder)
2376 """Proxy of C++ IMP::em2d::Em2DRestraint class"""
2377 __swig_setmethods__ = {}
2378 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2379 __setattr__ =
lambda self, name, value: _swig_setattr(self, Em2DRestraint, name, value)
2380 __swig_getmethods__ = {}
2381 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2382 __getattr__ =
lambda self, name: _swig_getattr(self, Em2DRestraint, name)
2384 """__init__(IMP::em2d::Em2DRestraint self) -> Em2DRestraint"""
2385 this = _IMP_em2d.new_Em2DRestraint()
2386 try: self.this.append(this)
2387 except: self.this = this
2388 def setup(self, *args):
2389 """setup(Em2DRestraint self, ScoreFunction score_function, Em2DRestraintParameters params)"""
2390 return _IMP_em2d.Em2DRestraint_setup(self, *args)
2392 def set_particles(self, *args):
2393 """set_particles(Em2DRestraint self, SingletonContainer particles_container)"""
2394 return _IMP_em2d.Em2DRestraint_set_particles(self, *args)
2396 def set_images(self, *args):
2397 """set_images(Em2DRestraint self, IMP::em2d::Images const em_images)"""
2398 return _IMP_em2d.Em2DRestraint_set_images(self, *args)
2400 def set_variance_images(self, *args):
2401 """set_variance_images(Em2DRestraint self, IMP::em2d::Images const variance_images)"""
2402 return _IMP_em2d.Em2DRestraint_set_variance_images(self, *args)
2404 def set_fast_mode(self, *args):
2405 """set_fast_mode(Em2DRestraint self, unsigned int n)"""
2406 return _IMP_em2d.Em2DRestraint_set_fast_mode(self, *args)
2408 def set_coarse_registration_mode(self, *args):
2409 """set_coarse_registration_mode(Em2DRestraint self, bool opt)"""
2410 return _IMP_em2d.Em2DRestraint_set_coarse_registration_mode(self, *args)
2412 def get_registration_results(self):
2413 """get_registration_results(Em2DRestraint self) -> IMP::em2d::RegistrationResults"""
2414 return _IMP_em2d.Em2DRestraint_get_registration_results(self)
2417 """get_input_particles(Em2DRestraint self) -> IMP::kernel::ParticlesTemp"""
2418 return _IMP_em2d.Em2DRestraint_get_input_particles(self)
2421 """get_input_containers(Em2DRestraint self) -> IMP::kernel::ContainersTemp"""
2422 return _IMP_em2d.Em2DRestraint_get_input_containers(self)
2424 def do_get_inputs(self):
2425 """do_get_inputs(Em2DRestraint self) -> IMP::kernel::ModelObjectsTemp"""
2426 return _IMP_em2d.Em2DRestraint_do_get_inputs(self)
2428 def get_version_info(self):
2429 """get_version_info(Em2DRestraint self) -> VersionInfo"""
2430 return _IMP_em2d.Em2DRestraint_get_version_info(self)
2432 def do_show(self, *args):
2433 """do_show(Em2DRestraint self, _ostream out)"""
2434 return _IMP_em2d.Em2DRestraint_do_show(self, *args)
2436 __swig_destroy__ = _IMP_em2d.delete_Em2DRestraint
2437 __del__ =
lambda self :
None;
2439 """__str__(Em2DRestraint self) -> std::string"""
2440 return _IMP_em2d.Em2DRestraint___str__(self)
2443 """__repr__(Em2DRestraint self) -> std::string"""
2444 return _IMP_em2d.Em2DRestraint___repr__(self)
2447 return _object_cast_to_Em2DRestraint(o)
2448 get_from = staticmethod(get_from)
2450 Em2DRestraint_swigregister = _IMP_em2d.Em2DRestraint_swigregister
2451 Em2DRestraint_swigregister(Em2DRestraint)
2453 class ClusterSet(_object):
2454 """Proxy of C++ IMP::em2d::ClusterSet class"""
2455 __swig_setmethods__ = {}
2456 __setattr__ =
lambda self, name, value: _swig_setattr(self, ClusterSet, name, value)
2457 __swig_getmethods__ = {}
2458 __getattr__ =
lambda self, name: _swig_getattr(self, ClusterSet, name)
2459 def __init__(self, *args):
2460 """__init__(IMP::em2d::ClusterSet self, unsigned int N) -> ClusterSet"""
2461 this = _IMP_em2d.new_ClusterSet(*args)
2462 try: self.this.append(this)
2463 except: self.this = this
2464 def do_join_clusters(self, *args):
2465 """do_join_clusters(ClusterSet self, unsigned int cluster_id1, unsigned int cluster_id2, double distance_between_clusters)"""
2466 return _IMP_em2d.ClusterSet_do_join_clusters(self, *args)
2468 def get_cluster_elements(self, *args):
2469 """get_cluster_elements(ClusterSet self, unsigned int id) -> IMP::Ints"""
2470 return _IMP_em2d.ClusterSet_get_cluster_elements(self, *args)
2472 def get_clusters_below_cutoff(self, *args):
2473 """get_clusters_below_cutoff(ClusterSet self, double cutoff) -> IMP::Ints"""
2474 return _IMP_em2d.ClusterSet_get_clusters_below_cutoff(self, *args)
2476 def get_cluster_formed_at_step(self, *args):
2477 """get_cluster_formed_at_step(ClusterSet self, unsigned int step) -> IMP::Ints"""
2478 return _IMP_em2d.ClusterSet_get_cluster_formed_at_step(self, *args)
2480 def get_distance_at_step(self, *args):
2481 """get_distance_at_step(ClusterSet self, unsigned int step) -> double"""
2482 return _IMP_em2d.ClusterSet_get_distance_at_step(self, *args)
2484 def get_id_for_cluster_at_step(self, *args):
2485 """get_id_for_cluster_at_step(ClusterSet self, unsigned int step) -> unsigned int"""
2486 return _IMP_em2d.ClusterSet_get_id_for_cluster_at_step(self, *args)
2488 def get_linkage_matrix(self):
2489 """get_linkage_matrix(ClusterSet self) -> IMP::FloatsList"""
2490 return _IMP_em2d.ClusterSet_get_linkage_matrix(self)
2492 def get_linkage_matrix_in_matlab_format(self):
2493 """get_linkage_matrix_in_matlab_format(ClusterSet self) -> IMP::FloatsList"""
2494 return _IMP_em2d.ClusterSet_get_linkage_matrix_in_matlab_format(self)
2496 def get_number_of_steps(self):
2497 """get_number_of_steps(ClusterSet self) -> unsigned int"""
2498 return _IMP_em2d.ClusterSet_get_number_of_steps(self)
2500 def show(self, *args):
2501 """show(ClusterSet self, _ostream out)"""
2502 return _IMP_em2d.ClusterSet_show(self, *args)
2505 """__str__(ClusterSet self) -> std::string"""
2506 return _IMP_em2d.ClusterSet___str__(self)
2509 """__repr__(ClusterSet self) -> std::string"""
2510 return _IMP_em2d.ClusterSet___repr__(self)
2512 __swig_destroy__ = _IMP_em2d.delete_ClusterSet
2513 __del__ =
lambda self :
None;
2514 ClusterSet_swigregister = _IMP_em2d.ClusterSet_swigregister
2515 ClusterSet_swigregister(ClusterSet)
2517 class SingleLinkage(_object):
2518 """Proxy of C++ IMP::em2d::SingleLinkage class"""
2519 __swig_setmethods__ = {}
2520 __setattr__ =
lambda self, name, value: _swig_setattr(self, SingleLinkage, name, value)
2521 __swig_getmethods__ = {}
2522 __getattr__ =
lambda self, name: _swig_getattr(self, SingleLinkage, name)
2524 """__init__(IMP::em2d::SingleLinkage self) -> SingleLinkage"""
2525 this = _IMP_em2d.new_SingleLinkage()
2526 try: self.this.append(this)
2527 except: self.this = this
2528 def __call__(self, *args):
2529 """__call__(SingleLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2530 return _IMP_em2d.SingleLinkage___call__(self, *args)
2532 def show(self, *args):
2533 """show(SingleLinkage self, _ostream out)"""
2534 return _IMP_em2d.SingleLinkage_show(self, *args)
2537 """__str__(SingleLinkage self) -> std::string"""
2538 return _IMP_em2d.SingleLinkage___str__(self)
2541 """__repr__(SingleLinkage self) -> std::string"""
2542 return _IMP_em2d.SingleLinkage___repr__(self)
2544 __swig_destroy__ = _IMP_em2d.delete_SingleLinkage
2545 __del__ =
lambda self :
None;
2546 SingleLinkage_swigregister = _IMP_em2d.SingleLinkage_swigregister
2547 SingleLinkage_swigregister(SingleLinkage)
2549 class CompleteLinkage(_object):
2550 """Proxy of C++ IMP::em2d::CompleteLinkage class"""
2551 __swig_setmethods__ = {}
2552 __setattr__ =
lambda self, name, value: _swig_setattr(self, CompleteLinkage, name, value)
2553 __swig_getmethods__ = {}
2554 __getattr__ =
lambda self, name: _swig_getattr(self, CompleteLinkage, name)
2556 """__init__(IMP::em2d::CompleteLinkage self) -> CompleteLinkage"""
2557 this = _IMP_em2d.new_CompleteLinkage()
2558 try: self.this.append(this)
2559 except: self.this = this
2560 def __call__(self, *args):
2561 """__call__(CompleteLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2562 return _IMP_em2d.CompleteLinkage___call__(self, *args)
2564 def show(self, *args):
2565 """show(CompleteLinkage self, _ostream out)"""
2566 return _IMP_em2d.CompleteLinkage_show(self, *args)
2569 """__str__(CompleteLinkage self) -> std::string"""
2570 return _IMP_em2d.CompleteLinkage___str__(self)
2573 """__repr__(CompleteLinkage self) -> std::string"""
2574 return _IMP_em2d.CompleteLinkage___repr__(self)
2576 __swig_destroy__ = _IMP_em2d.delete_CompleteLinkage
2577 __del__ =
lambda self :
None;
2578 CompleteLinkage_swigregister = _IMP_em2d.CompleteLinkage_swigregister
2579 CompleteLinkage_swigregister(CompleteLinkage)
2581 class AverageDistanceLinkage(_object):
2582 """Proxy of C++ IMP::em2d::AverageDistanceLinkage class"""
2583 __swig_setmethods__ = {}
2584 __setattr__ =
lambda self, name, value: _swig_setattr(self, AverageDistanceLinkage, name, value)
2585 __swig_getmethods__ = {}
2586 __getattr__ =
lambda self, name: _swig_getattr(self, AverageDistanceLinkage, name)
2588 """__init__(IMP::em2d::AverageDistanceLinkage self) -> AverageDistanceLinkage"""
2589 this = _IMP_em2d.new_AverageDistanceLinkage()
2590 try: self.this.append(this)
2591 except: self.this = this
2592 def __call__(self, *args):
2593 """__call__(AverageDistanceLinkage self, unsigned int id1, unsigned int id2, ClusterSet cluster_set, IMP::FloatsList const & distances) -> double"""
2594 return _IMP_em2d.AverageDistanceLinkage___call__(self, *args)
2596 def show(self, *args):
2597 """show(AverageDistanceLinkage self, _ostream out)"""
2598 return _IMP_em2d.AverageDistanceLinkage_show(self, *args)
2601 """__str__(AverageDistanceLinkage self) -> std::string"""
2602 return _IMP_em2d.AverageDistanceLinkage___str__(self)
2605 """__repr__(AverageDistanceLinkage self) -> std::string"""
2606 return _IMP_em2d.AverageDistanceLinkage___repr__(self)
2608 __swig_destroy__ = _IMP_em2d.delete_AverageDistanceLinkage
2609 __del__ =
lambda self :
None;
2610 AverageDistanceLinkage_swigregister = _IMP_em2d.AverageDistanceLinkage_swigregister
2611 AverageDistanceLinkage_swigregister(AverageDistanceLinkage)
2614 """Proxy of C++ IMP::em2d::CollisionCrossSection class"""
2615 __swig_setmethods__ = {}
2616 for _s
in [
IMP.base.Object]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2617 __setattr__ =
lambda self, name, value: _swig_setattr(self, CollisionCrossSection, name, value)
2618 __swig_getmethods__ = {}
2619 for _s
in [
IMP.base.Object]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2620 __getattr__ =
lambda self, name: _swig_getattr(self, CollisionCrossSection, name)
2621 def __init__(self, *args):
2622 """__init__(IMP::em2d::CollisionCrossSection self, unsigned int n_projections, double resolution, double pixel_size, double projection_image_size) -> CollisionCrossSection"""
2623 this = _IMP_em2d.new_CollisionCrossSection(*args)
2624 try: self.this.append(this)
2625 except: self.this = this
2626 def set_model_particles(self, *args):
2627 """set_model_particles(CollisionCrossSection self, IMP::kernel::ParticlesTemp const & ps)"""
2628 return _IMP_em2d.CollisionCrossSection_set_model_particles(self, *args)
2631 """get_ccs(CollisionCrossSection self) -> double"""
2632 return _IMP_em2d.CollisionCrossSection_get_ccs(self)
2634 def show(self, *args):
2635 """show(CollisionCrossSection self, _ostream out)"""
2636 return _IMP_em2d.CollisionCrossSection_show(self, *args)
2638 def get_version_info(self):
2639 """get_version_info(CollisionCrossSection self) -> VersionInfo"""
2640 return _IMP_em2d.CollisionCrossSection_get_version_info(self)
2642 __swig_destroy__ = _IMP_em2d.delete_CollisionCrossSection
2643 __del__ =
lambda self :
None;
2645 """__str__(CollisionCrossSection self) -> std::string"""
2646 return _IMP_em2d.CollisionCrossSection___str__(self)
2649 """__repr__(CollisionCrossSection self) -> std::string"""
2650 return _IMP_em2d.CollisionCrossSection___repr__(self)
2653 return _object_cast_to_CollisionCrossSection(o)
2654 get_from = staticmethod(get_from)
2656 CollisionCrossSection_swigregister = _IMP_em2d.CollisionCrossSection_swigregister
2657 CollisionCrossSection_swigregister(CollisionCrossSection)
2660 """Proxy of C++ IMP::em2d::GridStates class"""
2661 __swig_setmethods__ = {}
2663 __setattr__ =
lambda self, name, value: _swig_setattr(self, GridStates, name, value)
2664 __swig_getmethods__ = {}
2666 __getattr__ =
lambda self, name: _swig_getattr(self, GridStates, name)
2667 def __init__(self, *args):
2669 __init__(IMP::em2d::GridStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations,
2670 IMP::String const & name="GridStates") -> GridStates
2671 __init__(IMP::em2d::GridStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations) -> GridStates
2673 this = _IMP_em2d.new_GridStates(*args)
2674 try: self.this.append(this)
2675 except: self.this = this
2676 def get_position(self, *args):
2677 """get_position(GridStates self, unsigned int i) -> Vector3D"""
2678 return _IMP_em2d.GridStates_get_position(self, *args)
2680 def get_orientation(self, *args):
2681 """get_orientation(GridStates self, unsigned int i) -> Rotation3D"""
2682 return _IMP_em2d.GridStates_get_orientation(self, *args)
2684 def get_version_info(self):
2685 """get_version_info(GridStates self) -> VersionInfo"""
2686 return _IMP_em2d.GridStates_get_version_info(self)
2688 def do_show(self, *args):
2689 """do_show(GridStates self, _ostream out)"""
2690 return _IMP_em2d.GridStates_do_show(self, *args)
2692 __swig_destroy__ = _IMP_em2d.delete_GridStates
2693 __del__ =
lambda self :
None;
2695 """__str__(GridStates self) -> std::string"""
2696 return _IMP_em2d.GridStates___str__(self)
2699 """__repr__(GridStates self) -> std::string"""
2700 return _IMP_em2d.GridStates___repr__(self)
2703 return _object_cast_to_GridStates(o)
2704 get_from = staticmethod(get_from)
2706 GridStates_swigregister = _IMP_em2d.GridStates_swigregister
2707 GridStates_swigregister(GridStates)
2709 class ProjectionStates(GridStates):
2710 """Proxy of C++ IMP::em2d::ProjectionStates class"""
2711 __swig_setmethods__ = {}
2712 for _s
in [GridStates]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2713 __setattr__ =
lambda self, name, value: _swig_setattr(self, ProjectionStates, name, value)
2714 __swig_getmethods__ = {}
2715 for _s
in [GridStates]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2716 __getattr__ =
lambda self, name: _swig_getattr(self, ProjectionStates, name)
2717 def __init__(self, *args):
2719 __init__(IMP::em2d::ProjectionStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations,
2720 IMP::em2d::Images const & projections, IMP::String const & name="ProjectionStates") -> ProjectionStates
2721 __init__(IMP::em2d::ProjectionStates self, IMP::algebra::Vector3Ds const & positions, IMP::algebra::Rotation3Ds const & orientations,
2722 IMP::em2d::Images const & projections) -> ProjectionStates
2724 this = _IMP_em2d.new_ProjectionStates(*args)
2725 try: self.this.append(this)
2726 except: self.this = this
2728 """get_projection(ProjectionStates self, unsigned int i) -> Image"""
2729 return _IMP_em2d.ProjectionStates_get_projection(self, *args)
2731 __swig_destroy__ = _IMP_em2d.delete_ProjectionStates
2732 __del__ =
lambda self :
None;
2734 """__str__(ProjectionStates self) -> std::string"""
2735 return _IMP_em2d.ProjectionStates___str__(self)
2738 """__repr__(ProjectionStates self) -> std::string"""
2739 return _IMP_em2d.ProjectionStates___repr__(self)
2742 return _object_cast_to_ProjectionStates(o)
2743 get_from = staticmethod(get_from)
2745 ProjectionStates_swigregister = _IMP_em2d.ProjectionStates_swigregister
2746 ProjectionStates_swigregister(ProjectionStates)
2749 """Proxy of C++ IMP::em2d::DistanceFilter class"""
2750 __swig_setmethods__ = {}
2752 __setattr__ =
lambda self, name, value: _swig_setattr(self, DistanceFilter, name, value)
2753 __swig_getmethods__ = {}
2755 __getattr__ =
lambda self, name: _swig_getattr(self, DistanceFilter, name)
2756 def __init__(self, *args):
2758 __init__(IMP::em2d::DistanceFilter self, Subset subset_to_act_on, Subset subset_to_restrain, ParticleStatesTable ps_table,
2759 double max_distance) -> DistanceFilter
2761 this = _IMP_em2d.new_DistanceFilter(*args)
2762 try: self.this.append(this)
2763 except: self.this = this
2764 def show(self, *args):
2766 show(DistanceFilter self, _ostream out=std::cout)
2767 show(DistanceFilter self)
2769 return _IMP_em2d.DistanceFilter_show(self, *args)
2771 def get_version_info(self):
2772 """get_version_info(DistanceFilter self) -> VersionInfo"""
2773 return _IMP_em2d.DistanceFilter_get_version_info(self)
2775 def do_show(self, *args):
2776 """do_show(DistanceFilter self, _ostream out)"""
2777 return _IMP_em2d.DistanceFilter_do_show(self, *args)
2779 __swig_destroy__ = _IMP_em2d.delete_DistanceFilter
2780 __del__ =
lambda self :
None;
2782 """__str__(DistanceFilter self) -> std::string"""
2783 return _IMP_em2d.DistanceFilter___str__(self)
2786 """__repr__(DistanceFilter self) -> std::string"""
2787 return _IMP_em2d.DistanceFilter___repr__(self)
2790 return _object_cast_to_DistanceFilter(o)
2791 get_from = staticmethod(get_from)
2793 DistanceFilter_swigregister = _IMP_em2d.DistanceFilter_swigregister
2794 DistanceFilter_swigregister(DistanceFilter)
2797 """Proxy of C++ IMP::em2d::DistanceFilterTable class"""
2798 __swig_setmethods__ = {}
2800 __setattr__ =
lambda self, name, value: _swig_setattr(self, DistanceFilterTable, name, value)
2801 __swig_getmethods__ = {}
2803 __getattr__ =
lambda self, name: _swig_getattr(self, DistanceFilterTable, name)
2804 def __init__(self, *args):
2805 """__init__(IMP::em2d::DistanceFilterTable self, Subset subset_to_act_on, ParticleStatesTable ps_table, double max_distance) -> DistanceFilterTable"""
2806 this = _IMP_em2d.new_DistanceFilterTable(*args)
2807 try: self.this.append(this)
2808 except: self.this = this
2809 def show(self, *args):
2811 show(DistanceFilterTable self, _ostream out=std::cout)
2812 show(DistanceFilterTable self)
2814 return _IMP_em2d.DistanceFilterTable_show(self, *args)
2816 def get_version_info(self):
2817 """get_version_info(DistanceFilterTable self) -> VersionInfo"""
2818 return _IMP_em2d.DistanceFilterTable_get_version_info(self)
2820 def do_show(self, *args):
2821 """do_show(DistanceFilterTable self, _ostream out)"""
2822 return _IMP_em2d.DistanceFilterTable_do_show(self, *args)
2824 __swig_destroy__ = _IMP_em2d.delete_DistanceFilterTable
2825 __del__ =
lambda self :
None;
2827 """__str__(DistanceFilterTable self) -> std::string"""
2828 return _IMP_em2d.DistanceFilterTable___str__(self)
2831 """__repr__(DistanceFilterTable self) -> std::string"""
2832 return _IMP_em2d.DistanceFilterTable___repr__(self)
2835 return _object_cast_to_DistanceFilterTable(o)
2836 get_from = staticmethod(get_from)
2838 DistanceFilterTable_swigregister = _IMP_em2d.DistanceFilterTable_swigregister
2839 DistanceFilterTable_swigregister(DistanceFilterTable)
2841 class IntsOrder(_object):
2842 """Proxy of C++ IMP::em2d::IntsOrder class"""
2843 __swig_setmethods__ = {}
2844 __setattr__ =
lambda self, name, value: _swig_setattr(self, IntsOrder, name, value)
2845 __swig_getmethods__ = {}
2846 __getattr__ =
lambda self, name: _swig_getattr(self, IntsOrder, name)
2847 __repr__ = _swig_repr
2848 def __call__(self, *args):
2849 """__call__(IntsOrder self, IMP::Ints const & a, IMP::Ints const & b) -> bool"""
2850 return _IMP_em2d.IntsOrder___call__(self, *args)
2853 """__init__(IMP::em2d::IntsOrder self) -> IntsOrder"""
2854 this = _IMP_em2d.new_IntsOrder()
2855 try: self.this.append(this)
2856 except: self.this = this
2857 __swig_destroy__ = _IMP_em2d.delete_IntsOrder
2858 __del__ =
lambda self :
None;
2859 IntsOrder_swigregister = _IMP_em2d.IntsOrder_swigregister
2860 IntsOrder_swigregister(IntsOrder)
2863 """Proxy of C++ IMP::em2d::RigidBodiesImageFitRestraint class"""
2864 __swig_setmethods__ = {}
2865 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2866 __setattr__ =
lambda self, name, value: _swig_setattr(self, RigidBodiesImageFitRestraint, name, value)
2867 __swig_getmethods__ = {}
2868 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2869 __getattr__ =
lambda self, name: _swig_getattr(self, RigidBodiesImageFitRestraint, name)
2871 """get_input_particles(RigidBodiesImageFitRestraint self) -> IMP::kernel::ParticlesTemp"""
2872 return _IMP_em2d.RigidBodiesImageFitRestraint_get_input_particles(self)
2875 """get_input_containers(RigidBodiesImageFitRestraint self) -> IMP::kernel::ContainersTemp"""
2876 return _IMP_em2d.RigidBodiesImageFitRestraint_get_input_containers(self)
2878 def do_get_inputs(self):
2879 """do_get_inputs(RigidBodiesImageFitRestraint self) -> IMP::kernel::ModelObjectsTemp"""
2880 return _IMP_em2d.RigidBodiesImageFitRestraint_do_get_inputs(self)
2882 def get_version_info(self):
2883 """get_version_info(RigidBodiesImageFitRestraint self) -> VersionInfo"""
2884 return _IMP_em2d.RigidBodiesImageFitRestraint_get_version_info(self)
2886 def do_show(self, *args):
2887 """do_show(RigidBodiesImageFitRestraint self, _ostream out)"""
2888 return _IMP_em2d.RigidBodiesImageFitRestraint_do_show(self, *args)
2890 __swig_destroy__ = _IMP_em2d.delete_RigidBodiesImageFitRestraint
2891 __del__ =
lambda self :
None;
2892 def __init__(self, *args):
2893 """__init__(IMP::em2d::RigidBodiesImageFitRestraint self, ScoreFunction scf, IMP::core::RigidBodies const & rbs, Image img) -> RigidBodiesImageFitRestraint"""
2894 this = _IMP_em2d.new_RigidBodiesImageFitRestraint(*args)
2895 try: self.this.append(this)
2896 except: self.this = this
2897 def set_projecting_parameters(self, *args):
2898 """set_projecting_parameters(RigidBodiesImageFitRestraint self, ProjectingParameters p)"""
2899 return _IMP_em2d.RigidBodiesImageFitRestraint_set_projecting_parameters(self, *args)
2901 def set_orientations(self, *args):
2902 """set_orientations(RigidBodiesImageFitRestraint self, RigidBody rb, IMP::algebra::Rotation3Ds const & rots)"""
2903 return _IMP_em2d.RigidBodiesImageFitRestraint_set_orientations(self, *args)
2905 def get_number_of_masks(self, *args):
2906 """get_number_of_masks(RigidBodiesImageFitRestraint self, RigidBody rb) -> unsigned int"""
2907 return _IMP_em2d.RigidBodiesImageFitRestraint_get_number_of_masks(self, *args)
2910 """__str__(RigidBodiesImageFitRestraint self) -> std::string"""
2911 return _IMP_em2d.RigidBodiesImageFitRestraint___str__(self)
2914 """__repr__(RigidBodiesImageFitRestraint self) -> std::string"""
2915 return _IMP_em2d.RigidBodiesImageFitRestraint___repr__(self)
2918 return _object_cast_to_RigidBodiesImageFitRestraint(o)
2919 get_from = staticmethod(get_from)
2921 RigidBodiesImageFitRestraint_swigregister = _IMP_em2d.RigidBodiesImageFitRestraint_swigregister
2922 RigidBodiesImageFitRestraint_swigregister(RigidBodiesImageFitRestraint)
2925 def get_unique_index(*args):
2926 """get_unique_index(Rotation3D rot) -> IMP::Ints"""
2927 return _IMP_em2d.get_unique_index(*args)
2929 """Proxy of C++ IMP::em2d::RelativePositionMover class"""
2930 __swig_setmethods__ = {}
2932 __setattr__ =
lambda self, name, value: _swig_setattr(self, RelativePositionMover, name, value)
2933 __swig_getmethods__ = {}
2935 __getattr__ =
lambda self, name: _swig_getattr(self, RelativePositionMover, name)
2936 def __init__(self, *args):
2937 """__init__(IMP::em2d::RelativePositionMover self, RigidBody d, IMP::Float max_translation, IMP::Float max_rotation) -> RelativePositionMover"""
2938 this = _IMP_em2d.new_RelativePositionMover(*args)
2939 try: self.this.append(this)
2940 except: self.this = this
2941 def add_internal_transformations(self, *args):
2942 """add_internal_transformations(RelativePositionMover self, RigidBody d, IMP::algebra::Transformation3Ds transforms)"""
2943 return _IMP_em2d.RelativePositionMover_add_internal_transformations(self, *args)
2945 def set_random_move_probability(self, *args):
2946 """set_random_move_probability(RelativePositionMover self, IMP::Float p)"""
2947 return _IMP_em2d.RelativePositionMover_set_random_move_probability(self, *args)
2949 __swig_destroy__ = _IMP_em2d.delete_RelativePositionMover
2950 __del__ =
lambda self :
None;
2952 """__str__(RelativePositionMover self) -> std::string"""
2953 return _IMP_em2d.RelativePositionMover___str__(self)
2956 """__repr__(RelativePositionMover self) -> std::string"""
2957 return _IMP_em2d.RelativePositionMover___repr__(self)
2960 return _object_cast_to_RelativePositionMover(o)
2961 get_from = staticmethod(get_from)
2963 RelativePositionMover_swigregister = _IMP_em2d.RelativePositionMover_swigregister
2964 RelativePositionMover_swigregister(RelativePositionMover)
2967 """Proxy of C++ IMP::em2d::DummyRestraint class"""
2968 __swig_setmethods__ = {}
2969 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
2970 __setattr__ =
lambda self, name, value: _swig_setattr(self, DummyRestraint, name, value)
2971 __swig_getmethods__ = {}
2972 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
2973 __getattr__ =
lambda self, name: _swig_getattr(self, DummyRestraint, name)
2974 def __init__(self, *args):
2975 """__init__(IMP::em2d::DummyRestraint self, Particle p, Particle q) -> DummyRestraint"""
2976 this = _IMP_em2d.new_DummyRestraint(*args)
2977 try: self.this.append(this)
2978 except: self.this = this
2979 def show(self, *args):
2981 show(DummyRestraint self, _ostream out=std::cout)
2982 show(DummyRestraint self)
2984 return _IMP_em2d.DummyRestraint_show(self, *args)
2987 """get_input_particles(DummyRestraint self) -> IMP::kernel::ParticlesTemp"""
2988 return _IMP_em2d.DummyRestraint_get_input_particles(self)
2991 """get_input_containers(DummyRestraint self) -> IMP::kernel::ContainersTemp"""
2992 return _IMP_em2d.DummyRestraint_get_input_containers(self)
2994 def do_get_inputs(self):
2995 """do_get_inputs(DummyRestraint self) -> IMP::kernel::ModelObjectsTemp"""
2996 return _IMP_em2d.DummyRestraint_do_get_inputs(self)
2998 def get_version_info(self):
2999 """get_version_info(DummyRestraint self) -> VersionInfo"""
3000 return _IMP_em2d.DummyRestraint_get_version_info(self)
3002 def do_show(self, *args):
3003 """do_show(DummyRestraint self, _ostream out)"""
3004 return _IMP_em2d.DummyRestraint_do_show(self, *args)
3006 __swig_destroy__ = _IMP_em2d.delete_DummyRestraint
3007 __del__ =
lambda self :
None;
3009 """__str__(DummyRestraint self) -> std::string"""
3010 return _IMP_em2d.DummyRestraint___str__(self)
3013 """__repr__(DummyRestraint self) -> std::string"""
3014 return _IMP_em2d.DummyRestraint___repr__(self)
3017 return _object_cast_to_DummyRestraint(o)
3018 get_from = staticmethod(get_from)
3020 DummyRestraint_swigregister = _IMP_em2d.DummyRestraint_swigregister
3021 DummyRestraint_swigregister(DummyRestraint)
3024 """Proxy of C++ IMP::em2d::ParticlesDummyRestraint class"""
3025 __swig_setmethods__ = {}
3026 for _s
in [
IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,
'__swig_setmethods__',{}))
3027 __setattr__ =
lambda self, name, value: _swig_setattr(self, ParticlesDummyRestraint, name, value)
3028 __swig_getmethods__ = {}
3029 for _s
in [
IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,
'__swig_getmethods__',{}))
3030 __getattr__ =
lambda self, name: _swig_getattr(self, ParticlesDummyRestraint, name)
3031 def __init__(self, *args):
3032 """__init__(IMP::em2d::ParticlesDummyRestraint self, SingletonContainer sc) -> ParticlesDummyRestraint"""
3033 this = _IMP_em2d.new_ParticlesDummyRestraint(*args)
3034 try: self.this.append(this)
3035 except: self.this = this
3036 def show(self, *args):
3038 show(ParticlesDummyRestraint self, _ostream out=std::cout)
3039 show(ParticlesDummyRestraint self)
3041 return _IMP_em2d.ParticlesDummyRestraint_show(self, *args)
3044 """get_input_particles(ParticlesDummyRestraint self) -> IMP::kernel::ParticlesTemp"""
3045 return _IMP_em2d.ParticlesDummyRestraint_get_input_particles(self)
3048 """get_input_containers(ParticlesDummyRestraint self) -> IMP::kernel::ContainersTemp"""
3049 return _IMP_em2d.ParticlesDummyRestraint_get_input_containers(self)
3051 def do_get_inputs(self):
3052 """do_get_inputs(ParticlesDummyRestraint self) -> IMP::kernel::ModelObjectsTemp"""
3053 return _IMP_em2d.ParticlesDummyRestraint_do_get_inputs(self)
3055 def get_version_info(self):
3056 """get_version_info(ParticlesDummyRestraint self) -> VersionInfo"""
3057 return _IMP_em2d.ParticlesDummyRestraint_get_version_info(self)
3059 def do_show(self, *args):
3060 """do_show(ParticlesDummyRestraint self, _ostream out)"""
3061 return _IMP_em2d.ParticlesDummyRestraint_do_show(self, *args)
3063 __swig_destroy__ = _IMP_em2d.delete_ParticlesDummyRestraint
3064 __del__ =
lambda self :
None;
3066 """__str__(ParticlesDummyRestraint self) -> std::string"""
3067 return _IMP_em2d.ParticlesDummyRestraint___str__(self)
3070 """__repr__(ParticlesDummyRestraint self) -> std::string"""
3071 return _IMP_em2d.ParticlesDummyRestraint___repr__(self)
3074 return _object_cast_to_ParticlesDummyRestraint(o)
3075 get_from = staticmethod(get_from)
3077 ParticlesDummyRestraint_swigregister = _IMP_em2d.ParticlesDummyRestraint_swigregister
3078 ParticlesDummyRestraint_swigregister(ParticlesDummyRestraint)
3081 """Proxy of C++ std::pair<(IMP::algebra::Transformation2D,double)> class"""
3082 __swig_setmethods__ = {}
3083 __setattr__ =
lambda self, name, value: _swig_setattr(self, ResultAlign2D, name, value)
3084 __swig_getmethods__ = {}
3085 __getattr__ =
lambda self, name: _swig_getattr(self, ResultAlign2D, name)
3086 __repr__ = _swig_repr
3087 def __init__(self, *args):
3089 __init__(std::pair<(IMP::algebra::Transformation2D,double)> self) -> ResultAlign2D
3090 __init__(std::pair<(IMP::algebra::Transformation2D,double)> self, Transformation2D first, double second) -> ResultAlign2D
3091 __init__(std::pair<(IMP::algebra::Transformation2D,double)> self, ResultAlign2D p) -> ResultAlign2D
3093 this = _IMP_em2d.new_ResultAlign2D(*args)
3094 try: self.this.append(this)
3095 except: self.this = this
3096 __swig_setmethods__[
"first"] = _IMP_em2d.ResultAlign2D_first_set
3097 __swig_getmethods__[
"first"] = _IMP_em2d.ResultAlign2D_first_get
3098 if _newclass:first = _swig_property(_IMP_em2d.ResultAlign2D_first_get, _IMP_em2d.ResultAlign2D_first_set)
3099 __swig_setmethods__[
"second"] = _IMP_em2d.ResultAlign2D_second_set
3100 __swig_getmethods__[
"second"] = _IMP_em2d.ResultAlign2D_second_get
3101 if _newclass:second = _swig_property(_IMP_em2d.ResultAlign2D_second_get, _IMP_em2d.ResultAlign2D_second_set)
3102 def __len__(self):
return 2
3103 def __repr__(self):
return str((self.first, self.second))
3104 def __getitem__(self, index):
3109 def __setitem__(self, index, val):
3114 __swig_destroy__ = _IMP_em2d.delete_ResultAlign2D
3115 __del__ =
lambda self :
None;
3116 ResultAlign2D_swigregister = _IMP_em2d.ResultAlign2D_swigregister
3117 ResultAlign2D_swigregister(ResultAlign2D)
3120 def _do_hierarchical_clustering_single_linkage(*args):
3121 """_do_hierarchical_clustering_single_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3122 return _IMP_em2d._do_hierarchical_clustering_single_linkage(*args)
3124 def _do_hierarchical_clustering_complete_linkage(*args):
3125 """_do_hierarchical_clustering_complete_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3126 return _IMP_em2d._do_hierarchical_clustering_complete_linkage(*args)
3128 def _do_hierarchical_clustering_average_distance_linkage(*args):
3129 """_do_hierarchical_clustering_average_distance_linkage(IMP::FloatsList const & distances) -> ClusterSet"""
3130 return _IMP_em2d._do_hierarchical_clustering_average_distance_linkage(*args)
3131 do_hierarchical_clustering_single_linkage = _do_hierarchical_clustering_single_linkage
3132 do_hierarchical_clustering_complete_linkage = _do_hierarchical_clustering_complete_linkage
3133 do_hierarchical_clustering_average_distance_linkage = _do_hierarchical_clustering_average_distance_linkage
3136 def get_module_version():
3137 """get_module_version() -> std::string const"""
3138 return _IMP_em2d.get_module_version()
3141 """get_example_path(std::string fname) -> std::string"""
3142 return _IMP_em2d.get_example_path(*args)
3145 """get_data_path(std::string fname) -> std::string"""
3146 return _IMP_em2d.get_data_path(*args)
3147 import _version_check
3148 _version_check.check_version(get_module_version())