/* * END - LARGE PERSON GROUP */ /* * GROUP FACES * This method of grouping is useful if you don't need to create a person group. It will automatically group similar * images, whereas the person group method allows you to define the grouping. * A single "messyGroup" array contains face IDs for which no similarities were found. */ public static async Task Group(IFaceClient client, string url, string recognition_model) { Console.WriteLine("========GROUP FACES========"); Console.WriteLine(); // Create list of image names List <string> imageFileNames = new List <string> { "Family1-Dad1.jpg", "Family1-Dad2.jpg", "Family3-Lady1.jpg", "Family1-Daughter1.jpg", "Family1-Daughter2.jpg", "Family1-Daughter3.jpg" }; // Create empty dictionary to store the groups Dictionary <string, string> faces = new Dictionary <string, string>(); List <Guid?> faceIds = new List <Guid?>(); // First, detect the faces in your images foreach (var imageFileName in imageFileNames) { // Detect faces from image url. IList <DetectedFace> detectedFaces = await DetectFaceRecognize(client, $"{url}{imageFileName}", recognition_model); // Add detected faceId to faceIds and faces. faceIds.Add(detectedFaces[0].FaceId.Value); faces.Add(detectedFaces[0].FaceId.ToString(), imageFileName); } Console.WriteLine(); // Group the faces. Grouping result is a group collection, each group contains similar faces. var groupResult = await client.Face.GroupAsync(faceIds); // Face groups contain faces that are similar to all members of its group. for (int i = 0; i < groupResult.Groups.Count; i++) { Console.Write($"Found face group {i + 1}: "); foreach (var faceId in groupResult.Groups[i]) { Console.Write($"{faces[faceId.ToString()]} "); } Console.WriteLine("."); } // MessyGroup contains all faces which are not similar to any other faces. The faces that cannot be grouped. if (groupResult.MessyGroup.Count > 0) { Console.Write("Found messy face group: "); foreach (var faceId in groupResult.MessyGroup) { Console.Write($"{faces[faceId.ToString()]} "); } Console.WriteLine("."); } Console.WriteLine(); }
/// <summary> /// <param name="faceClient">Provide face client </param> /// <param name="url"></param> /// <param name="recognition_model"></param> /// <returns></returns> /// </summary> private static async Task <List <DetectedFace> > DetectFaceRecognize(IFaceClient faceClient, string url, string recognition_model) { using Stream fileStream = File.OpenRead(url); // Detect faces from image URL. Since only recognizing, use the recognition model 1. // We use detection model 2 because we are not retrieving attributes. IList <DetectedFace> detectedFaces = await faceClient.Face.DetectWithStreamAsync(fileStream, recognitionModel : recognition_model, detectionModel : DetectionModel.Detection02); Console.WriteLine($"{detectedFaces.Count} face(s) detected from image `{Path.GetFileName(url)}`"); return(detectedFaces.ToList()); }
/// <summary> /// 感情分析処理 /// </summary> /// <param name="client">Faseサービスインスタンス</param> /// <param name="url">画像のURL</param> /// <param name="recognitionModel">検出モデル</param> /// <returns></returns> private static async Task <IList <DetectedFace> > DetectFaceExtract(IFaceClient client, string url, string recognitionModel) { IList <DetectedFace> detectedFaces = await client.Face.DetectWithUrlAsync($"{url}", returnFaceAttributes : new List <FaceAttributeType> { FaceAttributeType.Emotion }, recognitionModel : recognitionModel); return(detectedFaces); }
public AzurePersonGroupRepository(ILogger <AzurePersonGroupRepository> logger) { _logger = logger; SUBSCRIPTION_KEY = Environment.GetEnvironmentVariable("AZURE_FACE_SUBSCRIPTION_KEY"); ENDPOINT = Environment.GetEnvironmentVariable("AZURE_FACE_ENDPOINT"); RECOGNITION_MODEL1 = RecognitionModel.Recognition01; _personGroupId = "myroomates"; _client = Authenticate(ENDPOINT, SUBSCRIPTION_KEY); _confidenceCoefficient = 0.5; }
public FaceRecognitionService(IConfiguration config) { this.IMAGE_BASE_URL = config.GetValue <string>("BlobStorage:StorageUrl"); this.SUBSCRIPTION_KEY = config.GetValue <string>("FaceRecognition:Key"); this.ENDPOINT = config.GetValue <string>("FaceRecognition:Endpoint");; this.client = new FaceClient(new ApiKeyServiceClientCredentials(SUBSCRIPTION_KEY)) { Endpoint = ENDPOINT }; }
private static async Task <List <DetectedFace> > DetectFaceRecognize(IFaceClient faceClient, Stream file, string recognitionModel) { var detectedFaces = await faceClient.Face.DetectWithStreamAsync( file, recognitionModel : recognitionModel, detectionModel : DetectionModel.Detection02); return(detectedFaces.ToList()); }
public virtual IEnumerable trainFaceRecongnition(PXAdapter adapter) { Save.Press(); PXLongOperation.StartOperation(this, delegate() { IFaceClient client = Trainer.Authenticate(MasterView.Current.FaceApiEndpoint, MasterView.Current.FaceApiSubscriptionKey); var trainer = new Trainer(client, MasterView.Current.FaceApiGroupID); bool uploaded = false; foreach (EPEmployee emp in PXSelect <EPEmployee> .Select(this)) { bool deleted = false; Person person = null; Guid[] files = PXNoteAttribute.GetFileNotes(this.Caches[typeof(EPEmployee)], emp); foreach (Guid fileID in files) { var fm = new PX.SM.UploadFileMaintenance(); PX.SM.FileInfo fi = fm.GetFile(fileID); string ext = System.IO.Path.GetExtension(fi.Name).ToLower(); PXTrace.WriteWarning(emp.AcctCD.TrimEnd() + " " + ext); if (ext.IsIn(".png", ".jpg", ".bmp")) { if (!deleted) { var utilities = new Utilities(client, MasterView.Current.FaceApiGroupID); utilities.DeleteEmployee(emp.AcctCD.TrimEnd()); deleted = true; } if (person == null) { person = trainer.GetEmployee_CreateIfNonExistent(emp.AcctCD.TrimEnd()); } using (var stream = new System.IO.MemoryStream(fi.BinData)) { PXTrace.WriteWarning(emp.AcctCD.TrimEnd() + " " + fi.Name + " " + stream.Length); trainer.UploadTrainingImageStream(person, stream); Thread.Sleep(1000); uploaded = true; } } } } if (uploaded) { trainer.InvokeTraining(); } }); return(adapter.Get()); }
//Person group creation for one Client static async Task CreateAndTrainWorkersPersonGroup(IFaceClient faceClient, List <WorkersForProcessing> listOfWorkersForProcessing, string personGroupId) { // Create a person group. await CreatePersonGroup(faceClient, personGroupId); // The person group person creation. await CreatePersonsWithFacesInPersonGroup(listOfWorkersForProcessing, faceClient, personGroupId); // Train Person group await TrainPersonGroup(faceClient, personGroupId); }
/* * Delete person group * After this entire sample is executed, delete the person group in your Azure account, * otherwise you cannot recreate one with the same name (if running sample repeatedly). */ public static async Task DeletePersonGroup(IFaceClient client, String personGroupId) { // First, list the person groups in each region Console.WriteLine("Delete started... "); IList <PersonGroup> list = await client.PersonGroup.ListAsync(); await client.PersonGroup.DeleteAsync(personGroupId); Console.WriteLine($"Deleted the person group {personGroupId}."); Console.WriteLine(); }
// Определяет лица на фото private static async Task <List <DetectedFace> > DetectFaceRecognize(IFaceClient faceClient, string url, string recognition_model) { // Detect faces from image URL. Since only recognizing, use the recognition model 1. // We use detection model 3 because we are not retrieving attributes. FileStream stream = new FileStream(url, FileMode.Open); IList <DetectedFace> detectedFaces = await faceClient.Face.DetectWithStreamAsync(stream, recognitionModel : recognition_model, detectionModel : DetectionModel.Detection02); Console.WriteLine($"{detectedFaces.Count} face(s) detected from image `{url}`"); return(detectedFaces.ToList()); }
public Tracker() { //TODO: store these somewhere var key = ""; var endpoint = "https://southcentralus.api.cognitive.microsoft.com"; faceClient = new FaceClient( new ApiKeyServiceClientCredentials(key), new System.Net.Http.DelegatingHandler[] { }); faceClient.Endpoint = endpoint; }
public FaceComparisonService(IOptions <AzureCognitiveServicesConfig> config, ILogger <FormRecognizerService> logger) { if (config == null) { throw new ArgumentNullException(nameof(config)); } _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _client = Authenticate(config.Value.Endpoint, config.Value.SubscriptionKey); }
public PhotoController(IOptions <AppSettings> appSettings) { this._appSettings = appSettings; _faceClient = new FaceClient( new ApiKeyServiceClientCredentials(appSettings.Value.FaceKey), new System.Net.Http.DelegatingHandler[] { } ); _faceClient.Endpoint = appSettings.Value.FaceEndPoint; _customerGroupId = appSettings.Value.FaceGroupID; }
public static async Task CreateSampleProjectAsync(IFaceClient client, string url, string personGroupId) { Dictionary <string, string[]> personDictionary = new Dictionary <string, string[]> { { "Family1-Dad", new[] { "Family1-Dad1.jpg", "Family1-Dad2.jpg" } }, { "Family1-Mom", new[] { "Family1-Mom1.jpg", "Family1-Mom2.jpg" } }, { "Family1-Son", new[] { "Family1-Son1.jpg", "Family1-Son2.jpg" } }, { "Family1-Daughter", new[] { "Family1-Daughter1.jpg", "Family1-Daughter2.jpg" } }, { "Family2-Lady", new[] { "Family2-Lady1.jpg", "Family2-Lady2.jpg" } }, { "Family2-Man", new[] { "Family2-Man1.jpg", "Family2-Man2.jpg" } } }; // string personGroupId = Guid.NewGuid().ToString(); // sourcePersonGroup = personGroupId; // This is solely for the snapshot operations example Console.WriteLine($"Create a person group ({personGroupId})."); await client.PersonGroup.CreateAsync(personGroupId, personGroupId, recognitionModel : PersonGroupSample.RECOGNITION_MODEL1); // The similar faces will be grouped into a single person group person. foreach (var groupedFace in personDictionary.Keys) { // Limit TPS await Task.Delay(250); Person person = await client.PersonGroupPerson.CreateAsync(personGroupId : personGroupId, name : groupedFace); Console.WriteLine($"Create a person group person '{groupedFace}'."); // Add face to the person group person. foreach (var similarImage in personDictionary[groupedFace]) { Console.WriteLine($"Add face to the person group person({groupedFace}) from image `{similarImage}`"); PersistedFace face = await client.PersonGroupPerson.AddFaceFromUrlAsync(personGroupId, person.PersonId, $"{url}{similarImage}", similarImage); } } Console.WriteLine(); Console.WriteLine($"Train person group {personGroupId}."); await client.PersonGroup.TrainAsync(personGroupId); // Wait until the training is completed. while (true) { await Task.Delay(1000); var trainingStatus = await client.PersonGroup.GetTrainingStatusAsync(personGroupId); Console.WriteLine($"Training status: {trainingStatus.Status}."); if (trainingStatus.Status == TrainingStatusType.Succeeded) { break; } } }
public FaceCrop() { /*This class isn't terribly well organized, and probbly needs brokend down into * additional helper classes. I just needed something that would crop a few thousand * camper's faces really quick and organize them accordingly. * --Mark */ var settings = SettingsComponent.GetComponent <MicrosoftFaceSettings>(); faceClient = Authenticate(settings.GetAttributeValue("Endpoint"), settings.GetAttributeValue("SubscriptionKey")); }
/// <summary> /// Initializes a new instance of the <see cref="CognitiveService"/> class. /// </summary> /// <param name="faceClient">The faceClient<see cref="IFaceClient"/>.</param> /// <param name="azureBlobService">The azureBlobService<see cref="IAzureBlobService"/>.</param> /// <param name="tableStorage">The tableStorage<see cref="ITableStorage"/>.</param> /// <param name="studentService">The studentService<see cref="IStudentService"/>.</param> public CognitiveService(IFaceClient faceClient, IAzureBlobService azureBlobService, ITableStorage tableStorage, IStudentService studentService) { _faceClient = faceClient; _azureBlobService = azureBlobService; _tableStorage = tableStorage; _studentService = studentService; if (Uri.IsWellFormedUriString(SettingConfigurations.CognitiveServiceEndPoint, UriKind.Absolute)) { faceClient.Endpoint = SettingConfigurations.CognitiveServiceEndPoint; } }
public HodorTabViewModel() { var subscriptionKey = ConfigurationManager.GetAzureSubscriptionKey(); var apiUri = ConfigurationManager.GetAzureApiUri(); _faceClient = new FaceClient(new ApiKeyServiceClientCredentials(subscriptionKey), new System.Net.Http.DelegatingHandler[] { }); _faceClient.Endpoint = apiUri; _personGroupViewModel = new PersonGroupViewModel(_faceClient, () => { return(ImagePath); }); Messenger.Default?.Register <FaceDetectedMessage>(this, FaceDetectedMessageHandler); Messenger.Default?.Register <CapturingStartedMessage>(this, CapturingStartedMessageHandler); }
public Form1() { InitializeComponent(); btnAnalysis.Enabled = false; _driver = new Driver(Constants.subscriptionKey, Constants.uriBase); _face = new Face(_driver); faceClient = new FaceClient( new ApiKeyServiceClientCredentials(Constants.subscriptionKey), new System.Net.Http.DelegatingHandler[] { }); faceClient.BaseUri = new Uri(Constants.uriBaseFrom); }
/* * END - FIND SIMILAR */ /* * VERIFY * The Verify operation takes a face ID from DetectedFace or PersistedFace and either another face ID * or a Person object and determines whether they belong to the same person. If you pass in a Person object, * you can optionally pass in a PersonGroup to which that Person belongs to improve performance. */ public static async Task Verify(IFaceClient client, string url, string recognitionModel02) { Console.WriteLine("========VERIFY========"); Console.WriteLine(); List <string> targetImageFileNames = new List <string> { "Family1-Dad1.jpg", "Family1-Dad2.jpg" }; string sourceImageFileName1 = "Family1-Dad3.jpg"; string sourceImageFileName2 = "Family1-Son1.jpg"; List <Guid> targetFaceIds = new List <Guid>(); foreach (var imageFileName in targetImageFileNames) { // Detect faces from target image url. List <DetectedFace> detectedFaces = await DetectFaceRecognize(client, $"{url}{imageFileName} ", recognitionModel02); targetFaceIds.Add(detectedFaces[0].FaceId.Value); Console.WriteLine($"{detectedFaces.Count} faces detected from image `{imageFileName}`."); } // Detect faces from source image file 1. List <DetectedFace> detectedFaces1 = await DetectFaceRecognize(client, $"{url}{sourceImageFileName1} ", recognitionModel02); Console.WriteLine($"{detectedFaces1.Count} faces detected from image `{sourceImageFileName1}`."); Guid sourceFaceId1 = detectedFaces1[0].FaceId.Value; // Detect faces from source image file 2. List <DetectedFace> detectedFaces2 = await DetectFaceRecognize(client, $"{url}{sourceImageFileName2} ", recognitionModel02); Console.WriteLine($"{detectedFaces2.Count} faces detected from image `{sourceImageFileName2}`."); Guid sourceFaceId2 = detectedFaces2[0].FaceId.Value; // Verification example for faces of the same person. VerifyResult verifyResult1 = await client.Face.VerifyFaceToFaceAsync(sourceFaceId1, targetFaceIds[0]); Console.WriteLine( verifyResult1.IsIdentical ? $"Faces from {sourceImageFileName1} & {targetImageFileNames[0]} are of the same (Positive) person, similarity confidence: {verifyResult1.Confidence}." : $"Faces from {sourceImageFileName1} & {targetImageFileNames[0]} are of different (Negative) persons, similarity confidence: {verifyResult1.Confidence}."); // Verification example for faces of different persons. VerifyResult verifyResult2 = await client.Face.VerifyFaceToFaceAsync(sourceFaceId2, targetFaceIds[0]); Console.WriteLine( verifyResult2.IsIdentical ? $"Faces from {sourceImageFileName2} & {targetImageFileNames[0]} are of the same (Negative) person, similarity confidence: {verifyResult2.Confidence}." : $"Faces from {sourceImageFileName2} & {targetImageFileNames[0]} are of different (Positive) persons, similarity confidence: {verifyResult2.Confidence}."); Console.WriteLine(); }
public CandidatesController(ApplicationDbContext context, IConfiguration configuration) { string key = configuration["Face:SubscriptionKey"]; string endpoint = configuration["Face:Endpoint"]; _context = context; _faceClient = new FaceClient( new ApiKeyServiceClientCredentials(key), new System.Net.Http.DelegatingHandler[] { } ); _faceClient.Endpoint = endpoint; }
public void FaceSnapshotTestFaceList() { using (MockContext context = MockContext.Start(this.GetType())) { HttpMockServer.Initialize(this.GetType(), "FaceSnapshotTestFaceList"); var sourceFaceListId = "source-face-list-id"; var name = $"name{sourceFaceListId}"; var userdata = $"userdata{sourceFaceListId}"; IFaceClient client = GetFaceClient(HttpMockServer.CreateInstance()); client.FaceList.CreateAsync(sourceFaceListId, name, userdata, recognitionModel: recognitionModel).Wait(); using (FileStream stream = new FileStream(Path.Combine("TestImages", "Satya4.jpg"), FileMode.Open)) { var persistedFace = client.FaceList.AddFaceFromStreamAsync(sourceFaceListId, stream, detectionModel: detectionModel).Result; Assert.NotNull(persistedFace); } var objectType = SnapshotObjectType.FaceList; var objectId = sourceFaceListId; var snapshotUserData = "User provided data for the snapshot."; var takeSnapshotResult = client.Snapshot.TakeAsync(objectType, objectId, ApplyScope, snapshotUserData).Result; Assert.NotNull(takeSnapshotResult.OperationLocation); var operationStatus = GetOperationResult(client, takeSnapshotResult.OperationLocation); Assert.NotNull(operationStatus); Assert.Equal(OperationStatusType.Succeeded, operationStatus.Status); var resourceId = Guid.Parse(operationStatus.ResourceLocation.Split('/').Last()); var targetFacelistId = "target-face-list-id"; var applyMode = SnapshotApplyMode.CreateNew; var applySnapshotResult = client.Snapshot.ApplyAsync(resourceId, targetFacelistId, applyMode).Result; Assert.NotNull(applySnapshotResult.OperationLocation); operationStatus = GetOperationResult(client, applySnapshotResult.OperationLocation); Assert.NotNull(operationStatus); Assert.Equal(operationStatus.Status.ToString(), OperationStatusType.Succeeded.ToString()); var targetObjectId = operationStatus.ResourceLocation.Split('/').Last(); Assert.Equal(targetFacelistId, targetObjectId); var targetFacelist = client.FaceList.GetAsync(targetFacelistId).Result; Assert.NotNull(targetFacelist); Assert.True(targetFacelist.PersistedFaces.Count == 1); client.FaceList.DeleteAsync(sourceFaceListId).Wait(); client.FaceList.DeleteAsync(targetFacelistId).Wait(); client.Snapshot.DeleteAsync(resourceId).Wait(); } }
public MyFace() { using (StreamReader r = new StreamReader(configPath)) { string jsonString = r.ReadToEnd(); Config config = JsonConvert.DeserializeObject <Config>(jsonString); faceClient = new FaceClient( new ApiKeyServiceClientCredentials(config.SubscriptionKey), new System.Net.Http.DelegatingHandler[] { }); faceClient.Endpoint = config.FaceEndpoint; } }
/// <summary> /// Identification against the person group. /// </summary> private static async Task IdentifyInPersonGroup(IFaceClient client, string personGroupId) { using (var fileStream = new FileStream("data\\PersonGroup\\Daughter\\Daughter1.jpg", FileMode.Open, FileAccess.Read)) { var detectedFaces = await client.Face.DetectWithStreamAsync(fileStream, recognitionModel : recognitionModel); var result = await client.Face.IdentifyAsync(detectedFaces.Select(face => face.FaceId).Where(faceId => faceId != null).Select(faceId => faceId.Value).ToList(), personGroupId); Console.WriteLine("Test identify against PersonGroup"); Console.WriteLine(JsonConvert.SerializeObject(result)); Console.WriteLine(); } }
private static async Task <List <DetectedFace> > DetectFaceRecognize(IFaceClient faceClient, Stream img, string RECOGNITION_MODEL1) { try { IList <DetectedFace> detectedFaces = await faceClient.Face.DetectWithStreamAsync(img, recognitionModel : RECOGNITION_MODEL1); return(detectedFaces.ToList()); } catch (Exception) { return(null); } }
public async Task <int> DetectFaceExtract(IFaceClient client, string url, string recognitionModel) { IList <DetectedFace> detectedFaces; detectedFaces = await client.Face.DetectWithUrlAsync($"{url}{string.Format("{0}.{1}", imageName.ImageName, imageName.ImageExtension)}", returnFaceAttributes : new List <FaceAttributeType> { FaceAttributeType.Accessories, FaceAttributeType.Age }, recognitionModel : recognitionModel); Console.WriteLine($"{detectedFaces.Count} face(s) detected from image `{imageName}`."); return((int)detectedFaces[0].FaceAttributes.Age); }
public async Task <IActionResult> GetFaceDetails([FromForm] IFormFile file) { if (file == null) { return(BadRequest()); } string SUBSCRIPTION_KEY = _config.GetValue <string>("Keys:SUBSCRIPTION_KEY"); string ENDPOINT = _config.GetValue <string>("Keys:ENDPOINT"); IFaceClient client = Authenticate(ENDPOINT, SUBSCRIPTION_KEY); FaceImage dataToReturn = await DetectFaceExtract(client, file, RECOGNITION_MODEL); return(Ok(dataToReturn)); }
static async Task Main(string[] args) { Console.WriteLine("Running"); var configCognitiveSubscriptionKey = Environment.GetEnvironmentVariable("AZURE_COGNITIVE_SUBSCRIPTION_KEY"); var configCognitiveEndpoint = Environment.GetEnvironmentVariable("AZURE_COGNITIVE_ENDPOINT"); var faceBaseImageUrl = Environment.GetEnvironmentVariable("AZURE_COGNITIVE_IMAGE_BASE_URL"); IFaceClient client = Authenticate(configCognitiveEndpoint, configCognitiveSubscriptionKey); //await DetectFaceExtract(client, faceBaseImageUrl, RECOGNITION_MODEL); await FindSimilar(client, faceBaseImageUrl, RECOGNITION_MODEL); }
public FaceService(IMapper mapper, IImagesRepository tRepository, IConfiguration configuration, IHttpContextAccessor contextAccessor) : base(mapper, tRepository, contextAccessor) { var faceApiConfig = configuration.GetSection("FaceApi"); FaceClient = new FaceClient( new ApiKeyServiceClientCredentials(faceApiConfig["faceKey"]), new DelegatingHandler[] { }) { Endpoint = faceApiConfig["faceEndpoint"] }; }
private async Task <DetectedFace> DetectFaceExtract(IFaceClient client, string url, string recognitionModel) { var face = await client.Face.DetectWithUrlAsync(url, returnFaceAttributes : new List <FaceAttributeType> { FaceAttributeType.Accessories, FaceAttributeType.Age, FaceAttributeType.Blur, FaceAttributeType.Emotion, FaceAttributeType.Exposure, FaceAttributeType.FacialHair, FaceAttributeType.Gender, FaceAttributeType.Glasses, FaceAttributeType.Hair, FaceAttributeType.HeadPose, FaceAttributeType.Makeup, FaceAttributeType.Noise, FaceAttributeType.Occlusion, FaceAttributeType.Smile }, recognitionModel : recognitionModel); return(face.FirstOrDefault()); }
/* * Take a snapshot of a person group * This sample uses a pre-existing person group and copies it from one Azure region to another. For example: from the EastUS region to the WestUS region * The same process can be used for face lists. * NOTE: a copy of the person group in the target region has a new person group ID, so it no longer associates with the source person group. */ public static async Task Snapshot(IFaceClient clientSource, IFaceClient clientTarget, string personGroupId, Guid azureSubscriptionId) { Console.WriteLine("========Sample of creating a snapshot========"); // Take a snapshot for the person group that was previously created in your source region. var takeSnapshotResult = await clientSource.Snapshot.TakeAsync(SnapshotObjectType.PersonGroup, personGroupId, new[] { azureSubscriptionId }); // Get operation id from response for tracking the progress of snapshot taking. var operationId = Guid.Parse(takeSnapshotResult.OperationLocation.Split('/')[2]); Console.WriteLine($"Taking snapshot(operation ID: {operationId})... Started"); // Wait for taking the snapshot to complete. OperationStatus operationStatus = null; do { Thread.Sleep(TimeSpan.FromMilliseconds(1000)); // Get the status of the operation. operationStatus = await clientSource.Snapshot.GetOperationStatusAsync(operationId); Console.WriteLine($"Operation Status: {operationStatus.Status}"); }while (operationStatus.Status != OperationStatusType.Succeeded && operationStatus.Status != OperationStatusType.Failed); // Confirm the location of the resource where the snapshot is taken and its snapshot ID var snapshotId = Guid.Parse(operationStatus.ResourceLocation.Split('/')[2]); Console.WriteLine($"Source region snapshot ID: {snapshotId}"); Console.WriteLine($"Taking snapshot of person group: {personGroupId}... Done\n"); // Apply the snapshot in target region, with a new ID. var newPersonGroupId = Guid.NewGuid().ToString(); targetPersonGroup = newPersonGroupId; var applySnapshotResult = await clientTarget.Snapshot.ApplyAsync(snapshotId, newPersonGroupId); // Get operation id from response for tracking the progress of snapshot applying. var applyOperationId = Guid.Parse(applySnapshotResult.OperationLocation.Split('/')[2]); Console.WriteLine($"Applying snapshot(operation ID: {applyOperationId})... Started"); // Wait for applying operation to complete do { Thread.Sleep(TimeSpan.FromMilliseconds(1000)); // Get the status of the operation. operationStatus = await clientSource.Snapshot.GetOperationStatusAsync(applyOperationId); Console.WriteLine($"Operation Status: {operationStatus.Status}"); }while (operationStatus.Status != OperationStatusType.Succeeded && operationStatus.Status != OperationStatusType.Failed); // Confirm location of the target resource location, with its ID. Console.WriteLine($"Person group in new region: {newPersonGroupId}"); Console.WriteLine("Applying snapshot... Done\n"); }