/// <summary> /// Add layer. /// </summary> /// <param name="layer">ObjectLayer for add.</param> public void AddLayer(ObjectLayer layer) { _objectLayers.Add(layer); FrameworkElement mapTip = (FrameworkElement)LayoutRoot.FindResource("MapTip"); _mapTips.CreateMapTipIfNeeded(layer, mapTip); }
private ObjectLayer Execute1stLevelSegmentation(GrayscaleProcessor gp, GrayscaleProcessor gpSobel, GrayscaleProcessor gpH) { ContourBasedSegmentation cbs = new ContourBasedSegmentation(); cbs.CreatePrimarySegmentation(gp, MAX_CONTOURLENGTH); cbs.EvaluateContours(c => { if (ContourProperties.FromContour(c).Convexity < 0.95) { return(-1); } return(ContourValue.GetValue(c, gpSobel)); }); ObjectLayer layer = cbs.CreateLayer(MIN_CONTOURLENGTH, int.MaxValue); layer = new ContourOptimizer().RemoveNonCompactPixels(layer, 3); layer = layer.CreateAbove(obj => { return(this.GetContourGradient(obj, gp) < 0); }); //layer=new ConcaveObjectSeparation().Execute(layer, 0.33, true); return(layer); }
/// <summary> /// Improve Calc-Function for Lumina /// </summary> /// <requred_features> /// Area /// </requred_features> /// <param name="lumina"></param> /// <returns></returns> public ObjectLayer ImprObjectLayer(ObjectLayer objectLayerLumina) { const double minArea = 500; var listImageObjects = new List <ImageObject>(); var mapObjectLayerMap = new Map(objectLayerLumina.Map.Width, objectLayerLumina.Map.Height); foreach (var imageObject in objectLayerLumina.Objects) { //Nur Werte Aufnehmen die auch die min. Bedingung erfüllen if (imageObject.Features.GetFeatureByName("area").Value >= minArea) { //In neue Liste eintragen listImageObjects.Add(ObjectLayerrUtils.CopyImageObject(imageObject.Id, imageObject)); //In neuer Map eintragen for (var x = 0; x < objectLayerLumina.Map.Width; x++) { for (var y = 0; y < objectLayerLumina.Map.Height; y++) { if (objectLayerLumina.Map[x, y] == imageObject.Id) { mapObjectLayerMap[x, y] = imageObject.Id; } } } } } return(new ObjectLayer(mapObjectLayerMap, listImageObjects.ToArray(), objectLayerLumina.Name)); }
/// <summary> /// new Feature: /// area /// </summary> /// <param name="objectLayer"></param> /// <returns></returns> public static ObjectLayer AddFeatureArea(ObjectLayer objectLayer) { var listImageObjects = new List <ImageObject>(); var dicCountPixel = objectLayer.Objects.ToDictionary(imageObject => imageObject.Id, imageObject => 0); for (var x = 0; x < objectLayer.Map.Width; x++) { for (var y = 0; y < objectLayer.Map.Height; y++) { if (objectLayer.Map[x, y] != 0) { dicCountPixel[objectLayer.Map[x, y]]++; } } } foreach (var imageObject in objectLayer.Objects) { var item = CopyImageObject(imageObject.Id, imageObject); item.Features.Add(new Feature("area", dicCountPixel[imageObject.Id])); listImageObjects.Add(item); } return(new ObjectLayer(objectLayer.Map, listImageObjects.ToArray(), objectLayer.Name)); }
public ObjectPointerTool(ILayerContext layerContext, ObjectLayer layer, Size gridSize) { _layerContext = layerContext; //_history = history; _layer = layer; _gridSize = gridSize; }
/// <summary> /// Create layer for showing unassigned orders of current schedule. /// </summary> private void _CreateUnassignedLayer() { _unassignedLayer = new ObjectLayer(_unassignedOrdersColl, typeof(Order), true, _stopOrdersLayer.MapLayer); _unassignedLayer.EnableToolTip(); mapCtrl.AddLayer(_unassignedLayer); _unassignedLayer.Selectable = true; }
private ObjectLayer GetObjectLayerFromFilterLayer(string filter_layer) { ObjectLayer objectLayer = ObjectLayer.NumLayers; switch (filter_layer.ToLower()) { case "buildings": return(ObjectLayer.Building); case "wires": return(ObjectLayer.Wire); case "liquidpipes": return(ObjectLayer.LiquidConduit); case "gaspipes": return(ObjectLayer.GasConduit); case "solidconduits": return(ObjectLayer.SolidConduit); case "tiles": return(ObjectLayer.FoundationTile); case "logic": return(ObjectLayer.LogicWires); case "backwall": return(ObjectLayer.Backwall); default: throw new ArgumentException("Invalid filter layer: " + filter_layer); } }
/// <summary> /// get necessary data for layers in a region /// </summary> /// <param name="layers">requested layers, namely agent, primitive and terrain</param> public void initialize(string[] layers) { m_hasAgentLyr = false; m_hasObjLyr = false; m_hasTerrainLyr = false; for (int i = 0; i < layers.Length; i++) { switch (layers[i]) { case "agent": m_agentLyr = new AgentLayer(m_scene); m_agentLyr.initialize(); m_hasAgentLyr = true; break; case "primitive": m_objLyr = new ObjectLayer(m_scene); m_objLyr.initialize(); m_hasObjLyr = true; break; case "terrain": m_terrainLyr = new TerrainLayer(m_scene); m_terrainLyr.initialize(); m_hasTerrainLyr = true; break; default: break; } } }
/// <summary> /// Set markers layer. /// </summary> /// <param name="markersLayer">Parent map control markers layer.</param> public void SetLayer(ObjectLayer markersLayer) { Debug.Assert(_markersLayer == null); Debug.Assert(markersLayer != null); _markersLayer = markersLayer; }
/// <summary> /// Create RegionsPage. /// </summary> /// <param name="mapCtrl">Map from parent page.</param> /// <param name="dataGridControl">Grid from parent page.</param> /// <param name="parentLayer">Layer, that contains regions.</param> /// <param name="type">Semantic type of regions. Barrier or Zone.</param> /// <param name="layoutRoot">Parent page layout root.</param> /// <param name="mapBorder">Container element for map.</param> public RegionsPage(MapControl mapCtrl, DataGridControlEx dataGridControl, ObjectLayer parentLayer, Type type, Grid layoutRoot, Border mapBorder) { _mapCtrl = mapCtrl; _mapCtrl.CanSelectCallback = _CanSelect; _mapCtrl.StartEditRegionCallback = _EditStarted; _mapCtrl.EndEditRegionCallback = _EditEnded; _dataGridControl = dataGridControl; _parentLayer = parentLayer; _type = type; if (_type == typeof(Zone)) { _polygonTool = new ZonePolygonTool(); _polygonTool.OnComplete += new EventHandler(_PolygonToolOnComplete); _mapCtrl.AddTool(_polygonTool, _CanActivateZonePolygonTool); } else if (_type == typeof(Barrier)) { _CreateBarrierTools(); } else { Debug.Assert(false); } _gridAutoFitHelper = new GridAutoFitHelper(dataGridControl, layoutRoot, mapBorder); }
/// <summary> /// Create layer for showing stops associated with orders of current schedule. /// </summary> private void _CreateStopOrdersLayer() { _stopOrdersLayer = new ObjectLayer(_stopOrders, typeof(Stop), true); _stopOrdersLayer.EnableToolTip(); _stopOrdersLayer.Selectable = true; mapCtrl.AddLayer(_stopOrdersLayer); }
private void LoadFriends(ObjectLayer a_friendLayer) { foreach (MapObject friend in a_friendLayer.MapObjects) { m_friends.Add(new Friend(friend, Convert.ToInt32(friend.Properties["ID"].AsInt32), Convert.ToBoolean(friend.Properties["CanInterract"].AsBoolean))); } }
/// <summary> /// Create layer for showing routes of current schedule. /// </summary> private void _CreateRoutesLayer() { _routesLayer = new ObjectLayer(_routesColl, typeof(Route), false); _routesLayer.EnableToolTip(); mapCtrl.AddLayer(_routesLayer); _routesLayer.Selectable = true; }
/// <summary> /// Create layer for showing stops associated with locations of current schedule. /// </summary> private void _CreateStopLocationsLayer() { _stopLocationsLayer = new ObjectLayer(_stopLocations, typeof(Stop), false); _stopLocationsLayer.EnableToolTip(); _stopLocationsLayer.Selectable = true; mapCtrl.AddLayer(_stopLocationsLayer); }
private ObjectLayer ProcessObjectLayer(ObjectLayer layer, ObjectPool objectLayerPool) { ObjectLayer outLayer = new ObjectLayer(layer.Name, layer.LayerOriginX, layer.LayerOriginY, layer.LayerWidth, layer.LayerHeight) { IsVisible = layer.IsVisible, Opacity = layer.Opacity, RasterMode = layer.RasterMode, }; foreach (Property prop in layer.PropertyManager.CustomProperties) { outLayer.PropertyManager.CustomProperties.Add(prop); } foreach (ObjectInstance obj in layer.Objects) { if (!objectLayerPool.Objects.Contains(obj.ObjectClass.Uid)) { objectLayerPool.Objects.Add(obj.ObjectClass); } outLayer.AddObject(obj); } return(outLayer); }
/// <summary> /// erzeugt einen WEKA-kompatiblen Datensatz aus einem <see cref="ObjectLayer"/> /// </summary> /// <param name="objectLayer"><see cref="ObjectLayer"/></param> /// <param name="classNames">Aufzählung der Klassennamen die im Datensatz verwendet werden sollen</param> /// <param name="classAttributeName">>Name für das Klassenattribut</param> /// <returns>Datensatz</returns> public static Instances CreateWekaData(this ObjectLayer objectLayer, IEnumerable <string> classNames, string classAttributeName = "class") { var instances = Util.CreateInstances(classNames, objectLayer.FindContainedFeatures(), objectLayer.Name, classAttributeName); instances.AddImageObjects(objectLayer); return(instances); }
public void ObjectTest() { AddressBook.ObjectLayer obLayer = new ObjectLayer(); Person person = new Person(0, "A", "B", 27074358, 27074358); obLayer.CheckIC(person.IC); }
/// <summary> /// Load all the bush objects into the world. /// </summary> /// <param name="bushes"></param> private void LoadBushes(ObjectLayer bushes) { int count = 0; foreach (var mapObject in bushes.MapObjects) { int x = mapObject.Bounds.X, y = mapObject.Bounds.Y; int tileX = x / TileWidth, tileY = y / TileHeight; var position = new Vector2(x - mapObject.Bounds.Width / 2f, y - mapObject.Bounds.Height / 2f); var bush = new Bush(position, WorldObjectAnimations, "/Bush/Green/Idle"); if (Objects[tileX, tileY] == null) { Objects[tileX, tileY] = new List <GameObject>(); } Objects[tileX, tileY].Add(bush); count++; } Log.Debug(" + {0} bushes.", count); }
private float GetTargetArea(ObjectLayer layer) { if (layer.Objects.Count == 0) { return(-1); } float targetArea = -1F; List <float> values = new List <float>(); for (int i = 0; i < layer.Objects.Count; i++) { ImageObject obj = layer.Objects[i]; float area = ContourProperties.FromContour(obj.Contour).Area; values.Add(area); } values.Sort(); int index = (int)(0.95 * values.Count); if (values.Count > 0) { targetArea = values[index]; } return(targetArea); }
/// <summary> /// Loads npc objects from the tmx map /// </summary> /// <param name="npcLayer"></param> private void LoadFriends(ObjectLayer npcLayer) { foreach (MapObject friend in npcLayer.MapObjects) { _nonPlayerCharacters.Add(new NonPlayerCharacter(friend, Convert.ToInt32(friend.Properties["ID"].AsInt32), Convert.ToBoolean(friend.Properties["CanInterract"].AsBoolean))); } }
/// <summary> /// fügt alle <see cref="ImageObject"/>s des <see cref="ObjectLayer"/> zu den <see cref="Instances"/> hinzu /// </summary> /// <param name="instances">Datensatz</param> /// <param name="objectLayer">auszuwertender <see cref="ObjectLayer"/></param> public static void AddImageObjects(this Instances instances, ObjectLayer objectLayer) { foreach (var io in objectLayer.Objects) { instances.CreateWekaInstance(io); } }
/// <summary> /// LoadContent will be called once per game and is the place to load /// all of your content. /// </summary> protected override void LoadContent() { // Create a new SpriteBatch, which can be used to draw textures. spriteBatch = new SpriteBatch(GraphicsDevice); map = Content.Load <Map>("Level1/Level1"); customCursor = Content.Load <Texture2D>("mouseCursor"); AspectRatio = GraphicsDevice.Viewport.AspectRatio; OldWindowSize = new Point(Window.ClientBounds.Width, Window.ClientBounds.Height); BlankTexture = new Texture2D(GraphicsDevice, 1, 1); BlankTexture.SetData(new Color[] { Color.FromNonPremultiplied(255, 255, 255, 255) }); spriteBatch = new SpriteBatch(GraphicsDevice); OffScreenRenderTarget = new RenderTarget2D(GraphicsDevice, Window.ClientBounds.Width, Window.ClientBounds.Height); hud.LoadContent(Content); this.collisionLayer = this.map.ObjectLayers["Collision"]; player.LoadContent(Content, "hero", mapView, collisionLayer); // Setting player position. this.objLayer = this.map.ObjectLayers["Objects"]; MapObject mapObj = this.objLayer.MapObjects.Where(p => p.Name.Equals("SpawnPoint", StringComparison.CurrentCultureIgnoreCase)).Select(p => p).First(); // Verificaion. if (mapObj != null) { // Get coordinates. Rectangle pos = Map.Translate(mapObj.Bounds, this.mapView); player.position = new Vector2(pos.X, pos.Y); } // TODO: use this.Content to load your game content here }
public FacilityObject ObjectAt(XYZ location, ObjectLayer layer) { if (!_objects.ContainsKey(location)) { return(new FacilityObject()); } return(_objects[location].First(x => x.ObjectLayer == layer)); }
public ObjectOrderCommand(ObjectLayer source) { _objectSource = source; _objects = new List <ObjectRecord>(); _toFront = new List <ObjectInstance>(); _toBack = new List <ObjectInstance>(); }
/// <summary> /// Retrieves an object layer by its name, resolving the value at runtime to handle /// differences in the layer enum. This method is slower than a direct lookup - /// consider caching the result. /// </summary> /// <param name="name">The name of the layer (use nameof()!)</param> /// <param name="defValue">The default value (use the value at compile time)</param> /// <returns>The value to use for this object layer.</returns> public static ObjectLayer GetObjectLayer(string name, ObjectLayer defValue) { if (!Enum.TryParse(name, out ObjectLayer value)) { value = defValue; } return(value); }
/// <summary> /// Create layer for showing ungeocoded orders. /// </summary> private void _CreateOrdersLayer() { _ordersLayer = new ObjectLayer(new List <Order>(), typeof(Order), false); _ordersLayer.EnableToolTip(); _ordersLayer.Selectable = false; mapCtrl.AddLayer(_ordersLayer); }
public EnemySystem(ObjectLayer a_enemyLayer, Level a_level, Map a_currentMap) { m_enemies = new List <Model.Enemy>(); m_spawnList = new List <Enemy>(); m_enemySpellSystem = new SpellSystem(); m_enemyId = 0; LoadEnemies(a_enemyLayer, a_level, a_currentMap); }
//Is not network synced, is used for prediction on local client when walking between matricies public void SetParentOnLocal(Transform newParent) { Unregister(); layer = newParent.GetComponentInChildren <ObjectLayer>(); Matrix = newParent.GetComponent <Matrix>(); transform.parent = layer.transform; Register(); }
public virtual void Start() { position = Vector3Int.FloorToInt(transform.localPosition); layer = transform.parent.GetComponent <ObjectLayer>(); layer.Objects.Add(position, this); }
private void Start() { metaTileMap = GetComponentInChildren <MetaTileMap>(); matrix = GetComponentInChildren <Matrix>(); objectLayer = GetComponentInChildren <ObjectLayer>(); tileChangeManager = GetComponent <TileChangeManager>(); CacheTileMaps(); }
public static void ProcessLayer(ObjectLayer layer,Point location) { Contract.Requires(null!=layer); for(var i=0;i<layer.Objects.Count;i++) { if(layer.Objects[i].Features.Contains(CentroidX.Name)&&layer.Objects[i].Features.Contains(CentroidY.Name)) continue; double[] centroid=Centroid.getCentroid(layer.Objects[i]); layer.Objects[i].Features.Add(new CentroidX(centroid[0]+location.X)); layer.Objects[i].Features.Add(new CentroidY(centroid[1]+location.Y)); } }
private static void DrawObjectsToImage(Bitmap bitmap, ObjectLayer layer, Color color) { //*** Exception, falls eines der Parameter null ist ********************************************** if (bitmap == null || layer == null || color == null) { throw new NullReferenceException("Parameter ungültig!"); } //*** Exception, falls Bild und Objektebene unterschiedliche Dimension haben ********************* if (bitmap.Width != layer.Map.Width || bitmap.Height != layer.Map.Height) { throw new ArgumentOutOfRangeException("bitmap"); } //*** Bildprozessor anlegen ********************************************************************** using (var processor = new BitmapProcessor(bitmap)) { //*** Über alle Konturpunkte der Objekte iterieren ******************************************* foreach (Point point in layer.Objects.ToArray().SelectMany(imageObject => imageObject.Contour.GetPoints())) { //*** Konturpunkt im Bild auf gegebene Farbe setzen ************************************** processor.SetRed(point.X, point.Y, color.R); processor.SetGreen(point.X, point.Y, color.G); processor.SetBlue(point.X, point.Y, color.B); } } }
private ObjectLayer Execute3rdLevelSegmentation(ObjectLayer l2ndLevel, GrayscaleProcessor gpSobel, GrayscaleProcessor gpH, float targetArea) { List<Contour> finalContours = new List<Contour>(); for (int i = 0; i < l2ndLevel.Objects.Count; i++) { finalContours.Add(l2ndLevel.Objects[i].Contour); } double[] hBackground = this.GetBackgroundHistogram(l2ndLevel, gpH); double[] hForeground = this.GetForegroundHistogram(l2ndLevel, gpH); Parallel.For(0, l2ndLevel.Objects.Count, i => { ImageObject obj = l2ndLevel.Objects[i]; ContourProperties cp = ContourProperties.FromContour(obj.Contour); obj.Features.Add(new Feature("Area", cp.Area)); }); Map map = new Map(gpSobel.Width, gpSobel.Height); Parallel.For(0, gpH.Height, dy => { for (int dx = 0; dx < gpH.Width; dx++) { UInt32 h = gpH[dx, dy]; if (hForeground[h] <= hBackground[h]) continue; UInt32 id = l2ndLevel.Map[dx, dy]; if (id != 0) { ImageObject obj = l2ndLevel.Objects.GetObjectById(id); double area = obj.Features["Area"].Value; if (area > 0.33 * targetArea) continue; } map[dx, dy] = 0xffffffff; } }); ObjectLayer layer = new ConnectedComponentCollector().Execute(map); layer = new ContourOptimizer().RemoveNonCompactPixels(layer, 3); for (int i = 0; i < layer.Objects.Count; i++) { finalContours.Add(layer.Objects[i].Contour); } Contour[] contours = this.Sort(finalContours.ToArray(), gpSobel, gpH, targetArea); layer = this.CreateLayer(gpSobel.Width, gpSobel.Height, contours); Map finalMap = new Map(layer.Map, false); for (int dy = 0; dy < gpH.Height; dy++) for (int dx = 0; dx < gpH.Width; dx++) { if (l2ndLevel.Map[dx, dy] != 0) continue; if (map[dx, dy] != 0) continue; finalMap[dx, dy] = 0; } layer = new ConnectedComponentCollector().Execute(finalMap); layer = new ContourOptimizer().RemoveNonCompactPixels(layer, 3); layer = new ConcaveObjectSeparation().Execute(layer, 0.33, true); double minArea = Math.Max(0.1 * targetArea, MIN_AREA); layer = layer.CreateAbove(obj => { float area = ContourProperties.FromContour(obj.Contour).Area; return area > minArea; }); layer = this.RefillContours(layer); return layer; }
private float GetTargetArea(ObjectLayer layer) { if (layer.Objects.Count == 0) return -1; float targetArea = -1F; List<float> values = new List<float>(); for (int i = 0; i < layer.Objects.Count; i++) { ImageObject obj = layer.Objects[i]; float area = ContourProperties.FromContour(obj.Contour).Area; values.Add(area); } values.Sort(); int index = (int)(0.95 * values.Count); if (values.Count > 0) targetArea = values[index]; return targetArea; }
private ObjectLayer RefillContours(ObjectLayer layer) { Map map = new Map(layer.Map.Width, layer.Map.Height); for (int i = 0; i < layer.Objects.Count; i++) { ImageObject obj = layer.Objects[i]; obj.Contour.Fill(map, obj.Id, true); } layer = new ConnectedComponentCollector().Execute(map); return layer; }
private double[] GetBackgroundHistogram(ObjectLayer layer, GrayscaleProcessor p) { Map map = new Map(p.Width, p.Height); for (int dy = 0; dy < p.Height; dy++) for (int dx = 0; dx < p.Width; dx++) { if (layer.Map[dx, dy] == 0) map[dx, dy] = 1; } double[,] distanceMap = new DistanceTransformation().Execute(map); double[] histogram = new double[256]; for (int dy = 0; dy < p.Height; dy++) for (int dx = 0; dx < p.Width; dx++) { if (map[dx, dy] == 0) continue; if (distanceMap[dx, dy] < 3) continue; histogram[p[dx, dy]]++; } return histogram; }
private double[] GetForegroundHistogram(ObjectLayer layer, GrayscaleProcessor p) { double[] histogram = new double[256]; Parallel.For(0, layer.Objects.Count, i => { int[] objHistogram = this.GetHistogram(layer.Objects[i], p); lock (histogram) { for (int j = 0; j < 256; j++) { int value = objHistogram[j]; histogram[j] += value; } } }); return histogram; }
public static void ProcessLayer(ObjectLayer layer) { Contract.Requires(null!=layer); ProcessLayer(layer,new Point(0,0)); }
public Map(XDocument xDocument) { version = null; orientation = Orientation.Orthogonal; width = 0; height = 0; tileWidth = 0; tileHeight = 0; backgroundColor = Color.black; XElement xMap = xDocument.Element("map"); foreach (XAttribute xAttribute in xMap.Attributes()) switch (xAttribute.Name.ToString()) { case "version": version = (string)xAttribute; break; case "orientation": orientation = (Orientation)Enum.Parse(typeof(Orientation), (string)xAttribute, true); break; case "width": width = (int)xAttribute; break; case "height": height = (int)xAttribute; break; case "tilewidth": tileWidth = (int)xAttribute; break; case "tileheight": tileHeight = (int)xAttribute; break; case "backgroundcolor": backgroundColor = ConvertXColor((string)xAttribute); break; } Tileset tileset; int tilesetLength; int tilesetIndex; TileLayer tileLayer; ObjectLayer objectLayer; ImageLayer imageLayer; List<Tileset> tilesetsList = new List<Tileset>(); List<TileLayer> tileLayersList = new List<TileLayer>(); List<ObjectLayer> objectLayersList = new List<ObjectLayer>(); List<ImageLayer> imageLayersList = new List<ImageLayer>(); List<ILayer> layersList = new List<ILayer>(); List<Property> propertyList = new List<Property>(); foreach (XElement xElement in xMap.Elements()) switch (xElement.Name.ToString()) { case "tileset": tileset = new Tileset(xElement); tilesetLength = tilesetsList.Count; if (tilesetLength == 0) tilesetsList.Add(tileset); else { tilesetIndex = tilesetLength; while (tilesetIndex-- > 0) if (tilesetIndex == 0) tilesetsList.Insert(0, tileset); else if (tileset.firstGID > tilesetsList[tilesetIndex].firstGID) { if (tilesetIndex == tilesetLength - 1) tilesetsList.Add(tileset); else tilesetsList.Insert(tilesetIndex + 1, tileset); } } break; case "layer": tileLayer = new TileLayer(xElement, width, height); tileLayersList.Add(tileLayer); layersList.Add(tileLayer); break; case "objectgroup": objectLayer = new ObjectLayer(xElement); objectLayersList.Add(objectLayer); layersList.Add(objectLayer); break; case "imagelayer": imageLayer = new ImageLayer(xElement); imageLayersList.Add(imageLayer); layersList.Add(imageLayer); break; case "properties": propertyList.AddRange(ConvertXProperties(xElement)); break; } tilesets = tilesetsList.ToArray(); tileLayers = tileLayersList.ToArray(); objectLayers = objectLayersList.ToArray(); imageLayers = imageLayersList.ToArray(); layers = layersList.ToArray(); properties = propertyList.ToArray(); }