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

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

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

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

{moleditpy_linux-3.6.3 → moleditpy_linux-3.6.5}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 3.6.3
+Version: 3.6.5
 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.3 → moleditpy_linux-3.6.5}/src/moleditpy_linux/ui/align_plane_dialog.py

@@ -31,6 +31,11 @@ try:
 except ImportError:
     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
 
@@ -242,18 +247,6 @@ class AlignPlaneDialog(BasePickingDialog):
             rotation_axis = np.cross(normal_vector, target_normal)
             rotation_axis_norm = np.linalg.norm(rotation_axis)
 
-            # 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)
-                )
-
             # Calculate new positions (rotated, centered back by default)
             conf = self.mol.GetConformer()
             new_positions = np.empty_like(positions)
@@ -266,7 +259,7 @@ class AlignPlaneDialog(BasePickingDialog):
                     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(
+                    rotated_pos = rodrigues_rotate(
                         centered_pos,
                         rotation_axis_normalized,
                         rotation_angle,

{moleditpy_linux-3.6.3 → moleditpy_linux-3.6.5}/src/moleditpy_linux/ui/alignment_dialog.py

@@ -38,6 +38,11 @@ try:
 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
 
@@ -192,21 +197,16 @@ class AlignmentDialog(Dialog3DPickingMixin, QDialog):
 
             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]),
@@ -214,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
 
@@ -231,45 +234,35 @@ 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 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())
+            # 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)

{moleditpy_linux-3.6.3 → moleditpy_linux-3.6.5}/src/moleditpy_linux/ui/io_logic.py

@@ -942,7 +942,7 @@ class IOManager:
                     symbol = self.host.view_3d_manager.current_mol.GetAtomWithIdx(
                         i
                     ).GetSymbol()
-                    xyz_lines.append(f"{symbol} {pos.x:.6f} {pos.y:.6f} {pos.z:.6f}")
+                    xyz_lines.append(f"  {symbol:<11}{pos.x:11.8f}      {pos.y:11.8f}      {pos.z:11.8f}")
 
                 with open(file_path, "w", encoding="utf-8") as f:
                     f.write("\n".join(xyz_lines) + "\n")

{moleditpy_linux-3.6.3 → moleditpy_linux-3.6.5}/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)]