private static void MapTagsAndObject(ImageAIDetectionResult imageAIResult, MediaAI mediaAi)
{
var tags = new List <MediaAITag>();
var objects = new List <MediaAIObject>();
foreach (ImageAIDetectionItem?item in imageAIResult.Items)
{
switch (item.Type)
{
case "tag":
tags.Add(new MediaAITag
{
Name = item.Name,
Confidence = item.Probability,
Source = AISource.ImageAI
});
break;
case "object":
objects.Add(new MediaAIObject
{
Name = item.Name,
Confidence = item.Probability,
Source = AISource.ImageAI,
Box = item.Box
});
break;
}
}
mediaAi.Tags = tags;
mediaAi.Objects = objects;
}
private async Task <MediaAI> SaveMediaAIDatas(IEnumerable <MediaAI> aiDatas, CancellationToken cancellationToken)
{
MediaAI?existing = await _mediaStore.MediaAI.GetByMediaIdAsync(
aiDatas.First().MediaId,
cancellationToken);
if (existing == null)
{
if (aiDatas.Count() == 1)
{
return(await SaveMediaAI(aiDatas.Single(), cancellationToken));
}
else
{
existing = new MediaAI
{
Id = Guid.NewGuid(),
MediaId = aiDatas.First().MediaId,
};
}
}
MediaAI merged = MergeAIData(existing, aiDatas);
await SaveMediaAI(merged, cancellationToken);
return(merged);
}
public async Task SaveImageAIDetectionAsync(
ImageAIDetectionResult imageAIResult,
CancellationToken cancellationToken)
{
var mediaAi = new MediaAI
{
Id = Guid.NewGuid(),
MediaId = imageAIResult.MediaId
};
MediaAISourceInfo sourceInfo = new()
{
AnalysisDate = DateTime.UtcNow,
Source = AISource.ImageAI,
Success = imageAIResult.Success
};
if (imageAIResult.Success)
{
MapTagsAndObject(imageAIResult, mediaAi);
}
else
{
sourceInfo.Data.Add("Error", imageAIResult.Error);
}
mediaAi.SourceInfo = new List <MediaAISourceInfo> {
sourceInfo
};
await SaveMediaAI(mediaAi, cancellationToken);
}
private MediaAI ToMediaAI(ImageAnalysis analysis)
{
var mediaAI = new MediaAI();
mediaAI.Tags = analysis.Tags.Select(x => new MediaAITag
{
Name = x.Name,
Confidence = x.Confidence * 100,
Source = Source
});
mediaAI.Objects = analysis.Objects.Select(x => new MediaAIObject
{
Name = x.ObjectProperty,
Confidence = x.Confidence * 100,
Source = Source,
Box = MapImageBox(x.Rectangle, analysis.Metadata)
});
mediaAI.Colors = MapColors(analysis.Color);
mediaAI.Caption = MapCaption(analysis.Description);
mediaAI.SourceInfo = GetSourceInfo(analysis);
return(mediaAI);
}
private MediaAISummary BuildSummary(MediaAI mediaAI)
{
return(new MediaAISummary
{
Sources = mediaAI.SourceInfo.Select(x => x.Source),
ObjectCount = mediaAI.Objects.Count(x => !x.Name.Equals("person", StringComparison.InvariantCultureIgnoreCase)),
PersonCount = mediaAI.Objects.Count(x => x.Name.Equals("person", StringComparison.InvariantCultureIgnoreCase)),
TagCount = mediaAI.Tags.Count()
});
}
public async Task <MediaAI> SaveAsync(
MediaAI mediaAI,
CancellationToken cancellationToken)
{
await _mediaStoreContext.MediaAI.ReplaceOneAsync(
x => x.MediaId == mediaAI.MediaId,
mediaAI,
new ReplaceOptions { IsUpsert = true },
cancellationToken);
return(mediaAI);
}
public async Task <MediaAI?> AnalyseMediaAsync(Media media, CancellationToken cancellationToken)
{
List <MediaAI> results = new List <MediaAI>();
foreach (ICloudAIMediaAnalyser imageAnalyzer in _analysers)
{
MediaAI aiData = await AnalyseMediaAsync(media, imageAnalyzer, cancellationToken);
results.Add(aiData);
}
MediaAI merged = await SaveMediaAIDatas(results, cancellationToken);
return(merged);
}
public async Task ProcessNewBySourceAsync(
AISource source,
CancellationToken cancellationToken)
{
IEnumerable <MediaAI> result = await _mediaStore.MediaAI.GetWithoutSourceInfoAsync(
source,
limit : 1,
excludePersons : true,
cancellationToken);
foreach (MediaAI mediaAI in result)
{
Media media = await _mediaService.GetByIdAsync(mediaAI.MediaId, cancellationToken);
ICloudAIMediaAnalyser analyser = _analysers.Single(x => x.Source == source);
MediaAI aiData = await AnalyseMediaAsync(media, analyser, cancellationToken);
await SaveMediaAIDatas(new[] { aiData }, cancellationToken);
}
}
private MediaAI MergeAIData(MediaAI existing, IEnumerable <MediaAI> aiDatas)
{
List <MediaAITag> tags = new();
tags.AddRangeIfNotNull(existing.Tags);
List <MediaAIObject> objects = new();
objects.AddRangeIfNotNull(existing.Objects);
List <MediaAISourceInfo> sources = new();
sources.AddRangeIfNotNull(existing.SourceInfo);
foreach (MediaAI?aiData in aiDatas)
{
tags.AddRangeIfNotNull(aiData.Tags);
objects.AddRangeIfNotNull(aiData.Objects);
sources.AddRangeIfNotNull(aiData.SourceInfo);
if (aiData.Colors != null)
{
existing.Colors = aiData.Colors;
}
if (aiData.Caption != null)
{
existing.Caption = aiData.Caption;
}
}
existing.Tags = tags;
existing.Objects = objects;
existing.SourceInfo = sources;
return(existing);
}
public async Task <MediaAI> GetAIDataAsync(
Media media,
double?minConfidence = null,
//AISource? source=null,
CancellationToken cancellationToken = default)
{
MediaAI ai = await _mediaService.GetAIDataAsync(media.Id, cancellationToken);
if (ai == null)
{
return(new MediaAI
{
Id = Guid.Empty,
MediaId = media.Id,
Objects = new List <MediaAIObject>(),
Tags = new List <MediaAITag>()
});
}
if (minConfidence.HasValue)
{
ai.Objects = ai.Objects.Where(x => x.Confidence >= minConfidence);
ai.Tags = ai.Tags.Where(x => x.Confidence >= minConfidence);
}
//if (source.HasValue)
//{
// ai.Objects = ai.Objects.Where(x => x.Source == source);
// ai.Tags = ai.Tags.Where(x => x.Source == source);
//}
ai.Objects = ai.Objects.OrderByDescending(x => x.Confidence);
ai.Tags = ai.Tags.OrderByDescending(x => x.Confidence);
return(ai);
}
private async Task <MediaAI> SaveMediaAI(MediaAI aiData, CancellationToken cancellationToken)
{
await _mediaStore.UpdateAISummaryAsync(aiData.MediaId, BuildSummary(aiData), cancellationToken);
return(await _mediaStore.MediaAI.SaveAsync(aiData, cancellationToken));
}
