如何在Swift+Xcode中为图片应用PNG格式LUT？按钮点击无效果排查

Hey there! Let's break down your problem step by step—no worries, we've all fumbled through copy-pasted code and weird crashes when starting out.

First, let's fix that crash when using non-CIColorCube filters #

The "Unexpectedly found nil while unwrapping an Optional value" error happens because your code is set up to handle only the CIColorCube filter, which relies on your LUT data. When you switch to another filter (like CISepiaTone or CIVignette), those filters don't need LUT parameters, so parts of your code that try to access LUT-related values end up grabbing a nil and force-unwrapping it (with !), which crashes the app.

Here's how to fix it:

• Wrap any LUT-specific code in a check that verifies you're using CIColorCube before running it. For example:

  if filterName == "CIColorCube" {
      // Run your LUT processing code here
      guard let lutFilter = colorCubeFilterFromLUT(...) else { return }
      // Apply the filter
  } else {
      // Handle other filters without LUT logic
      guard let filter = CIFilter(name: filterName) else {
          print("Invalid filter name")
          return
      }
      // Set up other filter parameters as needed
  }
  

• Replace all force-unwraps (!) with optional bindings (if let or guard let) wherever possible. This prevents crashes when values are unexpectedly nil.

Next, why your CIColorCube filter does nothing #

The most likely issue is that your 512x512 LUT image doesn't match the required dimensions for CIColorCube. Here's the key rule:
CIColorCube expects a LUT image where the total number of pixels equals cubeDimension³, where cubeDimension is an integer (usually a power of 2 like 8, 16, 32, or 64).

Typically, LUTs are arranged as:

• Width = cubeDimension × cubeDimension
• Height = cubeDimension

For example:

• A 32-dimension cube needs a 1024x32 image (32×32=1024 width, 32 height)
• A 16-dimension cube needs a 256x16 image

Your 512x512 image doesn't fit this pattern—512 isn't a perfect square multiplied by an integer cube dimension. The filter can't parse the LUT data correctly, so it just returns the original image with no changes.

Fixes for the no-effect issue:

1. Regenerate your LUT to match a valid dimension (e.g., 1024x32 for a 32-dimension cube). Most LUT generation tools let you set this dimension.
2. Adjust your colorCubeFilterFromLUT function to correctly calculate the cube dimension and parse pixel data. Here's a revised snippet to check:

   func colorCubeFilterFromLUT(lutImage: UIImage, targetCubeDimension: Int) -> CIFilter? {
       guard let cgImage = lutImage.cgImage else { return nil }
       let expectedWidth = targetCubeDimension * targetCubeDimension
       let expectedHeight = targetCubeDimension
       
       // Validate the LUT image size first
       guard cgImage.width == expectedWidth, cgImage.height == expectedHeight else {
           print("LUT image size (\(cgImage.width)x\(cgImage.height)) doesn't match cube dimension \(targetCubeDimension)")
           return nil
       }
       
       // Extract pixel data from the LUT image
       let bytesPerRow = cgImage.bytesPerRow
       var pixelData = [UInt8](repeating: 0, count: cgImage.height * bytesPerRow)
       
       guard let context = CGContext(data: &pixelData,
                                     width: cgImage.width,
                                     height: cgImage.height,
                                     bitsPerComponent: 8,
                                     bytesPerRow: bytesPerRow,
                                     space: CGColorSpaceCreateDeviceRGB(),
                                     bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else {
           return nil
       }
       
       context.draw(cgImage, in: CGRect(x: 0, y: 0, width: cgImage.width, height: cgImage.height))
       
       // Convert pixel data to CIColorCube's required cubeData format
       var cubeData = [Float]()
       for y in 0..<targetCubeDimension {
           for x in 0..<expectedWidth {
               let pixelOffset = (y * expectedWidth + x) * 4
               let red = Float(pixelData[pixelOffset]) / 255.0
               let green = Float(pixelData[pixelOffset + 1]) / 255.0
               let blue = Float(pixelData[pixelOffset + 2]) / 255.0
               
               cubeData.append(red)
               cubeData.append(green)
               cubeData.append(blue)
               cubeData.append(1.0) // Full alpha
           }
       }
       
       let filter = CIFilter(name: "CIColorCube")
       filter?.setValue(targetCubeDimension, forKey: "inputCubeDimension")
       filter?.setValue(Data(bytes: cubeData, count: cubeData.count * MemoryLayout<Float>.stride), forKey: "inputCubeData")
       return filter
   }
   

3. Test with a known valid LUT first (like a 1024x32 sample LUT) to confirm the function works before using your custom one.

Quick recap #

1. Guard your LUT code to only run when using CIColorCube to avoid crashes with other filters.
2. Use a LUT image that fits the cubeDimension × cubeDimension² size rule for CIColorCube.
3. Replace force-unwraps with safe optional bindings to prevent unexpected nil crashes.

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