cassdlcm/mediapipe
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge f300692929 into ec43bea176

Browse Source
This commit is contained in:
priankakariatyml 2024-01-02 10:36:49 +01:00 committed by GitHub
commit 681eb08676
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 717 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
mediapipe/tasks/ios/vision/image_embedder/BUILD Normal file
View File

@ -0,0 +1,54 @@
# Copyright 2023 The MediaPipe Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
package(default_visibility = ["//mediapipe/tasks:internal"])
licenses(["notice"])
objc_library(
name = "MPPImageEmbedderResult",
srcs = ["sources/MPPImageEmbedderResult.m"],
hdrs = ["sources/MPPImageEmbedderResult.h"],
deps = [
"//mediapipe/tasks/ios/components/containers:MPPEmbeddingResult",
"//mediapipe/tasks/ios/core:MPPTaskResult",
],
)
objc_library(
name = "MPPImageEmbedderOptions",
srcs = ["sources/MPPImageEmbedderOptions.m"],
hdrs = ["sources/MPPImageEmbedderOptions.h"],
deps = [
":MPPImageEmbedderResult",
"//mediapipe/tasks/ios/core:MPPTaskOptions",
"//mediapipe/tasks/ios/vision/core:MPPRunningMode",
],
)
objc_library(
name = "MPPImageEmbedder",
hdrs = ["sources/MPPImageEmbedder.h"],
copts = [
"-ObjC++",
"-std=c++17",
"-x objective-c++",
],
module_name = "MPPImageEmbedder",
deps = [
":MPPImageEmbedderOptions",
":MPPImageEmbedderResult",
"//mediapipe/tasks/ios/vision/core:MPPImage",
],
)

270
mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedder.h Normal file
View File

@ -0,0 +1,270 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import <Foundation/Foundation.h>
#import "mediapipe/tasks/ios/vision/core/sources/MPPImage.h"
#import "mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderOptions.h"
#import "mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderResult.h"
NS_ASSUME_NONNULL_BEGIN
/**
* @brief Performs embedding extraction on images.
*
* The API expects a TFLite model with optional, but strongly recommended,
* [TFLite Model Metadata.](https://www.tensorflow.org/lite/convert/metadata").
*
* The API supports models with one image input tensor and one or more output tensors. To be more
* specific, here are the requirements.
*
* Input image tensor
* (kTfLiteUInt8/kTfLiteFloat32)
* - image input of size `[batch x height x width x channels]`.
* - batch inference is not supported (`batch` is required to be 1).
* - only RGB inputs are supported (`channels` is required to be 3).
* - if type is kTfLiteFloat32, NormalizationOptions are required to be attached to the metadata
* for input normalization.
*
* At least one output tensor (kTfLiteUInt8/kTfLiteFloat32) with shape `[1 x N]` where N
* is the number of dimensions in the produced embeddings.
*/
NS_SWIFT_NAME(ImageEmbedder)
@interface MPPImageEmbedder : NSObject
/**
* Creates a new instance of `ImageEmbedder` from an absolute path to a TensorFlow Lite model file
* stored locally on the device and the default `ImageEmbedderOptions`.
*
* @param modelPath An absolute path to a TensorFlow Lite model file stored locally on the device.
*
* @return A new instance of `ImageEmbedder` with the given model path. `nil` if there is an
* error in initializing the image embedder.
*/
- (nullable instancetype)initWithModelPath:(NSString *)modelPath error:(NSError **)error;
/**
* Creates a new instance of `ImageEmbedder` from the given `ImageEmbedderOptions`.
*
* @param options The options of type `ImageEmbedderOptions` to use for configuring the
* `ImageEmbedder`.
*
* @return A new instance of `ImageEmbedder` with the given options. `nil` if there is an error in
* initializing the image embedder.
*/
- (nullable instancetype)initWithOptions:(MPPImageEmbedderOptions *)options
error:(NSError **)error NS_DESIGNATED_INITIALIZER;
/**
* Performs embedding extraction on the provided `MPImage` using the whole image as region of
* interest. Rotation will be applied according to the `orientation` property of the provided
* `MPImage`. Only use this method when the `ImageEmbedder` is created with running mode, `.image`.
*
* This method supports embedding extraction on RGBA images. If your `MPImage` has a
* source type of `.pixelBuffer` or `.sampleBuffer`, the underlying pixel buffer must use
* `kCVPixelFormatType_32BGRA` as its pixel format.
*
* If your `MPImage` has a source type of `.image` ensure that the color space is RGB with an Alpha
* channel.
*
* @param image The `MPImage` on which embedding extraction is to be performed.
*
* @return An `ImageEmbedderResult` object that contains a list of embedding extraction.
*/
- (nullable MPPImageEmbedderResult *)embedImage:(MPPImage *)image
error:(NSError **)error NS_SWIFT_NAME(embed(image:));
/**
* Performs embedding extraction on the provided `MPImage` cropped to the specified region of
* interest. Rotation will be applied on the cropped image according to the `orientation` property
* of the provided `MPImage`. Only use this method when the `ImageEmbedder` is created with running
* mode, `.image`.
*
* This method supports embedding extraction on RGBA images. If your `MPImage` has a
* source type of `.pixelBuffer` or `.sampleBuffer`, the underlying pixel buffer must use
* `kCVPixelFormatType_32BGRA` as its pixel format.
*
* If your `MPImage` has a source type of `.image` ensure that the color space is RGB with an Alpha
* channel.
*
* @param image The `MPImage` on which embedding extraction is to be performed.
* @param roi A `CGRect` specifying the region of interest within the given `MPImage`, on which
* embedding extraction should be performed.
*
* @return An `ImageEmbedderResult` object that contains a list of generated image embeddings.
*/
- (nullable MPPImageEmbedderResult *)embedImage:(MPPImage *)image
regionOfInterest:(CGRect)roi
error:(NSError **)error
NS_SWIFT_NAME(embed(image:regionOfInterest:));
/**
* Performs embedding extraction on the provided video frame of type `MPImage` using the whole image
* as region of interest. Rotation will be applied according to the `orientation` property of the
* provided `MPImage`. Only use this method when the `ImageEmbedder` is created with running mode
* `.video`.
*
* It's required to provide the video frame's timestamp (in milliseconds). The input timestamps must
* be monotonically increasing.
*
* This method supports embedding extraction on RGBA images. If your `MPImage` has a
* source type of `.pixelBuffer` or `.sampleBuffer`, the underlying pixel buffer must use
* `kCVPixelFormatType_32BGRA` as its pixel format.
*
* If your `MPImage` has a source type of `.image` ensure that the color space is RGB with an Alpha
* channel.
*
* @param image The `MPImage` on which embedding extraction is to be performed.
* @param timestampInMilliseconds The video frame's timestamp (in milliseconds). The input
* timestamps must be monotonically increasing.
*
* @return An `ImageEmbedderResult` object that contains a list of generated image embeddings.
*/
- (nullable MPPImageEmbedderResult *)embedVideoFrame:(MPPImage *)image
timestampInMilliseconds:(NSInteger)timestampInMilliseconds
error:(NSError **)error
NS_SWIFT_NAME(embed(videoFrame:timestampInMilliseconds:));
/**
* Performs embedding extraction on the provided video frame of type `MPImage` cropped to the
* specified region of interest. Rotation will be applied according to the `orientation` property of
* the provided `MPImage`. Only use this method when the `ImageEmbedder` is created with `.video`.
*
* It's required to provide the video frame's timestamp (in milliseconds). The input timestamps must
* be monotonically increasing.
*
* This method supports embedding extraction on RGBA images. If your `MPImage` has a
* source type of `.pixelBuffer` or `.sampleBuffer`, the underlying pixel buffer must use
* `kCVPixelFormatType_32BGRA` as its pixel format.
*
* If your `MPImage` has a source type of `.image` ensure that the color space is RGB with an Alpha
* channel.
*
* @param image A live stream image data of type `MPImage` on which embedding extraction is to be
* performed.
* @param timestampInMilliseconds The video frame's timestamp (in milliseconds). The input
* timestamps must be monotonically increasing.
* @param roi A `CGRect` specifying the region of interest within the video frame of type
* `MPImage`, on which embedding extraction should be performed.
*
* @return An `ImageEmbedderResult` object that contains a list of generated image embeddings.
*/
- (nullable MPPImageEmbedderResult *)embedVideoFrame:(MPPImage *)image
timestampInMilliseconds:(NSInteger)timestampInMilliseconds
regionOfInterest:(CGRect)roi
error:(NSError **)error
NS_SWIFT_NAME(embed(videoFrame:timestampInMilliseconds:regionOfInterest:));
/**
* Sends live stream image data of type `MPImage` to perform embedding extraction using the whole
* image as region of interest. Rotation will be applied according to the `orientation` property of
* the provided `MPImage`. Only use this method when the `ImageEmbedder` is created with running
* mode `.liveStream`.
*
* The object which needs to be continuously notified of the available results of image
* embedding extraction must confirm to `ImageEmbedderLiveStreamDelegate` protocol and implement the
* `imageEmbedder(_:didFinishEmbeddingWithResult:timestampInMilliseconds:error:)` delegate
* method.
*
* It's required to provide a timestamp (in milliseconds) to indicate when the input image is sent
* to the image embedder. The input timestamps must be monotonically increasing.
*
* This method supports embedding extraction on RGBA images. If your `MPImage` has a
* source type of `.pixelBuffer` or `.sampleBuffer`, the underlying pixel buffer must use
* `kCVPixelFormatType_32BGRA` as its pixel format.
*
* If the input `MPImage` has a source type of `.image` ensure that the color space is RGB with an
* Alpha channel.
*
* If this method is used for embedding live camera frames using `AVFoundation`, ensure that you
* request `AVCaptureVideoDataOutput` to output frames in `kCMPixelFormat_32RGBA` using its
* `videoSettings` property.
*
* @param image A live stream image data of type `MPImage` on which embedding extraction is to be
* performed.
* @param timestampInMilliseconds The timestamp (in milliseconds) which indicates when the input
* image is sent to the image embedder. The input timestamps must be monotonically increasing.
*
* @return `true` if the image was sent to the task successfully, otherwise `false`.
*/
- (BOOL)embedAsyncImage:(MPPImage *)image
timestampInMilliseconds:(NSInteger)timestampInMilliseconds
error:(NSError **)error
NS_SWIFT_NAME(embedAsync(image:timestampInMilliseconds:));
/**
* Sends live stream image data of type `MPImage` to perform embedding extraction, cropped to the
* specified region of interest.. Rotation will be applied according to the `orientation` property
* of the provided `MPImage`. Only use this method when the `ImageEmbedder` is created with
* `.liveStream`.
*
* The object which needs to be continuously notified of the available results of image embedding
* extraction must confirm to `ImageEmbedderLiveStreamDelegate` protocol and implement the
* `imageEmbedder(_:didFinishEmbeddingWithResult:timestampInMilliseconds:error:)` delegate
* method.
*
* It's required to provide a timestamp (in milliseconds) to indicate when the input image is sent
* to the image embedder. The input timestamps must be monotonically increasing.
*
* This method supports embedding extraction on RGBA images. If your `MPImage` has a
* source type of `.pixelBuffer` or `.sampleBuffer`, the underlying pixel buffer must use
* `kCVPixelFormatType_32BGRA` as its pixel format.
*
* If the input `MPImage` has a source type of `.image` ensure that the color space is RGB with an
* Alpha channel.
*
* If this method is used for embedding live camera frames using `AVFoundation`, ensure that you
* request `AVCaptureVideoDataOutput` to output frames in `kCMPixelFormat_32RGBA` using its
* `videoSettings` property.
*
* @param image A live stream image data of type `MPImage` on which embedding extraction is to be
* performed.
* @param timestampInMilliseconds The timestamp (in milliseconds) which indicates when the input
* image is sent to the image embedder. The input timestamps must be monotonically increasing.
* @param roi A `CGRect` specifying the region of interest within the given live stream image data
* of type `MPImage`, on which embedding extraction should be performed.
*
* @return `true` if the image was sent to the task successfully, otherwise `false`.
*/
- (BOOL)embedAsyncImage:(MPPImage *)image
timestampInMilliseconds:(NSInteger)timestampInMilliseconds
regionOfInterest:(CGRect)roi
error:(NSError **)error
NS_SWIFT_NAME(embedAsync(image:timestampInMilliseconds:regionOfInterest:));
- (instancetype)init NS_UNAVAILABLE;
/**
* Utility function to compute[cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity)
* between two `MPPEmbedding` objects.
*
* @param embedding1 One of the two `MPPEmbedding`s between whom cosine similarity is to be
* computed.
* @param embedding2 One of the two `MPPEmbedding`s between whom cosine similarity is to be
* computed.
* @param error An optional error parameter populated when there is an error in calculating cosine
* similarity between two embeddings.
*
* @return An `NSNumber` which holds the cosine similarity of type `double`.
*/
+ (nullable NSNumber *)cosineSimilarityBetweenEmbedding1:(MPPEmbedding *)embedding1
andEmbedding2:(MPPEmbedding *)embedding2
error:(NSError **)error
NS_SWIFT_NAME(cosineSimilarity(embedding1:embedding2:));
+ (instancetype)new NS_UNAVAILABLE;
@end
NS_ASSUME_NONNULL_END

104
mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderOptions.h Normal file
View File

@ -0,0 +1,104 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import <Foundation/Foundation.h>
#import "mediapipe/tasks/ios/core/sources/MPPTaskOptions.h"
#import "mediapipe/tasks/ios/vision/core/sources/MPPRunningMode.h"
#import "mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderResult.h"
NS_ASSUME_NONNULL_BEGIN
@class MPPImageEmbedder;
/**
* This protocol defines an interface for the delegates of `ImageEmbedder` object to receive
* results of asynchronous embedding extraction on images (i.e, when `runningMode` = `.liveStream`).
*
* The delegate of `ImageEmbedder` must adopt `ImageEmbedderLiveStreamDelegate` protocol.
* The methods in this protocol are optional.
*/
NS_SWIFT_NAME(ImageEmbedderLiveStreamDelegate)
@protocol MPPImageEmbedderLiveStreamDelegate <NSObject>
@optional
/**
* This method notifies a delegate that the results of asynchronous embedding extraction on
* an image submitted to the `ImageEmbedder` is available.
*
* This method is called on a private serial queue created by the `ImageEmbedder`
* for performing the asynchronous delegates calls.
*
* @param imageEmbedder The image embedder which performed the embedding extraction.
* This is useful to test equality when there are multiple instances of `ImageEmbedder`.
* @param result An `ImageEmbedderResult` object that contains a list of generated image embeddings.
* @param timestampInMilliseconds The timestamp (in milliseconds) which indicates when the input
* image was sent to the image embedder.
* @param error An optional error parameter populated when there is an error in performing embedding
* extraction on the input live stream image data.
*/
- (void)imageEmbedder:(MPPImageEmbedder *)imageEmbedder
didFinishEmbeddingWithResult:(nullable MPPImageEmbedderResult *)result
timestampInMilliseconds:(NSInteger)timestampInMilliseconds
error:(nullable NSError *)error
NS_SWIFT_NAME(imageEmbedder(_:didFinishClassification:timestampInMilliseconds:error:));
@end
/**
* Options for setting up a `ImageEmbedder`.
*/
NS_SWIFT_NAME(ImageEmbedderOptions)
@interface MPPImageEmbedderOptions : MPPTaskOptions <NSCopying>
/**
* Running mode of the image embedder task. Defaults to `.image`.
* `ImageEmbedder` can be created with one of the following running modes:
* 1. `.image`: The mode for performing embedding extraction on single image inputs.
* 2. `.video`: The mode for performing embedding extraction on the decoded frames of a
* video.
* 3. `.liveStream`: The mode for performing embedding extraction on a live stream of input
* data, such as from the camera.
*/
@property(nonatomic) MPPRunningMode runningMode;
/**
* An object that confirms to `ImageEmbedderLiveStreamDelegate` protocol. This object must
* implement `imageEmbedder(_:didFinishEmbeddingWithResult:timestampInMilliseconds:error:)` to
* receive the results of asynchronous embedding extraction on images (i.e, when `runningMode =
* .liveStream`).
*/
@property(nonatomic, weak, nullable) id<MPPImageEmbedderLiveStreamDelegate>
imageEmbedderLiveStreamDelegate;
/**
* @brief Sets whether L2 normalization should be performed on the returned embeddings.
* Use this option only if the model does not already contain a native L2_NORMALIZATION TF Lite Op.
* In most cases, this is already the case and L2 norm is thus achieved through TF Lite inference.
*
* `NO` by default.
*/
@property(nonatomic) BOOL l2Normalize;
/**
* @brief Sets whether the returned embedding should be quantized to bytes via scalar quantization.
* Embeddings are implicitly assumed to be unit-norm and therefore any dimensions is guaranteed to
* have value in [-1.0, 1.0]. Use the `l2Normalize` property if this is not the case.
*
* `NO` by default.
*/
@property(nonatomic) BOOL quantize;
@end
NS_ASSUME_NONNULL_END

29
mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderOptions.m Normal file
View File

@ -0,0 +1,29 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import "mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderOptions.h"
@implementation MPPImageEmbedderOptions
- (id)copyWithZone:(NSZone *)zone {
MPPImageEmbedderOptions *imageEmbedderOptions = [super copyWithZone:zone];
imageEmbedderOptions.runningMode = self.runningMode;
imageEmbedderOptions.l2Normalize = self.l2Normalize;
imageEmbedderOptions.quantize = self.quantize;
return imageEmbedderOptions;
}
@end

48
mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderResult.h Normal file
View File

@ -0,0 +1,48 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import <Foundation/Foundation.h>
#import "mediapipe/tasks/ios/components/containers/sources/MPPEmbeddingResult.h"
#import "mediapipe/tasks/ios/core/sources/MPPTaskResult.h"
NS_ASSUME_NONNULL_BEGIN
/** Represents the embedding results generated by `ImageEmbedder`. **/
NS_SWIFT_NAME(ImageEmbedderResult)
@interface MPPImageEmbedderResult : MPPTaskResult
/** The `MPPEmbedderResult` instance containing one embedding per embedder head. **/
@property(nonatomic, readonly) MPPEmbeddingResult *embeddingResult;
/**
* Initializes a new `ImageEmbedderResult` with the given `MPPEmbeddingResult` and
* timestamp (in milliseconds).
*
* @param embeddingResult The `EmbeddingResult` instance containing one set of results per
* classifier head.
* @param timestampInMilliseconds The timestamp (in millisecondss) for this result.
*
* @return An instance of `ImageEmbedderResult` initialized with the given
* `MPPEmbeddingResult` and timestamp (in milliseconds).
*/
- (instancetype)initWithEmbeddingResult:(MPPEmbeddingResult *)embeddingResult
timestampInMilliseconds:(NSInteger)timestampInMilliseconds;
- (instancetype)init NS_UNAVAILABLE;
+ (instancetype)new NS_UNAVAILABLE;
@end
NS_ASSUME_NONNULL_END

28
mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderResult.m Normal file
View File

@ -0,0 +1,28 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import "mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderResult.h"
@implementation MPPImageEmbedderResult
- (instancetype)initWithEmbeddingResult:(MPPEmbeddingResult *)embeddingResult
timestampInMilliseconds:(NSInteger)timestampInMilliseconds {
self = [super initWithTimestampInMilliseconds:timestampInMilliseconds];
if (self) {
_embeddingResult = embeddingResult;
}
return self;
}
@end

44
mediapipe/tasks/ios/vision/image_embedder/utils/BUILD Normal file
View File

@ -0,0 +1,44 @@
# Copyright 2023 The MediaPipe Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
package(default_visibility = ["//mediapipe/tasks:internal"])
licenses(["notice"])
objc_library(
name = "MPPImageEmbedderOptionsHelpers",
srcs = ["sources/MPPImageEmbedderOptions+Helpers.mm"],
hdrs = ["sources/MPPImageEmbedderOptions+Helpers.h"],
deps = [
"//mediapipe/framework:calculator_options_cc_proto",
"//mediapipe/tasks/cc/components/processors/proto:embedder_options_cc_proto",
"//mediapipe/tasks/cc/vision/image_embedder/proto:image_embedder_graph_options_cc_proto",
"//mediapipe/tasks/ios/common/utils:NSStringHelpers",
"//mediapipe/tasks/ios/core:MPPTaskOptionsProtocol",
"//mediapipe/tasks/ios/core/utils:MPPBaseOptionsHelpers",
"//mediapipe/tasks/ios/vision/image_embedder:MPPImageEmbedderOptions",
],
)
objc_library(
name = "MPPImageEmbedderResultHelpers",
srcs = ["sources/MPPImageEmbedderResult+Helpers.mm"],
hdrs = ["sources/MPPImageEmbedderResult+Helpers.h"],
deps = [
"//mediapipe/framework:packet",
"//mediapipe/tasks/cc/components/containers/proto:embeddings_cc_proto",
"//mediapipe/tasks/ios/components/containers/utils:MPPEmbeddingResultHelpers",
"//mediapipe/tasks/ios/vision/image_embedder:MPPImageEmbedderResult",
],
)

27
mediapipe/tasks/ios/vision/image_embedder/utils/sources/MPPImageEmbedderOptions+Helpers.h Normal file
View File

@ -0,0 +1,27 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "mediapipe/framework/calculator_options.pb.h"
#import "mediapipe/tasks/ios/core/sources/MPPTaskOptionsProtocol.h"
#import "mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderOptions.h"
NS_ASSUME_NONNULL_BEGIN
@interface MPPImageEmbedderOptions (Helpers) <MPPTaskOptionsProtocol>
- (void)copyToProto:(::mediapipe::CalculatorOptions *)optionsProto;
@end
NS_ASSUME_NONNULL_END

45
mediapipe/tasks/ios/vision/image_embedder/utils/sources/MPPImageEmbedderOptions+Helpers.mm Normal file
View File

@ -0,0 +1,45 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import "mediapipe/tasks/ios/vision/image_embedder/utils/sources/MPPImageEmbedderOptions+Helpers.h"
#import "mediapipe/tasks/ios/common/utils/sources/NSString+Helpers.h"
#import "mediapipe/tasks/ios/core/utils/sources/MPPBaseOptions+Helpers.h"
#include "mediapipe/tasks/cc/components/processors/proto/embedder_options.pb.h"
#include "mediapipe/tasks/cc/vision/image_embedder/proto/image_embedder_graph_options.pb.h"
namespace {
using CalculatorOptionsProto = ::mediapipe::CalculatorOptions;
using ImageEmbedderGraphOptionsProto =
::mediapipe::tasks::vision::image_embedder::proto::ImageEmbedderGraphOptions;
using EmbedderOptionsProto = ::mediapipe::tasks::components::processors::proto::EmbedderOptions;
} // namespace
@implementation MPPImageEmbedderOptions (Helpers)
- (void)copyToProto:(CalculatorOptionsProto *)optionsProto {
ImageEmbedderGraphOptionsProto *graphOptions =
optionsProto->MutableExtension(ImageEmbedderGraphOptionsProto::ext);
[self.baseOptions copyToProto:graphOptions->mutable_base_options()
withUseStreamMode:self.runningMode != MPPRunningModeImage];
EmbedderOptionsProto *embedderOptionsProto = graphOptions->mutable_embedder_options();
embedderOptionsProto->Clear();
embedderOptionsProto->set_l2_normalize(self.l2Normalize ? true : false);
embedderOptionsProto->set_quantize(self.quantize ? true : false);
}
@end

27
mediapipe/tasks/ios/vision/image_embedder/utils/sources/MPPImageEmbedderResult+Helpers.h Normal file
View File

@ -0,0 +1,27 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import "mediapipe/tasks/ios/vision/image_embedder/sources/MPPImageEmbedderResult.h"
#include "mediapipe/framework/packet.h"
NS_ASSUME_NONNULL_BEGIN
@interface MPPImageEmbedderResult (Helpers)
+ (MPPImageEmbedderResult *)imageEmbedderResultWithOutputPacket:(const mediapipe::Packet &)packet;
@end
NS_ASSUME_NONNULL_END

41
mediapipe/tasks/ios/vision/image_embedder/utils/sources/MPPImageEmbedderResult+Helpers.mm Normal file
View File

@ -0,0 +1,41 @@
// Copyright 2023 The MediaPipe Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#import "mediapipe/tasks/ios/components/containers/utils/sources/MPPEmbeddingResult+Helpers.h"
#import "mediapipe/tasks/ios/vision/image_embedder/utils/sources/MPPImageEmbedderResult+Helpers.h"
#include "mediapipe/tasks/cc/components/containers/proto/embeddings.pb.h"
static const int kMicrosecondsPerMillisecond = 1000;
namespace {
using EmbeddingResultProto = ::mediapipe::tasks::components::containers::proto::EmbeddingResult;
using ::mediapipe::Packet;
} // namespace
#define int kMicrosecondsPerMillisecond = 1000;
@implementation MPPImageEmbedderResult (Helpers)
+ (MPPImageEmbedderResult *)imageEmbedderResultWithOutputPacket:(const Packet &)packet {
MPPEmbeddingResult *embeddingResult =
[MPPEmbeddingResult embeddingResultWithProto:packet.Get<EmbeddingResultProto>()];
return [[MPPImageEmbedderResult alloc]
initWithEmbeddingResult:embeddingResult
timestampInMilliseconds:(NSInteger)(packet.Timestamp().Value() /
kMicrosecondsPerMillisecond)];
}
@end