public static Map GetMap(MapsEntities entities, int mapId) { if (MapExists(mapId)) return StudMapCache.Global.Maps[mapId]; else return new Map(); }
public void UpdateGraph(MapsEntities entities) { Nodes = GraphService.GetNodesDictionary(entities, Id); Edges = GraphService.GetEdgeList(entities, Id); GraphsForFloor = GraphService.GetAllGraphs(entities, Floors.Select(f => f.Id)); PathFinder = NavigationService.ComputeShortestPaths(Nodes, Edges); }
public static Floor GetFloor(MapsEntities entities, int floorId) { Floors floor = entities.Floors.FirstOrDefault(x => x.Id == floorId); if (floor == null) throw new ServiceException(ResponseError.FloorIdDoesNotExist); return Conversions.ToFloor(floor, ServerAdminBasePath); }
public FingerprintCache() { TimeoutInMinutes = TIMEOUT; using (var entities = new MapsEntities()) { Update(entities); } }
public static Node GetNodeForQRCode(MapsEntities entities, int mapId, string qrCode) { Data.Entities.NodeInformation nodeInformation = entities.NodeInformation.FirstOrDefault(x => x.QRCode == qrCode); if (nodeInformation == null) throw new ServiceException(ResponseError.QRCodeDosNotExist); return Conversions.ToNode(nodeInformation.Nodes); }
public static Node GetNodeForNFC(MapsEntities entities, int mapId, string nfcTag) { Data.Entities.NodeInformation nodeInformation = entities.NodeInformation.FirstOrDefault(x => x.NFCTag == nfcTag); if (nodeInformation == null) throw new ServiceException(ResponseError.NFCTagDoesNotExist); return Conversions.ToNode(nodeInformation.Nodes); }
public GlobalCacheObject() { TimeoutInMinutes = 24 * 60; using (var entities = new MapsEntities()) { Update(entities); } }
public FingerprintCacheObject(int mapId) { TimeoutInMinutes = Timeout; MapId = mapId; using (var entities = new MapsEntities()) { Update(entities); } }
public MapCache(int mapId) { TimeoutInMinutes = TIMEOUT; ID = mapId; using (var entities = new MapsEntities()) { Update(entities); } }
public static void DeleteGraphForFloor(MapsEntities entities, int floorId) { Floors floor = entities.Floors.Find(floorId); if (floor == null) throw new ServiceException(ResponseError.FloorIdDoesNotExist); int mapId = floor.MapId; entities.DeleteGraphFromFloor(floorId); StudMapCache.RemoveMap(mapId); }
private static List<Edge> CreateEdgeListe(MapsEntities entities, int mapId) { var edges = from edge in entities.Edges where edge.Graphs.MapId == mapId select new Edge { StartNodeId = edge.NodeStartId, EndNodeId = edge.NodeEndId }; return edges.ToList(); }
public static Dictionary<int, Dictionary<int, Normal>> ComputeNodeDistribution(MapsEntities entities) { var nodeDistributions = new Dictionary<int, Dictionary<int, Normal>>(); foreach (RSSDistribution dist in entities.RSSDistribution) { if (!nodeDistributions.ContainsKey(dist.NodeId)) nodeDistributions.Add(dist.NodeId, new Dictionary<int, Normal>()); nodeDistributions[dist.NodeId].Add(dist.AccessPointId, Normal.WithMeanStdDev(dist.AvgRSS ?? 0, dist.StDevRSS ?? 0.0)); } return nodeDistributions; }
public static FullNodeInformation GetFullNodeInformationForNode(MapsEntities entities, int nodeId) { NodeInformation info = GetNodeInformationForNode(entities, nodeId); Floor floor = FloorService.GetFloor(entities, info.Node.FloorId); Map map = MapService.GetMap(entities, floor.MapId); return new FullNodeInformation { Map = map, Floor = floor, Info = info }; }
private static Dictionary<int, Dictionary<int, Normal>> CalculateNodeDist(MapsEntities entities) { var nodeDistributions = new Dictionary<int, Dictionary<int, Normal>>(); foreach (var dist in entities.RSSDistribution) { if (!nodeDistributions.ContainsKey(dist.NodeId)) nodeDistributions.Add(dist.NodeId, new Dictionary<int, Normal>()); // Standardabweichung auf einen beliebigen Wert setzen, wenn nodeDistributions[dist.NodeId].Add(dist.AccessPointId, Normal.WithMeanStdDev(dist.AvgRSS ?? 0, dist.StDevRSS ?? 1.0)); } return nodeDistributions; }
public static Map CreateMap(MapsEntities entities, string mapName) { var newMap = new Maps { Name = mapName, CreationTime = DateTime.Now }; Maps insertedMap = entities.Maps.Add(newMap); entities.SaveChanges(); StudMapCache.Global.UpdateMaps(entities); return Conversions.ToMap(insertedMap); }
public static List<NodeInformation> GetNodeInformation(MapsEntities entities, int mapId, int floorId) { if (!StudMapCache.Global.Maps.ContainsKey(mapId)) throw new ServiceException(ResponseError.MapIdDoesNotExist); if (!entities.Floors.Any(f => f.Id == floorId)) throw new ServiceException(ResponseError.FloorIdDoesNotExist); List<Data.Entities.NodeInformation> nodes = entities.NodeInformation .Where( n => n.Nodes.Floors.MapId == mapId && n.Nodes.FloorId == floorId) .ToList(); return nodes.Select(Conversions.ToNodeInformation).ToList(); }
public static NodeInformation GetNodeInformationForNode(MapsEntities entities, int nodeId) { var result = new NodeInformation(); Nodes node = entities.Nodes.Find(nodeId); if (node == null) throw new ServiceException(ResponseError.NodeIdDoesNotExist); result.Node = Conversions.ToNode(node); Data.Entities.NodeInformation queriedNodeInformation = entities.NodeInformation.FirstOrDefault(x => x.NodeId == nodeId); // Wenn keine Infos hinterlegt sind, dann leere Info zurückgegeben // Wichtig: Das ist kein Fehlerfall if (queriedNodeInformation == null) return result; return Conversions.ToNodeInformation(queriedNodeInformation); }
public static void SaveFingerprintForNode(MapsEntities entities, int nodeId, Fingerprint fingerprint) { if (fingerprint == null) throw new ServiceException(ResponseError.FingeprintIsNotDefined); if (fingerprint.AccessPointScans == null || !fingerprint.AccessPointScans.Any()) return; Nodes node = entities.Nodes.Find(nodeId); if (node == null) throw new ServiceException(ResponseError.NodeIdDoesNotExist); // Fingerprint in DB einfügen Fingerprints fingerprints = entities.Fingerprints.Add(new Fingerprints { NodeId = node.Id }); entities.SaveChanges(); foreach (AccessPointScan apScan in fingerprint.AccessPointScans) { // Fehlenden AccessPoint ggf. anlegen AccessPoints ap = entities.AccessPoints.FirstOrDefault(x => x.MAC == apScan.AccessPoint.MAC); if (ap == null) { ap = entities.AccessPoints.Add(new AccessPoints { MAC = apScan.AccessPoint.MAC }); entities.SaveChanges(); } // Einzelmessung speichern entities.AccessPointScans.Add(new AccessPointScans { AccessPointId = ap.Id, RecievedSignalStrength = apScan.ReceivedSignalStrength, FingerprintId = fingerprints.Id }); } entities.SaveChanges(); StudMapCache.RemoveFingerprint(node.Floors.MapId); }
public static Floor CreateFloor(MapsEntities entities, int mapId, string name, string imageUrl) { if (!MapService.MapExists(mapId)) throw new ServiceException(ResponseError.MapIdDoesNotExist); var newFloor = new Floors { MapId = mapId, Name = name, ImageUrl = imageUrl, CreationTime = DateTime.Now }; Floors insertedFloor = entities.Floors.Add(newFloor); entities.SaveChanges(); StudMapCache.RemoveMap(mapId); return Conversions.ToFloor(insertedFloor, ServerAdminBasePath); }
public static Graph GetGraphForFloor(MapsEntities entities, int floorId) { Floors queriedFloor = entities.Floors.Find(floorId); if (queriedFloor == null) throw new ServiceException(ResponseError.FloorIdDoesNotExist); // Array aus Node-IDs auf dem angeforderten Floor erstellen ICollection<Nodes> nodes = queriedFloor.Nodes; IEnumerable<int> nodeIds = nodes.Select(n => n.Id); int[] nodeIdArray = nodeIds as int[] ?? nodeIds.ToArray(); // TODO: Hier wirklich auch Kanten zurückgeben, von denen nur // ein Endknoten auf dem geforderten Floor ist? // Erstmal nur Kanten, die komplett auf dem Floor sind zurückgeben IQueryable<Edges> edges = entities.Edges.Where(e => nodeIdArray.Contains(e.NodeStartId) && nodeIdArray.Contains(e.NodeEndId)); return Conversions.ToGraph(floorId, nodes, edges); }
public static List<NodeProbability> GetNodeProbabiltyForScan(MapsEntities entities, LocationRequest request) { // Gesammelte WLAN-Fingerprints aus DB auswerten und Verteilung bestimmen // Jetzt: gecachet! FingerprintCacheObject cache = StudMapCache.Fingerprint(request.MapId); MapCacheObject mapCache = StudMapCache.Map(request.MapId); Node previousNode = mapCache.Nodes.ContainsKey(request.PreviousNodeId) ? mapCache.Nodes[request.PreviousNodeId] : new Node {Id = 0}; // AccessPoint-Messung nach APs aufteilen Dictionary<int, int> apScans = AnalyseInputScan(request.Scans, cache.MACtoAP); // W'keit bestimmen, dass RSS-Werte an Knoten gemessen werden Func<int, double> getDistance; if (request.PreviousNodeId == 0) getDistance = nodeId => 1.0; else getDistance = nodeId => { double distance; if (mapCache.PathFinder.TryGetDistance(previousNode.Id, nodeId, out distance)) return distance; else return -1; }; List<NodeProbability> nodeProbs = CalculateNodeProbabilities(cache.NodeDistributions, apScans, getDistance); // Absteigend nach W'keit sortieren nodeProbs.Sort((m, n) => n.Probabilty.CompareTo(m.Probabilty)); // Maximal die angeforderte Anzahl an Knoten zurückliefern int count = Math.Min(request.NodeCount, nodeProbs.Count); return nodeProbs.GetRange(0, count); }
public static List<Node> GetConnectedNodes(MapsEntities entities, int nodeId) { bool nodeExists = entities.Nodes.Any(n => n.Id == nodeId); if (!nodeExists) throw new ServiceException(ResponseError.NodeIdDoesNotExist); // Node-IDs aller Endknoten der verbundenen Kanten sammeln IQueryable<Edges> edges = entities.Edges.Where( e => e.NodeStartId == nodeId || e.NodeEndId == nodeId); var connectedNodeIds = new HashSet<int>(); foreach (Edges edge in edges) { connectedNodeIds.Add(edge.NodeStartId); connectedNodeIds.Add(edge.NodeEndId); } // Den angeforderten Knoten herausfiltern connectedNodeIds.Remove(nodeId); IQueryable<Nodes> connectedNodes = entities.Nodes.Where( n => connectedNodeIds.Contains(n.Id)); return connectedNodes.ToList() .Select(Conversions.ToNode).ToList(); }
public void Update(MapsEntities entities) { MACtoAP = FingerprintService.CreateMACtoAPLookup(entities); NodeDistributions = FingerprintService.ComputeNodeDistribution(entities); }
private static Dictionary<string, int> CreateMACtoAPLookup(MapsEntities entities) { return entities.AccessPoints.ToDictionary(ap => ap.MAC, ap => ap.Id); }
public void Update(MapsEntities entities) { NodeDistributions = CalculateNodeDist(entities); MACtoAP = CreateMACtoAPLookup(entities); }
public static List<Edge> GetEdgeList(MapsEntities entities, int mapId) { return entities.Edges.Where(e => e.Graphs.MapId == mapId).ToList() .Select(Conversions.ToEdge).ToList(); }
private void Update(MapsEntities entities) { UpdateMaps(entities); UpdateFloors(entities); }
public void UpdateMaps(MapsEntities entities) { Maps = MapService.GetMaps(entities); }
public void UpdateFloors(MapsEntities entities) { Floors = FloorService.GetAllFloors(entities); }
public static Dictionary<int, Node> GetNodesDictionary(MapsEntities entities, int mapId) { return entities.Nodes.Where(n => n.Floors.MapId == mapId).ToList() .Select(Conversions.ToNode).ToDictionary(n => n.Id); }