Request for Non-Destructive Processing in `AlignFaceUsingLandmarks` Function

[cxf567]

Dear [Developer/Support Team]
My source images are relatively large, and they need to be processed multiple times. To optimize performance and ensure data integrity, I would like the AlignFaceUsingLandmarks function to not modify the input source image but instead return the processed result as a new image.

Currently, the function modifies the input image directly, which can lead to inefficiencies when the same image needs to be processed repeatedly. Returning a new image would allow me to maintain the original source image and reduce the overhead associated with cloning or creating multiple copies of the image.

Could you please consider updating the AlignFaceUsingLandmarks function to return the processed image rather than modifying the input? This change would greatly enhance the usability and efficiency of the function in scenarios where images need to be processed multiple times.

Thank you for your consideration.

Best regards

[georg-jung]

Hey @cxf567,

I think modifying it in this way would actually decrease performance for a lot of users and that is why it works how it currently does. To be able to return a modified copy of the image instead of working in-place, AlignFaceUsingLandmarks itself would need to perform Clone. If you call clone or FaceAiSharp does internally does not have any impact on performance. Thus, FaceAiSharp is designed as it currently is because this way, users who don't need to maintain an unmodified copy don't need to pay the cost for cloning. Users who need to maintain an unmodified copy would need to pay the cost of cloning in any way, but the current design enables all use cases in the most efficient way possible with just one API.

If you have any more specific ideas how to optimize this process, please let me know!

[georg-jung]

It could be possible that Clone(op) (what you propose) is faster than Clone().Mutate(op) (what you are currently forced to do). I'm not sure about the impact though and would be interested in seeing a quick benchmark before changing the API 🤔

[cxf567]

Hello,
My project frequently involves processing images with a resolution of around 6 million pixels, containing approximately 50 faces. Currently, I handle this as follows:

1foreach (var face in faces){
Image clonedImage = img.Clone();
rec.AlignFaceUsingLandmarks(clonedImage, face.Landmarks);
float[] embedding = rec.GenerateEmbedding(clonedImage);
// ...
}

If the processing result is returned, it can be written like this:
foreach (var face in faces){
float[] embedding = rec.GenerateEmbedding(rec.AlignFaceUsingLandmarks(img, face.Landmarks));
// ...
}

I am not sure about the internal process of the AlignFaceUsingLandmarks function. When dealing with images containing multiple faces, I wonder if this approach is better.
Most programmers don't care about the intermediate process; we need the final result. I think the most straightforward workflow would be something like this: :-)
var faces = det.DetectFaces(img).ToArray();
var imgs = rec.AlignFaceUsingLandmarks(img, faces);
var Embeddings = rec.GenerateEmbedding(imgs);

I'm not sure if my idea is correct, but I hope it serves as a reference.
Best regards!

[georg-jung]

I did some Benchmarks and they indeed seem to indicate that Clone(op) is faster in most cases - contrary to what I expected often even faster than Mutate(op), not only faster than Clone().Mutate(op). Thus it would make sense to change the API so that AlignFaceUsingLandmarks returns a cloned portion of the image: I will probably think about this a bit more, but probably implement something like you proposed. Thanks!