1

这可能是一件非常简单的事情，但我无法完全弄清楚如何将这些部分组合在一起。 这个问题和这个问题以及API 文档中的这个页面都在某种程度上暗示了答案，但我无法从他们那里找出我需要的东西。

所以现在我正在尝试实现一个简单的小程序来打开图像，将像素取出到一个数组中，对它们进行一些处理，然后将更新的像素保存为新图像。在这种特殊情况下，我想将每个像素周围 3x3 窗口的平均值作为简单的模糊。具体操作不是太重要（肯定有更有效的方法，我现在专门尝试编写一个幼稚的版本，以便以后与其他版本进行比较），但我无法弄清楚如何制作这个发生。现在我拥有的是：

let accessClampedArrayWithDefault (arr: uint32[][]) width height def x y : uint32[] =
    if x < 0 || x > width-1 || y < 0 || y > height-1 then
        def
    else
        arr.[x + width * y]

let extractPixelParts (p: Rgba32) =
    let R = uint32 p.R
    let G = uint32 p.G
    let B = uint32 p.B
    let A = uint32 p.A
    [|R; G; B; A|]

[<EntryPoint>]
let main argv =
    use img = Image.Load(@"D:\Users\sampleimage.jpg")    
    let mutable out_img = img.Clone()    
    let pxs = img.GetPixelSpan().ToArray() |> Array.map extractPixelParts    
    let mutable (nps: uint32[][]) = Array.zeroCreate pxs.Length    
    let ac = accessClampedArrayWithDefault pxs img.Width img.Height [|0u;0u;0u;0u|]

    for x in 0..img.Width-1 do
        for y in 0..img.Height-1 do
            let p = ac x y
            for z in -1..1 do
                for w in -1..1 do
                    let q = ac (x + z) (y + w)
                    nps.[x + y * img.Width] <- Array.zip p q |> Array.map (fun (a,b) -> a + b)
            nps.[x + y * img.Width] <- Array.map (fun i -> float i / 9.0 |> uint32 ) nps.[x + y * img.Width]

    let rpx = Array.collect (fun a -> Array.map byte a) nps

    let out_img = Image.Load<Rgba32>(img.GetConfiguration(), rpx, Formats.Jpeg.JpegDecoder())

    printfn "out_img's width is %d and height is %d" out_img.Width out_img.Height

但它失败了，但有一个例外let out_img =。如果我不包含 JpegDecoder 部分，那么我会收到一条关于缺少解码器的错误消息，但如果我确实包含它，那么我会收到一条关于缺少 SOI 的错误消息。

所以，我的问题是，我如何才能提取像素并以比 8 位（例如 32 位）更大的可变大小使用它们/每个通道，以便我可以执行无法以每个通道 8 位表示的中间操作，之前将最终结果转换回字节，然后将其重构回可以作为图像保存到磁盘的东西？

我很可能忘记提及一些重要的事情，所以请随时要求澄清:) 谢谢。

4

1 回答 1

2

我不熟悉 F#，但看起来有几个问题：

  • 该行将Image.Load<Rgba32>(img.GetConfiguration(), rpx, Formats.Jpeg.JpegDecoder())尝试解码Jpeg 编码的内存流（提供为byte[]）。

  • 关于你的问题：

    这样我就可以执行不能以每通道 8 位表示的中间操作

你为什么不在Rgba32[]阵列上工作？不需要这些extractPixelParts ...东西。由于不必要的堆分配，将所有像素存储在锯齿状数组 ( uint32[][]) 中会导致代码执行速度非常慢。

编辑： 对不起，我误解了这一点。如果您需要更高精度的中间操作，我建议使用Vector4！你可以使用pixel.ToVector4()和pixel.PackFromVector4(...)

我的建议（仍然没有优化但可能很容易理解）：

  1. 不要复制图像。只需创建一个Rgba32[](!!!)数组let pxs = img.GetPixelSpan().ToArray()
  2. arr[y * Width + x] = CreateMyNewRgbaPixelValueAtXY(....)使用CreateMyNewRgbaPixelValueAtXY(...)应返回的公式处理数组中的值Rgba32
  3. 通过 . 返回一个新图像Image.LoadPixelData(pxs)。该方法将通过将数据LoadPixelData复制到其中来创建新图像。pxs: Rgba32[]
  4. 处理您的原始图像！

编辑 2

为了以有效的方式执行中间操作，我建议如下：

  • 通过为每个输入像素inputPixelData:Vector4[]调用填充的中间数组创建一个pixel.ToVector4()
  • 创建另一个数组outputPixelData:Vector4[]并通过处理填充它inputPixelData
  • 使用（不知道在 F# 中最好的方法是什么）打包outputPixelData回pixels:Rgba32[]数组.PackFromVector4(outputPixelData[y * Width + x])
  • Image.LoadPixelData(pixels)

可能有更好的方法，但我不熟悉 F#。

于 2018-09-05T07:21:12.150 回答