MoleditPy-linux 2.4.1__py3-none-any.whl

moleditpy_linux/modules/planarize_dialog.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QLabel, QHBoxLayout, QPushButton, QMessageBox
+)
+from PyQt6.QtCore import Qt
+import numpy as np
+
+try:
+    from .dialog3_d_picking_mixin import Dialog3DPickingMixin
+except Exception:
+    from modules.dialog3_d_picking_mixin import Dialog3DPickingMixin
+
+class PlanarizeDialog(Dialog3DPickingMixin, QDialog):
+
+    """選択原子群を最適フィット平面へ投影して planarize するダイアログ
+    AlignPlane を参考にした選択UIを持ち、Apply ボタンで選択原子を平面へ直交射影する。
+    """
+    def __init__(self, mol, main_window, preselected_atoms=None, parent=None):
+        QDialog.__init__(self, parent)
+        Dialog3DPickingMixin.__init__(self)
+        self.mol = mol
+        self.main_window = main_window
+        self.selected_atoms = set()
+
+        if preselected_atoms:
+            # 事前選択された原子を追加
+            self.selected_atoms.update(preselected_atoms)
+
+        self.init_ui()
+
+        if self.selected_atoms:
+            self.show_atom_labels()
+            self.update_display()
+
+    def init_ui(self):
+        self.setWindowTitle("Planarize")
+        self.setModal(False)
+        layout = QVBoxLayout(self)
+
+        instruction_label = QLabel("Click atoms in the 3D view to select them for planarization (minimum 3 required).")
+        instruction_label.setWordWrap(True)
+        layout.addWidget(instruction_label)
+
+        self.selection_label = QLabel("No atoms selected")
+        layout.addWidget(self.selection_label)
+
+
+        button_layout = QHBoxLayout()
+        self.clear_button = QPushButton("Clear Selection")
+        self.clear_button.clicked.connect(self.clear_selection)
+        button_layout.addWidget(self.clear_button)
+    
+        # Select All Atoms ボタンを追加
+        self.select_all_button = QPushButton("Select All Atoms")
+        self.select_all_button.setToolTip("Select all atoms in the molecule for planarization")
+        self.select_all_button.clicked.connect(self.select_all_atoms)
+        button_layout.addWidget(self.select_all_button)
+
+        self.apply_button = QPushButton("Apply planarize")
+        self.apply_button.clicked.connect(self.apply_planarize)
+        self.apply_button.setEnabled(False)
+        button_layout.addWidget(self.apply_button)
+    
+        close_button = QPushButton("Close")
+        close_button.clicked.connect(self.reject)
+        button_layout.addWidget(close_button)
+
+        button_layout.addStretch()
+    
+        layout.addLayout(button_layout)
+
+        # enable picking
+        self.picker_connection = None
+        self.enable_picking()
+
+    def on_atom_picked(self, atom_idx):
+        if atom_idx in self.selected_atoms:
+            self.selected_atoms.remove(atom_idx)
+        else:
+            self.selected_atoms.add(atom_idx)
+        self.show_atom_labels()
+        self.update_display()
+
+    def clear_selection(self):
+        self.selected_atoms.clear()
+        self.clear_atom_labels()
+        self.update_display()
+
+    def update_display(self):
+        count = len(self.selected_atoms)
+        if count == 0:
+            self.selection_label.setText("Click atoms to select for planarize (minimum 3 required)")
+            self.apply_button.setEnabled(False)
+        else:
+            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 select_all_atoms(self):
+        """Select all atoms in the current molecule (or fallback) and update labels/UI."""
+        try:
+            # Prefer RDKit molecule if available
+            if hasattr(self, 'mol') and self.mol is not None:
+                try:
+                    n = self.mol.GetNumAtoms()
+                    # create a set of indices [0..n-1]
+                    self.selected_atoms = set(range(n))
+                except Exception:
+                    # fallback to main_window data map
+                    self.selected_atoms = set(self.main_window.data.atoms.keys()) if hasattr(self.main_window, 'data') else set()
+            else:
+                # fallback to main_window data map
+                self.selected_atoms = set(self.main_window.data.atoms.keys()) if hasattr(self.main_window, 'data') else set()
+
+            # Update labels and display
+            self.show_atom_labels()
+            self.update_display()
+
+        except Exception as e:
+            QMessageBox.warning(self, "Warning", f"Failed to select all atoms: {e}")
+
+    def show_atom_labels(self):
+        self.clear_atom_labels()
+        if not hasattr(self, 'selection_labels'):
+            self.selection_labels = []
+        if self.selected_atoms:
+            for i, atom_idx in enumerate(sorted(self.selected_atoms)):
+                pos = self.main_window.atom_positions_3d[atom_idx]
+                label_text = f"#{i+1}"
+                label_actor = self.main_window.plotter.add_point_labels(
+                    [pos], [label_text],
+                    point_size=20,
+                    font_size=12,
+                    text_color='cyan',
+                    always_visible=True
+                )
+                self.selection_labels.append(label_actor)
+
+    def clear_atom_labels(self):
+        if hasattr(self, 'selection_labels'):
+            for label_actor in self.selection_labels:
+                try:
+                    self.main_window.plotter.remove_actor(label_actor)
+                except Exception:
+                    pass
+            self.selection_labels = []
+
+    def apply_planarize(self):
+        if not self.selected_atoms or len(self.selected_atoms) < 3:
+            QMessageBox.warning(self, "Warning", "Please select at least 3 atoms for planarize.")
+            return
+
+        try:
+            selected_indices = list(sorted(self.selected_atoms))
+            selected_positions = self.main_window.atom_positions_3d[selected_indices].copy()
+
+            centroid = np.mean(selected_positions, axis=0)
+            centered_positions = selected_positions - centroid
+
+            # SVDによる最小二乗平面の法線取得
+            u, s, vh = np.linalg.svd(centered_positions, full_matrices=False)
+            normal = vh[-1]
+            norm = np.linalg.norm(normal)
+            if norm == 0:
+                QMessageBox.warning(self, "Warning", "Cannot determine fit plane (degenerate positions).")
+                return
+            normal = normal / norm
+
+            # 各点を重心を通る平面へ直交射影
+            projections = centered_positions - np.outer(np.dot(centered_positions, normal), normal)
+            new_positions = projections + centroid
+
+            # 分子座標を更新
+            conf = self.mol.GetConformer()
+            for i, new_pos in zip(selected_indices, new_positions):
+                conf.SetAtomPosition(int(i), new_pos.tolist())
+                self.main_window.atom_positions_3d[int(i)] = new_pos
+
+            # 3Dビュー更新
+            self.main_window.draw_molecule_3d(self.mol)
+            self.main_window.update_chiral_labels()
+            self.main_window.push_undo_state()
+
+            QMessageBox.information(self, "Success", f"Planarized {len(selected_indices)} atoms to best-fit plane.")
+
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to planarize: {e}")
+
+    def closeEvent(self, event):
+        """ダイアログが閉じられる時の処理"""
+        self.clear_atom_labels()
+        self.disable_picking()
+        super().closeEvent(event)
+
+    def reject(self):
+        """キャンセル時の処理"""
+        self.clear_atom_labels()
+        self.disable_picking()
+        super().reject()
+
+    def accept(self):
+        """OK時の処理"""
+        self.clear_atom_labels()
+        self.disable_picking()
+        super().accept()

moleditpy_linux/modules/plugin_interface.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+from typing import Callable, Optional, Any
+
+class PluginContext:
+    """
+    PluginContext provides a safe interface for plugins to interact with the application.
+    It is passed to the `initialize(context)` function of the plugin.
+    """
+    def __init__(self, manager, plugin_name: str):
+        self._manager = manager
+        self._plugin_name = plugin_name
+
+    def add_menu_action(self, path: str, callback: Callable, text: Optional[str] = None, icon: Optional[str] = None, shortcut: Optional[str] = None):
+        """
+        Register a menu action.
+        
+        Args:
+            path: Menu path, e.g., "File/Import", "Edit", or "MyPlugin" (top level).
+            callback: Function to call when triggered.
+            text: Label for the action (defaults to last part of path if None).
+            icon: Path to icon or icon name (optional).
+            shortcut: Keyboard shortcut (optional).
+        """
+        self._manager.register_menu_action(self._plugin_name, path, callback, text, icon, shortcut)
+
+    def add_toolbar_action(self, callback: Callable, text: str, icon: Optional[str] = None, tooltip: Optional[str] = None):
+        """
+        Register a toolbar action.
+        """
+        self._manager.register_toolbar_action(self._plugin_name, callback, text, icon, tooltip)
+
+    def register_drop_handler(self, callback: Callable[[str], bool], priority: int = 0):
+        """
+        Register a handler for file drops.
+        
+        Args:
+            callback: Function taking (file_path) -> bool. Returns True if handled.
+            priority: Higher priority handlers are tried first.
+        """
+        self._manager.register_drop_handler(self._plugin_name, callback, priority)
+
+
+
+    def get_3d_controller(self) -> 'Plugin3DController':
+        """
+        Returns a controller to manipulate the 3D scene (e.g. colors).
+        """
+        return Plugin3DController(self._manager.get_main_window())
+
+    def get_main_window(self) -> Any:
+        """
+        Returns the raw MainWindow instance. 
+        Use with caution; prefer specific methods when available.
+        """
+        return self._manager.get_main_window()
+
+    @property
+    def current_molecule(self) -> Any:
+        """
+        Get or set the current molecule (RDKit Mol object).
+        """
+        mw = self._manager.get_main_window()
+        if mw:
+            return mw.current_mol
+        return None
+
+    @current_molecule.setter
+    def current_molecule(self, mol: Any):
+        mw = self._manager.get_main_window()
+        if mw:
+            mw.current_mol = mol
+            if hasattr(mw, 'draw_molecule_3d'):
+                 mw.draw_molecule_3d(mol)
+
+    def add_export_action(self, label: str, callback: Callable):
+        """
+        Register a custom export action.
+        
+        Args:
+            label: Text to display in the Export menu (e.g., "Export as MyFormat...").
+            callback: Function to call when triggered.
+        """
+        self._manager.register_export_action(self._plugin_name, label, callback)
+
+    def register_optimization_method(self, method_name: str, callback: Callable[[Any], bool]):
+        """
+        Register a custom 3D optimization method.
+        
+        Args:
+            method_name: Name of the method to display in 3D Optimization menu.
+            callback: Function taking (rdkit_mol) -> bool (success).
+                      Modifies the molecule in-place.
+        """
+        self._manager.register_optimization_method(self._plugin_name, method_name, callback)
+
+    def register_file_opener(self, extension: str, callback: Callable[[str], None], priority: int = 0):
+        """
+        Register a handler for opening a specific file extension.
+        
+        Args:
+            extension: File extension including dot, e.g. ".xyz".
+            callback: Function taking (file_path) -> None.
+                      Should load the file into the main window.
+            priority: Higher priority handlers are tried first (default 0).
+        """
+        self._manager.register_file_opener(self._plugin_name, extension, callback, priority)
+
+
+
+    def add_analysis_tool(self, label: str, callback: Callable):
+        """
+        Register a tool in the Analysis menu.
+        
+        Args:
+            label: Text to display in the menu.
+            callback: Function to contact when triggered.
+        """
+        self._manager.register_analysis_tool(self._plugin_name, label, callback)
+
+    def register_save_handler(self, callback: Callable[[], dict]):
+        """
+        Register a callback to save state into the project file.
+        
+        Args:
+            callback: Function returning a dict of serializable data.
+        """
+        self._manager.register_save_handler(self._plugin_name, callback)
+
+    def register_load_handler(self, callback: Callable[[dict], None]):
+        """
+        Register a callback to restore state from the project file.
+        
+        Args:
+            callback: Function receiving the dict of saved data.
+        """
+    def register_load_handler(self, callback: Callable[[dict], None]):
+        """
+        Register a callback to restore state from the project file.
+        
+        Args:
+            callback: Function receiving the dict of saved data.
+        """
+        self._manager.register_load_handler(self._plugin_name, callback)
+
+    def register_3d_context_menu(self, callback: Callable, label: str):
+        """Deprecated: This method does nothing. Kept for backward compatibility."""
+        print(f"Warning: Plugin '{self._plugin_name}' uses deprecated 'register_3d_context_menu'. This API has been removed.")
+
+    def register_3d_style(self, style_name: str, callback: Callable[[Any, Any], None]):
+        """
+        Register a custom 3D rendering style.
+        
+        Args:
+            style_name: Name of the style (must be unique).
+            callback: Function taking (main_window, mol) -> None.
+                      Should fully handle drawing the molecule in the 3D view.
+        """
+        self._manager.register_3d_style(self._plugin_name, style_name, callback)
+
+    def register_document_reset_handler(self, callback: Callable[[], None]):
+        """
+        Register a callback to be called when a new document is created (File→New).
+        
+        Args:
+            callback: Function with no arguments that resets plugin state.
+        """
+        self._manager.register_document_reset_handler(self._plugin_name, callback)
+
+
+
+
+
+
+
+class Plugin3DController:
+    """Helper to manipulate the 3D scene."""
+    def __init__(self, main_window):
+        self._mw = main_window
+
+    def set_atom_color(self, atom_index: int, color_hex: str):
+        """
+        Set the color of a specific atom in the 3D view.
+        Args:
+            atom_index: RDKit atom index.
+            color_hex: Hex string e.g., "#FF0000".
+        """
+        # This will need to hook into the actual 3D view logic
+        if hasattr(self._mw, 'main_window_view_3d'):
+             # Logic to update color map and trigger redraw
+             # For now we can assume we might need to expose a method in view_3d
+             self._mw.main_window_view_3d.update_atom_color_override(atom_index, color_hex)
+             self._mw.plotter.render()
+
+    def set_bond_color(self, bond_index: int, color_hex: str):
+        """
+        Set the color of a specific bond in the 3D view.
+
+        Args:
+             bond_index: RDKit bond index.
+             color_hex: Hex string e.g., "#00FF00".
+        """
+        if hasattr(self._mw, 'main_window_view_3d'):
+            self._mw.main_window_view_3d.update_bond_color_override(bond_index, color_hex)
+            self._mw.plotter.render()