/// <summary>
/// sends a scan result to all connected clients
/// </summary>
/// <param name="userName">the name of the broadcaster</param>
/// <param name="pResult">the scan results</param>
public void SendScanResult(string userName, ScanResultPackage pResult)
{
//broadcast message
CurrentScanresults.Add(pResult);
Clients.All.scanresultRecieved(userName, pResult);
OnMessageEvent("[SignalR] " + userName + " broadcasted a result.");
}
/// <summary>
/// sends a scan result to all connected clients
/// </summary>
/// <param name="pResult">the result package</param>
public void sendScanResults(ScanResultPackage pResult)
{
if (_SignalRHandler != null)
{
_SignalRHandler.SendScanResultToClients(pResult);
}
}
/// <summary>
/// sends a scan result package to the signalr server which then broadcasts it to all clients
/// </summary>
/// <param name="pResult"></param>
public void SendScanResultToClients(ScanResultPackage pResult)
{
try
{
HubProxy.Invoke("SendScanResult", _name, pResult);
}
catch (Exception) { }
}
public ScanResultWindow(ScanResultPackage pResultPackage)
{
InitializeComponent();
this._Textblock_Date.Text = pResultPackage.timestamp.ToString();
this._Textblock_AlgorithmUsed.Text = pResultPackage.algorithmUsed.ToString();
this._Textblock_NumberOfClouds.Text = pResultPackage.numberOfClouds.ToString();
this._Textblock_NumberOfPoints.Text = pResultPackage.numberOfPoints.ToString();
this._Textblock_ScannedDelaunayVolume.Text = Math.Round(pResultPackage.scannedDelaunayVolume, 3).ToString() + " m³";
this._Textblock_ConvexScannedAlgorithmVolume.Text = Math.Round(pResultPackage.convexScannedAlgorithmVolume, 3).ToString() + " m³";
this._Textblock_ConcavScannedAlgorithmVolume.Text = Math.Round(pResultPackage.concavScannedAlgorithmVolume, 3).ToString() + " m³";
this._Textblock_NumberOfContainers.Text = pResultPackage.containerResults.Sum(t => t.amount).ToString();
this._Textblock_ContainerAccuracy.Text = Math.Round(pResultPackage.containerAccuracy, 3).ToString() + "%";
this._Textblock_PayloadVolume.Text = Math.Round(pResultPackage.estimatedPayloadVolume, 3) + " m³";
foreach (Post_KNV_MessageClasses.ScanResultPackage.ContainerResult res in pResultPackage.containerResults)
{
ContainerResultsListViewItem temp = new ContainerResultsListViewItem();
temp.name = res.containerType.containerName;
temp.amount = res.amount;
_ContainerResultListView.Items.Add(temp);
}
}
/// <summary>
/// ASYNC: calculates the results of the point cloud and returns a result package; throws OnResultPackageEvent when done, OnErrorEvent when an error occured
/// </summary>
/// <param name="pInputCloud">the input cloud</param>
/// <param name="pAlgorithm">the algorithm to chose</param>
/// <param name="pSettings">the configuration object</param>
public void calculateResults(PointCloud pInputCloud, ServerConfigObject pConfig)
{
_CancelTokenSource = new CancellationTokenSource();
Log.LogManager.updateAlgorithmStatus("Start Calculation Service");
Task <ScanResultPackage> t = new Task <ScanResultPackage>(() =>
{
//remove calibrated planes
pInputCloud.removePlaneFromPointcloud(pConfig.serverAlgorithmConfig.calibratedPlanes, pConfig.serverAlgorithmConfig.planar_ThresholdDistance);
this.OnNewPointPicturesEvent(pInputCloud.pictures);
//remove calibrated objects
pInputCloud.removePointcloudsFromPointCloud(pConfig.serverAlgorithmConfig.calibratedObjects, pConfig.serverAlgorithmConfig.euclidean_ExtractionRadius);
this.OnNewPointPicturesEvent(pInputCloud.pictures);
//remove noise via euclidean cluster extraction, discard too small ones
List <PointCloud> pointCloudList = EuclideanClusterExtraction.calculateEuclideanClusterExtraction(pInputCloud, pConfig.serverAlgorithmConfig.euclidean_ExtractionRadius, _CancelTokenSource.Token);
pointCloudList.RemoveAll(pcl => pcl.delaunayVolume < pConfig.serverAlgorithmConfig.euclidean_MinimumVolume);
if (pointCloudList.Count == 0)
{
throw new Exception("No valid point clouds found!");
}
//calculate items in result package
_CancelTokenSource.Token.ThrowIfCancellationRequested();
ScanResultPackage resultPack = new ScanResultPackage();
PlaneModel floorPlane = pConfig.serverAlgorithmConfig.calibratedPlanes.Find(pl => pl.isFloor);
//create concav and convex areas
List <IntermediateScanResultPackage> intermediateResultList = Algorithm.PlanarVolumeCalculation.CalculateIntermediateScanresults(pointCloudList,
floorPlane,
pConfig.serverAlgorithmConfig.downsamplingFactor,
pConfig.serverAlgorithmConfig.concav_angleThreshold);
//sum up convex and concav volume
resultPack.convexScannedAlgorithmVolume = 0d; resultPack.concavScannedAlgorithmVolume = 0d;
foreach (IntermediateScanResultPackage p in intermediateResultList)
{
resultPack.convexScannedAlgorithmVolume += p.convexPlaneArea * p.averageHeight;
resultPack.concavScannedAlgorithmVolume += p.concavPlaneArea * p.averageHeight;
}
//calculate best fit for container matching, check first if container calibration exist, aggregate result
resultPack.containerResults = null; resultPack.estimatedPayloadVolume = 0;
if (pConfig.calibratedContainers.Count > 0)
{
List <ContainerCalculation.tModel> bestFitSolutions = ContainerCalculation.CalculateBestFitSolutions(intermediateResultList, pConfig.calibratedContainers);
resultPack.containerResults = new List <ScanResultPackage.ContainerResult>();
//go through the best fit solution for every point cloud
foreach (ContainerCalculation.tModel p in bestFitSolutions)
{
foreach (Post_knv_Server.CalculationService.ContainerCalculation.tContainerModel m in p.containerResults)
{
//check if container exists in containerResults, if not add, if yes, just add
if (resultPack.containerResults.Exists(q => q.containerType == m.containerType))
{
resultPack.containerResults.Find(q => q.containerType == m.containerType).amount += m.amountOfContainers;
}
else
{
ScanResultPackage.ContainerResult res = new ScanResultPackage.ContainerResult();
res.containerType = m.containerType; res.amount = m.amountOfContainers;
resultPack.containerResults.Add(res);
}
//add container volume
resultPack.estimatedPayloadVolume += m.containerType.containerVolume * m.amountOfContainers;
}
}
//accumulate rating
resultPack.containerAccuracy = bestFitSolutions.Average(i => i.pRating);
//estimate payload
resultPack.estimatedPayloadVolume = resultPack.concavScannedAlgorithmVolume - resultPack.estimatedPayloadVolume;
}
//create results
resultPack.timestamp = DateTime.Now;
resultPack.algorithmUsed = pConfig.serverAlgorithmConfig.useAlgorithm;
resultPack.numberOfClouds = pointCloudList.Count;
resultPack.numberOfPoints = pointCloudList.Sum(p => p.count);
resultPack.scannedDelaunayVolume = pointCloudList.Sum(p => p.delaunayVolume);
resultPack.amountOfKinectsDataRequested = pInputCloud.ConfigObject.clientRequestObject.amountOfKinectsInRequest;
return(resultPack);
}, _CancelTokenSource.Token);
//task finishing
t.ContinueWith(calculationFinishedSuccessfully, TaskContinuationOptions.OnlyOnRanToCompletion);
t.ContinueWith(exceptionHandler, TaskContinuationOptions.OnlyOnFaulted);
t.Start();
}
/// <summary>
/// gets thrown when a new scan result is reported, ready from the calculation service
/// </summary>
/// <param name="pResult">the result package</param>
void _CalculationManager_OnResultPackageEvent(ScanResultPackage pResult)
{
_Webservice.sendScanResults(pResult);
OnNewScanResultEvent(pResult);
}
