המשימה 'פילוח תמונות' מאפשרת לחלק תמונות לאזורים על סמך הגדרות מוגדרות מראש ולהשתמש באפקטים חזותיים כמו טשטוש רקע. האלה הוראות לשימוש ב'פלח התמונות' באפליקציות ל-iOS.
דוגמת הקוד שמתוארת בהוראות אלה זמינה במכשירים הבאים: GitHub.
אפשר לראות את המשימה הזו באתר . מידע נוסף על היכולות, המודלים ואפשרויות ההגדרה במשימה הזאת סקירה כללית
קוד לדוגמה
דוגמה לקוד של MediaPipe Tasks כוללת הטמעה פשוטה של אפליקציית 'פלח תמונות' ל-iOS.
בדוגמה הזו מיושם כלי פילוח של תמונות שמפיק מסכות של קטגוריות. הוא משתמש המצלמה במכשיר iOS פיזי כדי לבצע פילוח של תמונות בפיד המצלמה או בתמונות ובסרטונים מגלריית המכשיר.
אפשר להשתמש באפליקציה כנקודת התחלה של אפליקציה משלך ל-iOS, או להתייחס אליה כשמשנים אפליקציה קיימת. הקוד לדוגמה של 'פלח התמונות' מתארח ב- GitHub.
להורדת הקוד
בהוראות הבאות מוסבר איך ליצור עותק מקומי של הדוגמה באמצעות כלי שורת הפקודה git.
כדי להוריד את הקוד לדוגמה:
משכפלים את מאגר ה-Git באמצעות הפקודה הבאה:
git clone https://github.com/google-ai-edge/mediapipe-samples/
לחלופין, להגדיר את מכונת ה-Git שלך לשימוש בקופה עם היעדר תשלום, כדי רק את הקבצים עבור האפליקציה לדוגמה של 'פלח התמונות':
cd mediapipe git sparse-checkout init --cone git sparse-checkout set examples/image_segmentation/ios/
אחרי שתיצרו גרסה מקומית של הקוד לדוגמה, תוכלו להתקין את ספריית המשימות של MediaPipe, פותחים את הפרויקט באמצעות Xcode ומריצים את האפליקציה. עבור ההוראות מפורטות במדריך ההגדרה ל-iOS.
רכיבים מרכזיים
הקבצים הבאים מכילים את הקוד החשוב של הדוגמה 'פילוח תמונות' יישום:
- ImageSegmenterService.swift: מאתחל את פילוח התמונות, מטפל בבחירת המודל ומפעיל מסיקה על נתוני הקלט.
- CameraViewController.swift: הטמעה של ממשק המשתמש עבור מצב הקלט של פיד המצלמה בשידור חי והצגה חזותית של תוצאות.
- MediaLibraryViewController.swift מטמיע את ממשק המשתמש עבור מצב קלט של קובצי תמונה ווידאו הצגת התוצאות באופן חזותי.
הגדרה
בקטע הזה מתוארים השלבים העיקריים להגדרת סביבת הפיתוח כדי להשתמש ב'פלח תמונות'. לקבלת מידע כללי על הגדרת סביבת פיתוח לשימוש במשימות MediaPipe, כולל גרסת פלטפורמה מומלץ לעיין במדריך ההגדרה ל-iOS.
יחסי תלות
'פלח התמונות' משתמש בספרייה MediaPipeTasksVision
, שחייבת להיות מותקנת
באמצעות CocoaPods. הספרייה תואמת גם לאפליקציות Swift ו-Objective-C
ולא נדרשת הגדרה נוספת ספציפית לשפה.
הוראות להתקנת CocoaPods ב-macOS מפורטות במאמר CocoaPods
במדריך ההתקנה.
לקבלת הוראות ליצירת Podfile
עם ה-pods שדרושים
באפליקציה, קראו את המאמר שימוש
CocoaPods.
מוסיפים את הרצף של MediaPipeTasksVision ב-Podfile
באמצעות הקוד הבא:
target 'MyImageSegmenterApp' do
use_frameworks!
pod 'MediaPipeTasksVision'
end
אם האפליקציה שלך כוללת יעדים לבדיקת יחידות, יש לעיין במדריך ההגדרה של
iOS למידע נוסף על ההגדרה
Podfile
.
דגם
למשימה 'פלח תמונות של MediaPipe' נדרש מודל מאומן התואם במשימה הזו. לקבלת מידע נוסף על המודלים הזמינים המאומנים עבור לפלח תמונות, ראו סקירה כללית של המשימה מודלים .
בוחרים מודל ומורידים אותו, ומוסיפים אותו לספריית הפרויקט באמצעות Xcode. לקבלת הוראות להוספת קבצים לפרויקט Xcode, קראו את המאמר ניהול קבצים ותיקיות ב-Xcode project.
משתמשים במאפיין BaseOptions.modelAssetPath
כדי לציין את הנתיב למודל
ב-App Bundle. בקטע הבא מופיע קוד לדוגמה.
יצירת המשימה
כדי ליצור את המשימה 'פילוח תמונות', אפשר להפעיל אחד מהמאתחלים שלה.
המאתחל של ImageSegmenter(options:)
מקבל ערכים להגדרה
אפשרויות.
אם אתם לא צריכים מפלח תמונות עם הגדרות מותאמות אישית
אפשר להשתמש במאתחל של ImageSegmenter(modelPath:)
כדי ליצור
פילוח תמונות עם אפשרויות ברירת המחדל. מידע נוסף על הגדרה
אפשרויות נוספות, ראו סקירה כללית של ההגדרות.
במשימה 'פילוח תמונות' יש תמיכה ב-3 סוגים של נתוני קלט: תמונות סטילס וקובצי וידאו
בסטרימינג של וידאו בשידור חי. כברירת מחדל, ImageSegmenter(modelPath:)
מאתחל
לתמונות סטילס. אם רוצים שהמשימה תופעל כדי לעבד סרטון
קבצים או שידורים חיים, צריך להשתמש ב-ImageSegmenter(options:)
כדי לציין את הסרטון
או במצב ריצה בשידור חי. במצב השידור החי נדרשות גם פעולות נוספות
את אפשרות ההגדרה של imageSegmenterLiveStreamDelegate
, שמאפשרת
פילוח תמונות שנועד לספק תוצאות של פילוח תמונות
באופן אסינכרוני.
כדי לראות איך יוצרים את המשימה, צריך לבחור את הכרטיסייה שמתאימה למצב הריצה ולהריץ את ההסקה.
Swift
תמונה
import MediaPipeTasksVision let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite") let options = ImageSegmenterOptions() options.baseOptions.modelAssetPath = modelPath options.runningMode = .image options.shouldOutputCategoryMask = true options.shouldOutputConfidenceMasks = false let imageSegmenter = try ImageSegmenter(options: options)
וידאו
import MediaPipeTasksVision let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite") let options = ImageSegmenterOptions() options.baseOptions.modelAssetPath = modelPath options.runningMode = .video options.shouldOutputCategoryMask = true options.shouldOutputConfidenceMasks = false let imageSegmenter = try ImageSegmenter(options: options)
שידור חי
import MediaPipeTasksVision // Class that conforms to the `imageSegmenterLiveStreamDelegate` protocol and // implements the method that the image segmenter calls once it finishes // performing segmentation of each input frame. class ImageSegmenterResultProcessor: NSObject, ImageSegmenterLiveStreamDelegate { func imageSegmenter( _ imageSegmenter: ImageSegmenter, didFinishSegmentation result: ImageSegmenterResult?, timestampInMilliseconds: Int, error: Error?) { // Process the image segmentation result or errors here. } } let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite") let options = ImageSegmenterOptions() options.baseOptions.modelAssetPath = modelPath options.runningMode = .liveStream options.shouldOutputCategoryMask = true options.shouldOutputConfidenceMasks = false // Set `imageSegmenterLiveStreamDelegate` to the object of the class that // confirms to the `ImageSegmenterLiveStreamDelegate` protocol. let processor = ImageSegmenterResultProcessor() options.imageSegmenterLiveStreamDelegate = processor let imageSegmenter = try ImageSegmenter(options: options)
Objective-C
תמונה
@import MediaPipeTasksVision; NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model" ofType:@"tflite"]; MPPImageSegmenterOptions *options = [[MPPImageSegmenterOptions alloc] init]; options.baseOptions.modelAssetPath = modelPath; options.runningMode = MPPRunningModeImage; options.shouldOutputCategoryMask = YES; options.shouldOutputConfidenceMasks = NO; MPPImageSegmenter *imageSegmenter = [[MPPImageSegmenter alloc] initWithOptions:options error:nil];
וידאו
@import MediaPipeTasksVision; NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model" ofType:@"tflite"]; MPPImageSegmenterOptions *options = [[MPPImageSegmenterOptions alloc] init]; options.baseOptions.modelAssetPath = modelPath; options.runningMode = MPPRunningModeVideo; options.shouldOutputCategoryMask = YES; options.shouldOutputConfidenceMasks = NO; MPPImageSegmenter *imageSegmenter = [[MPPImageSegmenter alloc] initWithOptions:options error:nil];
שידור חי
@import MediaPipeTasksVision; // Class that conforms to the `MPPImageSegmenterLiveStreamDelegate` protocol // and implements the method that the image segmenter calls once it finishes // performing segmentation of each input frame. @interface APPImageSegmenterResultProcessor : NSObject@end @implementation APPImageSegmenterResultProcessor - (void)imageSegmenter:(MPPImageSegmenter *)imageSegmenter didFinishSegmentationWithResult:(MPPImageSegmenterResult *)imageSegmenterResult timestampInMilliseconds:(NSInteger)timestampInMilliseconds error:(NSError *)error { // Process the image segmentation result or errors here. } @end NSString *modelPath = [[NSBundle mainBundle] pathForResource:@"model" ofType:@"tflite"]; MPPImageSegmenterOptions *options = [[MPPImageSegmenterOptions alloc] init]; options.baseOptions.modelAssetPath = modelPath; options.runningMode = MPPRunningModeLiveStream; options.shouldOutputCategoryMask = YES; options.shouldOutputConfidenceMasks = NO; // Set `imageSegmenterLiveStreamDelegate` to the object of the class that // confirms to the `MPPImageSegmenterLiveStreamDelegate` protocol. APPImageSegmenterResultProcessor *processor = [APPImageSegmenterResultProcessor new]; options.imageSegmenterLiveStreamDelegate = processor; MPPImageSegmenter *imageSegmenter = [[MPPImageSegmenter alloc] initWithOptions:options error:nil];
הטמעת הקוד לדוגמה של 'פלח התמונות' מאפשרת למשתמש לעבור בין במצבי עיבוד שונים. הגישה הזו הופכת את הקוד ליצירת משימה למורכב יותר לא מתאים לתרחיש לדוגמה שלכם.
אפשרויות תצורה
המשימה הזו כוללת את אפשרויות ההגדרה הבאות לאפליקציות ל-iOS:
שם האפשרות | תיאור | טווח ערכים | ערך ברירת מחדל |
---|---|---|---|
runningMode |
מגדיר את מצב הריצה של המשימה. יש שלושה סוגים
מצבים: IMAGE: המצב לקלט של תמונה יחידה. סרטון: המצב של פריימים מפוענחים בסרטון. LIVE_STREAM: המצב לשידור חי של קלט נתונים ממצלמה, במצב הזה, ImageSegmenterLiveStreamDelegate
חייב להיות מוגדר למופע במחלקה שמממש את
ImageSegmenterLiveStreamDelegate כדי לקבל את הפילוח
את התוצאות באופן אסינכרוני.
|
{RunningMode.image, RunningMode.video, RunningMode.liveStream } |
RunningMode.image |
shouldOutputCategoryMask |
אם המדיניות מוגדרת לערך True , הפלט כולל מסיכת פילוח
כמו תמונת uint8, שבה כל ערך של פיקסל מציין את הקטגוריה המנצחת.
עם ערך מסוים. |
{True, False } |
False |
shouldOutputConfidenceMasks |
אם המדיניות מוגדרת לערך True , הפלט כולל מסיכת פילוח
כתמונה עם ערך צף, שבו כל ערך צף מייצג את מהימנות
מפת הניקוד של הקטגוריה. |
{True, False } |
True |
displayNamesLocale |
מגדיר את השפה של תוויות שישמשו לשמות לתצוגה שסופקו
של מודל המשימה, אם יש כאלה. ברירת המחדל היא en עבור
אנגלית. אפשר להוסיף תוויות שמותאמות לשוק המקומי למטא-נתונים של מודל מותאם אישית
באמצעות TensorFlow Lite Metadata Writer API |
קוד אזור | en |
result_callback |
מגדיר את אוזן התוצאות לקבל את תוצאות הפילוח
באופן אסינכרוני כאשר פילוח התמונות נמצא במצב LIVE_STREAM .
אפשר להשתמש באפשרות הזו רק כשמצב הריצה מוגדר ל-LIVE_STREAM |
לא רלוונטי | לא רלוונטי |
כשמצב הריצה מוגדר ל-LIVE_STREAM
, 'פלח התמונות' דורש
אפשרות הגדרה נוספת imageSegmenterLiveStreamDelegate
,
שמאפשר ל'מפלח התמונות' להציג תוצאות של פילוח תמונות באופן אסינכרוני.
מקבל הגישה צריך להטמיע
אמצעי תשלום אחד (imageSegmenter(_:didFinishSegmentation:timestampInMilliseconds:error:)
),
למפלח התמונות קוראים לו אחרי שהוא מעבד את התוצאות של
בכל פריים.
שם האפשרות | תיאור | טווח ערכים | ערך ברירת מחדל |
---|---|---|---|
imageSegmenterLiveStreamDelegate |
מאפשר לכלי פילוח התמונות לקבל את התוצאות של ביצוע תמונה
סגמנטציה אסינכרונית במצב חי. המחלקה שהמופע שלה הוא
שהוגדר למאפיין הזה
imageSegmenter(_:didFinishSegmentation:timestampInMilliseconds:error:)
. |
לא רלוונטי | לא מוגדר |
הכנת נתונים
צריך להמיר את תמונת הקלט או המסגרת לאובייקט MPImage
לפני
ומעבירים אותו לכלי 'פלח התמונות'. ב-MPImage
יש תמיכה בסוגים שונים של קובצי תמונה ב-iOS
ויכולים להשתמש בהם בכל מצב ריצה לצורך הסקת מסקנות. לקבלת מידע נוסף
מידע על MPImage
, מתייחס
MPImage API
צריך לבחור פורמט תמונה ל-iOS בהתאם לתרחיש לדוגמה שלכם ולמצב הריצה
מחייב.MPImage
מקבל את UIImage
, CVPixelBuffer
,
CMSampleBuffer
פורמטים של תמונות ל-iOS.
UIImage
הפורמט UIImage
מתאים במיוחד למצבי הריצה הבאים:
תמונות: תמונות מ-App Bundle, מגלריית משתמשים או ממערכת קבצים בפורמט אפשר להמיר
UIImage
תמונות לאובייקטMPImage
.סרטונים: משתמשים ב-AVAssetImageGenerator כדי לחלץ פריימים של וידאו CGImage וממירים אותן ל-
UIImage
תמונות.
Swift
// Load an image on the user's device as an iOS `UIImage` object. // Convert the `UIImage` object to a MediaPipe's Image object having the default // orientation `UIImage.Orientation.up`. let image = try MPImage(uiImage: image)
Objective-C
// Load an image on the user's device as an iOS `UIImage` object. // Convert the `UIImage` object to a MediaPipe's Image object having the default // orientation `UIImageOrientationUp`. MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
הדוגמה מאתחלת MPImage
עם ברירת המחדל
UIImage.Orientation.Up
לכיוון מסוים. אפשר לאתחל MPImage
עם כל אחד מהפורמטים הנתמכים
UIImage.Orientation
ערכים. מפלח התמונות לא תומך בכיוונים משוכפלים כמו .upMirrored
,
.downMirrored
, .leftMirrored
, .rightMirrored
.
למידע נוסף על UIImage
, יש לעיין ב-UIImage Apple Developer
מסמכים.
CVPixelBuffer
הפורמט CVPixelBuffer
מתאים מאוד לאפליקציות שיוצרות פריימים
ולהשתמש ב-CoreImage של iOS
לעיבוד טקסט.
הפורמט CVPixelBuffer
מתאים במיוחד למצבי הריצה הבאים:
תמונות: אפליקציות שיוצרות
CVPixelBuffer
תמונות לאחר עיבוד מסוים באמצעות ה-frameworkCoreImage
של iOS, ניתן לשלוח אל 'פלח התמונות' מצב הרצת התמונות.סרטונים: ניתן להמיר פריימים של וידאו לפורמט
CVPixelBuffer
עבור והעיבוד מתבצע במקטע התמונות במצב וידאו.בשידור חי: אפליקציות שמשתמשות במצלמת iOS ליצירת פריימים עשויים לעבור המרה בפורמט
CVPixelBuffer
לעיבוד לפני השליחה פילוח תמונות במצב שידור חי.
Swift
// Obtain a CVPixelBuffer. // Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the default // orientation `UIImage.Orientation.up`. let image = try MPImage(pixelBuffer: pixelBuffer)
Objective-C
// Obtain a CVPixelBuffer. // Convert the `CVPixelBuffer` object to a MediaPipe's Image object having the // default orientation `UIImageOrientationUp`. MPImage *image = [[MPPImage alloc] initWithUIImage:image error:nil];
כדי לקבל מידע נוסף על CVPixelBuffer
, אפשר לעיין ב-CVPixelBuffer Apple
מפתחי המשחק
מסמכים.
CMSampleBuffer
הפורמט CMSampleBuffer
מאחסן דוגמאות מדיה מסוג מדיה אחיד,
הוא גבוה מאוד למצב ההרצה של השידור החי. הפריימים בשידור חי ממצלמות iOS
מועברים באופן אסינכרוני בפורמט CMSampleBuffer
על ידי iOS
AVCaptureVideoDataOutput.
Swift
// Obtain a CMSampleBuffer. // Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the default // orientation `UIImage.Orientation.up`. let image = try MPImage(sampleBuffer: sampleBuffer)
Objective-C
// Obtain a `CMSampleBuffer`. // Convert the `CMSampleBuffer` object to a MediaPipe's Image object having the // default orientation `UIImageOrientationUp`. MPImage *image = [[MPPImage alloc] initWithSampleBuffer:sampleBuffer error:nil];
מידע נוסף על CMSampleBuffer
זמין ב-CMSampleBuffer Apple
מפתחי המשחק
מסמכים.
הרצת המשימה
כדי להפעיל את פילוח התמונות, צריך להשתמש בשיטה segment()
הספציפית
מצב ריצה:
- תמונת סטילס:
segment(image:)
- סרטון:
segment(videoFrame:timestampInMilliseconds:)
- צפייה בשידור חי:
segmentAsync(image:timestampInMilliseconds:)
דוגמאות הקוד הבאות מראות פשוט איך להפעיל את 'פלח התמונות' מצבי הריצה השונים הבאים:
Swift
תמונה
let result = try imageSegmenter.segment(image: image)
וידאו
let result = try imageSegmenter.segment( videoFrame: image, timestampInMilliseconds: timestamp)
שידור חי
try imageSegmenter.segmentAsync( image: image, timestampInMilliseconds: timestamp)
Objective-C
תמונה
MPPImageSegmenterResult *result = [imageSegmenter segmentImage:image error:nil];
וידאו
MPPImageSegmenterResult *result = [imageSegmenter segmentVideoFrame:image timestampInMilliseconds:timestamp error:nil];
שידור חי
BOOL success = [imageSegmenter segmentAsyncImage:image timestampInMilliseconds:timestamp error:nil];
בדוגמה של הקוד של מפלח התמונות אפשר לראות את ההטמעה של כל אחד מהמצבים האלה.
בצורה מפורטת יותר segment(image:)
,
segment(videoFrame:timestampInMilliseconds:)
, וגם
segmentAsync(image:timestampInMilliseconds:)
.
שימו לב לנקודות הבאות:
כשמפעילים מצב וידאו או שידור חי, צריך גם לספק חותמת הזמן של מסגרת הקלט למשימה של 'פלח התמונות'.
בהפעלה במצב תמונה או וידאו, המשימה 'פלח תמונות' חוסמת את את ה-thread הנוכחי עד לסיום העיבוד של תמונת הקלט או המסגרת. שפת תרגום לא לחסום את השרשור הנוכחי, צריך לבצע את העיבוד ברקע שרשור באמצעות iOS שליחה או NSOperation של מסגרות.
כשפועלים במצב שידור חי, המשימה 'פילוח תמונות' חוזרת באופן מיידי והיא לא חוסמת את השרשור הנוכחי. היא מפעילה את
imageSegmenter(_:didFinishSegmentation:timestampInMilliseconds:error:)
באמצעות מקטע התמונות אחרי העיבוד של כל מסגרת קלט. מקטע תמונות מפעיל שיטה זו באופן אסינכרוני על סדרה ייעודית תור לשליחת הודעות. להצגת תוצאות בממשק המשתמש, יש לשלוח את יוצגו לתור הראשי אחרי עיבוד התוצאות. אם מתבצעת קריאה לפונקציהsegmentAsync
כשמשימה של 'פלח התמונות' לא פנויה כשמעבד פריים אחר, ה-Image Segmenter מתעלם ממסגרת הקלט החדשה.
טיפול בתוצאות והצגתן
כשמריצים את ההסקה, המשימה 'פילוח תמונות' מחזירה ImageSegmenterResult
שמכיל את התוצאות של משימת הפילוח. התוכן של
הפלט תלוי בסוג הפלט שמגדירים כאשר
הוגדר
את המשימה.
בתמונות הבאות מוצג תרשים של פלט המשימה של קטגוריה
מסכת ערכים. טווח המסכה של הקטגוריה הוא [0, 255]
וערך כל פיקסל
שמייצג את אינדקס הקטגוריה המנצחת של פלט המודל. הקטגוריה הזוכה
הוא בעל הציון הגבוה ביותר מבין הקטגוריות שהמודל יכול לזהות.
פלט של התממה של התמונה והקטגוריה המקורית. תמונת המקור מ- פסקל VOC 2012 של הכיתובים.
הקוד לדוגמה של 'פלח התמונות' מדגים איך להציג את 'פלח התמונות' תוצאות, קראו את הקוד דוגמה לקבלת פרטים.