SyncVotingMixin --> sync_voting module

Author: j-c-c

src/aspire/abinitio/__init__.py

@@ -8,7 +8,6 @@
 from .commonline_sdp import CommonlineSDP
 from .commonline_lud import CommonlineLUD
 from .commonline_irls import CommonlineIRLS
-from .sync_voting import SyncVotingMixin
 from .commonline_sync import CLSyncVoting
 from .commonline_sync3n import CLSync3N
 from .commonline_c3_c4 import CLSymmetryC3C4

src/aspire/abinitio/commonline_c2.py

@@ -3,7 +3,8 @@
 import numpy as np
 from scipy.linalg import eigh
 
-from aspire.abinitio import CLOrient3D, JSync, SyncVotingMixin
+from aspire.abinitio import CLOrient3D, JSync
+from aspire.abinitio.sync_voting import _syncmatrix_ij_vote_3n
 from aspire.utils import J_conjugate, Rotation, all_pairs
 
 from .commonline_utils import (
@@ -15,7 +16,7 @@
 logger = logging.getLogger(__name__)
 
 
-class CLSymmetryC2(CLOrient3D, SyncVotingMixin):
+class CLSymmetryC2(CLOrient3D):
     """
     Define a class to estimate 3D orientations using common lines methods for molecules with C2 cyclic symmetry.
 
@@ -241,7 +242,7 @@ def _estimate_relative_viewing_directions(self):
         self.build_clmatrix()
 
         # Step 2: Calculate relative rotations associated with both mutual common lines.
-        Rijs, Rijgs = self._estimate_all_Rijs_c2(self.clmatrix)
+        Rijs, Rijgs = self._estimate_all_Rijs_c2()
 
         # Step 3: Inner J-synchronization
         Rijs, Rijgs = self._local_J_sync_c2(Rijs, Rijgs)
@@ -338,23 +339,36 @@ def _estimate_inplane_rotations(self, vis, Rijs, Rijgs):
     # Secondary Methods for computing outer product #
     #################################################
 
-    def _estimate_all_Rijs_c2(self, clmatrix):
+    def _estimate_all_Rijs_c2(self):
         """
         Estimate the two sets of relative rotations, Rijs and Rijgs, between pairs
         of images using the voting method.
 
-        :param clmatrix: 2 x n_img x n_img array holding two sets of mutual common-lines
-            between pairs of images.
         :return: Relative rotations, Rijs and Rijgs.
         """
         k_list = np.arange(self.n_img)
-        n_theta = self.n_theta
         pairs = all_pairs(self.n_img)
         Rijs = np.zeros((len(pairs), 3, 3), dtype=self.dtype)
         Rijgs = np.zeros((len(pairs), 3, 3), dtype=self.dtype)
         for idx, (i, j) in enumerate(pairs):
-            Rijs[idx] = self._syncmatrix_ij_vote_3n(clmatrix[0], i, j, k_list, n_theta)
-            Rijgs[idx] = self._syncmatrix_ij_vote_3n(clmatrix[1], i, j, k_list, n_theta)
+            Rijs[idx] = _syncmatrix_ij_vote_3n(
+                self.clmatrix[0],
+                i,
+                j,
+                k_list,
+                self.n_theta,
+                self.hist_bin_width,
+                self.full_width,
+            )
+            Rijgs[idx] = _syncmatrix_ij_vote_3n(
+                self.clmatrix[1],
+                i,
+                j,
+                k_list,
+                self.n_theta,
+                self.hist_bin_width,
+                self.full_width,
+            )
 
         return Rijs, Rijgs
 

src/aspire/abinitio/commonline_c3_c4.py

@@ -3,7 +3,8 @@
 import numpy as np
 from numpy.linalg import norm, svd
 
-from aspire.abinitio import CLOrient3D, JSync, SyncVotingMixin
+from aspire.abinitio import CLOrient3D, JSync
+from aspire.abinitio.sync_voting import _syncmatrix_ij_vote_3n
 from aspire.operators import PolarFT
 from aspire.utils import J_conjugate, Rotation, all_pairs, anorm, trange
 
@@ -16,7 +17,7 @@
 logger = logging.getLogger(__name__)
 
 
-class CLSymmetryC3C4(CLOrient3D, SyncVotingMixin):
+class CLSymmetryC3C4(CLOrient3D):
     """
     Define a class to estimate 3D orientations using common lines methods for molecules with
     C3 and C4 cyclic symmetry.
@@ -144,7 +145,7 @@ def _estimate_relative_viewing_directions(self):
         Riis = self._estimate_all_Riis_c3_c4(sclmatrix)
 
         # Step 4: Calculate relative rotations
-        Rijs = self._estimate_all_Rijs_c3_c4(self.clmatrix)
+        Rijs = self._estimate_all_Rijs_c3_c4()
 
         # Step 5: Inner J-synchronization
         vijs, viis = self._local_J_sync_c3_c4(Rijs, Riis)
@@ -317,17 +318,21 @@ def _estimate_all_Riis_c3_c4(self, sclmatrix):
 
         return Riis
 
-    def _estimate_all_Rijs_c3_c4(self, clmatrix):
+    def _estimate_all_Rijs_c3_c4(self):
         """
         Estimate Rijs using the voting method.
         """
-        n_img = self.n_img
-        n_theta = self.n_theta
-        pairs = all_pairs(n_img)
+        pairs = all_pairs(self.n_img)
         Rijs = np.zeros((len(pairs), 3, 3))
         for idx, (i, j) in enumerate(pairs):
-            Rijs[idx] = self._syncmatrix_ij_vote_3n(
-                clmatrix, i, j, np.arange(n_img), n_theta
+            Rijs[idx] = _syncmatrix_ij_vote_3n(
+                self.clmatrix,
+                i,
+                j,
+                np.arange(self.n_img),
+                self.n_theta,
+                self.hist_bin_width,
+                self.full_width,
             )
 
         return Rijs

src/aspire/abinitio/commonline_sync.py

@@ -2,14 +2,15 @@
 
 import numpy as np
 
-from aspire.abinitio import CLOrient3D, SyncVotingMixin
+from aspire.abinitio import CLOrient3D
+from aspire.abinitio.sync_voting import _rotratio_eulerangle_vec, _vote_ij
 from aspire.utils import nearest_rotations
 from aspire.utils.matlab_compat import stable_eigsh
 
 logger = logging.getLogger(__name__)
 
 
-class CLSyncVoting(CLOrient3D, SyncVotingMixin):
+class CLSyncVoting(CLOrient3D):
     """
     Define a class to estimate 3D orientations using synchronization matrix and voting method.
 
@@ -199,9 +200,11 @@ def _syncmatrix_ij_vote(self, clmatrix, i, j, k_list, n_theta):
         :return: The (i,j) rotation block of the synchronization matrix
         """
 
-        _, good_k = self._vote_ij(clmatrix, n_theta, i, j, k_list)
+        _, good_k = _vote_ij(
+            clmatrix, n_theta, i, j, k_list, self.hist_bin_width, self.full_width
+        )
 
-        rots = self._rotratio_eulerangle_vec(clmatrix, i, j, good_k, n_theta)
+        rots = _rotratio_eulerangle_vec(clmatrix, i, j, good_k, n_theta)
 
         if rots is not None:
             rot_mean = np.mean(rots, 0)

src/aspire/abinitio/commonline_sync3n.py

@@ -6,14 +6,15 @@
 from numpy.linalg import norm
 from scipy.optimize import curve_fit
 
-from aspire.abinitio import CLOrient3D, SyncVotingMixin
+from aspire.abinitio import CLOrient3D
+from aspire.abinitio.sync_voting import _syncmatrix_ij_vote_3n
 from aspire.utils import J_conjugate, all_pairs, nearest_rotations, random, tqdm, trange
 from aspire.utils.matlab_compat import stable_eigsh
 
 logger = logging.getLogger(__name__)
 
 
-class CLSync3N(CLOrient3D, SyncVotingMixin):
+class CLSync3N(CLOrient3D):
     """
     Define a class to estimate 3D orientations using common lines Sync3N methods (2017).
 
@@ -955,7 +956,7 @@ def _estimate_all_Rijs_host(self, clmatrix):
         Rijs = np.zeros((len(self._pairs), 3, 3))
 
         for idx, (i, j) in enumerate(tqdm(self._pairs, desc="Estimate Rijs")):
-            Rijs[idx] = self._syncmatrix_ij_vote_3n(
+            Rijs[idx] = _syncmatrix_ij_vote_3n(
                 clmatrix, i, j, np.arange(n_img), n_theta
             )