import numpy as np import cv2 import os from scipy.sparse import csc_matrix from include.singlephoton import SinglePhotonImaging # import os def fcn_PoissonRV(lambda_, ni=None, nj=None): """ 生成泊松分布随机数矩阵 (向量化实现) 参数: lambda_ (float/array): 泊松分布参数λ（标量或二维数组） ni (int): 输出矩阵的行数（当lambda为标量时必填） nj (int): 输出矩阵的列数（当lambda为标量时必填） 返回: np.ndarray: 生成的泊松随机数矩阵[ni, nj] 异常: ValueError: 输入参数不符合要求时抛出 """ # ========================= 参数验证 ========================= # 情况1：未指定ni/nj时，lambda必须是二维数组 if ni is None and nj is None: if not isinstance(lambda_, np.ndarray) or lambda_.ndim != 2: raise ValueError("当未指定ni/nj时，lambda必须是二维数组!") ni, nj = lambda_.shape # 情况2：指定了ni/nj elif ni is not None and nj is not None: # 如果lambda是标量，扩展为指定大小的矩阵 if np.isscalar(lambda_): lambda_ = np.full((ni, nj), lambda_) # 如果lambda是数组，验证形状是否匹配 elif isinstance(lambda_, np.ndarray) and lambda_.shape != (ni, nj): raise ValueError(f"lambda形状{lambda_.shape}与({ni},{nj})不匹配!") # 情况3：参数不完整 else: raise ValueError("必须同时指定ni和nj，或都不指定!") # ========================= 初始化 ========================= ks1 = np.zeros((ni, nj), dtype=int) # 结果矩阵 ks2 = np.ones((ni, nj), dtype=int) # 比较矩阵 produ = np.ones((ni, nj)) # 乘积累加器 # ========================= 主循环 ========================= while np.any(ks1 != ks2): # 更新乘积（向量化操作） produ *= np.random.rand(ni, nj) # 保存当前状态 ks2 = ks1.copy() # 找出需要增加计数的位置（向量化掩码操作） mask = produ >= np.exp(-lambda_) ks1[mask] += 1 return ks1 def tof2spad(tof, binnum): h, w = tof.shape # 将 data_processed 重塑为列向量 tof = tof.T data = tof.reshape(h * w) # 创建一个大小为 h * w 行，10000 列的零矩阵 spad = np.zeros((h * w, int(binnum)), dtype=float) # 遍历 data for i in range(h * w): d = data[i] for j in range(len(d)): if int(d[j] - 1) < binnum: spad[i, int(d[j] - 1)] += 1 spad = csc_matrix(spad) return spad def generate_simdata( Z_true, Alpha_true, SBR=0.2, meanSigDetect=2, save_path=None, zMax=15, binDuration=8e-12, ): """ 生成单光子数据集仿真数据（Python版本） 参数: Z_true (array): 深度真值 Alpha_true (array): 反射率真值 SBR (float): 信号背景比 (默认0.2) meanSigDetect (int): 每像素平均信号光子数 (推荐值2/3/4) save_path (str): 数据保存路径 (.mat文件) 返回: tuple: (tBinMax, binDuration, sigDetect, totDetect) tBinMax (int): 最大时间bin数 binDuration (float): 单个时间bin持续时间 (秒) sigDetect (np.ndarray): 信号光子 totDetect (np.ndarray): 检测事件对象数组 [H,W] (每个元素包含时间bin序列) """ # 第一阶段: 物理参数配置 # 场景参数 # zMax = 15.0 # 最大探测距离(米) # binDuration = 8e-12 # 单个时间bin持续时间(秒) pulseRMS = 270 / 8 # 脉冲RMS宽度(时间bin数) # 计算衍生参数 ttd = 3e8 * binDuration / 2 # 时间到距离转换因子 (米/bin) tBinMax = int(round(zMax / ttd)) # 最大时间bin数 pulseSTD = pulseRMS / 2 # 高斯脉冲标准差 # print("tBinMax:",tBinMax) # 第二阶段: 信号光子生成 # 计算时间维度真实值 T_true = np.floor(Z_true / ttd).astype(int) # 计算总帧数 numFrames = int(meanSigDetect * 500) # 标准化反射率参数 Lr, Lc = Alpha_true.shape Alpha_true = meanSigDetect * Alpha_true / np.mean(Alpha_true) / numFrames # 生成信号光子数（泊松分布） numSigDetect = fcn_PoissonRV(numFrames * Alpha_true) actual_mean = np.mean(numSigDetect) sigDetect = np.empty((Lr, Lc), dtype=object) sampMean = np.zeros((Lr, Lc)) # 遍历每个像素生成时间分布 for i in range(Lr): for j in range(Lc): mu = T_true[i, j] n = numSigDetect[i, j] # 生成高斯分布时间偏移 tempVect = np.round(mu + pulseSTD * np.random.randn(n)).astype(int) sampMean[i, j] = np.mean(tempVect) if n > 0 else 0 sigDetect[i, j] = tempVect # 第三阶段: 背景噪声生成 # 计算背景光子率 bgndRate = actual_mean / numFrames / SBR # 生成背景光子数 numBgndDetect = fcn_PoissonRV(numFrames * bgndRate, Lr, Lc) bgndDetect = np.empty((Lr, Lc), dtype=object) # 生成均匀分布时间 for i in range(Lr): for j in range(Lc): n = numBgndDetect[i, j] bgndDetect[i, j] = np.random.randint(0, tBinMax, n) # 第四阶段: 数据合并与后处理 totDetect = np.empty((Lr, Lc), dtype=object) for i in range(Lr): for j in range(Lc): combined = np.concatenate((sigDetect[i, j], bgndDetect[i, j])) combined = np.sort(combined) combined = combined[combined > 0] # 移除非法时间bin totDetect[i, j] = combined spad = tof2spad(totDetect, tBinMax) sigDetect = tof2spad(sigDetect, tBinMax) return tBinMax, sigDetect, spad # 补充泊松生成函数（原型实现） def fcn_PoissonRV(lamda, *shape): if not shape: return np.random.poisson(lamda) else: return np.random.poisson(lamda, shape) import cv2 import numpy as np import os from scipy.io import savemat from pathlib import Path def generate_sim_imageNet( depth_path, rgb_path, SBR=0.2, meanSigDetect=4, save_path=None ): """ 生成cityscapes数据集仿真数据（Python版本） 参数: depth_path (str): 深度图文件路径 (npz) rgb_path (str): RGB图像文件路径 SBR (float): 信号背景比 (默认0.2) meanSigDetect (int): 每像素平均信号光子数 (推荐值2/3/4) save_path (str): 数据保存路径 (.npz文件) 返回: tuple: (Z_true, totDetect, tBinMax, binDuration) Z_true (np.ndarray): 真实深度图矩阵 [H,W] (单位:米) totDetect (np.ndarray): 检测事件对象数组 [H,W] (每个元素包含时间bin序列) tBinMax (int): 最大时间bin数 binDuration (float): 单个时间bin持续时间 (秒) PS: 由于使用DepthAnything数据生成的深度图,是三通道的,所以在处理前需要先将其转换为单通道的 为了保证数据兼容性，所以统一提取第一个通道作为深度数据 """ # 第一阶段: 基础数据加载与参数初始化 # 读取深度图并转换为米单位 # 读取深度图的最大深度 # binDuration = 4e-10 # zMax = 15 # binDuration = zMax/1.5e11 # 读取深度数据 Z_true = np.load(depth_path, allow_pickle=True).astype(np.float64) if Z_true.ndim == 3: Z_true = Z_true[:, :, 0] # 1. 避免除零和过小值 threshold = 1e-10 Z_affine_safe = np.clip(Z_true, threshold, None) # 2. 取倒数得到缩放深度 Z_scaled = 1 / Z_affine_safe max_value = np.max(Z_scaled) min_value = np.min(Z_scaled) # # 3. 截断离群值（可选） # lower, upper = np.percentile(Z_scaled, [1, 99]) # Z_clipped = np.clip(Z_scaled, lower, upper) # 4. 归一化到[0,1] Z_normalized = (Z_scaled - min_value) / (max_value - min_value) # 5. 反转方向：近处亮，远处暗 Z_depth = (1 - Z_normalized)*max_value # zMax = np.max(Z_true) zMax = int(np.max(Z_true)*1.5) binDuration = zMax / 2e11 # 验证时间箱数量 ttd = 3e8 * binDuration / 2 # 时间到距离转换因子 (米/bin) tBinMax = int(round(zMax / ttd)) # 最大时间bin数 print(f"tBinMax: {tBinMax}") # 计算深度范围 (必须在缩放前获取原始深度最大值) # zMax = int(np.max(Z_true) + 1) # zMax = 15 # binDuration = 10e-11 # 计算目标尺寸（保持长宽比） target_size = 64 height, width = Z_true.shape scale = target_size / min(height, width) new_width = int(width * scale) new_height = int(height * scale) # 缩放深度图（使用INTER_AREA保持精度） Z_true = cv2.resize( Z_true, (new_width, new_height), interpolation=cv2.INTER_AREA ) # 读取并处理RGB图像 rgb_img = cv2.imread(rgb_path) Alpha_true = cv2.cvtColor(rgb_img, cv2.COLOR_BGR2GRAY).astype(np.float64) # 以相同比例缩放灰度图 Alpha_true = cv2.resize( Alpha_true, (new_width, new_height), interpolation=cv2.INTER_AREA ) # # 输出最终尺寸信息 # print(f"深度图最终尺寸: {Z_true.shape}") # print(f"反射率图最终尺寸: {Alpha_true.shape}") # # 动态计算zMax（忽略深度为0的无效点） # valid_depths = Z_true[Z_true > 0] # 筛选有效深度点（>0） # if valid_depths.size > 0: # zMax = np.max(valid_depths) * 2 # 取最大值并增加10%余量 # else: # zMax = 15 # 默认值（无有效点时使用） tBinMax, sigDetect, spad = generate_simdata( Z_true, Alpha_true, SBR, meanSigDetect, save_path, zMax, binDuration ) lr, lc = Z_true.shape sp = SinglePhotonImaging(lr, lc, binDuration) depth = sp.ssp(spad) if save_path: # 创建保存目录（如果不存在） os.makedirs(os.path.dirname(save_path), exist_ok=True) dic_data = {} dic_data["depth_ssp"] = depth dic_data["Z_true"] = Z_true dic_data["tBinMax"] = tBinMax dic_data["binDuration"] = binDuration dic_data["spad_data"] = spad.data dic_data["spad_indices"] = spad.indices dic_data["spad_indptr"] = spad.indptr dic_data["spad_shape"] = spad.shape dic_data["sigDetect_data"] = sigDetect # scipy.io.savemat(save_path, dic_data) np.savez_compressed(save_path, **dic_data)