protected override void OnInit(EventArgs e)
{
if (Request.QueryString["color"] != null)
{
CreateImage();
return;
}
base.OnInit(e);
if (!IsPostBack)
{
var googleMapsEnabled = true;
var usuario = DAOFactory.UsuarioDAO.FindById(WebSecurity.AuthenticatedUser.Id);
if (usuario != null && usuario.PorEmpresa && usuario.Empresas.Count == 1)
{
var empresa = usuario.Empresas.First() as Empresa;
if (empresa != null)
{
googleMapsEnabled = empresa.GoogleMapsEnabled;
}
}
Monitor1.EnableTimer = false;
Monitor1.Initialize(googleMapsEnabled);
Monitor1.AddLayers(LayerFactory.GetVector(LayerRecorrido, true),
LayerFactory.GetMarkers(LayerEntregas, true));
}
}
private void button_showOnMap_Click(object sender, EventArgs e)
{
List <NamedXyz> coordsB = this.ShowCoordsA;
if (ShowLayer != null && coordsB != null)
{
List <AnyInfo.Geometries.Point> lonlats = new List <AnyInfo.Geometries.Point>();
int i = 1;
foreach (var g in coordsB)
{
var find = this.ShowCoordsB.Find(m => String.Equals(m.Name, g.Name, StringComparison.CurrentCultureIgnoreCase));
if (find == null)
{
continue;
}
var geoCoord = Geo.Coordinates.CoordTransformer.XyzToGeoCoord(g.Value);
var name = find.Name;// + "," + find.Value.ToString();
lonlats.Add(new AnyInfo.Geometries.Point(geoCoord, (i++) + "", name));
}
Layer layer = LayerFactory.CreatePointLayer(lonlats);
ShowLayer(layer);
}
else
{
MessageBox.Show("请先读取！");
}
}
private void GetFeaturesAndAddAttachment()
{
// open the geodatabase
using (var geodatabase = new Geodatabase(@"c:\ProSDKWorkshop\data\generic.gdb"))
{
// open the SamplePoints feature class
var pointFeatureClass = geodatabase.OpenDataset <FeatureClass>("SamplePoints");
// retrieve all features from the feature class
using (var rowCursor = pointFeatureClass.Search())
{
while (rowCursor.MoveNext())
{
// for each feature
using (var currentFeature = rowCursor.Current as Feature)
{
// add the sample picture as an attachment
currentFeature.AddAttachment(new Attachment("SamplePicture", "image/png",
CreateMemoryStreamFromContentsOf(@"c:\ProSDKWorkshop\data\redlands.png")));
}
}
}
}
// add the feature class as a layer to the active map
LayerFactory.CreateFeatureLayer(new Uri(@"c:\ProSDKWorkshop\data\generic.gdb\SamplePoints"), MapView.Active.Map);
}
public object Clone()
{
GeoServicesClass clone = new GeoServicesClass(_dataset);
clone._clonedThemes = new List <IWebServiceTheme>();
var themes = (_clonedThemes != null) ?
_clonedThemes :
(_dataset?._themes ?? new List <IWebServiceTheme>());
foreach (IWebServiceTheme theme in themes)
{
if (theme == null || theme.Class == null)
{
continue;
}
clone._clonedThemes.Add(LayerFactory.Create(
theme.Class,
theme as ILayer, clone) as IWebServiceTheme);
}
clone.BeforeMapRequest = BeforeMapRequest;
clone.AfterMapRequest = AfterMapRequest;
clone.ModifyResponseOuput = ModifyResponseOuput;
return(clone);
}
private void GetFeaturesAndAddAttachment()
{
// TODO
// open the file geodatabase c:\ProSDKWorkshop\data\generic.gdb
using (Geodatabase geodatabase = new Geodatabase(@"c:\ProSDKWorkshop\data\generic.gdb"))
{
using (FeatureClass pointFeatureClass = geodatabase.OpenDataset <FeatureClass>("SamplePoints"))
{
using (RowCursor features = pointFeatureClass.Search())
{
while (features.MoveNext())
{
Feature currentFeature = features.Current as Feature;
currentFeature.AddAttachment(new Attachment("SamplePicture", "image/png",
CreateMemoryStreamFromContentsOf(@"C:\ProSDKWorkshop\data\redlands.png")));
}
}
}
}
// TODO
// open the SamplePoints feature class
// TODO
// retrieve all features by searching the feature class
// TODO
// for each feature add the attachment
// TODO
// add the sample picture as an attachment
// add the feature class as a layer to the active map
LayerFactory.CreateFeatureLayer(new Uri(@"c:\ProSDKWorkshop\data\generic.gdb\SamplePoints"), MapView.Active.Map);
}
private void button_showOnMap_Click(object sender, EventArgs e)
{
if (ShowLayer != null && this.param != null)
{
double time = 0;
OrbitParamCaculator caculator = new OrbitParamCaculator();
List <XYZ> xyzs = new List <XYZ>();
for (int i = 0; i < 500; i++)
{
time = i * 10000;
XYZ xyz = caculator.GetSatPos(param, time);
xyzs.Add(xyz);
}
List <AnyInfo.Geometries.Point> lonlats = new List <AnyInfo.Geometries.Point>();
int j = 0;
foreach (var item in xyzs)
{
GeoCoord geoCoord = CoordTransformer.XyzToGeoCoord(item);
lonlats.Add(new AnyInfo.Geometries.Point(geoCoord, j + ""));
j++;
}
Layer layer = LayerFactory.CreatePointLayer(lonlats);
ShowLayer(layer);
}
}
// Decode a single layer
private static string DecodeLayer(int index, string payload, IDecoder decoder)
{
switch(index)
{
// Decode layer using the appropriate layer logic and selected decoder
case 0:
return LayerFactory.InitializeLayer(LayerEnum.Layer0).Decode(payload, decoder);
case 1:
return LayerFactory.InitializeLayer(LayerEnum.Layer1).Decode(payload, decoder);
case 2:
return LayerFactory.InitializeLayer(LayerEnum.Layer2).Decode(payload, decoder);
case 3:
return LayerFactory.InitializeLayer(LayerEnum.Layer3).Decode(payload, decoder);
case 4:
return LayerFactory.InitializeLayer(LayerEnum.Layer4).Decode(payload, decoder);
case 5:
return LayerFactory.InitializeLayer(LayerEnum.Layer5).Decode(payload, decoder);
default:
throw new ArgumentException("Invalid layer index provided");
}
}
public override void OnClick()
{
if (RuleSetMessage.imagePath != null)
{
ILayer layer = LayerFactory.CreateDefaultLayer(RuleSetMessage.imagePath);
}
}
/// <summary>
/// 建立图层
/// </summary>
/// <returns></returns>
public Layer Build()
{
int index = 0;
List <Point> lonLats = new List <Point>();
foreach (var item in _results.ToArray())
{
index++;
if (index > start)
{
var single = item;
var geoCoord = Geo.Coordinates.CoordTransformer.XyzToGeoCoord(item.Value.Value);
var pt = new Point(geoCoord, index.ToString(), item.Name);
lonLats.Add(pt);
}
}
Layer layer = LayerFactory.CreatePointLayer(lonLats);
foreach (var item in dicData)
{
CreatePtFeature(layer, item.Value, item.Key);
}
layer.FeatureSource.BuildIndexing();
layer.UseLayerStyle = false;
return(layer);
}
private void InitializeMap()
{
Monitor.EnableTimer = false;
Monitor.MultiplePopUps = true;
var googleMapsEnabled = true;
var usuario = DAOFactory.UsuarioDAO.FindById(WebSecurity.AuthenticatedUser.Id);
if (usuario != null && usuario.PorEmpresa && usuario.Empresas.Count == 1)
{
var empresa = usuario.Empresas.First() as Empresa;
if (empresa != null)
{
googleMapsEnabled = empresa.GoogleMapsEnabled;
}
}
Monitor.Initialize(googleMapsEnabled);
Monitor.AddLayers(LayerFactory.GetVector(Layers.Recorrido, true),
LayerFactory.GetVector(Layers.MensajesDuracion, true),
LayerFactory.GetVector(Layers.Geocercas, true),
LayerFactory.GetMarkers(Layers.PuntosDeInteres, true),
LayerFactory.GetMarkers(Layers.Mensajes, true),
LayerFactory.GetMarkers(Layers.Eventos, true));
Monitor.AddControls(ControlFactory.GetToolbar(false, false, false, false, false, true, true));
Monitor.ZoomTo(8);
Monitor.Hide();
//this.RegisterStartupJScript("map", string.Format("var map = $M('{0}');", (object) Monitor.MapDivId));
this.RegisterStartupJScript("map", string.Format("var map = null;", (object)Monitor.MapDivId));
}
public ExtensionLoader(LayerFactory _layerFactory, GeometryFactory _geometryFactory)
{
codeProvider = new CSharpCodeProvider();
compiler = codeProvider.CreateCompiler();
layerFactory = _layerFactory;
geometryFactory = _geometryFactory;
}
/// <summary>
/// Creates Kohonen network architecture with specified number of neurons in
/// input and map layer
/// </summary>
/// <param name="inputNeuronsCount">
/// number of neurons in input layer </param>
/// <param name="outputNeuronsCount">
/// number of neurons in output layer </param>
private void createNetwork(int inputNeuronsCount, int outputNeuronsCount)
{
// specify input neuron properties (use default: weighted sum input with
// linear transfer)
NeuronProperties inputNeuronProperties = new NeuronProperties();
// specify map neuron properties
NeuronProperties outputNeuronProperties = new NeuronProperties(typeof(Neuron), typeof(Difference), typeof(Linear)); // transfer function - input function - neuron type
// set network type
this.NetworkType = NeuralNetworkType.KOHONEN;
// createLayer input layer
Layer inLayer = LayerFactory.createLayer(inputNeuronsCount, inputNeuronProperties);
this.addLayer(inLayer);
// createLayer map layer
Layer mapLayer = LayerFactory.createLayer(outputNeuronsCount, outputNeuronProperties);
this.addLayer(mapLayer);
// createLayer full connectivity between input and output layer
ConnectionFactory.fullConnect(inLayer, mapLayer);
// set network input and output cells
NeuralNetworkFactory.DefaultIO = this;
this.LearningRule = new KohonenLearning();
}
private void AddDataset(IDataset dataset)
{
if (dataset == null || dataset.Elements == null)
{
return;
}
if (dataset.State != DatasetState.opened)
{
if (!dataset.Open())
{
MessageBox.Show("Can't open dataset '" + dataset.DatasetName + "'.\n" + dataset.lastErrorMsg);
return;
}
}
foreach (IDatasetElement element in dataset.Elements)
{
if (element == null)
{
continue;
}
ILayer layer = LayerFactory.Create(element.Class);
dgLayers.Rows.Add(new object[] { true, element.Title, true });
_elements.Add(new DatasetItemElement(dataset, layer));
}
}
public void OnEvent(object element, object dataset)
{
if (!(element is IFeatureLayer) || !(((IFeatureLayer)element).Class is IFeatureClass))
{
return;
}
ExportFeatureClassDialog dlg = new ExportFeatureClassDialog(
((_doc != null && _doc.FocusMap != null) ? _doc.FocusMap.Display : null),
element as IFeatureLayer);
if (dlg.ShowDialog() == DialogResult.OK)
{
IDatasetElement destElement = dlg.DestinationDatasetElement;
if (destElement != null && destElement.Class != null)
{
if (MessageBox.Show("Add new feature class to map?", "Add", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
ILayer layer = LayerFactory.Create(destElement.Class);
_doc.FocusMap.AddLayer(layer, 0);
if (_doc.Application is IMapApplication)
{
((IMapApplication)_doc.Application).RefreshActiveMap(DrawPhase.All);
}
}
}
}
}
protected void InitializeMonitor()
{
Monitor.DrawLine += MonitorDrawLine;
Monitor.FeatureModified += MonitorFeatureModified;
Monitor.EnableTimer = false;
if (IsPostBack)
{
return;
}
Monitor.DrawLineMethod = EventMethods.PostBack;
Monitor.ModFeatureMethod = EventMethods.PostBack;
Monitor.ImgPath = Config.Monitor.GetMonitorImagesFolder(Page);
Monitor.GoogleMapsScript = Config.Map.GoogleMapsKey;
Monitor.AddLayers(LayerFactory.GetGoogleStreet(CultureManager.GetLabel("LAYER_GSTREET"), MinZoomLevel),
//LayerFactory.GetCompumap(CultureManager.GetLabel("LAYER_COMPUMAP"), Config.Map.CompumapTiles, MIN_ZOOM_LEVEL),
LayerFactory.GetOpenStreetMap(CultureManager.GetLabel("LAYER_OSM")),
LayerFactory.GetGoogleSatellite(CultureManager.GetLabel("LAYER_GSAT"), MinZoomLevel),
LayerFactory.GetGoogleHybrid(CultureManager.GetLabel("LAYER_GHIBRIDO"), MinZoomLevel),
LayerFactory.GetGooglePhysical(CultureManager.GetLabel("LAYER_GFISICO"), MinZoomLevel),
LayerFactory.GetVector(LayerRecorrido, true, StyleFactory.GetHandlePoint()),
LayerFactory.GetMarkers(LayerMarkers, true));
Monitor.AddControls(ControlFactory.GetLayerSwitcher(),
ControlFactory.GetNavigation(),
ControlFactory.GetPanZoomBar(),
ControlFactory.GetToolbar(false, false, false, true, false, true, false, false, LayerRecorrido));
if (MapLoad != null)
{
MapLoad(Monitor, EventArgs.Empty);
}
}
private void toolStripButton2_Click(object sender, EventArgs e)
{
SegClassForm segClassForm = new SegClassForm();
segClassForm.ShowDialog();
if (RuleSetMessage.OutShpPath != null || RuleSetMessage.OutClassResultsPath != null)
{
if (RuleSetMessage.OutShpPath != null)
{
ILayer layer = LayerFactory.CreateDefaultLayer(RuleSetMessage.OutShpPath);
if (layer != null)
{
axMapControl2.FocusMap.AddLayer(layer);
axMapControl2.ActiveView.PartialRefresh(ViewDrawPhaseType.ViewAll);
RuleSetMessage.OutShpPath = null;
}
}
else
{
ILayer layer = LayerFactory.CreateDefaultLayer(RuleSetMessage.OutClassResultsPath);
if (layer != null)
{
axMapControl2.FocusMap.AddLayer(layer);
axMapControl2.ActiveView.PartialRefresh(ViewDrawPhaseType.ViewAll);
RuleSetMessage.OutClassResultsPath = null;
}
}
}
}
private async Task <string> UploadImpl()
{
// Create EsriHttpClient object
var httpClient = new EsriHttpClient();
// Upload vtpk file to the currently active portal
var itemToUpload = ItemFactory.Create(FilePath);
var tags = new string[] { "ArcGIS Pro", "SDK", "UploadVtpkToAgol Demo" };
var portalUrl = ArcGISPortalManager.Current.GetActivePortal().PortalUri.ToString();
var result = httpClient.Upload(
portalUrl, itemToUpload, string.Empty, tags);
if (result.Item1 == false)
{
return($@"Unable to upload this item: {FilePath} to ArcGIS Online");
}
string userName = ArcGISPortalManager.Current.GetActivePortal().GetSignOnUsername();
string query = $@"q=owner:{userName} tags:""UploadVtpkToAgol Demo"" ";
// Once uploaded make another REST call to search for the uploaded data
var searchUrl = new UriBuilder(portalUrl)
{
Path = "sharing/rest/search",
Query = $@"{query}&f=json"
};
var searchResults = httpClient.Get(searchUrl.Uri.ToString());
dynamic resultItems = JObject.Parse(await searchResults.Content.ReadAsStringAsync());
long numberOfTotalItems = resultItems.total.Value;
if (numberOfTotalItems == 0)
{
return($@"Unable to find uploaded item with query: {query}");
}
var resultItemList = new List <dynamic>();
resultItemList.AddRange(resultItems.results);
//get the first result
dynamic item = resultItemList[0];
// Create an item from the search results
string itemId = item.id;
var currentItem = ItemFactory.Create(itemId, ItemFactory.ItemType.PortalItem);
// Finally add the feature service to the map
// if we have an item that can be turned into a layer
// add it to the map
if (LayerFactory.CanCreateLayerFrom(currentItem))
{
LayerFactory.CreateLayer(currentItem, MapView.Active.Map);
}
return($@"Uploaded this item: {FilePath} to ArcGIS Online and added the item to the Map");
}
/// <summary>
/// Creates MultiLayerPerceptron Network architecture - fully connected
/// feed forward with specified number of neurons in each layer
/// </summary>
/// <param name="neuronsInLayers"> collection of neuron numbers in getLayersIterator </param>
/// <param name="neuronProperties"> neuron properties </param>
private void createNetwork(List <int> neuronsInLayers, NeuronProperties neuronProperties)
{
// set network type
this.NetworkType = NeuralNetworkType.MULTI_LAYER_PERCEPTRON;
// create input layer
NeuronProperties inputNeuronProperties = new NeuronProperties(typeof(InputNeuron), typeof(Linear));
Layer layer = LayerFactory.createLayer(neuronsInLayers[0], inputNeuronProperties);
bool useBias = true; // use bias neurons by default
if (neuronProperties.hasProperty("useBias"))
{
useBias = (bool)neuronProperties.getProperty("useBias");
}
if (useBias)
{
layer.addNeuron(new BiasNeuron());
}
this.addLayer(layer);
// create layers
Layer prevLayer = layer;
//for(Integer neuronsNum : neuronsInLayers)
for (int layerIdx = 1; layerIdx < neuronsInLayers.Count; layerIdx++)
{
int neuronsNum = neuronsInLayers[layerIdx];
// createLayer layer
layer = LayerFactory.createLayer(neuronsNum, neuronProperties);
if (useBias && (layerIdx < (neuronsInLayers.Count - 1)))
{
layer.addNeuron(new BiasNeuron());
}
// add created layer to network
this.addLayer(layer);
// createLayer full connectivity between previous and this layer
if (prevLayer != null)
{
ConnectionFactory.fullConnect(prevLayer, layer);
}
prevLayer = layer;
}
// set input and output cells for network
NeuralNetworkFactory.DefaultIO = this;
// set learnng rule
// this.setLearningRule(new BackPropagation());
this.LearningRule = new MomentumBackpropagation();
// this.setLearningRule(new DynamicBackPropagation());
this.randomizeWeights(new RangeRandomizer(-0.7, 0.7));
}
public Task <IDatasetElement> Element(string title)
{
if (_fc != null)
{
return(Task.FromResult <IDatasetElement>(LayerFactory.Create(_fc)));
}
return(Task.FromResult <IDatasetElement>(null));
}
/// <summary>
/// Adds a layer to the current map using the given path or url
/// </summary>
/// <remarks>Gets run in the worker thread</remarks>
/// <param name="uri"></param>
/// <returns></returns>
public Task <Layer> AddLayer(string uri)
{
return(QueuedTask.Run(() =>
{
Map map = MapView.Active.Map;
return LayerFactory.CreateLayer(new Uri(uri), map);
}));
}
private void PrepareLanguages(LayerFactory layerFactory)
{
mapLanguageTextBox.Leave += (_, __) => layerFactory.MapLanguage = mapLanguageTextBox.Text;
layerFactory.MapLanguage = mapLanguageTextBox.Text;
trafficIncidentsLanguageTextBox.Leave += (_, __) => layerFactory.UserLanguage = trafficIncidentsLanguageTextBox.Text;
layerFactory.UserLanguage = trafficIncidentsLanguageTextBox.Text;
}
public void Bind()
{
var windowFactory = new WindowFactory();
var popUpFactory = new PopUpFactory();
var factory = new LayerFactory(windowFactory, popUpFactory);
_managerUi.Bind(factory);
}
private void button_showOnMap_Click(object sender, EventArgs e)
{
if (ShowLayer != null && lonLats.Count != 0)
{
Layer layer = LayerFactory.CreatePointLayer(lonLats);
ShowLayer(layer);
}
}
private void button_showOnMap_Click(object sender, EventArgs e)
{
if (showPointLayer != null && points != null)
{
Layer layer = LayerFactory.CreatePointLayer(points);
showPointLayer(layer);
}
}
protected async override void OnClick()
{
//TODO - Get the URL of the Active Portal
//HINT: Use PortalManager
string portalUrl = PortalManager.GetActivePortal().ToString();
UriBuilder searchURL = new UriBuilder(portalUrl);
searchURL.Path = "sharing/rest/search";
string layers = "(type:\"Map Service\" OR type:\"Image Service\" OR type:\"Feature Service\" OR type:\"WMS\" OR type:\"KML\")";
//any public layer content
searchURL.Query = string.Format("q={0}&f=json", layers);
EsriHttpClient httpClient = new EsriHttpClient();
var searchResponse = httpClient.Get(searchURL.Uri.ToString());
dynamic resultItems = JObject.Parse(await searchResponse.Content.ReadAsStringAsync());
//Use EsriHttpClient to call Online - Use the GET method
//TODO get the JSON result from the searchResponse
//HINT - examine methoods of searchResponse.Content
//TODO Parse the returned JSON - here you will use the Newtonsoft library's JObject
//examine JObject.Parse. Use a dynamic type to get the results of the Parse
long numberOfTotalItems = resultItems.total.Value;
if (numberOfTotalItems == 0)
{
return;
}
List <dynamic> resultItemList = new List <dynamic>();
resultItemList.AddRange(resultItems.results);
//TODO add the ".results" of the returned JSON.
//eg: resultItemList.AddRange(resultItems.results);
//get the first result from resultItemList (or an index of your choice)
//dynamic item = ....
dynamic item = resultItemList[0];
//TODO create an Item via the ItemFactory. Use the ItemFactory.ItemType.PortalItem item type.
string itemID = item.id;
Item currentItem = ItemFactory.Create(itemID, ItemFactory.ItemType.PortalItem);
await QueuedTask.Run(() => {
// if we have an item that can be turned into a layer
// add it to the map
//TODO use the LayerFactory.CreateLayer and the MapView.Active.Map
if (LayerFactory.CanCreateLayerFrom(currentItem))
{
LayerFactory.CreateLayer(currentItem, MapView.Active.Map);
}
});
}
private void button_drawOnMap_Click(object sender, EventArgs e)
{
if (ShowLayer != null && Headers != null)
{
List <AnyInfo.Geometries.Point> lonlats = GetPoints(Headers);
Layer layer = LayerFactory.CreatePointLayer(lonlats);
ShowLayer(layer);
}
}
public void InitLayers(Transform layersParent)
{
m_UILayers = new UILayer[(int)UILayerType.TYPE_MAX];
m_UILayers[(int)UILayerType.TYPE_BASE] = LayerFactory.CreateUILayer(UILayerType.TYPE_BASE, layersParent);
m_UILayers[(int)UILayerType.TYPE_POP] = LayerFactory.CreateUILayer(UILayerType.TYPE_POP, layersParent);
m_UILayers[(int)UILayerType.TYPE_MESSAGE] = LayerFactory.CreateUILayer(UILayerType.TYPE_MESSAGE, layersParent);
m_UILayers[(int)UILayerType.TYPE_DEATH] = LayerFactory.CreateUILayer(UILayerType.TYPE_DEATH, layersParent);
pop_Layer = m_UILayers[(int)UILayerType.TYPE_POP];
}
public Task <List <IDatasetElement> > Elements()
{
List <IDatasetElement> elements = new List <IDatasetElement>();
if (_fc != null)
{
elements.Add(LayerFactory.Create(_fc));
}
return(Task.FromResult(elements));
}
// Prosessoi kaikki layerit.
private void ProcessLayers(List <Tuple <string, int> > drawOrderPairs, IEnumerable <BaseSerializedLayer> serializedLayers)
{
LayerFactory layerFactory = new LayerFactory(game, map.TileEngine);
SheetFactory sheetFactory = new SheetFactory();
foreach (BaseSerializedLayer serializedLayer in serializedLayers)
{
// alustaa layerin
Size size = new Size(serializedLayer.Width, serializedLayer.Height);
ILayer layer = layerFactory.MakeNew(serializedLayer);
// alustaa tilejen parametrit ja indeksoi ne
TileParameters tileParameters = GetRightTileParameters(serializedLayer, map.TileEngine);
// jos layeri on tilayeri, tehdään sille tile sheetti
if (serializedLayer is SerializedTileLayer)
{
SerializedTileLayer tileLayer = serializedLayer as SerializedTileLayer;
layer.Sheet = sheetFactory.MakeNew(layer.GetType(), new object[]
{
tileLayer.SheetPath, contentManager, map.TileEngine
});
}
// jos layeri on animaatio layeri, tehdään sille animaatio sheetti
else if (serializedLayer is SerializedAnimationLayer)
{
SerializedAnimationLayer animationLayer = serializedLayer as SerializedAnimationLayer;
layer.Sheet = sheetFactory.MakeNew(layer.GetType(), new object[]
{
animationLayer.SheetPath, contentManager, map.TileEngine,
new AnimationManager(animationLayer.AnimationManager.FrameCount, animationLayer.AnimationManager.FrameTime)
});
}
// alustaa layerin ja sen tilet
layer.Initialize(tileParameters);
// lisää layerin managerille
map.LayerManager.AddLayer(layer);
// jos layeri ei ole rule, otetaan sen draworder huomioon
if (!(layer is Layer <RuleTile>))
{
AddDrawOrder(drawOrderPairs, serializedLayer);
}
// prosessoidaan objectit jos layeri sisältää objecti tilejä
if (layer is Layer <ObjectTile> )
{
ProcessMapObjects(serializedLayer, layer);
}
// rakennetaan componentit layerille lopuksi
ComponentBuilder componentBuilder = new ComponentBuilder(game);
layer.Components.AddComponents(componentBuilder.BuildComponents(layer));
}
}
private List <BikeTouringGISLayer> GetLayers(string path)
{
var gpxData = GetGPXData(path);
_vm.AddPoIs(gpxData.WayPoints);
var layerFactory = new LayerFactory(gpxData.WayPointsExtent);
_vm.AddRoutes(layerFactory.CreateRoutes("unittest", gpxData.Routes));
_vm.BikeTouringGISLayers = new ObservableCollection <BikeTouringGISLayer>(_vm.Map.GetBikeTouringGISLayers());
return(_vm.BikeTouringGISLayers.ToList());
}
