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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 3.6.2
+Version: 3.6.3
 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.3}/pyproject.toml

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

{moleditpy_linux-3.6.2 → moleditpy_linux-3.6.3}/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.3
 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.3}/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,17 @@ 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
 
 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 +48,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 +80,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 +129,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 +163,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 +175,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 +191,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 +199,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 +231,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 +242,61 @@ 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)
-                    )
+            # 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
+            # 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_rotation(
-                        centered_pos, rotation_axis, rotation_angle
+                        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.3}/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,18 @@ 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
+
 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 +58,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 +91,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 +141,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 +156,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 +173,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,8 +187,8 @@ 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()
 
@@ -235,6 +258,14 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
                             ),
                         )
 
+            # If move_to_origin is False, translate back so atom1 is
+            # at its original position
+            if not self.move_to_origin_checkbox.isChecked():
+                for i in range(self.mol.GetNumAtoms()):
+                    current_pos = np.array(conf.GetAtomPosition(i))
+                    restored_pos = current_pos - translation
+                    conf.SetAtomPosition(i, restored_pos.tolist())
+
             # 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())]
@@ -243,6 +274,11 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
             # 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 +286,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.3}/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.3}/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()