MoleditPy-linux 3.6.2__tar.gz → 3.6.4__tar.gz

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 3.6.2
+Version: 3.6.4
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "MoleditPy-linux"
 
-version = "3.6.2"
+version = "3.6.4"
 
 license = {file = "LICENSE"}
 

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 3.6.2
+Version: 3.6.4
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/src/moleditpy_linux/ui/align_plane_dialog.py

@@ -10,10 +10,13 @@ Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
 """
 
-import numpy as np
+import logging
 from typing import TYPE_CHECKING, Literal, Optional, Sequence
 
+import numpy as np
+
 from PyQt6.QtWidgets import (
+    QCheckBox,
     QHBoxLayout,
     QLabel,
     QMessageBox,
@@ -24,15 +27,22 @@ from PyQt6.QtWidgets import (
 from rdkit import Chem
 
 try:
-    from .base_picking_dialog import BasePickingDialog
+    from .base_picking_dialog import BasePickingDialog, SelectionList
 except ImportError:
-    from moleditpy_linux.ui.base_picking_dialog import BasePickingDialog
+    from moleditpy_linux.ui.base_picking_dialog import BasePickingDialog, SelectionList
+
+try:
+    from ..core.mol_geometry import rodrigues_rotate
+except ImportError:
+    from moleditpy_linux.core.mol_geometry import rodrigues_rotate
 
 if TYPE_CHECKING:
     from .main_window import MainWindow
 
 
 class AlignPlaneDialog(BasePickingDialog):
+    """Dialog for aligning selected atoms to a principal plane (XY, XZ, or YZ)."""
+
     def __init__(
         self,
         mol: Chem.Mol,
@@ -43,20 +53,31 @@ class AlignPlaneDialog(BasePickingDialog):
     ) -> None:
         super().__init__(mol, main_window, parent)
         self.plane = plane
-        self.selected_atoms: set[int] = set()
+        self._selected_atoms = SelectionList()
 
         # Add preselected atoms
         if preselected_atoms:
-            self.selected_atoms.update(preselected_atoms)
+            self._selected_atoms.update(preselected_atoms)
 
         self.init_ui()
 
         # Add labels to preselected atoms
-        if self.selected_atoms:
+        if self._selected_atoms:
             self.show_atom_labels()
             self.update_display()
 
+    @property
+    def selected_atoms(self) -> SelectionList:
+        """Return the ordered list of selected atom indices."""
+        return self._selected_atoms
+
+    @selected_atoms.setter
+    def selected_atoms(self, val: object) -> None:
+        """Replace the selection with a new SelectionList built from val."""
+        self._selected_atoms = SelectionList(val)  # type: ignore[arg-type]
+
     def init_ui(self) -> None:
+        """Build and lay out all widgets for the plane-alignment dialog."""
         plane_names = {"xy": "XY", "xz": "XZ", "yz": "YZ"}
         self.setWindowTitle(f"Align to {plane_names[self.plane]} Plane")
         self.setModal(False)
@@ -64,11 +85,18 @@ class AlignPlaneDialog(BasePickingDialog):
 
         # Instructions
         instruction_label = QLabel(
-            f"Click atoms in the 3D view to select them for align to the {plane_names[self.plane]} plane. At least 3 atoms are required."
+            f"Click atoms in the 3D view to select them for align to "
+            f"the {plane_names[self.plane]} plane. At least 3 atoms "
+            f"are required."
         )
         instruction_label.setWordWrap(True)
         layout.addWidget(instruction_label)
 
+        # Move to zero plane option (default False)
+        self.move_to_zero_plane_checkbox = QCheckBox("Move the plane to the zero plane")
+        self.move_to_zero_plane_checkbox.setChecked(False)
+        layout.addWidget(self.move_to_zero_plane_checkbox)
+
         # Selected atoms display
         self.selection_label = QLabel("No atoms selected")
         layout.addWidget(self.selection_label)
@@ -106,11 +134,12 @@ class AlignPlaneDialog(BasePickingDialog):
 
     def on_atom_picked(self, atom_idx: int) -> None:
         """Handle the event when an atom is picked in the 3D view."""
-        if atom_idx in self.selected_atoms:
-            self.selected_atoms.remove(atom_idx)
+        if atom_idx in self._selected_atoms:
+            self._selected_atoms.remove(atom_idx)
         else:
-            self.selected_atoms.add(atom_idx)
+            self._selected_atoms.append(atom_idx)
 
+        self.show_atom_labels()
         self.update_display()
 
     def clear_selection(self) -> None:
@@ -139,6 +168,7 @@ class AlignPlaneDialog(BasePickingDialog):
             self.update_display()
 
         except (AttributeError, RuntimeError, TypeError, KeyError) as e:
+            logging.exception("Failed to select all atoms")
             QMessageBox.warning(self, "Warning", f"Failed to select all atoms: {e}")
 
     def update_display(self) -> None:
@@ -150,8 +180,15 @@ class AlignPlaneDialog(BasePickingDialog):
             )
             self.apply_button.setEnabled(False)
         else:
-            # Just show the count of selected atoms (to prevent dialog resizing)
-            self.selection_label.setText(f"Selected {count} atoms")
+            atom_list = sorted(self.selected_atoms)
+            atom_display = []
+            for i, atom_idx in enumerate(atom_list):
+                symbol = self.mol.GetAtomWithIdx(atom_idx).GetSymbol()
+                atom_display.append(f"#{i + 1}: {symbol}({atom_idx})")
+
+            self.selection_label.setText(
+                f"Selected {count} atoms: {', '.join(atom_display)}"
+            )
             self.apply_button.setEnabled(count >= 3)
 
     def show_atom_labels(self) -> None:
@@ -159,7 +196,7 @@ class AlignPlaneDialog(BasePickingDialog):
         if self.selected_atoms:
             sorted_atoms = sorted(self.selected_atoms)
             pairs = [(idx, f"#{i + 1}") for i, idx in enumerate(sorted_atoms)]
-            self.show_atom_labels_for(pairs, color="blue")
+            self.show_atom_labels_for(pairs, color="yellow")
         else:
             self.clear_atom_labels()
 
@@ -167,7 +204,9 @@ class AlignPlaneDialog(BasePickingDialog):
         """Apply plane alignment (rotation-based)."""
         if len(self.selected_atoms) < 3:
             QMessageBox.warning(
-                self, "Warning", "Please select at least 3 atoms for align."
+                self,
+                "Warning",
+                "Please select at least 3 atoms for align.",
             )
             return
         try:
@@ -197,7 +236,8 @@ class AlignPlaneDialog(BasePickingDialog):
             elif self.plane == "yz":
                 target_normal = np.array([1, 0, 0])  # X-axis direction
             else:
-                target_normal = np.array([0, 0, 1])  # Default to Z-axis (XY plane)
+                # Default to Z-axis (XY plane)
+                target_normal = np.array([0, 0, 1])
 
             # Adjust normal vector direction
             if np.dot(normal_vector, target_normal) < 0:
@@ -207,36 +247,49 @@ class AlignPlaneDialog(BasePickingDialog):
             rotation_axis = np.cross(normal_vector, target_normal)
             rotation_axis_norm = np.linalg.norm(rotation_axis)
 
-            if rotation_axis_norm > 1e-10:
-                rotation_axis = rotation_axis / rotation_axis_norm
-                cos_angle = np.dot(normal_vector, target_normal)
-                cos_angle = np.clip(cos_angle, -1.0, 1.0)
-                rotation_angle = np.arccos(cos_angle)
-
-                # Rodrigues' rotation formula
-                def rodrigues_rotation(
-                    v: np.ndarray, axis: np.ndarray, angle: float
-                ) -> np.ndarray:
-                    cos_a = np.cos(angle)
-                    sin_a = np.sin(angle)
-                    return (  # type: ignore[no-any-return]
-                        v * cos_a
-                        + np.cross(axis, v) * sin_a
-                        + axis * np.dot(axis, v) * (1 - cos_a)
-                    )
-
-                # Rotate all atoms
-                conf = self.mol.GetConformer()
-                for i in range(self.mol.GetNumAtoms()):
-                    current_pos = np.array(conf.GetAtomPosition(i))
-                    centered_pos = current_pos - centroid
-                    rotated_pos = rodrigues_rotation(
-                        centered_pos, rotation_axis, rotation_angle
+            # Calculate new positions (rotated, centered back by default)
+            conf = self.mol.GetConformer()
+            new_positions = np.empty_like(positions)
+            for i in range(self.mol.GetNumAtoms()):
+                current_pos = np.array(conf.GetAtomPosition(i))
+                centered_pos = current_pos - centroid
+                if rotation_axis_norm > 1e-10:
+                    rot_norm = rotation_axis_norm
+                    rotation_axis_normalized = rotation_axis / rot_norm
+                    cos_angle = np.dot(normal_vector, target_normal)
+                    cos_angle = np.clip(cos_angle, -1.0, 1.0)
+                    rotation_angle = np.arccos(cos_angle)
+                    rotated_pos = rodrigues_rotate(
+                        centered_pos,
+                        rotation_axis_normalized,
+                        rotation_angle,
                     )
-                    new_pos = rotated_pos + centroid
-                    positions[i] = new_pos
+                else:
+                    rotated_pos = centered_pos
+                new_pos = rotated_pos + centroid
+                new_positions[i] = new_pos
+
+            # If move_to_zero_plane is True, translate so the plane
+            # of selected atoms is at zero
+            if self.move_to_zero_plane_checkbox.isChecked():
+                selected_new_positions = new_positions[selected_indices]
+                new_centroid = np.mean(selected_new_positions, axis=0)
+                translation_offset = np.zeros(3)
+                if self.plane == "xy":
+                    translation_offset[2] = new_centroid[2]
+                elif self.plane == "xz":
+                    translation_offset[1] = new_centroid[1]
+                elif self.plane == "yz":
+                    translation_offset[0] = new_centroid[0]
+                new_positions = new_positions - translation_offset
+
+            # Update the conformer positions array in place
+            for i in range(self.mol.GetNumAtoms()):
+                positions[i] = new_positions[i]
 
             self._update_molecule_geometry(positions)
+            self.show_atom_labels()
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+            logging.exception("Failed to apply align")
             QMessageBox.critical(self, "Error", f"Failed to apply align: {str(e)}")

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/src/moleditpy_linux/ui/alignment_dialog.py

@@ -10,11 +10,14 @@ Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
 """
 
-import numpy as np
+import logging
 from typing import TYPE_CHECKING, Literal, Optional, Sequence
 
+import numpy as np
+
 from PyQt6.QtGui import QCloseEvent
 from PyQt6.QtWidgets import (
+    QCheckBox,
     QDialog,
     QHBoxLayout,
     QLabel,
@@ -30,11 +33,23 @@ try:
 except ImportError:
     from moleditpy_linux.ui.dialog_3d_picking_mixin import Dialog3DPickingMixin
 
+try:
+    from .base_picking_dialog import SelectionList
+except ImportError:
+    from moleditpy_linux.ui.base_picking_dialog import SelectionList
+
+try:
+    from ..core.mol_geometry import rodrigues_rotate
+except ImportError:
+    from moleditpy_linux.core.mol_geometry import rodrigues_rotate
+
 if TYPE_CHECKING:
     from .main_window import MainWindow
 
 
 class AlignmentDialog(Dialog3DPickingMixin, QDialog):
+    """Dialog for aligning two selected atoms along a principal axis (X, Y, or Z)."""
+
     def __init__(
         self,
         mol: Chem.Mol,
@@ -48,21 +63,32 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
         self.mol = mol
         self.main_window = main_window
         self.axis = axis
-        self.selected_atoms: set[int] = set()
+        self._selected_atoms = SelectionList()
 
         # Add preselected atoms (maximum 2)
         if preselected_atoms:
-            self.selected_atoms.update(preselected_atoms[:2])
+            self._selected_atoms.update(preselected_atoms[:2])
 
         self.init_ui()
 
         # Add labels to preselected atoms
-        if self.selected_atoms:
-            for i, atom_idx in enumerate(sorted(self.selected_atoms), 1):
-                self.add_selection_label(atom_idx, f"Atom {i}")
+        if self._selected_atoms:
+            for i, atom_idx in enumerate(self._selected_atoms, 1):
+                self.add_selection_label(atom_idx, f"#{i}", color="yellow")
             self.update_display()
 
+    @property
+    def selected_atoms(self) -> SelectionList:
+        """Return the ordered list of selected atom indices."""
+        return self._selected_atoms
+
+    @selected_atoms.setter
+    def selected_atoms(self, val: object) -> None:
+        """Replace the selection with a new SelectionList built from val."""
+        self._selected_atoms = SelectionList(val)  # type: ignore[arg-type]
+
     def init_ui(self) -> None:
+        """Build and lay out all widgets for the alignment dialog."""
         axis_names = {"x": "X-axis", "y": "Y-axis", "z": "Z-axis"}
         self.setWindowTitle(f"Align to {axis_names[self.axis]}")
         self.setModal(False)
@@ -70,11 +96,17 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
 
         # Instructions
         instruction_label = QLabel(
-            f"Click atoms in the 3D view to select them for alignment to the {axis_names[self.axis]}. Exactly 2 atoms are required. The first atom will be moved to the origin, and the second atom will be positioned on the {axis_names[self.axis]}."
+            f"Click atoms in the 3D view to select them for alignment to the "
+            f"{axis_names[self.axis]}. Exactly 2 atoms are required."
         )
         instruction_label.setWordWrap(True)
         layout.addWidget(instruction_label)
 
+        # Move to origin option (default False)
+        self.move_to_origin_checkbox = QCheckBox("Move the first atom to the origin")
+        self.move_to_origin_checkbox.setChecked(False)
+        layout.addWidget(self.move_to_origin_checkbox)
+
         # Selected atoms display
         self.selection_label = QLabel("No atoms selected")
         layout.addWidget(self.selection_label)
@@ -114,10 +146,10 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
         else:
             # Maximum of 2 atoms can be selected
             if len(self.selected_atoms) < 2:
-                self.selected_atoms.add(atom_idx)
+                self.selected_atoms.append(atom_idx)
                 # Show label indicating selection order
-                label_text = f"Atom {len(self.selected_atoms)}"
-                self.add_selection_label(atom_idx, label_text)
+                label_text = f"#{len(self.selected_atoms)}"
+                self.add_selection_label(atom_idx, label_text, color="yellow")
 
         self.update_display()
 
@@ -129,14 +161,12 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
             )
             self.apply_button.setEnabled(False)
         elif len(self.selected_atoms) == 1:
-            selected_list = list(self.selected_atoms)
-            atom = self.mol.GetAtomWithIdx(selected_list[0])
+            atom = self.mol.GetAtomWithIdx(self.selected_atoms[0])
             self.selection_label.setText(f"Selected 1 atom: {atom.GetSymbol()}")
             self.apply_button.setEnabled(False)
         elif len(self.selected_atoms) == 2:
-            selected_list = sorted(list(self.selected_atoms))
-            atom1 = self.mol.GetAtomWithIdx(selected_list[0])
-            atom2 = self.mol.GetAtomWithIdx(selected_list[1])
+            atom1 = self.mol.GetAtomWithIdx(self.selected_atoms[0])
+            atom2 = self.mol.GetAtomWithIdx(self.selected_atoms[1])
             self.selection_label.setText(
                 f"Selected 2 atoms: {atom1.GetSymbol()}, {atom2.GetSymbol()}"
             )
@@ -148,13 +178,11 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
         self.selected_atoms.clear()
         self.update_display()
 
-    def remove_atom_label(self, atom_idx: int) -> None:
-        """Remove a label for a specific atom."""
-        # Re-draw all labels for simplicity
+    def remove_atom_label(self, _atom_idx: int) -> None:
+        """Remove a label for a specific atom (redraws all labels)."""
         self.clear_selection_labels()
-        for i, idx in enumerate(sorted(self.selected_atoms), 1):
-            if idx != atom_idx:
-                self.add_selection_label(idx, f"Atom {i}")
+        for i, idx in enumerate(self.selected_atoms, 1):
+            self.add_selection_label(idx, f"#{i}", color="yellow")
 
     def apply_alignment(self) -> None:
         """Apply the specific axial alignment to the molecule."""
@@ -164,26 +192,21 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
             )
             return
         try:
-            selected_list = sorted(list(self.selected_atoms))
-            atom1_idx, atom2_idx = selected_list[0], selected_list[1]
+            atom1_idx = self.selected_atoms[0]
+            atom2_idx = self.selected_atoms[1]
 
             conf = self.mol.GetConformer()
 
-            # Get current atom positions
-            pos1 = np.array(conf.GetAtomPosition(atom1_idx))
-            pos2 = np.array(conf.GetAtomPosition(atom2_idx))
-
-            # Translate entire molecule so atom1 is at the origin
-            translation = -pos1
-            for i in range(self.mol.GetNumAtoms()):
-                current_pos = np.array(conf.GetAtomPosition(i))
-                new_pos = current_pos + translation
-                conf.SetAtomPosition(i, new_pos.tolist())
+            # Get original atom positions
+            positions = np.array(
+                [list(conf.GetAtomPosition(i)) for i in range(self.mol.GetNumAtoms())]
+            )
+            centroid = np.mean(positions, axis=0)
 
-            # Get new position of atom2 after translation
-            pos2_translated = pos2 + translation
+            pos1 = positions[atom1_idx]
+            pos2 = positions[atom2_idx]
 
-            # Calculate rotation to align atom2 relative to the chosen axis
+            # Calculate rotation to align atom1 -> atom2 relative to the chosen axis
             axis_vectors = {
                 "x": np.array([1.0, 0.0, 0.0]),
                 "y": np.array([0.0, 1.0, 0.0]),
@@ -191,10 +214,13 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
             }
             target_axis = axis_vectors[self.axis]
 
-            # Direction vector from origin to translated atom2
-            current_vector = pos2_translated
+            # Direction vector from atom1 to atom2
+            current_vector = pos2 - pos1
             current_length = np.linalg.norm(current_vector)
 
+            # Keep track of rotated positions (initially original positions)
+            new_positions = np.copy(positions)
+
             if current_length > 1e-10:  # If not a zero vector
                 current_vector_normalized = current_vector / current_length
 
@@ -208,41 +234,44 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
                     cos_angle = np.clip(cos_angle, -1.0, 1.0)
                     rotation_angle = np.arccos(cos_angle)
 
-                    # Use Rodrigues' rotation formula
-                    def rodrigues_rotation(
-                        v: np.ndarray, k: np.ndarray, theta: float
-                    ) -> np.ndarray:
-                        cos_theta = np.cos(theta)
-                        sin_theta = np.sin(theta)
-                        return (  # type: ignore[no-any-return]
-                            v * cos_theta
-                            + np.cross(k, v) * sin_theta
-                            + k * np.dot(k, v) * (1 - cos_theta)
-                        )
-
-                    # Apply rotation to all atoms
+                    # Apply rotation to all atoms about the molecule's centroid
                     for i in range(self.mol.GetNumAtoms()):
-                        current_pos = np.array(conf.GetAtomPosition(i))
-                        rotated_pos = rodrigues_rotation(
-                            current_pos, rotation_axis, rotation_angle
-                        )
-                        conf.SetAtomPosition(
-                            i,
-                            Geometry.Point3D(
-                                float(rotated_pos[0]),
-                                float(rotated_pos[1]),
-                                float(rotated_pos[2]),
-                            ),
+                        rel_pos = positions[i] - centroid
+                        rotated_pos = rodrigues_rotate(
+                            rel_pos, rotation_axis, rotation_angle
                         )
+                        new_positions[i] = rotated_pos + centroid
+
+            # If move_to_origin is True, translate entire molecule so atom1 ends up at origin
+            if (
+                hasattr(self, "move_to_origin_checkbox")
+                and self.move_to_origin_checkbox.isChecked()
+            ):
+                new_pos1 = new_positions[atom1_idx]
+                new_positions = new_positions - new_pos1
+
+            # Update conformer positions
+            for i in range(self.mol.GetNumAtoms()):
+                conf.SetAtomPosition(
+                    i,
+                    Geometry.Point3D(
+                        float(new_positions[i][0]),
+                        float(new_positions[i][1]),
+                        float(new_positions[i][2]),
+                    ),
+                )
 
             # Update 3D positions
-            self.main_window.view_3d_manager.atom_positions_3d = np.array(
-                [list(conf.GetAtomPosition(i)) for i in range(self.mol.GetNumAtoms())]
-            )
+            self.main_window.view_3d_manager.atom_positions_3d = new_positions
 
             # Update 3D visualization
             self.main_window.view_3d_manager.draw_molecule_3d(self.mol)
 
+            # Restore selection labels
+            self.clear_selection_labels()
+            for i, idx in enumerate(self.selected_atoms, 1):
+                self.add_selection_label(idx, f"#{i}", color="yellow")
+
             # Update chirality labels
             self.main_window.view_3d_manager.update_chiral_labels()
 
@@ -250,10 +279,13 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
             self.main_window.edit_actions_manager.push_undo_state()
 
             QMessageBox.information(
-                self, "Success", f"Alignment to {self.axis.upper()}-axis completed."
+                self,
+                "Success",
+                f"Alignment to {self.axis.upper()}-axis completed.",
             )
 
         except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+            logging.exception("Failed to apply alignment")
             QMessageBox.critical(self, "Error", f"Failed to apply alignment: {str(e)}")
 
     def closeEvent(self, event: Optional[QCloseEvent]) -> None:

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/src/moleditpy_linux/ui/base_picking_dialog.py

@@ -28,6 +28,26 @@ if TYPE_CHECKING:
     from .main_window import MainWindow
 
 
+class SelectionList(list):
+    """Order-preserving list that compares equal to sets/lists/tuples of same elements."""
+
+    def __eq__(self, other: object) -> bool:
+        """Compare by membership, ignoring order."""
+        if isinstance(other, (set, list, tuple)):
+            return set(self) == set(other)
+        return super().__eq__(other)
+
+    def add(self, item: int) -> None:
+        """Append item only if not already present."""
+        if item not in self:
+            self.append(item)
+
+    def update(self, items: object) -> None:
+        """Append each item that is not already present."""
+        for item in items:  # type: ignore[union-attr]
+            self.add(item)
+
+
 class BasePickingDialog(Dialog3DPickingMixin, QDialog):
     """
     Base class for any dialog requiring 3D atom picking.

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/src/moleditpy_linux/ui/dialog_logic.py

@@ -16,6 +16,7 @@ import logging
 
 import json
 import os
+import sys
 from typing import Any, List, Literal, Optional, cast
 
 from PyQt6.QtWidgets import QInputDialog, QMessageBox, QDialog
@@ -23,7 +24,7 @@ from PyQt6.QtCore import Qt
 
 
 try:
-    # package relative imports (preferred when running as `python -m moleditpy`)
+    # package relative imports (preferred when running as python -m moleditpy)
     from .about_dialog import AboutDialog
     from .align_plane_dialog import AlignPlaneDialog
     from .alignment_dialog import AlignmentDialog
@@ -71,13 +72,19 @@ except ImportError:
 
 
 class DialogManager:
-    """Independent manager for UI dialogs, ported from MainWindowDialogManager mixin."""
+    """Independent manager for UI dialogs.
+
+    Ported from MainWindowDialogManager mixin.
+    """
 
     def __init__(self, host: Any) -> None:
         self.host = host
 
     def _get_preselected_atoms_3d(self) -> List[int]:
-        """Helper to collect preselected atoms from measurement mode (3D Select)."""
+        """Helper to collect preselected atoms from measurement mode.
+
+        Specifically for 3D Select.
+        """
         preselected_atoms = []
         if hasattr(self.host, "edit_3d_manager"):
             if self.host.edit_3d_manager.selected_atoms_for_measurement:
@@ -96,6 +103,7 @@ class DialogManager:
         dialog.exec()
 
     def open_periodic_table_dialog(self) -> None:
+        """Open the periodic table dialog and wire up element-selection callback."""
         dialog = PeriodicTableDialog(self.host)
         dialog.element_selected.connect(
             self.host.ui_manager.set_atom_from_periodic_table
@@ -108,6 +116,7 @@ class DialogManager:
         dialog.exec()
 
     def open_analysis_window(self) -> None:
+        """Open the analysis window for the current 3D molecule, if available."""
         if self.host.view_3d_manager.current_mol:
             dialog = AnalysisWindow(
                 self.host.view_3d_manager.current_mol,
@@ -126,7 +135,10 @@ class DialogManager:
         dialog.exec()
 
     def open_template_dialog_and_activate(self) -> None:
-        """Open the template dialog and activate the selected template for use in the main window"""
+        """Open the template dialog and activate it.
+
+        Used in the main window.
+        """
         # Check for existing dialog
         _template_dialog = getattr(self.host, "_template_dialog", None)
         if _template_dialog and not _template_dialog.isHidden():
@@ -218,7 +230,8 @@ class DialogManager:
 
     def _show_modeless_dialog(self, dialog: QDialog) -> None:
         """Show a modeless dialog on top, especially important for macOS."""
-        dialog.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
+        if sys.platform == "darwin":
+            dialog.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
         dialog.show()
         dialog.raise_()
         dialog.activateWindow()

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.4}/src/moleditpy_linux/ui/translation_dialog.py

@@ -10,6 +10,7 @@ Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
 """
 
+import logging
 from typing import Any
 
 import numpy as np
@@ -35,6 +36,8 @@ _TAB_DELTA = 1
 
 
 class TranslationDialog(BasePickingDialog):
+    """Dialog for translating selected atoms either absolutely or relatively."""
+
     def __init__(
         self,
         mol: Any,
@@ -45,6 +48,19 @@ class TranslationDialog(BasePickingDialog):
         super().__init__(mol, main_window, parent)
         self.selected_atoms = set()
 
+        # Predefine widgets to satisfy pylint W0201
+        self.abs_selection_label = None
+        self.abs_x_input = None
+        self.abs_y_input = None
+        self.abs_z_input = None
+        self.move_mol_checkbox = None
+        self.abs_apply_btn = None
+        self.delta_selection_label = None
+        self.dx_input = None
+        self.dy_input = None
+        self.dz_input = None
+        self.apply_button = None
+
         if preselected_atoms:
             self.selected_atoms.update(preselected_atoms)
 
@@ -56,7 +72,7 @@ class TranslationDialog(BasePickingDialog):
             self.tabs.blockSignals(True)
             if len(self.selected_atoms) == 1:
                 self.tabs.setCurrentIndex(_TAB_ABSOLUTE)
-                self._populate_abs_inputs_from_atom(next(iter(self.selected_atoms)))
+                self._populate_abs_inputs_from_centroid()
             else:
                 self.tabs.setCurrentIndex(_TAB_DELTA)
             self.tabs.blockSignals(False)
@@ -68,6 +84,7 @@ class TranslationDialog(BasePickingDialog):
     # ------------------------------------------------------------------
 
     def init_ui(self) -> None:
+        """Initialize and lay out all dialog widgets."""
         self.setWindowTitle("Translate Atoms")
         self.setModal(False)
         layout = QVBoxLayout(self)
@@ -89,16 +106,18 @@ class TranslationDialog(BasePickingDialog):
         self.enable_picking()
 
     def _build_absolute_tab(self) -> QWidget:
+        """Build the Absolute tab widget."""
         widget = QWidget()
         layout = QVBoxLayout(widget)
 
         instr = QLabel(
-            "Click one atom to select it, then specify its target absolute coordinates (Å)."
+            "Click atoms to select them. The centroid of the selection "
+            "will be translated to the target absolute coordinates (Å)."
         )
         instr.setWordWrap(True)
         layout.addWidget(instr)
 
-        self.abs_selection_label = QLabel("No atom selected")
+        self.abs_selection_label = QLabel("No atoms selected")
         layout.addWidget(self.abs_selection_label)
 
         coord_row = QHBoxLayout()
@@ -122,10 +141,17 @@ class TranslationDialog(BasePickingDialog):
         abs_clear_btn = QPushButton("Clear Selection")
         abs_clear_btn.clicked.connect(self._abs_clear_selection)
         btn_row.addWidget(abs_clear_btn)
+
+        abs_all_btn = QPushButton("Select All Atoms")
+        abs_all_btn.setToolTip("Select all atoms in the molecule")
+        abs_all_btn.clicked.connect(self._abs_select_all)
+        btn_row.addWidget(abs_all_btn)
+
         origin_btn = QPushButton("Set to Origin")
         origin_btn.setToolTip("Set target coordinates to the origin")
         origin_btn.clicked.connect(self._set_origin)
         btn_row.addWidget(origin_btn)
+
         btn_row.addStretch()
         self.abs_apply_btn = QPushButton("Move Molecule")
         self.abs_apply_btn.clicked.connect(self.apply_absolute)
@@ -185,7 +211,8 @@ class TranslationDialog(BasePickingDialog):
     # Tab switching
     # ------------------------------------------------------------------
 
-    def _on_tab_changed(self, index: int) -> None:
+    def _on_tab_changed(self, _index: int) -> None:
+        """Handle tab switching event to reset active selections."""
         if hasattr(self, "_is_initializing") and self._is_initializing:
             return
         self.selected_atoms.clear()
@@ -203,9 +230,12 @@ class TranslationDialog(BasePickingDialog):
             self._delta_on_atom_picked(atom_idx)
 
     def _abs_on_atom_picked(self, atom_idx: int) -> None:
-        # Enforce single selection: replace previous atom
-        self.selected_atoms = {atom_idx}
-        self._populate_abs_inputs_from_atom(atom_idx)
+        """Toggle atom in/out of the absolute-tab selection, then refresh centroid."""
+        if atom_idx in self.selected_atoms:
+            self.selected_atoms.discard(atom_idx)
+        else:
+            self.selected_atoms.add(atom_idx)
+        self._populate_abs_inputs_from_centroid()
         self.update_display()
         self.show_atom_labels()
 
@@ -221,19 +251,24 @@ class TranslationDialog(BasePickingDialog):
     # Absolute tab helpers
     # ------------------------------------------------------------------
 
-    def _populate_abs_inputs_from_atom(self, atom_idx: int) -> None:
+    def _populate_abs_inputs_from_centroid(self) -> None:
+        """Populate X/Y/Z inputs with the centroid of all currently selected atoms."""
+        if not self.selected_atoms:
+            return
         mol = self.main_window.view_3d_manager.current_mol
         if mol is None:
             return
         conf = mol.GetConformer()
         if conf is None:
             return
-        pos = conf.GetPositions()[atom_idx]
-        self.abs_x_input.setText(f"{pos[0]:.4f}")
-        self.abs_y_input.setText(f"{pos[1]:.4f}")
-        self.abs_z_input.setText(f"{pos[2]:.4f}")
+        positions = conf.GetPositions()
+        centroid = np.mean([positions[i] for i in self.selected_atoms], axis=0)
+        self.abs_x_input.setText(f"{centroid[0]:.4f}")
+        self.abs_y_input.setText(f"{centroid[1]:.4f}")
+        self.abs_z_input.setText(f"{centroid[2]:.4f}")
 
     def _abs_clear_selection(self) -> None:
+        """Clear the absolute-tab selection and reset coordinate inputs."""
         self.selected_atoms.clear()
         self.clear_atom_labels()
         self.abs_x_input.setText("0.000")
@@ -241,19 +276,35 @@ class TranslationDialog(BasePickingDialog):
         self.abs_z_input.setText("0.000")
         self.update_display()
 
+    def _abs_select_all(self) -> None:
+        """Select all atoms in the molecule for the absolute tab."""
+        try:
+            mol = self.main_window.view_3d_manager.current_mol
+            if mol is not None:
+                self.selected_atoms = set(range(mol.GetNumAtoms()))
+            self._populate_abs_inputs_from_centroid()
+            self.show_atom_labels()
+            self.update_display()
+        except (AttributeError, RuntimeError, TypeError) as exc:
+            logging.exception("Failed to select all atoms: %s", exc)
+
     def _set_origin(self) -> None:
         self.abs_x_input.setText("0.0000")
         self.abs_y_input.setText("0.0000")
         self.abs_z_input.setText("0.0000")
 
-    def _on_move_mol_toggled(self, state: int) -> None:
-        label = "Move Molecule" if self.move_mol_checkbox.isChecked() else "Move Atom"
+    def _on_move_mol_toggled(self, _state: int) -> None:
+        """Update Apply button label to reflect move-molecule vs move-selected mode."""
+        label = (
+            "Move Molecule" if self.move_mol_checkbox.isChecked() else "Move Selected"
+        )
         self.abs_apply_btn.setText(label)
 
     def apply_absolute(self) -> None:
+        """Translate selected atoms so their centroid reaches the target coordinates."""
         self.mol = self.main_window.view_3d_manager.current_mol
-        if len(self.selected_atoms) != 1:
-            QMessageBox.warning(self, "Warning", "Please select exactly one atom.")
+        if not self.selected_atoms:
+            QMessageBox.warning(self, "Warning", "Please select at least one atom.")
             return
 
         try:
@@ -266,10 +317,9 @@ class TranslationDialog(BasePickingDialog):
             )
             return
 
-        atom_idx = next(iter(self.selected_atoms))
         positions = self.mol.GetConformer().GetPositions()
-        current = positions[atom_idx]
-        delta = np.array([tx, ty, tz]) - current
+        centroid = np.mean([positions[i] for i in self.selected_atoms], axis=0)
+        delta = np.array([tx, ty, tz]) - centroid
 
         if np.allclose(delta, 0):
             return
@@ -277,10 +327,12 @@ class TranslationDialog(BasePickingDialog):
         if self.move_mol_checkbox.isChecked():
             positions += delta
         else:
-            positions[atom_idx] += delta
+            for atom_idx in self.selected_atoms:
+                positions[atom_idx] += delta
 
         self._update_molecule_geometry(positions)
         self._push_undo()
+        self._populate_abs_inputs_from_centroid()
         self.show_atom_labels()
 
     # ------------------------------------------------------------------
@@ -288,11 +340,13 @@ class TranslationDialog(BasePickingDialog):
     # ------------------------------------------------------------------
 
     def clear_selection(self) -> None:
+        """Clear active atom selection for the relative tab."""
         self.selected_atoms.clear()
         self.clear_atom_labels()
         self.update_display()
 
     def select_all_atoms(self) -> None:
+        """Select all atoms in the molecule for relative translation."""
         try:
             if hasattr(self, "mol") and self.mol is not None:
                 self.selected_atoms = set(range(self.mol.GetNumAtoms()))
@@ -308,6 +362,7 @@ class TranslationDialog(BasePickingDialog):
             QMessageBox.warning(self, "Warning", f"Failed to select all atoms: {e}")
 
     def apply_translation(self) -> None:
+        """Apply relative translation vector to selected atoms."""
         self.mol = self.main_window.view_3d_manager.current_mol
         if not self.selected_atoms:
             QMessageBox.warning(self, "Warning", "Please select at least one atom.")
@@ -340,17 +395,32 @@ class TranslationDialog(BasePickingDialog):
     # ------------------------------------------------------------------
 
     def update_display(self) -> None:
+        """Update label descriptions and button enablement states."""
         tab = self.tabs.currentIndex()
         count = len(self.selected_atoms)
 
         if tab == _TAB_ABSOLUTE:
             if count == 0:
-                self.abs_selection_label.setText("Click one atom to select it")
+                self.abs_selection_label.setText("Click atoms to select them")
                 self.abs_apply_btn.setEnabled(False)
             else:
-                atom_idx = next(iter(self.selected_atoms))
-                sym = self.mol.GetAtomWithIdx(atom_idx).GetSymbol()
-                self.abs_selection_label.setText(f"Selected: atom {atom_idx} ({sym})")
+                mol = self.main_window.view_3d_manager.current_mol
+                if mol is not None and self.selected_atoms:
+                    positions = mol.GetConformer().GetPositions()
+                    centroid = np.mean(
+                        [positions[i] for i in self.selected_atoms], axis=0
+                    )
+                    centroid_str = (
+                        f"({centroid[0]:.3f}, {centroid[1]:.3f}, {centroid[2]:.3f})"
+                    )
+                    self.abs_selection_label.setText(
+                        f"{count} atom{'s' if count != 1 else ''} selected "
+                        f"— centroid: {centroid_str}"
+                    )
+                else:
+                    self.abs_selection_label.setText(
+                        f"{count} atom{'s' if count != 1 else ''} selected"
+                    )
                 self.abs_apply_btn.setEnabled(True)
         else:
             if count == 0:
@@ -365,6 +435,7 @@ class TranslationDialog(BasePickingDialog):
                 self.apply_button.setEnabled(True)
 
     def show_atom_labels(self) -> None:
+        """Redraw selection numeric tags in the active 3D viewport."""
         if self.selected_atoms:
             sorted_atoms = sorted(self.selected_atoms)
             pairs = [(idx, str(i + 1)) for i, idx in enumerate(sorted_atoms)]