/// <summary>
/// 添加等级符号专题图
/// Add the theme of graduated symbol
/// </summary>
public void ThemeRangeThemeDisplay()
{
try
{
Map map = m_mapControl.Map;
Layers layers = map.Layers;
Int32 count = layers.Count;
Datasources datasources = m_workspace.Datasources;
Datasource datasource = datasources[0];
Datasets datasets = datasource.Datasets;
DatasetVector datasetVector = datasets["BaseMap_R"] as DatasetVector;
ThemeGraduatedSymbol themeGraduatedSymbol = new ThemeGraduatedSymbol();
themeGraduatedSymbol.Expression = "Urban";
themeGraduatedSymbol.BaseValue = 150.00000;
themeGraduatedSymbol.GraduatedMode = GraduatedMode.SquareRoot;
themeGraduatedSymbol.IsFlowEnabled = false;
GeoStyle geoStyle = themeGraduatedSymbol.PositiveStyle;
geoStyle.LineColor = Color.Pink;
m_layer = layers.Add(datasetVector, themeGraduatedSymbol, true);
m_themeLayerName = m_layer.Name;
m_mapControl.Map.Refresh();
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
}
}
private void BuildNetwork(Matrix <double> trainingSetInput, Matrix <double> trainingSetOutput, List <int> hiddenLayersWidth)
{
int inputLayerWidth = trainingSetInput.ColumnCount; //Number of variables of the input
int outputLayerWidth = trainingSetOutput.ColumnCount; //Number of variables of the output
Layers.Clear();
Layers.Add(new Layer(inputLayerWidth, hiddenLayersWidth[0], "INPUT"));
Layers[0].SetLayerNeuronNames(NetworkGraphics.InputNames);
for (int i = 0; i < hiddenLayersWidth.Count; i++)
{
if (i == hiddenLayersWidth.Count - 1) //Last Hidden Layer
{
Layers.Add(new Layer(hiddenLayersWidth[i], outputLayerWidth, "HIDDEN" + i));
}
else
{
Layers.Add(new Layer(hiddenLayersWidth[i], hiddenLayersWidth[i + 1], "HIDDEN" + i));
}
}
Layers.Add(new Layer(outputLayerWidth, 0, "OUTPUT")); //LastLayer
Layers[Layers.Count - 1].SetLayerNeuronNames(NetworkGraphics.OutputNames);
}
public Room2()
{
Layers.Add(new ObjectLayer()
{
Name = "Object layer 69"
});
}
public LayeredImage(Int32 width, Int32 height)
{
_width = width;
_height = height;
_layers = new Layers(this);
_checkerboard = new Bitmap(32, 32, PixelFormat.Format24bppRgb);
Color darkgray = Color.FromArgb(102, 102, 102);
Color lightgray = Color.FromArgb(153, 153, 153);
for (Int32 i = 0; i < 32; i++)
{
for (Int32 j = 0; j < 32; j++)
{
if ((i < 16 && j < 16) || (i >= 16 && j >= 16))
{
_checkerboard.SetPixel(j, i, lightgray);
}
else
{
_checkerboard.SetPixel(j, i, darkgray);
}
}
}
Layer bglayer = _layers.Add();
Graphics g = Graphics.FromImage(bglayer._bitmap._bitmap);
TextureBrush brush = new TextureBrush(_checkerboard);
g.FillRectangle(brush, 0, 0, _width, _height);
brush.Dispose();
g.Dispose();
}
public Canvas()
{
Highlights = new Layer();
Selections = new Layer();
CurrentLayer = new Layer();
Layers.Add(CurrentLayer);
}
private void PopulateLayers()
{
char[] pixelData = EncodedImageData.ToCharArray();
Console.WriteLine($"total - {pixelData.Length} per layer - {(Width * Height)} num layers - {(pixelData.Length / (Width * Height))}");
int layerCount = pixelData.Length / (Width * Height);
int pixelsManaged = 0;
for (int i = 1; i <= layerCount; i++)
{
ImageLayer layer = new ImageLayer(i);
layer.Pixels = new int[Width, Height];
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
char pixel = pixelData[pixelsManaged];
layer.Pixels[x, y] = Int32.Parse(pixel.ToString());
if (layer.LayerNumber == 1)
{
Console.WriteLine($"{x},{y} - {pixel}");
}
pixelsManaged++;
}
}
Layers.Add(layer);
}
}
private void AddLocation(Location location)
{
BasicGeoposition position = new BasicGeoposition
{
Latitude = location.Latitude,
Longitude = location.Longitude,
Altitude = location.Altitude
};
Geopoint point = new Geopoint(position);
var marker = new MapIcon
{
Location = point,
NormalizedAnchorPoint = new Point(0.5, 1.0),
Title = location.Name,
ZIndex = 0,
};
Elements.Add(marker);
var LandmarksLayer = new MapElementsLayer
{
ZIndex = 1,
MapElements = Elements
};
Layers.Add(LandmarksLayer);
SelectLocation(marker);
}
/// <summary>
/// Creates a new map with values.
/// </summary>
/// <param name="width">The width in tiles.</param>
/// <param name="height">The height in tiles.</param>
/// <param name="tileWidth">The tilewidth in pixels.</param>
/// <param name="tileHeight">The tileheight in pixels.</param>
/// <param name="tilesetPath">The path to the tileset.</param>
public void CreateNew(short width, short height, short tileWidth, short tileHeight, string tilesetPath)
{
for (int i = 0; i < 9; ++i)
{
Scripts.Add("");
}
// create a base layer:
Layer layer = new Layer();
layer.CreateNew(width, height);
Layers.Add(layer);
// create a starting tile:
Tileset = new Tileset();
if (string.IsNullOrEmpty(tilesetPath))
{
Tileset.CreateNew(tileWidth, tileHeight);
}
else
{
Tileset = Tileset.FromFile(tilesetPath);
Scripts[0] = Path.GetFileName(tilesetPath);
}
}
public void CreateHiddenLayers(int[] hiddenLayersNeurons, int lastHiddenLayerNeurons)
{
int layersCount = hiddenLayersNeurons.Length;
for (int layer = 0; layer < layersCount; layer++)
{
Layer hiddenLayer = new Layer();
for (int i = 0; i < hiddenLayersNeurons[layer]; i++)
{
Neuron neuron = new Neuron();
if (layer == hiddenLayersNeurons.Length - 1)
{
neuron.GenerateWeights(lastHiddenLayerNeurons, randomWeight);
}
else
{
neuron.GenerateWeights(hiddenLayersNeurons[layer + 1], randomWeight);
}
hiddenLayer.Neurons.Add(neuron);
}
Layers.Add(hiddenLayer);
}
}
public bool AddLayer()
{
try
{
NameForm form = new NameForm(Layers);
if (form.ShowDialog(this) == DialogResult.OK)
{
Layer layer = new Layer(Layers.Lib, form.InputText);
layer.Init(AppLayer);
if (Layers.Add(layer))
{
this.UpdateList(layer);
if (AutoSave)
{
using (Context context = Lib.GetContext()) layer.Save(context);
}
if (OnLayerAdded != null)
{
OnLayerAdded(this, new LayerEventArgs(layer));
}
return(true);
}
else
{
string s = Locale.Get("_notuniquename") + ": " + layer.Name;
MessageBox.Show(s);
}
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
return(false);
}
public void AddNewLayer(string name)
{
Layers.Add(new Layer {
Name = name, Index = Layers.Count()
});
_SelectedLayer = 1;
}
public void ctor(XmlElement xml, Atlas atlas, float delay, Action onDoneSlide = null, MapMetaCompleteScreen meta = null)
{
// Translates to : this(xml, atlas, delay, onDoneSlide)
ctor(xml, atlas, delay, onDoneSlide);
this.meta = meta;
if (meta != null)
{
StartScroll = meta.Start;
CenterScroll = meta.Center;
Offset = meta.Offset;
Layers.Clear();
if (meta.Layers != null && meta.Layers.Length > 0)
{
foreach (MapMetaCompleteScreenLayer layer in meta.Layers)
{
if (!string.IsNullOrEmpty(layer.Type) && layer.Type.Equals("ui", StringComparison.CurrentCultureIgnoreCase))
{
HasUI = true;
Layers.Add(new UILayerNoXML(this, layer));
continue;
}
Layers.Add(new ImageLayerNoXML(Offset, atlas, layer));
}
}
}
// Let's just hope that the running SlideRoutine takes the changes into account.
}
private void Layers_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
for (int i = 0; i < e.NewItems.Count; i++)
{
LayerVM addedVM = (LayerVM)e.NewItems[i];
LayerVM craftedVM = adapter(addedVM);
if (e.NewItems.Count == 0)
{
Layers.Add(craftedVM);
}
else
{
Layers.Insert(e.NewStartingIndex + i, craftedVM);
}
}
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
if (e.OldItems.Count != 1)
{
throw new InvalidOperationException();
}
Layers.RemoveAt(e.OldStartingIndex);
break;
default:
throw new NotImplementedException();
}
}
public FpsController(Game game) : base(game)
{
var layer = new Layer("FpsLayer");
layer.AddDrawable(new FpsCounter("Fonts\\Courier New", new Vector2(20, 20)));
Layers.Add(layer);
}
private void CreateLayers(int[] layers)
{
Layer lastLayer = null;
for (int i = 0; i < layers.Length; i++)
{
int nrOfOutputs = layers[i];
Layer layer = new Layer();
if (i == 0)
{
layer.Create(this, nrOfOutputs);
}
else
{
int nrOfInputs = layers[i - 1];
layer.Create(this, nrOfOutputs, nrOfInputs);
// ading the neighbors layers references
layer.Previous = lastLayer;
lastLayer.Next = layer;
}
lastLayer = layer;
Layers.Add(layer);
}
}
public ItemsHitTestSpec(IEnumerable <IItemsLayer> layers,
IEnumerable <ISpatialItem> spatialItems, bool boundaryOnly = false,
bool topmostOnly = false, bool selectedItemsOnly = false,
bool activeItemsOnly = false)
{
if (layers != null)
{
LimitLayers = true;
foreach (IItemsLayer layer in layers)
{
Layers.Add(layer);
}
}
if (spatialItems != null)
{
LimitItems = true;
foreach (ISpatialItem item in spatialItems)
{
SpatialItems.Add(item);
}
}
BoundaryOnly = boundaryOnly;
TopmostOnly = topmostOnly;
SelectedItemsOnly = selectedItemsOnly;
ActiveItemsOnly = activeItemsOnly;
}
void OnDeserialized(StreamingContext context)
{
if (!Layers.Any(lyr => lyr.Handler.GetType().Equals(typeof(Aurora.Settings.Layers.WrapperLightsLayerHandler))))
{
Layers.Add(new Layer("Wrapper Lighting", new Aurora.Settings.Layers.WrapperLightsLayerHandler()));
}
}
/// <summary>
/// Adds a new layer to the mipmap, conserving the ordering by rejected radius.
/// </summary>
/// <param name="maxRadius"></param>
public void AddLayer(float maxRadius)
{
Layers.Add(new MipMapLayer <T>(Width, Height, maxRadius));
// sort the list by radii so that when adding objects, one can iterate over the list and always find the layer with the objects with smallest radius on top.
Layers = Layers.OrderByDescending(layer => layer.MaxRadius).ToList();
}
/// <summary>
/// Creates a new layer with bottom x axis and left y axis, which is not linked.
/// </summary>
public void CreateNewLayerNormalBottomXLeftY()
{
XYPlotLayer newlayer = new XYPlotLayer(DefaultLayerPosition, DefaultLayerSize);
newlayer.CreateDefaultAxes();
Layers.Add(newlayer);
}
public HelixDependencyConfigurationProvider(XmlNode configNode)
{
if (configNode == null)
{
return;
}
var layers = configNode.ChildNodes.OfType <XmlElement>()
.Where(node => node.NodeType == XmlNodeType.Element && node.Name.Equals("layer"));
foreach (var layer in layers)
{
Layers.Add(XmlActivator.CreateObject <IHelixLayer>(layer));
}
foreach (var helixLayer in Layers)
{
var dependencies = helixLayer.DependsOn?.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
if (dependencies != null)
{
foreach (var dependency in dependencies)
{
var dep = Layers.FirstOrDefault(p =>
p.Name.Equals(dependency, StringComparison.InvariantCultureIgnoreCase));
helixLayer.DependentLayers.Add(dep as HelixLayer);
}
}
}
}
///////////////////////////////////////////////////////////////////////////
/// <summary>
/// Load Layers Info section, including image data.
/// </summary>
/// <param name="reader">PSD reader.</param>
/// <param name="hasHeader">Whether the Layers Info section has a length header.</param>
private void LoadLayers(PsdBinaryReader reader, bool hasHeader)
{
UInt32 sectionLength = 0;
if (hasHeader)
{
sectionLength = reader.ReadUInt32();
if (sectionLength <= 0)
{
return;
}
}
var startPosition = reader.BaseStream.Position;
var numLayers = reader.ReadInt16();
// If numLayers < 0, then number of layers is absolute value,
// and the first alpha channel contains the transparency data for
// the merged result.
if (numLayers < 0)
{
AbsoluteAlpha = true;
numLayers = Math.Abs(numLayers);
}
if (numLayers == 0)
{
return;
}
for (int i = 0; i < numLayers; i++)
{
var layer = new Layer(reader, this);
Layers.Add(layer);
}
//-----------------------------------------------------------------------
// Load image data for all channels.
foreach (var layer in Layers)
{
foreach (var channel in layer.Channels)
{
channel.LoadPixelData(reader);
}
}
// Length is set to 0 when called on higher bitdepth layers.
if (sectionLength > 0)
{
// Layers Info section is documented to be even-padded, but Photoshop
// actually pads to 4 bytes.
var endPosition = startPosition + sectionLength;
if (reader.BaseStream.Position < endPosition)
{
reader.BaseStream.Position = endPosition;
}
}
}
protected override void LoadView(ControlInfo controlInfo)
{
//Map
ViewLayer.GlobeCamera.CameraDistance = GeoHelper.EarthRadius + 23;
ViewLayer.GlobeCamera.GoToPlace(GlobeCamera.Places.SaintPetersburg_VO);
ViewLayer.GlobeCamera.Parameters.MinCameraDistance = GeoHelper.EarthRadius + 1;
ViewLayer.GlobeCamera.Parameters.MaxCameraDistance = GeoHelper.EarthRadius + 100;
tiles = new TilesGisLayer(Game, ViewLayer.GlobeCamera)
{
IsVisible = true
};
tiles.SetMapSource(TilesGisLayer.MapSource.Dark);
tiles.ZOrder = 2000;
Layers.Add(new GisLayerWrapper(tiles));
//Touch
Game.Touch.Tap += p =>
{
bool clear = false;
for (int i = 0; i < frames.Count; i++)
{
var f = frames[i];
if (f.sendToHell)
{
f.Parent.Remove(f);
f = null;
clear = true;
}
}
//if (clear) frames.Clear();
onMouseClick(p.Position.X, p.Position.Y);
};
Game.Touch.Manipulate += OnManipulate;
var frame = (Panel as GisPanel).Frame;
frame.Click += (sender, args) => {
bool clear = false;
for (int i = 0; i < frames.Count; i++)
{
var f = frames[i];
if (f.sendToHell)
{
f.Parent.Remove(f);
f = null;
clear = true;
}
}
//if (clear) frames.Clear();
onMouseClick(args.X, args.Y);
};
//Data
//VK
initPosts();
frames = new List <WebPostFrame>();
}
/// <summary>
/// Adds layer to the rule set.
/// </summary>
/// <param name="layer"></param>
public void Add(RuleLayer layer)
{
layerIndexer++;
layer.Set = this;
layer.PositionNumber = layerIndexer;
Layers.Add(layer);
}
public Document(IEnumerable <Layer> layers)
{
foreach (var l in layers)
{
Layers.Add(l);
}
Layers.CollectionChanged += AddLayer;
}
/// <summary>
/// Adds layer to the decision option set.
/// </summary>
/// <param name="layer"></param>
public void Add(DecisionOptionLayer layer)
{
layerIndexer++;
layer.Set = this;
layer.PositionNumber = layerIndexer;
Layers.Add(layer);
}
public void AddLayer(string name)
{
Layers.Add(new MapLayer(name));
if (Tag != null)
{
Tag.CacheAddLayer();
}
}
/// <summary>
/// Adds a layer to this Rhythm, if the rhythm already has MaxLayers layers does nothing.
/// </summary>
public Rhythm AddLayer(string layer)
{
if (Layers.Count < MidiDefaults.Layers)
{
Layers.Add(layer);
}
return(this);
}
public Network(int depth)
{
for (int i = 0; i < depth; i++)
{
int order = (int)Math.Pow(2, i);
Layers.Add(new Layer[order, order]);
}
}
public void AddNewAnswerLayer(int offset, GraphicalAnswerLayer answerLayer)
{
var layerViewModel = new Layer(this, lessonModel, answerLayer);
Layers.Add(new KeyValuePair <int, Layer>(offset, layerViewModel));
CurrentLayerIndex = Layers.Count - 1; // Select the last Layer (which is the Answer Layer)
CurrentLayer.DisplaySaliencyMap(); // Compile SaliencyMap for the Layer
}
protected override void addLayers()
{
Layers.Add(new Layer(content.Load <Texture2D>("Backgrounds/Level1/layer_07_2048 x 1546"), new Rectangle(0, 0, 5120, 1730)));
Layers.Add(new Layer(content.Load <Texture2D>("Backgrounds/Level1/layer_05_1920 x 1080"), new Rectangle(0, 0, 5120, 2230)));
Layers.Add(new Layer(content.Load <Texture2D>("Backgrounds/Level1/layer_04_1920 x 1080"), new Rectangle(0, 0, 5120, 2230)));
Layers.Add(new Layer(content.Load <Texture2D>("Backgrounds/Level1/layer_03_1920 x 1080"), new Rectangle(0, 0, 5120, 2290)));
Layers.Add(new Layer(content.Load <Texture2D>("Backgrounds/Level1/layer_01_1920 x 1080"), new Rectangle(0, 0, 5120, 1730)));
}
/**
<summary>Populates a PDF file with contents.</summary>
*/
private void Populate(
Document document
)
{
// Initialize a new page!
Page page = new Page(document);
document.Pages.Add(page);
// Initialize the primitive composer (within the new page context)!
PrimitiveComposer composer = new PrimitiveComposer(page);
composer.SetFont(new StandardType1Font(document, StandardType1Font.FamilyEnum.Helvetica, true, false), 12);
// Initialize the block composer (wrapping the primitive one)!
BlockComposer blockComposer = new BlockComposer(composer);
// Initialize the document layer configuration!
LayerDefinition layerDefinition = document.Layer;
document.PageMode = Document.PageModeEnum.Layers; // Shows the layers tab on document opening.
// Get the root layers collection!
Layers rootLayers = layerDefinition.Layers;
// 1. Nested layers.
{
Layer nestedLayer = new Layer(document, "Nested layers");
rootLayers.Add(nestedLayer);
Layers nestedSubLayers = nestedLayer.Layers;
Layer nestedLayer1 = new Layer(document, "Nested layer 1");
nestedSubLayers.Add(nestedLayer1);
Layer nestedLayer2 = new Layer(document, "Nested layer 2");
nestedSubLayers.Add(nestedLayer2);
nestedLayer2.Locked = true;
/*
NOTE: Text in this section is shown using PrimitiveComposer.
*/
composer.BeginLayer(nestedLayer);
composer.ShowText(nestedLayer.Title, new PointF(50, 50));
composer.End();
composer.BeginLayer(nestedLayer1);
composer.ShowText(nestedLayer1.Title, new PointF(50, 75));
composer.End();
composer.BeginLayer(nestedLayer2);
composer.ShowText(nestedLayer2.Title, new PointF(50, 100));
composer.End();
}
// 2. Simple group (labeled group of non-nested, inclusive-state layers).
{
Layers simpleGroup = new Layers(document, "Simple group");
rootLayers.Add(simpleGroup);
Layer layer1 = new Layer(document, "Grouped layer 1");
simpleGroup.Add(layer1);
Layer layer2 = new Layer(document, "Grouped layer 2");
simpleGroup.Add(layer2);
/*
NOTE: Text in this section is shown using BlockComposer along with PrimitiveComposer
to demonstrate their flexible cooperation.
*/
blockComposer.Begin(new RectangleF(50, 125, 200, 50), XAlignmentEnum.Left, YAlignmentEnum.Middle);
composer.BeginLayer(layer1);
blockComposer.ShowText(layer1.Title);
composer.End();
blockComposer.ShowBreak(new SizeF(0, 15));
composer.BeginLayer(layer2);
blockComposer.ShowText(layer2.Title);
composer.End();
blockComposer.End();
}
// 3. Radio group (labeled group of non-nested, exclusive-state layers).
{
Layers radioGroup = new Layers(document, "Radio group");
rootLayers.Add(radioGroup);
Layer radio1 = new Layer(document, "Radiogrouped layer 1");
radioGroup.Add(radio1);
radio1.Visible = true;
Layer radio2 = new Layer(document, "Radiogrouped layer 2");
radioGroup.Add(radio2);
radio2.Visible = false;
Layer radio3 = new Layer(document, "Radiogrouped layer 3");
radioGroup.Add(radio3);
radio3.Visible = false;
// Register this option group in the layer configuration!
LayerGroup options = new LayerGroup(document);
options.Add(radio1);
options.Add(radio2);
options.Add(radio3);
layerDefinition.OptionGroups.Add(options);
/*
NOTE: Text in this section is shown using BlockComposer along with PrimitiveComposer
to demonstrate their flexible cooperation.
*/
blockComposer.Begin(new RectangleF(50, 185, 200, 75), XAlignmentEnum.Left, YAlignmentEnum.Middle);
composer.BeginLayer(radio1);
blockComposer.ShowText(radio1.Title);
composer.End();
blockComposer.ShowBreak(new SizeF(0, 15));
composer.BeginLayer(radio2);
blockComposer.ShowText(radio2.Title);
composer.End();
blockComposer.ShowBreak(new SizeF(0, 15));
composer.BeginLayer(radio3);
blockComposer.ShowText(radio3.Title);
composer.End();
blockComposer.End();
}
// 4. Print-only layer.
{
Layer printOnlyLayer = new Layer(document, "Print-only layer");
printOnlyLayer.Visible = false;
printOnlyLayer.Printable = true;
printOnlyLayer.Locked = true;
rootLayers.Add(printOnlyLayer);
composer.BeginLayer(printOnlyLayer);
composer.ShowText(printOnlyLayer.Title, new PointF(50, 270));
composer.End();
}
composer.Flush();
}
public LayeredImage(Int32 width, Int32 height)
{
_width = width;
_height = height;
_layers = new Layers(this);
// checker board brush
_checkerboard = new Bitmap(32, 32, PixelFormat.Format24bppRgb);
Color darkgray = Color.FromArgb(102,102,102);
Color lightgray = Color.FromArgb(153,153,153);
for (Int32 i = 0; i < 32; i++) {
for (Int32 j = 0; j < 32; j++) {
if ((i < 16 && j < 16) || (i >= 16 && j >= 16))
_checkerboard.SetPixel(j, i, lightgray);
else
_checkerboard.SetPixel(j, i, darkgray);
}
}
// background layer
Layer bglayer = _layers.Add();
Graphics g = Graphics.FromImage(bglayer._bitmap._bitmap);
TextureBrush brush = new TextureBrush(_checkerboard);
g.FillRectangle(brush, 0, 0, _width, _height);
brush.Dispose();
g.Dispose();
}
