public void SetDimensions(UniImage lastImage)
{
using (var bitmap = lastImage.AsBitmap())
{
lastImage.Width = bitmap.Width;
lastImage.Height = bitmap.Height;
}
}
private async Task RerenderAsync()
{
StatusProp.Value = "Rendering heatmap...";
_lastImage = await GetImageAsync(_lastHyperId);
var skImage = RenderMask(_lastImage);
var image = SKImageIntoUniImage(skImage);
//SkImageProp.Value = result;
ImageProp.Value = image.Data;
StatusProp.Value = "Finished updating heatmap.";
}
private SKImage RenderMask(UniImage sourceImage)
{
using (var skBitmap = SKBitmap.Decode(sourceImage.Data))
{
SKImage result;
SKImage heatmap = null;
if (_settings.RenderingMode == RenderingMode.Masks)
{
heatmap = GenerateMaskFromValuesMatrix(_globalMatrix, _width, _height,
_settings.UseCustomNormalizationSettings ? _settings.MinimumNumberOfOverlaps : (uint?)null,
_settings.UseCustomNormalizationSettings ? _settings.MaximumNumberOfOverlaps : (uint?)null);
}
else if (_settings.RenderingMode == RenderingMode.LowerPointOfGeometry)
{
var points = _frames.SelectMany(it => it).ToArray();
heatmap = Render(points, _width, _height).ToSKImage();
}
if (heatmap == null)
{
return(SKImage.FromBitmap(skBitmap));
}
using (var tempSurface = SKSurface.Create(new SKImageInfo(heatmap.Width, heatmap.Height)))
using (heatmap)
{
//get the drawing canvas of the surface
var canvas = tempSurface.Canvas;
var skPaint = new SKPaint
{
BlendMode = SKBlendMode.Plus
};
//set background color
canvas.Clear(SKColors.Transparent);
canvas.DrawBitmap(skBitmap, 0, 0, skPaint);
canvas.DrawImage(heatmap, 0, 0, skPaint);
// return the surface as a manageable image
result = tempSurface.Snapshot();
}
return(result);
}
}
private UniImage SKImageIntoUniImage(SKImage skImage)
{
UniImage image;
using (skImage)
{
using (var skData = skImage.Encode(SKEncodedImageFormat.Jpeg, 70))
{
var bytes = skData.ToArray();
image = new UniImage(ImageFormats.Jpeg, bytes, skImage.Width, skImage.Height);
}
}
return(image);
}
public Graphics FromImage(UniImage image, out int?width, out int?height)
{
width = null;
height = null;
using (var defaultBitmap = image?.AsBitmap())
{
if (defaultBitmap == null)
{
return(null);
}
width = defaultBitmap.Width;
height = defaultBitmap.Height;
return(Graphics.FromImage(defaultBitmap));
}
}
private async Task UpdateImageDataAsync(HyperId hyperId)
{
_lastImage = await GetImageAsync(hyperId);
if (_lastImage.Width > 0 && _lastImage.Height > 0)
{
_width = _lastImage.Width.Value;
_height = _lastImage.Height.Value;
}
else
{
using (var bitmap = SKBitmap.Decode(_lastImage.Data))
{
_width = bitmap.Width;
_height = bitmap.Height;
}
}
}
public UniImage GetMask(UniImage image, HyperTagGeometry geometry, HyperTagGeometryMask geometryMask, bool IsExtractMode)
{
using (var defaultBitmap = image?.AsBitmap())
{
if (defaultBitmap == null)
{
return(null);
}
using (var maskedBitmap = RasterHelper.Instance.RenderTagMask(defaultBitmap, geometry, geometryMask, IsExtractMode))
{
if (maskedBitmap == null)
{
return(null);
}
var maskedImage = new UniImage();
maskedImage.FromBitmap(maskedBitmap);
return(maskedImage);
}
}
}
public async Task RunGenerationAsync(DateTime?from, DateTime?to)
{
_keepWorking = true;
_ctSource = new CancellationTokenSource();
var source = new TaskCompletionSource <bool>();
_completionTask = source.Task;
try
{
_frames = new ConcurrentFixedSizeQueue <List <HeatPoint> >(int.MaxValue);
ProtectOriginalMetadataSet();
if (from.HasValue)
{
_metadataSet.FromDate = from;
}
if (to.HasValue)
{
_metadataSet.ToDate = to;
}
await CountTagsTotalAsync();
if (this.TotalCountProp.Value == 0)
{
_lastImage = await GetFirstImageForMetadatasetAssetAsync(from);
ImageProp.Value = _lastImage.Data;
PertcantageProcessedUpdated?.Invoke(100);
}
var batchSize = 100;
var batchesNum = Math.Ceiling((double)TotalCountProp.Value / batchSize);
batchesNum = Math.Min(batchesNum, _settings.NumberOfBatchesToProcess);
var hyperIds = new List <HyperId>();
for (int i = 0; i < batchesNum; i++)
{
StatusProp.Value = $"Processing batch {(i + 1)} out of {batchesNum}...";
if (!_keepWorking || _ct.IsCancellationRequested)
{
return;
}
var skip = batchSize * i;
var findArgs = new FindHyperDocumentsArgs(typeof(HyperTag))
{
Skip = skip,
Limit = batchSize
};
var conditions = await MetaDataSetHelper.GenerateFilterFromMetaDataSetAsync(_hyperStore, _metadataSet);
findArgs.DescriptorConditions.AddCondition(conditions.Result);
//hyper tag ids condition
var hyperTagIdscondition = new MultiScopeCondition(AndOr.Or);
foreach (var id in _metadataSet.HyperTagIds ?? new HyperDocumentId[] { })
{
hyperTagIdscondition.AddCondition("_id", id.Id);
}
if (hyperTagIdscondition.ConditionsCount > 0)
{
findArgs.DocumentConditions.AddCondition(hyperTagIdscondition);
}
var tagDocs = await _hyperStore.ExecuteAsync(findArgs) ?? new HyperDocument[0];
if (!_keepWorking || _ct.IsCancellationRequested)
{
return;
}
var tags = tagDocs.Select(it => it.GetPayload <HyperTag>()).ToArray();
var grouppedBySlice = tags.GroupBy(it =>
{
var item = it.GetElement <IHyperTagHyperIds>();
return(item.HyperId);
}).ToArray();
if (!_keepWorking || _ct.IsCancellationRequested)
{
return;
}
if (_width == 0 || _height == 0)
{
var hyperId = grouppedBySlice.First().Key;
await UpdateImageDataAsync(hyperId);
_globalMatrix = new uint[_height, _width];
ImageProp.Value = _lastImage.Data;
if (!_keepWorking || _ct.IsCancellationRequested)
{
return;
}
}
grouppedBySlice = grouppedBySlice.OrderBy(x => x.Key).ToArray();
// Group by asset first?
var groupedByFragment = grouppedBySlice.GroupBy(x => x.Key.FragmentId.Value).ToArray();
foreach (var group in groupedByFragment)
{
var sliceGroupsOfFragment = group.ToArray();
foreach (var sliceTags in sliceGroupsOfFragment)
{
await _pauseResetEvent.WaitAsync();
var framePoints = new List <HeatPoint>();
foreach (var tag in sliceTags)
{
// TODO: Reintegrate RealImage processing logic
if (_settings.RenderingMode == RenderingMode.Masks || _settings.RenderingMode == RenderingMode.RealImage)
{
var tagExtraction = ProcessMaskedTag(tag);
if (tagExtraction != null)
{
ProcessMaskOverlapsIntoMatrix(tagExtraction.Image, tagExtraction.Rect);
}
}
else if (_settings.RenderingMode == RenderingMode.LowerPointOfGeometry)
{
ProcessGeometryTag(tag, framePoints);
}
}
_frames.Enqueue(framePoints);
}
if (!_keepWorking || _ct.IsCancellationRequested)
{
return;
}
}
_lastHyperId = grouppedBySlice.Last().Key;
await RerenderAsync();
var tagDocsCount = tagDocs.Count();
ItemsProcessed.Value += tagDocsCount;
PertcantageLabel.Value = ((double)100 * ItemsProcessed.Value / TotalCountProp.Value).ToString("0.00", System.Globalization.CultureInfo.InvariantCulture) + "%";
PertcantageProcessedUpdated?.Invoke(100 * tagDocsCount / (double)TotalCountProp.Value);
}
}
catch (Exception ex)
{
Logger.Instance.Error(this.GetType(), nameof(RunGenerationAsync), ex.Message);
}
finally
{
source.SetResult(true);
}
}
