obtenir une erreur après le traitement de l'image. iOS, Swift

Question

Je reçois cette erreur lorsque j'essaie de traiter une image et d'envoyer à OCR Swift.

NSAssert(widthOfImage > 0 && heightOfImage > 0, @"Passed image must not be empty - it should be at least 1px tall and wide"); 

si je contourner la fonction de rectangles de poignée et simplement appeler la fonction OCR rapide avec la première image prise il fonctionne très bien, mais après avoir mis l'image à travers la fonction processImage il se bloque avec l'erreur ci-dessus.

Voici mes fonctions.

lazy var rectanglesRequest: VNDetectRectanglesRequest = { 
    print("Tony 1 Requested....") 
    return VNDetectRectanglesRequest(completionHandler: self.handleRectangles) 

}() 

@objc func processImage() { 
    finalImage = nil 
    //  finalImage = main.correctedImageView.image 

    guard let uiImage = correctedImageView.image 
     else { fatalError("no image from image picker") } 
    guard let ciImage = CIImage(image: uiImage) 
     else { fatalError("can't create CIImage from UIImage") } 
    let orientation = CGImagePropertyOrientation(uiImage.imageOrientation) 
    inputImage = ciImage.oriented(forExifOrientation: Int32(orientation.rawValue)) 

    // Show the image in the UI. 
    // imageView.image = uiImage 

    // Run the rectangle detector, which upon completion runs the ML classifier. 
    let handler = VNImageRequestHandler(ciImage: ciImage, orientation: CGImagePropertyOrientation(rawValue: UInt32(Int32(orientation.rawValue)))!) 
    DispatchQueue.global(qos: .userInteractive).async { 
     do { 
      try handler.perform([self.rectanglesRequest]) 
     } catch { 
      print(error) 
     } 
    } 
} 




func handleRectangles(request: VNRequest, error: Error?) { 
    guard let observations = request.results as? [VNRectangleObservation] 
     else { fatalError("unexpected result type from VNDetectRectanglesRequest") } 
    guard let detectedRectangle = observations.first else { 
     //   DispatchQueue.main.async { 
     //    self.classificationLabel.text = "No rectangles detected." 
     //   } 
     return 
    } 

    let imageSize = inputImage.extent.size 

    // Verify detected rectangle is valid. 
    let boundingBox = detectedRectangle.boundingBox.scaled(to: imageSize) 
    guard inputImage.extent.contains(boundingBox) 
     else { print("invalid detected rectangle"); return } 

    // Rectify the detected image and reduce it to inverted grayscale for applying model. 
    let topLeft = detectedRectangle.topLeft.scaled(to: imageSize) 
    let topRight = detectedRectangle.topRight.scaled(to: imageSize) 
    let bottomLeft = detectedRectangle.bottomLeft.scaled(to: imageSize) 
    let bottomRight = detectedRectangle.bottomRight.scaled(to: imageSize) 
    let correctedImage = inputImage 
     .cropped(to: boundingBox) 
     .applyingFilter("CIPerspectiveCorrection", parameters: [ 
      "inputTopLeft": CIVector(cgPoint: topLeft), 
      "inputTopRight": CIVector(cgPoint: topRight), 
      "inputBottomLeft": CIVector(cgPoint: bottomLeft), 
      "inputBottomRight": CIVector(cgPoint: bottomRight) 
      ]) 


    // Show the pre-processed image 
    DispatchQueue.main.async { 
     print("Tony: 1 adding image") 
     self.finalImage = UIImage(ciImage: correctedImage) 
     self.FinalizedImage.image = self.finalImage 

     //   }else { 
     //    print("Tony: No corected image......") 

     if self.FinalizedImage.image != nil { 

     print("Tony: 2 Got here to OCR") 
     self.perform(#selector(self.startOCR), with: nil, afterDelay: 1.0) 
    } 
} 
} 

avec cette fonction OCR

@objc func startOCR() { 
    print("Tony: OCR called") 
      if self.FinalizedImage.image != nil { 
     swiftOCRInstance.recognize(FinalizedImage.image!) {recognizedString in 
      self.classificationLabel.text = recognizedString 
      print("Tony: \(recognizedString)") 
      } 
     }else { 
      print("Tony: No image here") 
     } 
    } 

Answer 1

j'ai pu comprendre. J'ai dû convertir l'image de ciImage en cgImage, puis revenir à uiImage. Comme le ciImage est seulement des données sur la façon dont le filtre affectera l'image une fois qu'il est traité, j'ai donc dû le solidifier en premier.

un ciImage var inputImage ou faire l'image d'entrée = une autre ciImage que vous utilisez

inputImage = correctedImage 

    // Show the pre-processed image 
    DispatchQueue.main.async { 
     print("Tony: 1 adding image") 

     let cgImage = self.context.createCGImage(self.inputImage, from: self.inputImage.extent) 
     self.finalImageView.image = UIImage(cgImage: cgImage!) 


     //Filter Logic 
     let currentFilter = CIFilter(name: "CISharpenLuminance") 
     currentFilter!.setValue(CIImage(image: UIImage(cgImage: cgImage!)), forKey: kCIInputImageKey) 


     let output = currentFilter!.outputImage 
     let cgimg = self.context.createCGImage(output!, from: output!.extent) 
     let processedImage = UIImage(cgImage: cgimg!) 
     self.finalImageView.image = processedImage 

     // Then start the OCR work using finalImageView.image as the input image of the OCR