利用Pandas和Numpy在Python中筛选等距像素对的问题

你的第二种方法错误原因 #

你得到全整数距离的问题很明确：没有计算欧氏距离的平方根，或者误用了非欧氏距离（比如曼哈顿距离|dx|+|dy|）。比如坐标(0,2)和(3,1)的dx=3，dy=-1，dx²+dy²=10，开平方后才是√10≈3.16的浮点数；如果只保留平方和或者用曼哈顿距离，结果就是整数10或者4，这和你描述的错误现象完全匹配。

高效实现方案（无双重循环） #

以下是基于Numpy/Scipy的高效实现步骤，避免双重循环，同时正确计算欧氏距离并筛选符合容差的点对：

步骤1：读取数据并生成坐标矩阵 #

首先读取CSV文件，然后生成所有像素点的(x,y)坐标数组：

import numpy as np

# 读取CSV数据（pd.read_csv读取后可转成numpy数组：pixel_data = pd.read_csv("your_pixels.csv").values）
pixel_data = np.loadtxt("your_pixels.csv")
# 生成x坐标（列索引）和y坐标（行索引）
x_coords = np.arange(pixel_data.shape[1])
y_coords = np.arange(pixel_data.shape[0])
# 生成网格并展平为N×2的坐标数组（N为总像素数）
xx, yy = np.meshgrid(x_coords, y_coords)
all_coords = np.column_stack((xx.ravel(), yy.ravel()))

步骤2：计算所有点对的欧氏距离 #

推荐两种方法，根据像素数量选择：

方法A：Numpy广播（适合像素数<1000的场景）

直接用广播计算全距离矩阵，代码简洁：

# 计算所有点对的x、y差值
dx = all_coords[:, 0, None] - all_coords[:, 0]
dy = all_coords[:, 1, None] - all_coords[:, 1]
# 计算欧氏距离
distance_matrix = np.sqrt(dx**2 + dy**2)

方法B：Scipy pdist（适合像素数较多的场景，内存更高效）

pdist只计算上三角部分的距离，再转成方阵，避免重复计算：

from scipy.spatial.distance import pdist, squareform

# 计算所有点对的欧氏距离（仅计算上三角）
distances = pdist(all_coords, metric="euclidean")
# 转成对称的距离矩阵
distance_matrix = squareform(distances)

步骤3：筛选符合容差的点对 #

设定目标距离target_dist和容差tol，然后筛选出符合条件的点对，同时排除自身对和重复对：

target_dist = np.sqrt(10)  # 示例目标距离，对应你提到的(0,2)和(3,1)的距离
tol = 0.1  # 容差范围

# 1. 创建掩码：排除自身点对（对角线元素）
self_mask = np.eye(len(all_coords), dtype=bool)
# 2. 筛选距离在[target_dist-tol, target_dist+tol]之间的点对
valid_mask = (distance_matrix >= target_dist - tol) & (distance_matrix <= target_dist + tol) & ~self_mask
# 3. 获取符合条件的点对索引，只保留i<j的对（避免重复，比如(i,j)和(j,i)只保留一次）
valid_pairs = np.argwhere(valid_mask)
valid_pairs = valid_pairs[valid_pairs[:, 0] < valid_pairs[:, 1]]

# 可选：获取对应点对的坐标和像素值
for i, j in valid_pairs:
    coord1 = all_coords[i]
    coord2 = all_coords[j]
    pixel1 = pixel_data[coord1[1], coord1[0]]  # 注意y是行索引，x是列索引
    pixel2 = pixel_data[coord2[1], coord2[0]]
    print(f"点对({coord1[0]},{coord1[1]})与({coord2[0]},{coord2[1]})，像素值分别为{pixel1}和{pixel2}")

超大数据量优化：KDTree近邻查询 #

如果像素数非常多（比如>10000），全距离矩阵会占用大量内存，此时用KDTree的范围查询更高效：

from scipy.spatial import KDTree

tree = KDTree(all_coords)
valid_pairs = []

for idx, point in enumerate(all_coords):
    # 查询所有距离在[target_dist-tol, target_dist+tol]之间的点
    # 先查上限，再过滤下限
    neighbors = tree.query_ball_point(point, r=target_dist + tol, p=2)
    # 排除自身和距离小于下限的点，同时只保留索引大于当前idx的点（避免重复）
    for neighbor_idx in neighbors:
        if neighbor_idx > idx:
            dist = np.linalg.norm(point - all_coords[neighbor_idx])
            if dist >= target_dist - tol:
                valid_pairs.append((idx, neighbor_idx))

valid_pairs = np.array(valid_pairs)

内容的提问来源于stack exchange，提问作者diedro