Creazione del software per la manipolazione e gestione dei Tensori Narrativi (Narrative Tensors) di Luigi Usai

#Creazione del software per la manipolazione e gestione dei Tensori Narrativi (Narrative Tensors) di Luigi Usai

# versione iniziale 0.0.0.5

# per ora i tensori sono generati random: bisogna implementare l’algoritmo corretto di creazione tensore narrativo.

import sys
import os
import json
import numpy as np
import matplotlib.pyplot as plt
from PyQt5.QtWidgets import QApplication, QMainWindow, QAction, QFileDialog, QMessageBox, QTextEdit, QLabel, QVBoxLayout, QDialog
from PyQt5.QtGui import QPixmap
from PyQt5.QtCore import Qt
from docx import Document
import PyPDF2

class TensoreNarrativoApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("Interfaccia Tensore Narrativo")
        self.setGeometry(300, 300, 800, 500)

        self.text_edit = QTextEdit(self)
        self.setCentralWidget(self.text_edit)

        self.file_path = None
        self.tensore_path = "Tensori_Salvati/"

        if not os.path.exists(self.tensore_path):
            os.makedirs(self.tensore_path)

        # Creazione del menu
        menu_bar = self.menuBar()
        file_menu = menu_bar.addMenu("File")
        about_menu = menu_bar.addMenu("About")

        file_menu.addAction(QAction("Apri File", self, triggered=self.load_file))
        file_menu.addAction(QAction("Salva File", self, triggered=self.save_file))
        file_menu.addAction(QAction("Crea Tensore da Testo", self, triggered=self.create_tensor))
        file_menu.addAction(QAction("Carica Tensore Esistente", self, triggered=self.load_existing_tensor))
        file_menu.addAction(QAction("Visualizza Tensore", self, triggered=self.visualize_tensor))

        about_menu.addAction(QAction("Informazioni", self, triggered=self.show_about))

    def load_file(self):
        file_path, _ = QFileDialog.getOpenFileName(self, "Seleziona un File", "", "Text Files (*.txt);;Word Files (*.docx);;PDF Files (*.pdf)")
        if file_path:
            self.file_path = file_path
            self.text_edit.setText(self.read_file(file_path))

    def read_file(self, file_path):
        try:
            if file_path.endswith(".txt"):
                with open(file_path, "r", encoding="utf-8") as f:
                    return f.read()
            elif file_path.endswith(".docx"):
                doc = Document(file_path)
                return "\n".join([para.text for para in doc.paragraphs])
            elif file_path.endswith(".pdf"):
                with open(file_path, "rb") as f:
                    reader = PyPDF2.PdfReader(f)
                    return "\n".join([page.extract_text() for page in reader.pages])
        except Exception as e:
            QMessageBox.warning(self, "Errore di lettura", f"Impossibile aprire il file: {str(e)}")
        return ""

    def save_file(self):
        if self.file_path:
            with open(self.file_path, "w", encoding="utf-8") as f:
                f.write(self.text_edit.toPlainText())
            QMessageBox.information(self, "Salvataggio", "Il file è stato salvato con successo!")
        else:
            QMessageBox.warning(self, "Errore", "Nessun file caricato, impossibile salvare.")

    def create_tensor(self):
        if not self.file_path:
            QMessageBox.warning(self, "Errore", "Carica prima un file!")
            return

        text = self.text_edit.toPlainText()
        tensore = self.generate_tensor(text)

        tensor_filename = os.path.join(self.tensore_path, os.path.basename(self.file_path) + "_tensor.json")
        with open(tensor_filename, "w", encoding="utf-8") as f:
            json.dump(tensore, f, indent=4)

        QMessageBox.information(self, "Tensore Generato", f"Tensore salvato con successo in {tensor_filename}")

    def generate_tensor(self, text):
        """Crea un tensore narrativo con valori normalizzati."""
        np.random.seed(42)  # Per risultati coerenti
        return {
            "Dimensione Tematica": round(np.random.uniform(0, 1), 2),
            "Dimensione Linguaggio e Stile": round(np.random.uniform(0, 1), 2),
            "Dimensione Struttura Temporale e Ritmo": round(np.random.uniform(0, 1), 2),
            "Dimensione Evoluzione Personaggi": round(np.random.uniform(0, 1), 2),
            "Dimensione Tonalità ed Emozioni": round(np.random.uniform(0, 1), 2)
        }

    def visualize_tensor(self):
        """Genera una visualizzazione grafica del Tensore Narrativo."""
        tensor_data = self.generate_tensor(self.text_edit.toPlainText())
        labels = list(tensor_data.keys())
        values = list(tensor_data.values())

        fig, ax = plt.subplots(figsize=(6, 6))
        ax.pie(values, labels=labels, autopct='
        ax.axis("equal")

        plt.title("Distribuzione delle Dimensioni del Tensore Narrativo")
        plt.show()

    def load_existing_tensor(self):
        tensor_file, _ = QFileDialog.getOpenFileName(self, "Carica Tensore", self.tensore_path, "JSON Files (*.json)")
        if tensor_file:
            with open(tensor_file, "r", encoding="utf-8") as f:
                tensor_data = json.load(f)
            QMessageBox.information(self, "Tensore Caricato", f"Tensore:\n{json.dumps(tensor_data, indent=4)}")

    def show_about(self):
        """Mostra la finestra About con informazioni sul software."""
        about_window = QDialog(self)
        about_window.setWindowTitle("Informazioni")
        about_window.setGeometry(400, 400, 400, 300)

        layout = QVBoxLayout()

        image_label = QLabel()
        pixmap = QPixmap("luigiusai.jpg")  # Assicurati che l'immagine esista nella directory del programma
        image_label.setPixmap(pixmap)
        layout.addWidget(image_label)

        text_label = QLabel("Software Tensori Narrativi\nAutore: Dr. Luigi Usai\nCreato il: 13 Maggio 2025 a Quartucciu")
        layout.addWidget(text_label)

        about_window.setLayout(layout)
        about_window.exec_()  # Usa exec_() per mantenere la finestra aperta

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = TensoreNarrativoApp()
    window.show()
    sys.exit(app.exec_())