# 選擇輸入文件和停用詞文件 
analyzer.select_input_file() 
analyzer.select_stopwords_file() 


# 處理文件 
analyzer.process_file()

# 執(zhí)行基礎(chǔ)分析 
analyzer.word_frequency_analysis() 
analyzer.character_count_analysis() 
analyzer.sentence_count_analysis()

# 執(zhí)行高級(jí)分析 
analyzer.pos_tagging_analysis() 
analyzer.named_entity_recognition() 
analyzer.keyword_extraction_analysis()

# 執(zhí)行可視化 
analyzer.generate_word_cloud() 
analyzer.generate_word_freq_chart() 
analyzer.generate_word_cooccurrence_network()

# 執(zhí)行NLP任務(wù) 
analyzer.text_classification() 
analyzer.sentiment_analysis() 
analyzer.text_summarization()

# -*- coding: utf-8 -*-
import sys
import os
import jieba
import jieba.posseg as pseg
import jieba.analyse
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from collections import Counter
import re
import networkx as nx
import matplotlib.pyplot as plt
from wordcloud import WordCloud
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
import numpy as np
import string

class ChineseTextAnalyzer:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title("中文文本分析程序")
        self.window.geometry("800x600")

        self.notebook = ttk.Notebook(self.window)
        self.notebook.pack(fill=tk.BOTH, expand=True)

        self.input_file = ""
        self.output_file = ""
        self.text_content = ""
        self.stopwords = set()
        self.punctuation = set(string.punctuation + '，。?。?、；：""''（）【】《》')

        self.create_file_tab()
        self.create_basic_analysis_tab()
        self.create_advanced_analysis_tab()
        self.create_visualization_tab()
        self.create_nlp_tab()

    def create_file_tab(self):
        file_tab = ttk.Frame(self.notebook)
        self.notebook.add(file_tab, text="文件操作")

        input_frame = ttk.LabelFrame(file_tab, text="輸入文件")
        input_frame.pack(fill=tk.X, padx=5, pady=5)

        self.input_entry = ttk.Entry(input_frame, width=50)
        self.input_entry.pack(side=tk.LEFT, padx=5, pady=5)

        input_button = ttk.Button(input_frame, text="瀏覽", command=self.select_input_file)
        input_button.pack(side=tk.LEFT, padx=5, pady=5)

        stopwords_frame = ttk.LabelFrame(file_tab, text="停用詞文件")
        stopwords_frame.pack(fill=tk.X, padx=5, pady=5)

        self.stopwords_entry = ttk.Entry(stopwords_frame, width=50)
        self.stopwords_entry.pack(side=tk.LEFT, padx=5, pady=5)

        stopwords_button = ttk.Button(stopwords_frame, text="瀏覽", command=self.select_stopwords_file)
        stopwords_button.pack(side=tk.LEFT, padx=5, pady=5)

        process_button = ttk.Button(file_tab, text="處理文件", command=self.process_file)
        process_button.pack(pady=10)

        self.file_log = tk.Text(file_tab, height=10)
        self.file_log.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

    def create_basic_analysis_tab(self):
        basic_tab = ttk.Frame(self.notebook)
        self.notebook.add(basic_tab, text="基礎(chǔ)分析")

        options_frame = ttk.LabelFrame(basic_tab, text="分析選項(xiàng)")
        options_frame.pack(fill=tk.X, padx=5, pady=5)

        self.word_freq_var = tk.BooleanVar()
        word_freq_check = ttk.Checkbutton(options_frame, text="詞頻統(tǒng)計(jì)", variable=self.word_freq_var)
        word_freq_check.pack(anchor=tk.W)

        self.char_count_var = tk.BooleanVar()
        char_count_check = ttk.Checkbutton(options_frame, text="字符數(shù)統(tǒng)計(jì)", variable=self.char_count_var)
        char_count_check.pack(anchor=tk.W)

        self.sentence_count_var = tk.BooleanVar()
        sentence_count_check = ttk.Checkbutton(options_frame, text="句子數(shù)統(tǒng)計(jì)", variable=self.sentence_count_var)
        sentence_count_check.pack(anchor=tk.W)

        analyze_button = ttk.Button(basic_tab, text="開始分析", command=self.perform_basic_analysis)
        analyze_button.pack(pady=10)

        self.basic_log = tk.Text(basic_tab, height=10)
        self.basic_log.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

    def create_advanced_analysis_tab(self):
        advanced_tab = ttk.Frame(self.notebook)
        self.notebook.add(advanced_tab, text="高級(jí)分析")

        options_frame = ttk.LabelFrame(advanced_tab, text="分析選項(xiàng)")
        options_frame.pack(fill=tk.X, padx=5, pady=5)

        self.pos_tagging_var = tk.BooleanVar()
        pos_tagging_check = ttk.Checkbutton(options_frame, text="詞性標(biāo)注", variable=self.pos_tagging_var)
        pos_tagging_check.pack(anchor=tk.W)

        self.named_entity_var = tk.BooleanVar()
        named_entity_check = ttk.Checkbutton(options_frame, text="命名實(shí)體識(shí)別", variable=self.named_entity_var)
        named_entity_check.pack(anchor=tk.W)

        self.keyword_extraction_var = tk.BooleanVar()
        keyword_extraction_check = ttk.Checkbutton(options_frame, text="關(guān)鍵詞提取", variable=self.keyword_extraction_var)
        keyword_extraction_check.pack(anchor=tk.W)

        analyze_button = ttk.Button(advanced_tab, text="開始分析", command=self.perform_advanced_analysis)
        analyze_button.pack(pady=10)

        self.advanced_log = tk.Text(advanced_tab, height=10)
        self.advanced_log.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

    def create_visualization_tab(self):
        visualization_tab = ttk.Frame(self.notebook)
        self.notebook.add(visualization_tab, text="可視化")

        options_frame = ttk.LabelFrame(visualization_tab, text="可視化選項(xiàng)")
        options_frame.pack(fill=tk.X, padx=5, pady=5)

        self.word_cloud_var = tk.BooleanVar()
        word_cloud_check = ttk.Checkbutton(options_frame, text="詞云圖", variable=self.word_cloud_var)
        word_cloud_check.pack(anchor=tk.W)

        self.word_freq_chart_var = tk.BooleanVar()
        word_freq_chart_check = ttk.Checkbutton(options_frame, text="詞頻柱狀圖", variable=self.word_freq_chart_var)
        word_freq_chart_check.pack(anchor=tk.W)

        self.word_cooccurrence_var = tk.BooleanVar()
        word_cooccurrence_check = ttk.Checkbutton(options_frame, text="詞語共現(xiàn)網(wǎng)絡(luò)", variable=self.word_cooccurrence_var)
        word_cooccurrence_check.pack(anchor=tk.W)

        visualize_button = ttk.Button(visualization_tab, text="生成可視化", command=self.perform_visualization)
        visualize_button.pack(pady=10)

        self.visualization_log = tk.Text(visualization_tab, height=10)
        self.visualization_log.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

    def create_nlp_tab(self):
        nlp_tab = ttk.Frame(self.notebook)
        self.notebook.add(nlp_tab, text="NLP任務(wù)")

        options_frame = ttk.LabelFrame(nlp_tab, text="NLP選項(xiàng)")
        options_frame.pack(fill=tk.X, padx=5, pady=5)

        self.text_classification_var = tk.BooleanVar()
        text_classification_check = ttk.Checkbutton(options_frame, text="文本分類", variable=self.text_classification_var)
        text_classification_check.pack(anchor=tk.W)

        self.sentiment_analysis_var = tk.BooleanVar()
        sentiment_analysis_check = ttk.Checkbutton(options_frame, text="情感分析", variable=self.sentiment_analysis_var)
        sentiment_analysis_check.pack(anchor=tk.W)

        self.text_summarization_var = tk.BooleanVar()
        text_summarization_check = ttk.Checkbutton(options_frame, text="文本摘要", variable=self.text_summarization_var)
        text_summarization_check.pack(anchor=tk.W)

        nlp_button = ttk.Button(nlp_tab, text="執(zhí)行NLP任務(wù)", command=self.perform_nlp_tasks)
        nlp_button.pack(pady=10)

        self.nlp_log = tk.Text(nlp_tab, height=10)
        self.nlp_log.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

    def select_input_file(self):
        """選擇輸入文件"""
        self.input_file = filedialog.askopenfilename(filetypes=[("Text files", "*.txt")])
        self.input_entry.delete(0, tk.END)
        self.input_entry.insert(0, self.input_file)
        self.file_log.insert(tk.END, f"已選擇輸入文件: {self.input_file}\n")

    def select_output_file(self):
        """選擇輸出文件"""
        self.output_file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files", "*.txt")])
        self.output_entry.delete(0, tk.END)
        self.output_entry.insert(0, self.output_file)
        self.file_log.insert(tk.END, f"已選擇輸出文件: {self.output_file}\n")

    def select_stopwords_file(self):
        """選擇停用詞文件"""
        stopwords_file = filedialog.askopenfilename(filetypes=[("Text files", "*.txt")])
        self.stopwords_entry.delete(0, tk.END)
        self.stopwords_entry.insert(0, stopwords_file)
        self.file_log.insert(tk.END, f"已選擇停用詞文件: {stopwords_file}\n")

        # 讀取停用詞
        try:
            with open(stopwords_file, 'r', encoding='utf-8') as f:
                self.stopwords = set(line.strip() for line in f)
            self.file_log.insert(tk.END, f"成功讀取 {len(self.stopwords)} 個(gè)停用詞\n")
        except Exception as e:
            self.file_log.insert(tk.END, f"讀取停用詞文件失敗: {str(e)}\n")

    def process_file(self):
        """處理文件"""
        if not self.input_file:
            messagebox.showerror("錯(cuò)誤", "請(qǐng)選擇輸入文件")
            return

        try:
            with open(self.input_file, 'r', encoding='utf-8') as f:
                self.text_content = f.read()
            self.file_log.insert(tk.END, f"文件讀取成功，共 {len(self.text_content)} 個(gè)字符\n")

            # 去除標(biāo)點(diǎn)符號(hào)
            self.text_content = ''.join(char for char in self.text_content if char not in self.punctuation)

            # 如果有停用詞，進(jìn)行分詞并去除停用詞
            if self.stopwords:
                words = jieba.lcut(self.text_content)
                filtered_words = [word for word in words if word not in self.stopwords]
                self.text_content = ' '.join(filtered_words)
                self.file_log.insert(tk.END, f"已去除停用詞和標(biāo)點(diǎn)符號(hào)，處理后共 {len(filtered_words)} 個(gè)詞\n")
            else:
                self.file_log.insert(tk.END, "已去除標(biāo)點(diǎn)符號(hào)\n")
        except Exception as e:
            self.file_log.insert(tk.END, f"文件讀取失敗: {str(e)}\n")

    def perform_basic_analysis(self):
        """執(zhí)行基礎(chǔ)分析"""
        if not self.text_content:
            messagebox.showerror("錯(cuò)誤", "請(qǐng)先處理文件")
            return

        self.basic_log.delete(1.0, tk.END)

        if self.word_freq_var.get():
            self.word_frequency_analysis()

        if self.char_count_var.get():
            self.character_count_analysis()

        if self.sentence_count_var.get():
            self.sentence_count_analysis()

    def word_frequency_analysis(self):
        """詞頻統(tǒng)計(jì)"""
        words = jieba.lcut(self.text_content)
        # 去除停用詞和空字符串
        words = [word for word in words if word not in self.stopwords and word.strip()]
        word_freq = Counter(words)
        self.basic_log.insert(tk.END, "詞頻統(tǒng)計(jì) (Top 10):\n")
        for word, freq in word_freq.most_common(10):
            self.basic_log.insert(tk.END, f"{word}: {freq}\n")
        self.basic_log.insert(tk.END, "\n")


    def character_count_analysis(self):
        """字符數(shù)統(tǒng)計(jì)"""
        char_count = len(self.text_content)
        self.basic_log.insert(tk.END, f"字符數(shù): {char_count}\n\n")

    def sentence_count_analysis(self):
        """句子數(shù)統(tǒng)計(jì)"""
        sentences = re.split(r'[。??？]', self.text_content)
        sentence_count = len([s for s in sentences if s.strip()])
        self.basic_log.insert(tk.END, f"句子數(shù): {sentence_count}\n\n")

    def perform_advanced_analysis(self):
        """執(zhí)行高級(jí)分析"""
        if not self.text_content:
            messagebox.showerror("錯(cuò)誤", "請(qǐng)先處理文件")
            return

        self.advanced_log.delete(1.0, tk.END)

        if self.pos_tagging_var.get():
            self.pos_tagging_analysis()

        if self.named_entity_var.get():
            self.named_entity_recognition()

        if self.keyword_extraction_var.get():
            self.keyword_extraction_analysis()

    def pos_tagging_analysis(self):
        """詞性標(biāo)注"""
        words = pseg.cut(self.text_content)
        # 去除停用詞和空字符串
        words = [(word, flag) for word, flag in words if word not in self.stopwords and word.strip()]
        self.advanced_log.insert(tk.END, "詞性標(biāo)注 (前20個(gè)):\n")
        for word, flag in words[:20]:
            self.advanced_log.insert(tk.END, f"{word}/{flag} ")
        self.advanced_log.insert(tk.END, "\n\n")

    def named_entity_recognition(self):
        """命名實(shí)體識(shí)別"""
        words = pseg.cut(self.text_content)
        # 去除停用詞和空字符串
        words = [(word, flag) for word, flag in words if word not in self.stopwords and word.strip()]
        entities = []
        for word, flag in words:
            if flag.startswith('n'):
                entities.append(word)
        self.advanced_log.insert(tk.END, "命名實(shí)體識(shí)別 (Top 10):\n")
        for entity in Counter(entities).most_common(10):
            self.advanced_log.insert(tk.END, f"{entity[0]}: {entity[1]}\n")
        self.advanced_log.insert(tk.END, "\n")

    def keyword_extraction_analysis(self):
        """關(guān)鍵詞提取"""
        keywords = jieba.analyse.extract_tags(self.text_content, topK=10)
        self.advanced_log.insert(tk.END, "關(guān)鍵詞提取 (Top 10):\n")
        for keyword in keywords:
            self.advanced_log.insert(tk.END, f"{keyword} ")
        self.advanced_log.insert(tk.END, "\n\n")

    def perform_visualization(self):
        """執(zhí)行可視化"""
        if not self.text_content:
            messagebox.showerror("錯(cuò)誤", "請(qǐng)先處理文件")
            return

        self.visualization_log.delete(1.0, tk.END)

        if self.word_cloud_var.get():
            self.generate_word_cloud()

        if self.word_freq_chart_var.get():
            self.generate_word_freq_chart()

        if self.word_cooccurrence_var.get():
            self.generate_word_cooccurrence_network()

    def generate_word_cloud(self):
        """生成詞云圖"""
        import matplotlib.font_manager as fm

        words = jieba.lcut(self.text_content)
        # 去除停用詞和空字符串
        words = [word for word in words if word not in self.stopwords and word.strip()]
        word_freq = Counter(words)

        # 將詞頻轉(zhuǎn)換為字符串
        text = ' '.join([word for word, freq in word_freq.items() for _ in range(freq)])

        # 設(shè)置中文字體
        font_path = 'simhei.ttf'  # 請(qǐng)確保這個(gè)字體文件在您的系統(tǒng)中或項(xiàng)目目錄下
        font_prop = fm.FontProperties(fname=font_path)

        wordcloud = WordCloud(font_path=font_path, width=800, height=400,
                              background_color="white").generate(text)

        plt.figure(figsize=(10, 5))
        plt.imshow(wordcloud, interpolation="bilinear")
        plt.axis("off")
        plt.title("詞云圖", fontproperties=font_prop)
        plt.savefig("wordcloud.png")
        plt.close()

        self.visualization_log.insert(tk.END, "詞云圖已生成，保存為 wordcloud.png\n")

    def generate_word_freq_chart(self):
        """生成詞頻柱狀圖"""
        import matplotlib.font_manager as fm

        words = jieba.lcut(self.text_content)
        # 去除停用詞和空字符串
        words = [word for word in words if word not in self.stopwords and word.strip()]
        word_freq = Counter(words)
        top_words = dict(word_freq.most_common(20))

        # 設(shè)置中文字體
        font_path = 'simhei.ttf'  # 請(qǐng)確保這個(gè)字體文件在您的系統(tǒng)中或項(xiàng)目目錄下
        font_prop = fm.FontProperties(fname=font_path)

        plt.figure(figsize=(12, 6))
        plt.bar(top_words.keys(), top_words.values())
        plt.title("詞頻柱狀圖 (Top 20)", fontproperties=font_prop)
        plt.xlabel("詞語", fontproperties=font_prop)
        plt.ylabel("頻率", fontproperties=font_prop)
        plt.xticks(rotation=45, ha='right', fontproperties=font_prop)
        plt.tight_layout()
        plt.savefig("word_freq_chart.png")
        plt.close()

        self.visualization_log.insert(tk.END, "詞頻柱狀圖已生成，保存為 word_freq_chart.png\n")

    def generate_word_cooccurrence_network(self):
        """生成詞語共現(xiàn)網(wǎng)絡(luò)"""
        import matplotlib.font_manager as fm

        words = jieba.lcut(self.text_content)
        # 去除停用詞和空字符串
        words = [word for word in words if word not in self.stopwords and word.strip()]
        word_pairs = [(words[i], words[i+1]) for i in range(len(words)-1)]
        pair_freq = Counter(word_pairs)

        G = nx.Graph()
        for (word1, word2), freq in pair_freq.most_common(50):
            G.add_edge(word1, word2, weight=freq)

        # 設(shè)置中文字體
        font_path = 'simhei.ttf'  # 請(qǐng)確保這個(gè)字體文件在您的系統(tǒng)中或項(xiàng)目目錄下
        font_prop = fm.FontProperties(fname=font_path)

        plt.figure(figsize=(12, 8))
        pos = nx.spring_layout(G)
        nx.draw(G, pos, with_labels=True, node_color='lightblue', node_size=1000,
                font_size=16, font_weight='bold', font_family=font_prop.get_name())
        edge_weights = nx.get_edge_attributes(G, 'weight')
        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_weights)
        plt.title("詞語共現(xiàn)網(wǎng)絡(luò)", fontproperties=font_prop)
        plt.axis('off')
        plt.tight_layout()
        plt.savefig("word_cooccurrence_network.png")
        plt.close()

        self.visualization_log.insert(tk.END, "詞語共現(xiàn)網(wǎng)絡(luò)已生成，保存為 word_cooccurrence_network.png\n")

    def perform_nlp_tasks(self):
        """執(zhí)行NLP任務(wù)"""
        if not self.text_content:
            messagebox.showerror("錯(cuò)誤", "請(qǐng)先處理文件")
            return

        self.nlp_log.delete(1.0, tk.END)

        if self.text_classification_var.get():
            self.text_classification()

        if self.sentiment_analysis_var.get():
            self.sentiment_analysis()

        if self.text_summarization_var.get():
            self.text_summarization()

    def text_classification(self):
        """文本分類"""
        # 這里使用一個(gè)簡單的基于關(guān)鍵詞的分類方法
        keywords = {
            '科技': ['人工智能', '區(qū)塊鏈', '5G', '量子計(jì)算', '物聯(lián)網(wǎng)'],
            '體育': ['足球', '籃球', '網(wǎng)球', '奧運(yùn)會(huì)', '世界杯'],
            '娛樂': ['電影', '音樂', '明星', '綜藝', '演唱會(huì)'],
            '經(jīng)濟(jì)': ['股票', '基金', '投資', '金融', '經(jīng)濟(jì)']
        }

        words = jieba.lcut(self.text_content)
        # 去除停用詞
        words = [word for word in words if word not in self.stopwords]
        word_freq = Counter(words)

        scores = {}
        for category, kw_list in keywords.items():
            score = sum(word_freq.get(kw, 0) for kw in kw_list)
            scores[category] = score

        predicted_category = max(scores, key=scores.get)
        self.nlp_log.insert(tk.END, f"文本分類結(jié)果：{predicted_category}\n\n")

    def sentiment_analysis(self):
        """情感分析"""
        # 這里使用一個(gè)簡單的基于詞典的情感分析方法
        positive_words = set(['喜歡', '高興', '快樂', '美好', '優(yōu)秀', '棒', '好'])
        negative_words = set(['討厭', '失望', '難過', '糟糕', '差勁', '壞', '不好'])

        words = jieba.lcut(self.text_content)
        # 去除停用詞
        words = [word for word in words if word not in self.stopwords]
        positive_count = sum(1 for word in words if word in positive_words)
        negative_count = sum(1 for word in words if word in negative_words)

        if positive_count > negative_count:
            sentiment = "正面"
        elif positive_count < negative_count:
            sentiment = "負(fù)面"
        else:
            sentiment = "中性"

        self.nlp_log.insert(tk.END, f"情感分析結(jié)果：{sentiment}\n")
        self.nlp_log.insert(tk.END, f"正面詞數(shù)量：{positive_count}\n")
        self.nlp_log.insert(tk.END, f"負(fù)面詞數(shù)量：{negative_count}\n\n")

    def text_summarization(self):
        """文本摘要"""
        sentences = re.split(r'[。??？]', self.text_content)
        sentences = [sent.strip() for sent in sentences if sent.strip()]

        # 使用TF-IDF來計(jì)算句子的重要性
        vectorizer = TfidfVectorizer()
        tfidf_matrix = vectorizer.fit_transform(sentences)

        # 計(jì)算每個(gè)句子的平均TF-IDF分?jǐn)?shù)
        sentence_scores = tfidf_matrix.sum(axis=1).A1

        # 選擇前3個(gè)最重要的句子作為摘要
        top_sentences_indices = sentence_scores.argsort()[-3:][::-1]
        summary = [sentences[i] for i in sorted(top_sentences_indices)]

        self.nlp_log.insert(tk.END, "文本摘要：\n")
        for sent in summary:
            self.nlp_log.insert(tk.END, f"{sent}。\n")
        self.nlp_log.insert(tk.END, "\n")

    def run(self):
        """運(yùn)行程序"""
        self.window.mainloop()


if __name__ == "__main__":
    analyzer = ChineseTextAnalyzer()
    analyzer.run()