有灰色描边

时间: 2025-08-09 10:23:30 AIGC 浏览: 22
<think>嗯,用户提到在Unity的DrawingController脚本中绘制时出现了灰色描边的问题,需要解决这个问题,特别是涉及到画笔的Shader。首先,我得想一下可能的原因。通常,这种问题可能和材质设置、Shader代码或者渲染管线有关。首先,用户可能在使用自定义的Shader时,没有正确处理好颜色或透明度。比如,Shader中的输出颜色可能被某些计算覆盖,导致边缘出现不期望的灰色。另外,检查材质是否有额外的贴图或者属性被错误地应用,比如法线贴图或者金属度设置,这些可能会影响最终颜色。 然后,渲染管线也是一个需要考虑的因素。如果项目使用的是URP或HDRP,可能需要调整Shader的兼容性。比如,URP需要特定的Lighting Mode设置,如果Shader没有适配,可能会导致渲染问题。此外,Alpha通道的处理是否正确,特别是如果画笔需要透明效果,可能需要检查Blend模式是否正确设置,避免混合时出现灰色边缘。接下来,用户可能没有正确初始化材质属性。比如,颜色属性可能在Shader中被默认设置为灰色,而用户没有在脚本中正确赋值。这时候,检查脚本中是否有将颜色参数传递给Shader,比如使用Material.SetColor方法。 另外,Stencil Buffer的问题也可能导致这种情况。如果多个绘制对象叠加,Stencil Buffer设置不正确可能导致边缘残留。需要检查Shader中是否有正确的Stencil配置,确保绘制区域被正确覆盖。 还可能涉及到抗锯齿(Anti-aliasing)或后期处理效果。某些后处理效果可能会在边缘添加额外的颜色,需要暂时禁用这些效果来排查问题。总结下来,可能的解决步骤包括:检查并修改Shader中的颜色输出,确保没有硬编码的灰色值;调整Alpha混合模式;适配URP/HDRP的设置;在脚本中正确设置材质属性;配置StencilBuffer;以及检查后处理的影响。需要一步步排除这些可能性,找出具体原因并进行调整。</think>### Unity绘制灰色描边问题分析与解决方案 #### 问题原因分析 1. **Shader颜色混合问题** - 画笔Shader的透明通道未正确处理颜色混合,导致边缘叠加出现灰色 - 检查Shader中的混合模式设置: ```glsl Blend SrcAlpha OneMinusSrcAlpha // 标准透明混合公式 ``` [^2] 2. **材质属性未初始化** - 颜色属性$_Color$未被正确赋值,默认显示灰色 - 在C#脚本中初始化材质时应显式设置颜色: ```csharp brushMaterial.SetColor("_Color", new Color(1,1,1,0.5f)); ``` 3. **深度缓冲冲突** - 多个绘制层叠加时未正确管理深度测试,导致边缘残留 - 修改Shader深度测试参数: ```glsl ZWrite Off ZTest Always ``` #### 修正方案 1. **基础着色器修正** ```glsl Shader "Custom/BrushShader" { Properties { _Color ("Main Color", Color) = (1,1,1,1) } SubShader { Tags { "Queue"="Transparent" } Blend SrcAlpha OneMinusSrcAlpha ZWrite Off Pass { CGPROGRAM #pragma vertex vert #pragma fragment frag struct appdata { float4 vertex : POSITION; }; struct v2f { float4 pos : SV_POSITION; }; fixed4 _Color; v2f vert (appdata v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); return o; } fixed4 frag (v2f i) : SV_Target { return _Color; // 确保直接输出设定颜色 } ENDCG } } } ``` 2. **脚本层优化** ```csharp public class DrawingController : MonoBehaviour { public Material brushMaterial; void Start() { brushMaterial.SetColor("_Color", Color.white); brushMaterial.SetFloat("_AlphaCutoff", 0.1f); } void UpdateDrawing() { // 绘制时动态更新颜色参数 brushMaterial.SetVector("_MainTex_ST", new Vector4(1,1,0,0)); } } ``` #### URP适配要点 在Universal Render Pipeline中需添加: ```glsl #pragma require _TEXTURE2D #pragma target 3.5 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" ```
阅读全文

相关推荐

import numpy as np import matplotlib.pyplot as plt import networkx as nx from matplotlib.gridspec import GridSpec from matplotlib.patches import FancyBboxPatch, Circle import matplotlib.patheffects as pe import pandas as pd # 全局样式配置(专业学术风格) plt.rcParams.update({ "font.family": ["Times New Roman", "SimHei"], # 英文用Times New Roman,中文用黑体 "font.size": 10, "axes.unicode_minus": False, "figure.dpi": 300, "axes.linewidth": 0.8, # 坐标轴线条宽度 "grid.linewidth": 0.4, # 网格线宽度 "legend.frameon": True, "legend.framealpha": 0.9, "legend.edgecolor": "white", "legend.fancybox": True }) # 专业配色方案(符合学术图表规范,区分度高) COLORS = { "A_source": "#2E86AB", # 深蓝色(A突水点及水流) "B_source": "#A23B72", # 深紫红色(B突水点及水流) "confluence": "#F18F01", # 橙色(双源合流) "full": "#C73E1D", # 深红色(已充满) "unreached": "#8A9BA8", # 浅灰色(未到达) "background": "#F8F9FA", # 浅灰背景 "grid": "#E9ECEF", # 网格色 "text": "#2D3436" # 文字色 } class MineDoubleSourceVisualizerEnhanced: def __init__(self): # 1. 构建结构化巷道网络(避免随机杂乱,保证可视化清晰) self.nodes = self._generate_structured_nodes() # 结构化化节点(分区域布局) self.edges = self._generate_logical_edges() # 逻辑化巷道(保证传播路径清晰) self.G = self._build_directed_graph() # 有向图(体现现水流方向) # 2. 模型核心参数(与问题三一致) self.params = { "A": {"id": "P001", "trigger": 0, "pos": self.nodes["P001"]}, # 突水点A(t=0) "B": {"id": "P010", "trigger": 4, "pos": self.nodes["P010"]}, # 突水点B(t=4) "confluence": {"id": "P006", "pos": self.nodes["P006"]}, # 合流节点C "flow_rate": 30, # 单源涌水量(m³/min) "velocity": 75, # 水流速度(m/min,基于30m³/min流量计算) "width": 4, # 巷道宽度(m) "height": 3, # 巷道高度(m) "key_times": [0, 4, 7, 10, 15] # 关键时间点(覆盖全流程) } # 3. 预计算水流传播数据(确保可视化逻辑准确) self.propagation_data = self._simulate_propagation() self.confluence_analysis = self._analyze_confluence_effect() def _generate_structured_nodes(self): """生成结构化节点(分A区、B区、合流区,避免杂乱)""" nodes = {} # A突水点周边节点(左上区域) nodes["P001"] = (20, 80, 15.0) # A突水点(Z=15m,最高高程) nodes["P002"] = (10, 70, 14.5) # A下游1(水平) nodes["P003"] = (30, 70, 14.5) # A下游2(水平) nodes["P004"] = (20, 60, 14.0) # A下游3(下行) nodes["P005"] = (10, 50, 13.5) # A下游4(下行) # 合流节点及周边(中间区域) nodes["P006"] = (50, 50, 13.0) # 合流节点C(Z=13m) nodes["P007"] = (40, 60, 13.5) # 连接A区与合流区 nodes["P008"] = (60, 60, 13.5) # 合流区下游1 nodes["P009"] = (50, 40, 12.5) # 合流区下游2(下行) # B突水点周边节点(右上区域) nodes["P010"] = (80, 80, 14.0) # B突水点(Z=14m) nodes["P011"] = (70, 70, 13.8) # B下游1(水平) nodes["P012"] = (90, 70, 13.8) # B下游2(水平) nodes["P013"] = (80, 60, 13.5) # B下游3(下行) nodes["P014"] = (70, 50, 13.2) # B下游4(下行,连接合流区) nodes["P015"] = (90, 50, 13.2) # B下游5(下行) # 其他补充节点(保证网络完整性) nodes["P016"] = (30, 40, 12.8) # 连接A区与合流区下游 nodes["P017"] = (70, 40, 12.3) # 连接B区与合流区下游 nodes["P018"] = (50, 30, 12.0) # 最终下游节点 nodes["P019"] = (30, 20, 11.5) # 最终下游节点2 nodes["P020"] = (70, 20, 11.5) # 最终下游节点3 return nodes def _generate_logical_edges(self): """生成逻辑化巷道(保证水流方向清晰,避免交叉)""" edges = [ # A突水点传播路径 ("P001", "P002", {"length": 14.14}), # 斜向(10√2≈14.14m) ("P001", "P003", {"length": 14.14}), ("P001", "P004", {"length": 20.0}), # 垂直下行(20m) ("P004", "P005", {"length": 14.14}), ("P005", "P007", {"length": 36.06}), # 连接A区与合流区 ("P007", "P006", {"length": 14.14}), # 到合流节点C # B突水点传播路径 ("P010", "P011", {"length": 14.14}), ("P010", "P012", {"length": 14.14}), ("P010", "P013", {"length": 20.0}), ("P013", "P014", {"length": 14.14}), ("P014", "P006", {"length": 28.28}), # 连接B区与合流节点C ("P013", "P015", {"length": 14.14}), # 合流后传播路径 ("P006", "P008", {"length": 14.14}), ("P006", "P009", {"length": 20.0}), ("P009", "P018", {"length": 20.0}), ("P008", "P017", {"length": 14.14}), ("P017", "P020", {"length": 28.28}), ("P009", "P016", {"length": 28.28}), ("P016", "P019", {"length": 20.0}) ] return edges def _build_directed_graph(self): """构建有向图(体现水流方向,仅水平/下行)""" G = nx.DiGraph() for u, v, attr in self.edges: G.add_edge(u, v, length=attr["length"]) return G def _simulate_propagation(self): """模拟水流传播(精准计算到达/充满时间,含合流效应)""" # 初始化数据结构 data = { "nodes": {n: {"arrival": np.inf, "source": None} for n in self.nodes}, "edges": {f"{u}-{v}": {"arrival": np.inf, "full": np.inf, "source": None} for u, v, _ in self.edges} } # 突水点初始化 data["nodes"][self.params["A"]["id"]]["arrival"] = self.params["A"]["trigger"] data["nodes"][self.params["A"]["id"]]["source"] = "A" data["nodes"][self.params["B"]["id"]]["arrival"] = self.params["B"]["trigger"] data["nodes"][self.params["B"]["id"]]["source"] = "B" # 模拟传播过程(时间步长0.1分钟,保证精度) for t in np.arange(0, 20.1, 0.1): # 遍历所有节点,更新下游传播 for node in self.nodes: if abs(data["nodes"][node]["arrival"] - t) < 0.01: # 当前时间到达的节点 for neighbor in self.G.successors(node): edge_id = f"{node}-{neighbor}" if edge_id not in data["edges"]: continue # 计算传播时间(长度/速度) edge_len = self.G[node][neighbor]["length"] travel_time = edge_len / self.params["velocity"] arrival_t = t + travel_time # 更新边状态 if data["edges"][edge_id]["arrival"] > arrival_t: # 计算充满时间(容积/流量) volume = edge_len * self.params["width"] * self.params["height"] flow_rate = self.params["flow_rate"] full_t = arrival_t + (volume / flow_rate) data["edges"][edge_id]["arrival"] = arrival_t data["edges"][edge_id]["full"] = full_t data["edges"][edge_id]["source"] = data["nodes"][node]["source"] # 更新节点状态 if data["nodes"][neighbor]["arrival"] > arrival_t: data["nodes"][neighbor]["arrival"] = arrival_t data["nodes"][neighbor]["source"] = data["nodes"][node]["source"] elif data["nodes"][neighbor]["source"] != data["nodes"][node]["source"]: # 合流:节点标记为"both" data["nodes"][neighbor]["source"] = "both" # 合流后流量翻倍,重新计算充满时间 edge_id = f"{node}-{neighbor}" if edge_id in data["edges"]: edge_len = self.G[node][neighbor]["length"] volume = edge_len * self.params["width"] * self.params["height"] data["edges"][edge_id]["full"] = arrival_t + (volume / (2 * self.params["flow_rate"])) data["edges"][edge_id]["source"] = "both" return data def _analyze_confluence_effect(self): """分析合流效应(量化对比数据)""" confluence_node = self.params["confluence"]["id"] # 选取合流前后的关键巷道 key_edges = { "A→C": "P007-P006", # A到合流点 "B→C": "P014-P006", # B到合流点 "C→D1": "P006-P008", # 合流后下游1 "C→D2": "P006-P009" # 合流后下游2 } analysis = {"node": confluence_node, "edges": {}} for name, edge_id in key_edges.items(): u, v = edge_id.split("-") edge_len = self.G[u][v]["length"] volume = edge_len * self.params["width"] * self.params["height"] # 单源充满时间(30m³/min) time_single = volume / self.params["flow_rate"] # 合流充满时间(60m³/min) time_confluence = volume / (2 * self.params["flow_rate"]) analysis["edges"][name] = { "length": edge_len, "volume": volume, "time_single": time_single, "time_confluence": time_confluence, "reduction": time_single - time_confluence, "arrival_A": self.propagation_data["edges"][edge_id]["arrival"] if "A" in name else np.inf, "arrival_B": self.propagation_data["edges"][edge_id]["arrival"] if "B" in name else np.inf } return analysis def _get_edge_style(self, edge_id, current_time): """获取巷道样式(颜色、线型、宽度)""" edge_data = self.propagation_data["edges"][edge_id] # 未到达 if edge_data["arrival"] > current_time: return { "color": COLORS["unreached"], "linewidth": 1.5, "linestyle": "-.", "zorder": 1 } # 已充满 elif edge_data["full"] <= current_time: return { "color": COLORS["full"], "linewidth": 2.0, "linestyle": "-", "zorder": 3 # 提高层级让白色边框可见 } # A源水流 elif edge_data["source"] == "A": return { "color": COLORS["A_source"], "linewidth": 2.0, "linestyle": "-", "zorder": 2 } # B源水流 elif edge_data["source"] == "B": return { "color": COLORS["B_source"], "linewidth": 2.0, "linestyle": "-", "zorder": 2 } # 双源合流 else: return { "color": COLORS["confluence"], "linewidth": 2.5, "linestyle": "-", "zorder": 4 # 最高层级突出合流效果 } def _get_node_style(self, node_id, current_time): """获取节点样式(颜色、大小、标注)""" node_data = self.propagation_data["nodes"][node_id] # 突水点 if node_id == self.params["A"]["id"]: return { "color": COLORS["A_source"], "size": 120, "label": "A", "edgecolor": "white", "linewidth": 2 } elif node_id == self.params["B"]["id"]: return { "color": COLORS["B_source"], "size": 120, "label": "B", "edgecolor": "white", "linewidth": 2 } # 合流节点 elif node_id == self.params["confluence"]["id"]: return { "color": COLORS["confluence"], "size": 120, "label": "C", "edgecolor": "white", "linewidth": 2 } # 普通节点 if node_data["arrival"] > current_time: return { "color": "white", "size": 50, "label": None, "edgecolor": COLORS["unreached"], "linewidth": 1 } elif node_data["source"] == "A": return { "color": COLORS["A_source"], "size": 60, "label": None, "edgecolor": "white", "linewidth": 1 } elif node_data["source"] == "B": return { "color": COLORS["B_source"], "size": 60, "label": None, "edgecolor": "white", "linewidth": 1 } else: # 合流节点 return { "color": COLORS["confluence"], "size": 70, "label": None, "edgecolor": "white", "linewidth": 1 } def plot_propagation_stages(self): """绘制多阶段水流传播图(核心可视化)""" fig = plt.figure(figsize=(16, 12)) fig.patch.set_facecolor(COLORS["background"]) gs = GridSpec(2, 3, figure=fig, wspace=0.2, hspace=0.3) # 绘制关键时间点的传播图 for i, time in enumerate(self.params["key_times"]): ax = fig.add_subplot(gs[i // 3, i % 3]) ax.set_facecolor(COLORS["background"]) ax.grid(True, color=COLORS["grid"], linestyle="-") # 获取2D坐标(忽略Z轴) pos_2d = {n: (self.nodes[n][0], self.nodes[n][1]) for n in self.nodes} # 绘制巷道(边)- 分两层绘制以实现"描边"效果 for u, v, _ in self.edges: edge_id = f"{u}-{v}" style = self._get_edge_style(edge_id, time) # 对于需要突出的边(已充满和合流),先绘制白色粗边作为"描边" if style["color"] in [COLORS["full"], COLORS["confluence"]]: nx.draw_networkx_edges( self.G, pos_2d, edgelist=[(u, v)], ax=ax, edge_color="white", width=style["linewidth"] + 1.5, style=style["linestyle"], zorder=style["zorder"] - 0.5 ) # 绘制实际边 nx.draw_networkx_edges( self.G, pos_2d, edgelist=[(u, v)], ax=ax, edge_color=style["color"], width=style["linewidth"], style=style["linestyle"], zorder=style["zorder"] ) # 绘制节点 for node in self.nodes: style = self._get_node_style(node, time) nx.draw_networkx_nodes( self.G, pos_2d, nodelist=[node], ax=ax, node_color=style["color"], node_size=style["size"], edgecolors=style["edgecolor"], linewidths=style["linewidth"], zorder=5 # 节点在最上层 ) # 添加节点标签(仅关键节点) if style["label"]: nx.draw_networkx_labels( self.G, pos_2d, labels={node: style["label"]}, ax=ax, font_size=10, font_weight="bold", font_color="white", path_effects=[pe.Stroke(linewidth=1.5, foreground="black"), pe.Normal()], zorder=6 ) # 添加标题和坐标轴 ax.set_title(f"t = {time} 分钟", fontsize=12, pad=10, color=COLORS["text"]) ax.set_xlabel("X坐标 (m)", fontsize=9) ax.set_ylabel("Y坐标 (m)", fontsize=9) ax.set_xlim(0, 100) ax.set_ylim(10, 90) ax.tick_params(axis="both", which="major", labelsize=8) # 添加统一图例(右侧) legend_ax = fig.add_subplot(gs[:, 2]) legend_ax.set_facecolor(COLORS["background"]) legend_ax.axis("off") # 图例元素 legend_items = [ plt.Line2D([0], [0], color=COLORS["A_source"], lw=2, label="A源水流"), plt.Line2D([0], [0], color=COLORS["B_source"], lw=2, label="B源水流"), plt.Line2D([0], [0], color=COLORS["confluence"], lw=2.5, label="双源合流"), plt.Line2D([0], [0], color=COLORS["full"], lw=2, label="已充满巷道"), plt.Line2D([0], [0], color=COLORS["unreached"], lw=1.5, linestyle="-.", label="未到达巷道"), Circle((0, 0), 0.5, color=COLORS["A_source"], ec="white", lw=2, label="突水点A"), Circle((0, 0), 0.5, color=COLORS["B_source"], ec="white", lw=2, label="突水点B"), Circle((0, 0), 0.5, color=COLORS["confluence"], ec="white", lw=2, label="合流点C") ] # 绘制图例 legend_ax.legend( handles=legend_items, loc="center left", fontsize=10, frameon=True, framealpha=0.9, edgecolor="white", facecolor="white" ) # 添加主标题 fig.suptitle("双突水点水流蔓延过程可视化", fontsize=16, y=0.95, color=COLORS["text"]) plt.tight_layout() plt.savefig("双突水点水流蔓延过程.png", bbox_inches="tight") plt.show() def plot_confluence_comparison(self): """绘制合流效应对比图(突出模型核心差异)""" fig = plt.figure(figsize=(12, 6)) fig.patch.set_facecolor(COLORS["background"]) gs = GridSpec(1, 2, figure=fig, wspace=0.3) # 1. 充满时间对比柱状图 ax1 = fig.add_subplot(gs[0, 0]) ax1.set_facecolor(COLORS["background"]) ax1.grid(True, axis="y", color=COLORS["grid"]) # 准备数据 edges = list(self.confluence_analysis["edges"].keys()) time_single = [self.confluence_analysis["edges"][e]["time_single"] for e in edges] time_confluence = [self.confluence_analysis["edges"][e]["time_confluence"] for e in edges] x = np.arange(len(edges)) width = 0.35 # 绘制柱状图 bars1 = ax1.bar(x - width / 2, time_single, width, label="单源(30m³/min)", color=COLORS["A_source"], edgecolor="white", linewidth=0.8) bars2 = ax1.bar(x + width / 2, time_confluence, width, label="双源合流(60m³/min)", color=COLORS["confluence"], edgecolor="white", linewidth=0.8) # 添加数据标签 for bar in bars1: height = bar.get_height() ax1.text(bar.get_x() + bar.get_width() / 2., height + 0.1, f"{height:.1f}min", ha="center", va="bottom", fontsize=8) for bar in bars2: height = bar.get_height() ax1.text(bar.get_x() + bar.get_width() / 2., height + 0.1, f"{height:.1f}min", ha="center", va="bottom", fontsize=8) # 设置坐标轴 ax1.set_title("合流前后巷道充满时间对比", fontsize=12, pad=10) ax1.set_xlabel("关键巷道", fontsize=10) ax1.set_ylabel("充满时间(分钟)", fontsize=10) ax1.set_xticks(x) ax1.set_xticklabels(edges, fontsize=9) ax1.legend(loc="upper left", fontsize=9) ax1.set_ylim(0, max(time_single) * 1.2) # 2. 流量分配示意图 ax2 = fig.add_subplot(gs[0, 1]) ax2.set_facecolor(COLORS["background"]) ax2.axis("off") ax2.set_xlim(0, 10) ax2.set_ylim(0, 8) # 绘制流量分配图 # 标题 ax2.text(5, 7.5, "合流节点流量分配机制", ha="center", fontsize=12, fontweight="bold") # 流入箭头(A源) ax2.arrow(3, 6, 0, -1.5, width=0.2, head_width=0.5, head_length=0.3, fc=COLORS["A_source"], ec=COLORS["A_source"]) ax2.text(2.5, 6.5, "A源: 30m³/min", rotation=90, va="bottom", fontsize=10) # 流入箭头(B源) ax2.arrow(7, 6, 0, -1.5, width=0.2, head_width=0.5, head_length=0.3, fc=COLORS["B_source"], ec=COLORS["B_source"]) ax2.text(7.5, 6.5, "B源: 30m³/min", rotation=90, va="bottom", fontsize=10) # 合流节点 ax2.add_patch(Circle((5, 4), 0.8, color=COLORS["confluence"], ec="white", lw=2)) ax2.text(5, 4, "合流节点C", ha="center", va="center", fontsize=10, fontweight="bold", color="white") # 流出箭头1 ax2.arrow(3, 2.5, 0, -1.5, width=0.2, head_width=0.5, head_length=0.3, fc=COLORS["confluence"], ec=COLORS["confluence"]) ax2.text(2.5, 2.0, "分流1: 30m³/min", rotation=90, va="top", fontsize=10) # 流出箭头2 ax2.arrow(7, 2.5, 0, -1.5, width=0.2, head_width=0.5, head_length=0.3, fc=COLORS["confluence"], ec=COLORS["confluence"]) ax2.text(7.5, 2.0, "分流2: 30m³/min", rotation=90, va="top", fontsize=10) # 中间说明 ax2.text(5, 3.2, "总流量: 60m³/min", ha="center", fontsize=10, fontstyle="italic") plt.tight_layout() plt.savefig("合流效应对比与流量分配.png", bbox_inches="tight") plt.show() def plot_timeline_analysis(self): """绘制时间轴分析图(展示全流程特征)""" fig = plt.figure(figsize=(14, 8)) fig.patch.set_facecolor(COLORS["background"]) ax = fig.add_subplot(111) ax.set_facecolor(COLORS["background"]) ax.grid(True, color=COLORS["grid"], linestyle="-") # 提取数据并排序 edges = list(self.propagation_data["edges"].keys()) # 按到达时间排序 sorted_edges = sorted(edges, key=lambda x: self.propagation_data["edges"][x]["arrival"]) # 只取前15条关键巷道(避免过于拥挤) plot_edges = sorted_edges[:15] # 绘制时间轴 for i, edge_id in enumerate(plot_edges): data = self.propagation_data["edges"][edge_id] # 确定颜色 if data["source"] == "A": color = COLORS["A_source"] elif data["source"] == "B": color = COLORS["B_source"] else: color = COLORS["confluence"] # 对于需要突出的线条,先绘制白色粗线作为"描边" if color in [COLORS["full"], COLORS["confluence"]]: ax.plot([data["arrival"], data["full"]], [i, i], color="white", linewidth=5, solid_capstyle="round", zorder=2) # 绘制时间线 ax.plot([data["arrival"], data["full"]], [i, i], color=color, linewidth=3, solid_capstyle="round", zorder=3) # 到达时刻标记 ax.scatter(data["arrival"], i, color=color, s=50, zorder=4, edgecolors="white", linewidths=0.8) # 充满时刻标记 ax.scatter(data["full"], i, color=color, s=50, marker="s", zorder=4, edgecolors="white", linewidths=0.8) # 添加关键时间标记线 # A突水点触发 ax.axvline(x=self.params["A"]["trigger"], color=COLORS["A_source"], linestyle="--", alpha=0.7, linewidth=1.5) ax.text(self.params["A"]["trigger"], len(plot_edges) - 0.5, f"A源触发: {self.params['A']['trigger']}min", color=COLORS["A_source"], va="center", rotation=90, fontsize=9) # B突水点触发 ax.axvline(x=self.params["B"]["trigger"], color=COLORS["B_source"], linestyle="--", alpha=0.7, linewidth=1.5) ax.text(self.params["B"]["trigger"], len(plot_edges) - 1.5, f"B源触发: {self.params['B']['trigger']}min", color=COLORS["B_source"], va="center", rotation=90, fontsize=9) # 合流开始时间(A源到达合流点时间) confluence_time = self.propagation_data["nodes"][self.params["confluence"]["id"]]["arrival"] ax.axvline(x=confluence_time, color=COLORS["confluence"], linestyle="--", alpha=0.7, linewidth=1.5) ax.text(confluence_time, len(plot_edges) - 2.5, f"开始合流: {confluence_time:.1f}min", color=COLORS["confluence"], va="center", rotation=90, fontsize=9) # 设置坐标轴 ax.set_title("巷道水流到达与充满时间轴", fontsize=12, pad=10) ax.set_xlabel("时间(分钟)", fontsize=10) ax.set_ylabel("巷道(按水流到达顺序)", fontsize=10) ax.set_ylim(-1, len(plot_edges)) ax.set_yticks(range(len(plot_edges))) ax.set_yticklabels(plot_edges, fontsize=8) ax.set_xlim(-0.5, 16) ax.tick_params(axis="x", labelsize=9) # 添加图例 legend_items = [ plt.Line2D([0], [0], color=COLORS["A_source"], lw=2, label="A源水流"), plt.Line2D([0], [0], color=COLORS["B_source"], lw=2, label="B源水流"), plt.Line2D([0], [0], color=COLORS["confluence"], lw=2, label="双源合流"), plt.Line2D([0], [0], marker="o", color="w", markerfacecolor="black", markersize=6, label="到达时刻"), plt.Line2D([0], [0], marker="s", color="w", markerfacecolor="black", markersize=6, label="充满时刻") ] ax.legend(handles=legend_items, loc="upper right", fontsize=9) plt.tight_layout() plt.savefig("巷道水流时间轴分析.png", bbox_inches="tight") plt.show() def generate_all_visualizations(self): """生成所有优化后的可视化图表""" print("生成水流蔓延过程可视化...") self.plot_propagation_stages() print("生成合流效应对比图...") self.plot_confluence_comparison() print("生成时间轴分析图...") self.plot_timeline_analysis() print("所有可视化图表已保存为PNG文件") if __name__ == "__main__": # 创建可视化实例并生成所有图表 visualizer = MineDoubleSourceVisualizerEnhanced() visualizer.generate_all_visualizations() 代码如上 报错内容如下 E:\Anaconda\python.exe C:\Users\cheny\Desktop\PythonProject2\tu.py 生成水流蔓延过程可视化... Traceback (most recent call last): File "C:\Users\cheny\Desktop\PythonProject2\tu.py", line 630, in <module> visualizer.generate_all_visualizations() File "C:\Users\cheny\Desktop\PythonProject2\tu.py", line 616, in generate_all_visualizations self.plot_propagation_stages() File "C:\Users\cheny\Desktop\PythonProject2\tu.py", line 358, in plot_propagation_stages nx.draw_networkx_edges( TypeError: draw_networkx_edges() got an unexpected keyword argument 'zorder' 进程已结束,退出代码为 1

大家在看

recommend-type

广告识别文本.rar

广告营销类,文本语料,人工收集标注出广告类文本和非广告类文本,可直接跑lgb等二分类模型,对于识别一些广告营销类文本的模型训练,是个不错的语料
recommend-type

专杀工具Zbot或Zeus专杀.zip

专杀工具Zbot或Zeus专杀.zip
recommend-type

docker-gophish:Docker容器的gophish

是一个针对企业和渗透测试人员设计的开源网络钓鱼工具包。 它提供了快速,轻松地设置和执行网络钓鱼攻击以及安全意识培训的能力。 用法 以下是一些示例片段,可帮助您开始创建容器。 码头工人 docker create \ --name=gophish \ -p 443:443 \ -p 3333:3333 \ -v :/data \ --restart unless-stopped \ warhorse/gophish 码头工人组成 与docker-compose v2模式兼容。 --- version: "2" services: gophish: image: warhorse/gophish container_name: gophish environment: ADMIN_USE_TLS: "
recommend-type

intouch 2014R2 SP1版本 永久授权

仅供学习 2014R2SP1 RC 60000 第一大步骤 安装虚拟硬狗,即软狗 1.安装驱动,Virtual USB Multikey64bit driver - Signed a.桌面图标“此电脑 ”右键-属性, 选择"管理",选择“设备管理器” b.“设备管理器”界面,先点击选中计算机名称,点击菜单栏“操作”,选择“添加过时硬件” c.点击“下一步”,选择“安装我手动从列表选择的硬件”并点击“下一步” d.“显示所有设备”,点击“下一步” e.点击“从磁盘安装”,选择“浏览”,找到Virtual USB Multikey64bit driver - Signed文件夹内multikey.inf的文件,并选择 f.一直下一步,中途选择信任,直至安装完成。 如果安装完成后“设备管理器”界面会有一个红色感叹号的设备,自己下载驱动精灵 2.导入虚拟狗,双击 INTOUCH 2014R2SP1 RC 60000\AC5A0000.reg 3.重启电脑 第二大步骤 导入INTOUCH授权, 1. 左下角微软徽标-Invensys-License Manag
recommend-type

提取dxf文件中的图形信息

最新推荐

recommend-type

前端分析-2023071100789s79

前端分析-2023071100789s79
recommend-type

用C语言掌握网络编程:套接字与安全代码编写指南

《使用C进行动手网络编程》是一本由Lewis Van Winkle编写的书籍,由Packt出版,专注于教授读者如何使用C语言编写网络程序。在这本书中,作者不仅向读者介绍了C语言中套接字编程的基础知识,还深入探讨了如何开发安全且优化的网络代码。以下是从书籍标题、描述和标签中提取出的关键知识点: 1. C语言网络编程基础 - 套接字编程是网络通信的核心技术,它允许计算机之间通过网络传输数据。 - 在C语言中使用套接字API编写网络程序是一项高级技能,需要对网络协议和操作系统API有深入的理解。 - 学习套接字编程可以帮助开发者构建客户端和服务器端的网络应用。 2. 跨平台套接字编程API - 跨平台编程是软件开发中的重要概念,意味着编写的应用能够在多种操作系统上运行。 - 套接字API在不同的操作系统中存在差异,但也有共通之处,作者可能会介绍如何编写适应多个操作系统的网络代码。 3. 支持IPv4和IPv6技术的实现 - IPv4和IPv6是互联网上使用的两种主要网络层协议。 - 随着IPv6的推广,网络程序需要能够同时支持这两种协议,实现无缝通信。 4. TCP和UDP连接的工作原理 - 传输控制协议(TCP)和用户数据报协议(UDP)是两种常用的传输层协议。 - TCP提供可靠的、面向连接的通信服务,而UDP提供不可靠的、无连接的数据传输服务。 - 本书可能涉及如何在C语言中使用TCP和UDP实现网络应用。 5. 主机名解析和DNS工作机制 - 域名系统(DNS)用于将域名解析为IP地址,这是互联网通信的关键部分。 - 主机名解析是网络程序中常见需求,了解DNS的工作原理对于网络开发来说至关重要。 6. 使用HTTP和HTTPS与Web API进行接口 - 超文本传输协议(HTTP)和安全超文本传输协议(HTTPS)是互联网上应用最广泛的协议之一。 - 学习如何使用HTTP和HTTPS可以让开发者与Web API进行交互,开发出能够访问网络资源的应用程序。 7. 通过SMTP进行电子邮件协议的实践 - 简单邮件传输协议(SMTP)用于发送电子邮件。 - 掌握SMTP协议能够使开发者实现发送邮件的功能,这对于许多网络应用来说是一个有用的特性。 8. 物联网(IoT)的新方法 - 物联网指的是将各种日常物品通过网络连接起来的设备或系统。 - C语言是物联网开发中常用的编程语言之一,因其性能高效且对资源的要求低。 - 探索物联网的新方法可能包括对嵌入式系统编程的介绍,以及如何在受限设备上实现网络通信。 总结来说,这本书是一本针对有志于深入学习C语言网络编程的开发者或学生编写的实用性教材。通过阅读本书,读者不仅可以学习到网络编程的基础知识,还能够掌握如何开发出稳定、高效的网络应用,并了解网络技术的最新发展,特别是物联网方面的应用。书中内容的组织结构和实例代码可以帮助读者将理论知识转化为实践经验,对于希望扩展自己网络编程技能的初学者和专业人士来说,是一本宝贵的参考资料。
recommend-type

阻塞 vs 非阻塞任务提交:接口设计背后的性能权衡与场景选择建议

# 摘要 本文系统探讨了阻塞与非阻塞任务提交机制在并发编程中的核心作用,从基本概念出发,剖析同步与异步、阻塞与非阻塞的本质区别及其在线程行为和执行模型中的体现。文章深入研究任务调度的关键性能指标及并发模型的支持机制,结合线程池、Future/Promise、Reactor与Actor等技术,分析阻塞与非阻塞在Java线程池、Spring异步注解和Netty框架中的具体实现。通过对比不同任
recommend-type

zsh安装

### 安装 Zsh Shell Zsh(Z Shell)是一个功能强大的 Unix shell,相比传统的 Bash,它提供了更丰富的功能和更好的交互体验。以下是针对 Linux 和 macOS 系统安装 Zsh 的详细步骤。 #### 在 Linux 上安装 Zsh Linux 系统通常可以通过包管理器安装 Zsh。常见的发行版如 CentOS、Ubuntu、Debian 等均支持通过以下方式安装: - **CentOS / RHEL 系统**: 使用 `yum` 安装 Zsh: ```bash sudo yum install zsh ``` 如果使用的是较新
recommend-type

Python包装器urlscan-py:简化urlscan.io API使用

标题中提到的“urlscan-py”是一个Python语言编写的包装器程序,专为urlscan.io的API服务。这表明它是一个开发工具,使得在Python中调用urlscan.io的API变得更加容易,从而实现对URL的扫描功能。 描述部分详细介绍了如何使用urlscan-py。首先,提供了通过Docker使用urlscan-py的方法,即使用“docker pull heywoodlh/urlscan-py”命令来下载Docker镜像。接着,提到可以通过PyPI(Python Package Index)安装urlscan-py,使用“pip3 install --user urlscan-py”命令进行安装。这样,Python开发者就可以在本地环境中使用urlscan-py。 安装后,用户需要保存API密钥。这一步是与urlscan.io服务交互所必需的,API密钥类似于一个访问令牌,用于在调用API时验证用户身份和授权。API密钥应保存在默认的数据库中,该数据库还会记录所有启动的扫描结果。在Linux系统中,默认数据库文件的位置通常为“~/.urlscan/urlscan.db”,在Windows系统中位置可能有所不同。 如果API密钥输入错误,或者在使用过程中发生其他错误导致数据库中的API密钥值不正确,用户可以通过执行“urlscan init --api xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx”命令来重新初始化API密钥并保存到本地数据库。这个命令中的“--api”参数后面应该跟随实际的API密钥。如果需要修改或覆盖已经存在的错误密钥,可以重复执行上述命令。 在描述中还暗示了urlscan-py的一些潜在功能,例如启动URL扫描和记录结果。尽管没有详细说明,但通常此类包装器会提供诸如启动扫描、获取扫描状态、查看扫描结果等接口或命令,用户可以通过这些接口或命令与urlscan.io的API进行交互。 关于“【标签】: Python”,这指的是urlscan-py程序使用Python语言编写。Python是一种广泛使用的高级编程语言,以其简洁易读的语法、强大的标准库以及在科学计算、网络开发、数据科学等领域的广泛应用而知名。由于Python的易用性和灵活性,它常常被用来快速开发各种工具和应用程序。 最后,“【压缩包子文件的文件名称列表】: urlscan-py-master”提示了该文件所在的具体位置或版本库的名称。在软件开发中,文件名称列表通常用来标识包含特定代码或资源的文件夹或压缩包。此处的“urlscan-py-master”可能指的是包含urlscan-py源代码的主分支(master branch),或者是包含该程序所有资源的压缩包名称。用户可能需要通过下载或克隆这个名称所指向的资源来进行安装或者开发工作。 综上所述,urlscan-py是一个为urlscan.io API提供Python语言接口的工具,它可以简化对特定URL的扫描工作。开发者可通过Docker或PyPI的方式安装urlscan-py,并通过命令行操作来初始化和管理API密钥。此外,urlscan-py的源代码可能位于名为“urlscan-py-master”的资源库中。
recommend-type

深入pthread_mutex_t与pthread_cond_t:彻底避免死锁和虚假唤醒的6种策略

# 摘要 线程同步是多线程编程中保障数据一致性和程序正确性的核心机制,而pthread_mutex_t与pthread_cond_t是POSIX线程库中实现同步的关键工具。本文系统阐述了线程同步的基础概念与典型问题,深入剖析互斥锁的类型、机制及其正确使用模式,并揭示了因加锁顺序不当或异常路径导致的死锁成因。结合条件变量的工作原理,重点探讨虚假唤醒的本质及循环验证谓词的必要性。进一步提出锁层级排序、
recommend-type

ububtu 更新火狐浏览器

在 Ubuntu 系统上更新 Firefox 浏览器可以通过多种方式进行,包括使用系统自带的软件更新工具、通过官方 PPA 添加最新版本,或者手动下载并安装 Firefox 的 tar.gz 包。以下是几种常见的更新方法: ### 使用 APT 更新 Firefox Ubuntu 默认的软件包管理工具 APT 可以用于更新 Firefox。首先确保系统软件包索引是最新的,然后执行升级命令: ```bash sudo apt update sudo apt upgrade firefox ``` 这种方法适用于大多数用户,能够确保 Firefox 更新到官方仓库提供的最新版本[^1]。 ##
recommend-type

Aurora Engine在NEAR上部署EVM:Rust实现的前沿探索

标题《Aurora Engine在NEAR协议上实现以太坊虚拟机(EVM)-Rust开发》所涉及的知识点主要集中在区块链技术领域,特别是与智能合约开发、多链互操作性、以及Rust编程语言的相关技术细节。以下是对标题和描述中提到的内容进行详细解释。 ### 区块链互操作性与Aurora Engine Aurora Engine是一种重要的区块链技术,它的出现解决了不同区块链协议之间的互操作性问题。互操作性是区块链技术发展中的关键挑战之一,因为它能够允许跨不同区块链的资产、数据和功能进行交互。在本例中,Aurora Engine被用来在NEAR协议上实现以太坊虚拟机(EVM),这意味着NEAR协议能够运行以太坊智能合约,这对于以太坊的开发者和用户来说是一个巨大的便利。 ### NEAR协议与以太坊虚拟机(EVM) NEAR协议是一个开源的云计算平台,支持智能合约的运行,并且着重于高性能、高可扩展性和易用性。NEAR支持的智能合约是用Rust语言编写的,提供了安全、高效的方式来处理交易和状态的变更。通过实现EVM,NEAR协议能够提供一个与以太坊兼容的环境,这样原本为以太坊开发的智能合约和去中心化应用(dApp)就可以不需要做大量的修改直接移植到NEAR协议上。 ### 部署网络与链ID状态 描述中提到了部署网络和链ID状态,这通常指的是在不同环境(如主网、测试网、本地开发网等)中智能合约部署的具体配置。在区块链领域,主网(MainNet)是指正式上线并用于生产环境的网络,而测试网(如BetaNet或TestNet)是为了测试目的而存在的网络,本地开发网(Local)则是开发者在本地机器上搭建的,用于本地开发和测试的网络。链ID是一个独特的标识符,用于区分不同的区块链网络。 ### WebAssembly工具链 WebAssembly(Wasm)是一种执行字节码的轻量级虚拟机,它在区块链领域的智能合约开发中扮演着重要角色。WebAssembly支持多语言编程,特别是Rust语言,因此它被广泛用于区块链智能合约的开发中。GNU Make是一个构建自动化工具,用于在编程中自动化编译过程。描述中提到的“每晚构建”可能是指在开发过程中定期自动执行构建过程,以便进行持续集成和测试。 ### Rust开发环境的构建 Rust是一种系统编程语言,它专注于速度、内存安全和并发性。描述中提及了部署Aurora Engine时必须满足的Rust开发环境配置,这包括安装Rust的nightly版本(即开发版),并添加wasm32-unknown-unknown目标,这个目标支持将Rust编译为WebAssembly格式。rustup是一个用于管理Rust版本的工具,它可以安装不同版本的Rust编译器并更新工具链。 ### 标签:Rust与加密货币 标签中的“Rust”指出了这个项目与Rust编程语言的紧密关联。由于Rust的设计目标与区块链的需求高度契合,它已经成为区块链领域中非常流行的编程语言。标签中的“Cryptocurrencies”表明Aurora Engine与加密货币和区块链技术直接相关,特别是它在兼容EVM方面的作用。 ### 压缩包子文件的文件名称列表 文件名称列表“aurora-engine-master”表示当前讨论的项目可能是一个开源项目,它包含一个名为“master”的主分支,通常是指项目的主要代码分支。在这种情况下,开发者可以获取该代码库,并在本地环境中进行测试、修改和部署。通常这类代码库中会包含编译脚本、合约源代码、智能合约的接口定义等。 总结而言,这个文件中提到的知识点涵盖了区块链智能合约开发的多个方面,特别是关于跨链互操作性和Rust编程语言在区块链生态中的应用。这不仅对于区块链开发者来说是一个重要的参考,同时也为对区块链技术感兴趣的读者提供了一个深入理解EVM兼容性和智能合约开发的窗口。
recommend-type

函数指针+void*参数传递精髓:实现通用回调接口的3大陷阱与避坑指南

# 摘要 本文系统探讨了基于函数指针与void*参数的通用回调机制的核心原理及其在工业级软件中的应用与风险。文章首先解析函数指针的调用约定与void*的类型擦除特性,进而提出通用回调接口的抽象建模方法,并深入剖析类型不匹配、生命周期失控及线程安全等三大经典陷阱。结合防御式编程理念,本文提出了封装结构体、编译期类型检查与运行时校验相结合的防护策略,并通过构建高可靠事件注册系统展示实践
recommend-type

ragflow ES数据库结构是什么

RagFlow 使用 Elasticsearch 作为其核心数据存储组件之一,主要用于高效检索文档片段,并结合生成模型输出高质量的回答。Elasticsearch 的结构设计在 RagFlow 中扮演着重要角色,尤其是在处理大规模非结构化或半结构化文档时,其倒排索引机制能够显著提升检索效率。 在 RagFlow 的整体架构中,Elasticsearch 主要用于存储经过解析和向量化处理的文档块(chunks),这些文档块通常包含文本内容及其对应的嵌入向量(embeddings)。每个文档块在进入 Elasticsearch 之前会经过多个处理阶段,包括文本清洗、分段、语义解析以及向量化。这一