如何在C#中对一维数组插值扩长并实现二维数组的分辨率提升？

一、一维数组处理 #

你的IncreaseResolution(float[,] origin)函数参数为二维数组，若要处理一维数组，可重载一个接受float[]的版本，或是将一维数组转为单行列的二维数组（如new float[1, 3] { {1,2,4} }）。

实现逻辑 #

对一维数组的每一对相邻元素，计算二者的平均值并插入到中间位置，最终新数组长度为原长度 × 2 - 1。

代码示例（C#） #

// 处理一维数组的重载方法
public float[] IncreaseResolution(float[] origin)
{
    if (origin == null || origin.Length <= 1)
        return origin;

    int newLength = origin.Length * 2 - 1;
    float[] result = new float[newLength];
    int index = 0;

    for (int i = 0; i < origin.Length - 1; i++)
    {
        // 保留原元素
        result[index++] = origin[i];
        // 插入相邻元素的平均值
        result[index++] = (origin[i] + origin[i + 1]) / 2f;
    }
    // 添加最后一个原元素
    result[index] = origin[^1];

    return result;
}

// 调用示例
float[] test = {1, 2, 4};
float[] expanded = IncreaseResolution(test);
// 输出结果：{1, 1.5, 2, 3, 4}

若必须使用原float[,]参数的方法，可先转成二维数组处理，再转回一维：

public float[,] IncreaseResolution(float[,] origin)
{
    if (origin.GetLength(0) != 1)
        throw new ArgumentException("仅处理单行列的二维数组用于一维扩长");

    int originalLength = origin.GetLength(1);
    int newLength = originalLength * 2 - 1;
    float[,] result = new float[1, newLength];
    int index = 0;

    for (int i = 0; i < originalLength - 1; i++)
    {
        result[0, index++] = origin[0, i];
        result[0, index++] = (origin[0, i] + origin[0, i + 1]) / 2f;
    }
    result[0, index] = origin[0, originalLength - 1];

    return result;
}

// 调用示例
float[,] test2D = new float[1,3] { {1,2,4} };
float[,] expanded2D = IncreaseResolution(test2D);
// 提取结果：expanded2D[0,0]到expanded2D[0,4]对应{1,1.5,2,3,4}

二、二维数组平滑扩长 #

二维数组的平滑扩长需要对行和列分别执行线性插值：先对每一行做一维插值扩展列数，再对处理后的数组的每一列做一维插值扩展行数，最终得到的数组尺寸为(2×原行数-1) × (2×原列数-1)，实现平滑扩长效果。

实现逻辑 #

1. 行插值：对原数组的每一行，按一维插值方式扩展列数，得到列数翻倍减一的中间数组。
2. 列插值：对中间数组的每一列，按一维插值方式扩展行数，得到最终的二维扩长数组。

代码示例（C#） #

// 通用一维插值方法
private float[] LinearInterpolate(float[] input)
{
    if (input == null || input.Length <= 1)
        return input;

    int newLen = input.Length * 2 - 1;
    float[] output = new float[newLen];
    int idx = 0;
    for (int i = 0; i < input.Length - 1; i++)
    {
        output[idx++] = input[i];
        output[idx++] = (input[i] + input[i + 1]) / 2f;
    }
    output[idx] = input[^1];
    return output;
}

// 二维数组扩长方法
public float[,] IncreaseResolution2D(float[,] origin)
{
    if (origin == null || origin.GetLength(0) <= 0 || origin.GetLength(1) <= 0)
        return origin;

    int rows = origin.GetLength(0);
    int cols = origin.GetLength(1);

    // 第一步：对每一行插值，扩展列数
    float[,] rowExpanded = new float[rows, cols * 2 - 1];
    for (int r = 0; r < rows; r++)
    {
        float[] row = new float[cols];
        for (int c = 0; c < cols; c++)
        {
            row[c] = origin[r, c];
        }
        float[] expandedRow = LinearInterpolate(row);
        for (int c = 0; c < expandedRow.Length; c++)
        {
            rowExpanded[r, c] = expandedRow[c];
        }
    }

    // 第二步：对每一列插值，扩展行数
    int newCols = rowExpanded.GetLength(1);
    float[,] finalResult = new float[rows * 2 - 1, newCols];
    for (int c = 0; c < newCols; c++)
    {
        float[] col = new float[rows];
        for (int r = 0; r < rows; r++)
        {
            col[r] = rowExpanded[r, c];
        }
        float[] expandedCol = LinearInterpolate(col);
        for (int r = 0; r < expandedCol.Length; r++)
        {
            finalResult[r, c] = expandedCol[r];
        }
    }

    return finalResult;
}

// 调用示例
// 原二维数组：2行2列
float[,] original2D = new float[,]
{
    {1, 3},
    {5, 7}
};
float[,] expanded2D = IncreaseResolution2D(original2D);
// 最终3行3列结果：
// {1, 2, 3}
// {3, 4, 5}
// {5, 6, 7}

说明 #

当前使用的是线性插值（平均值），若需要更复杂的平滑效果（如三次插值），可修改LinearInterpolate方法的插值逻辑，当前逻辑完全满足“插入中间值”的平滑扩长需求。

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