public async Task Initialize(IHyperArgsSink store, string metadataSetId, int smallestPageSize)
{
this.HyperStore = store;
if (metadataSetId == null)
{
MetadataSetLoadFailed.Value = true;
return;
}
MetadataSetId = new HyperDocumentId(metadataSetId, typeof(HyperMetadataSet));
var metadataSetFilter = await store.ExecuteAsync(new RetrieveHyperDocumentArgs(MetadataSetId));
if (metadataSetFilter != null)
{
this._smallestPageSize = smallestPageSize;
PageSize = smallestPageSize;
this._metadataSet = metadataSetFilter.GetPayload <HyperMetadataSet>();
this.DashApiPort = await GetDashApiPort();
await LoadTotalPages();
await LoadHyperTags();
await InitializeMetadatasetEdgeDates();
}
else
{
MetadataSetLoadFailed.Value = true;
}
}
public async Task <HyperMission> GetMissionAsync(
string missionId,
CancellationToken cancellationToken = default(CancellationToken))
{
if (_netStore == null)
{
throw new ApplicationException("Node does not exist.");
}
if (string.IsNullOrWhiteSpace(missionId))
{
throw new ArgumentException(nameof(missionId));
}
var retrieveHyperDocumentArgs = new RetrieveHyperDocumentArgs()
{
DocumentId = HyperDocumentId.Create <HyperMission>(missionId)
};
var hyperDocument = await _netStore.ExecuteAsync(retrieveHyperDocumentArgs);
var mission = hyperDocument.GetPayload <HyperMission>();
if (mission.Id == missionId)
{
return(mission);
}
throw new ApplicationException("Missing mission");
}
private async Task Populate()
{
IsLoadedData = false;
if (HyperStore == null || string.IsNullOrWhiteSpace(MissionId))
{
return;
}
var documentId = HyperDocumentId.Create <HyperMission>(MissionId);
var argTagonomy = new RetrieveHyperDocumentArgs(documentId);
var doc = await HyperStore.ExecuteAsync(argTagonomy);
if (argTagonomy.ExecutionResult.IsNotSuccess)
{
return;
}
var data = doc?.GetPayload <HyperMission>();
Source = new MissionItemVm(data, HyperStore);
await Source.UpdateStatus();
Source.OnToastMessage = OnToastMessage;
SelectedPhase = Source.Mission?.Phases.FirstOrDefault();
IsLoadedData = true;
}
public async Task DeleteTheme(StyleTheme data)
{
var args = new DeleteHyperDocumentArgs(HyperDocumentId.Create <StyleTheme>(data.Id));
var isDeleteSuccessful = await HyperStore.ExecuteAsync(args);
if (isDeleteSuccessful)
{
DataList.RemoveAll(it => it.Id == data.Id);
}
}
public async Task <DashboardData> GetDashboard(string dashboardId)
{
var documentId = HyperDocumentId.Create <DashboardData>(dashboardId);
var args = new RetrieveHyperDocumentArgs(documentId);
var doc = await HyperStore.ExecuteAsync(args);
if (args.ExecutionResult.IsNotSuccess)
{
return(null);
}
var dashboard = doc?.GetPayload <DashboardData>();
return(dashboard);
}
public ZoneOverlayEntry ToDomainModel()
{
var domain = new ZoneOverlayEntry();
BaseOverlayEntryJsModel.MapBasePropertiesToDomainModel(domain, this);
domain.Points = this.Points;
domain.Alias = this.Alias;
domain.MetadataSetId = this.MetadataSetId != null?HyperDocumentId.Create <HyperMetadataSet>(this.MetadataSetId) : (HyperDocumentId?)null;
domain.FixedCameraEnhancementId = this.FixedCameraEnhancementId != null?HyperDocumentId.Create <FixedCameraEnhancedData>(this.FixedCameraEnhancementId) : (HyperDocumentId?)null;
domain.View = this.View;
return(domain);
}
public async Task <HyperMission> GetHyperMissionAsync()
{
if (string.IsNullOrEmpty(Request.MissionId))
{
throw new ArgumentException(nameof(Request.MissionId));
}
var retrieveHyperDocumentArgs = new RetrieveHyperDocumentArgs()
{
DocumentId = HyperDocumentId.Create <HyperMission>(Request.MissionId)
};
var hyperDocument = await _netStore.ExecuteAsync(retrieveHyperDocumentArgs);
var mission = hyperDocument.GetPayload <HyperMission>();
return(mission);
}
private async Task PopulateData()
{
if (HyperStore == null || string.IsNullOrWhiteSpace(WorkflowId))
{
return;
}
var documentId = HyperDocumentId.Create <HyperWorkflow>(WorkflowId);
var args = new RetrieveHyperDocumentArgs(documentId);
var doc = await HyperStore.ExecuteAsync(args);
if (args.ExecutionResult.IsNotSuccess)
{
return;
}
Source = doc?.GetPayload <HyperWorkflow>();
}
public async Task <StyleTheme> GetThemeAsync()
{
if (string.IsNullOrWhiteSpace(this.Source.Theme?.Id))
{
return(null);
}
var documentId = HyperDocumentId.Create <StyleTheme>(this.Source.Theme?.Id);
var args = new RetrieveHyperDocumentArgs(documentId);
var doc = await HyperStore.ExecuteAsync(args);
if (args.ExecutionResult.IsNotSuccess)
{
return(null);
}
var theme = doc?.GetPayload <StyleTheme>();
return(theme);
}
public async Task <DashboardData> GetDashboardAsync()
{
if (string.IsNullOrWhiteSpace(this.Widget.Dashboard?.Id))
{
return(null);
}
var documentId = HyperDocumentId.Create <DashboardData>(this.Widget.Dashboard?.Id);
var args = new RetrieveHyperDocumentArgs(documentId);
var doc = await HyperStore.ExecuteAsync(args);
if (args.ExecutionResult.IsNotSuccess)
{
return(null);
}
var dashboard = doc?.GetPayload <DashboardData>();
return(dashboard);
}
public async Task <HyperMission> LoadMission(HyperMetadataSet metadataset)
{
var missionId = metadataset?.MissionIds?.FirstOrDefault().Id;
if (string.IsNullOrWhiteSpace(missionId))
{
return(null);
}
var retrieveHyperDocumentArgs = new RetrieveHyperDocumentArgs()
{
DocumentId = HyperDocumentId.Create <HyperMission>(missionId)
};
var hyperDocument = await _netStore.ExecuteAsync(retrieveHyperDocumentArgs);
var mission = hyperDocument.GetPayload <HyperMission>();
return(mission);
}
private async Task PopulateData()
{
if (HyperStore == null || string.IsNullOrWhiteSpace(TagonomyId))
{
return;
}
var documentId = HyperDocumentId.Create <Tagonomy>(TagonomyId);
var argTagonomy = new RetrieveHyperDocumentArgs(documentId);
var doc = await HyperStore.ExecuteAsync(argTagonomy);
if (argTagonomy.ExecutionResult.IsNotSuccess)
{
return;
}
Source = doc?.GetPayload <Tagonomy>();
RefreshNavigation();
}
private async Task PopulateData()
{
if (HyperStore == null || string.IsNullOrWhiteSpace(TagonomyId))
{
return;
}
var documentId = HyperDocumentId.Create <Tagonomy>(TagonomyId);
var argTagonomy = new RetrieveHyperDocumentArgs(documentId);
var doc = await HyperStore.ExecuteAsync(argTagonomy);
if (argTagonomy.ExecutionResult.IsNotSuccess)
{
return;
}
_rootTagonomy = doc?.GetPayload <Tagonomy>();
_unprocessedSourceTagonomies.Clear();
_processedSourceTagonomies.Clear();
var args = new FindHyperDocumentsArgs(typeof(Tagonomy), true);
_allTagonomies = ((await this.HyperStore.ExecuteAsyncThrows(args)) ?? new Node.Common.HyperDocument[0])
.Select(x => x.GetPayload <Tagonomy>())
.ToArray();
_unprocessedSourceTagonomies.Add(_rootTagonomy.Id, _rootTagonomy);
while (_unprocessedSourceTagonomies.Any())
{
foreach (var unprocTagonomie in _unprocessedSourceTagonomies.Select(x => x.Value).ToArray())
{
var linkingNodesInner = GetLinkingNodes(unprocTagonomie);
ProcessLinkingNodes(linkingNodesInner, unprocTagonomie, true);
}
}
GoBackwards();
}
private async Task LoadHyperMissionAsync()
{
if (_request == null || string.IsNullOrEmpty(_request.MissionId))
{
return;
}
var retrieveHyperDocumentArgs = new RetrieveHyperDocumentArgs()
{
DocumentId = HyperDocumentId.Create <HyperMission>(_request.MissionId)
};
var hyperDocument = await _netStore.ExecuteAsync(retrieveHyperDocumentArgs);
var mission = hyperDocument.GetPayload <HyperMission>();
if (mission != null)
{
Mission = mission;
}
}
/// <summary>
/// Generates a heatmap based on subset of tags using Fixed Camera Preset with homography.
/// </summary>
/// <param name="tags">Subset of tags to use.</param>
/// <param name="fixedCameraPresetId">Id of Fixed Camera Preset to take homography configuration from.</param>
/// <param name="renderingMode">If enabled, heatmap masks will be rendered, otherwise real pixels from corresponding frames will be rendered in overlap.</param>
/// <param name="cutOff">If we should cutoff the image by homography or just render a polygon line over.</param>
public async Task <UniImage> GenerateFromTagsAsync(List <HyperTag> tags, HyperDocumentId fixedCameraPresetId, bool cutOff = false, int tagGroupsLimit = 30)
{
if (tags == null || tags.Count < 1)
{
return(null);
}
var configuration = await RetrieveHyperDocumentArgs.RetrieveAsyncThrows <FixedCameraEnhancedData>(_hyperStore, fixedCameraPresetId);
if (configuration == null)
{
return(null);
}
var tagsWithHyperId = tags.Select(x => new
{
Tag = x,
HyperId = x.GetElement <IHyperTagHyperIds>().HyperId
}).ToArray();
tagsWithHyperId = tagsWithHyperId.OrderBy(x => x.HyperId).ToArray();
var hyperId = tagsWithHyperId.First().HyperId;
if (!_keepWorking || _ct.IsCancellationRequested)
{
return(null);
}
await UpdateImageDataAsync(hyperId);
if (!_keepWorking || _ct.IsCancellationRequested)
{
return(null);
}
SKImage maskedImage = null;
if (_settings.RenderingMode == RenderingMode.Masks)
{
_globalMatrix = new uint[_height, _width];
foreach (var tag in tags)
{
var tagExtraction = ProcessMaskedTag(tag);
if (tagExtraction != null)
{
ProcessMaskOverlapsIntoMatrix(tagExtraction.Image, tagExtraction.Rect);
}
}
maskedImage = RenderMask(_lastImage);
}
else if (_settings.RenderingMode == RenderingMode.LowerPointOfGeometry)
{
var framePoints = new List <HeatmapRenderHelper.HeatPoint>();
foreach (var tag in tags)
{
ProcessGeometryTag(tag, framePoints);
}
var mask = HeatmapRenderHelper.RenderToSkImage(framePoints, _width, _height);
maskedImage = BlendTwoImages(SKBitmap.Decode(_lastImage.Data), mask, SKBlendMode.Plus);
}
else if (_settings.RenderingMode == RenderingMode.RealImage)
{
var tagsBySlice = tagsWithHyperId.GroupBy(x => x.HyperId).OrderBy(x => x.Key).ToArray();
var sourceBitmap = SKBitmap.Decode(_lastImage.Data);
foreach (var tagsForSlice in tagsBySlice.Take(tagGroupsLimit))
{
if (!_keepWorking || _ct.IsCancellationRequested)
{
return(null);
}
var args = new RetrieveFragmentFramesArgs
{
AssetId = tagsForSlice.Key.AssetId.Value,
TrackId = tagsForSlice.Key.TrackId.Value,
FragmentId = tagsForSlice.Key.FragmentId.Value,
SliceIds = new HyperSliceId[] { tagsForSlice.Key.SliceId.Value },
FabricServiceId = this._settings.FabricServiceId
};
var result = await _hyperStore.ExecuteAsync(args) ?? new RetrieveFragmentFramesArgs.SliceResult[0];
if (result.Length == 0)
{
continue;
}
var frame = result[0].Image;
var frameSkBitmap = SKBitmap.Decode(frame.Data);
_globalMatrix = new uint[_height, _width];
foreach (var tag in tagsForSlice.Select(x => x.Tag))
{
if (!_keepWorking || _ct.IsCancellationRequested)
{
return(null);
}
var tagExtraction = ProcessMaskedTag(tag);
if (tagExtraction != null)
{
ProcessMaskTransparencyIntoMatrix(tagExtraction.Image, tagExtraction.Rect);
}
}
var sourcePixelsAddr = sourceBitmap.GetPixels();
var destPixelsAddr = frameSkBitmap.GetPixels();
byte MixColors(byte color1, byte color2, byte transparencyValue)
{
var transparency2 = (double)1 / 255 * transparencyValue;
var transparency1 = 1 - transparency2;
var result = (byte)((color1 * transparency1) + (color2 * transparency2));
return(result);
}
unsafe
{
byte *sourcePtr = (byte *)sourcePixelsAddr.ToPointer();
byte *destPtr = (byte *)destPixelsAddr.ToPointer();
for (int row = 0; row < sourceBitmap.Height; row++)
{
for (int col = 0; col < sourceBitmap.Width; col++)
{
var transpValue = _globalMatrix[row, col];
if (transpValue == 0) // Do not modify anything
{
sourcePtr += 4;
destPtr += 4;
}
else
{
var destBlue = *destPtr++; // blue
var destGreen = *destPtr++; // green
var destRed = *destPtr++; // red
destPtr++; // skip alpha
var sourceBlue = *sourcePtr;
var sourceGreen = *(sourcePtr + 1);
var sourceRed = *(sourcePtr + 2);
var mixedBlue = MixColors(sourceBlue, destBlue, (byte)transpValue);
var mixedGreen = MixColors(sourceGreen, destGreen, (byte)transpValue);
var mixedRed = MixColors(sourceRed, destRed, (byte)transpValue);
*sourcePtr++ = mixedBlue; // blue
*sourcePtr++ = mixedGreen; // green
*sourcePtr++ = mixedRed; // red
sourcePtr++; // skip alpha
}
}
}
}
}
maskedImage = SKImage.FromBitmap(sourceBitmap);
}
if (maskedImage == null)
{
return(null);
}
if (cutOff)
{
return(RenderWithCrop(maskedImage, configuration));
}
else
{
return(RenderWithNoCutoff(maskedImage, configuration));
}
}
public override Task VisualizeInCrossModuleAsync(IModuleVm moduleVm, IHyperArgsSink hyperStore, CrossModuleVisualizationRequest request, HyperDocumentId moduleContainerId, string pageTitle, bool?showInExternalBrowser)
{
throw new NotImplementedException();
}
