/// <summary>
/// Disposes the map object
/// </summary>
public void Dispose()
{
_disposing = true;
AbortFetch();
if (DisposeLayersOnDispose)
{
if (Layers != null)
{
foreach (var disposable in Layers.OfType <IDisposable>())
{
disposable.Dispose();
}
}
if (BackgroundLayer != null)
{
foreach (var disposable in BackgroundLayer.OfType <IDisposable>())
{
disposable.Dispose();
}
}
}
Layers?.Clear();
BackgroundLayer?.Clear();
}
/// <summary>
/// Disposes the map object
/// </summary>
public void Dispose()
{
if (DisposeLayersOnDispose)
{
if (Layers != null)
{
foreach (ILayer layer in Layers)
{
if (layer is IDisposable)
{
((IDisposable)layer).Dispose();
}
}
}
if (BackgroundLayer != null)
{
foreach (ILayer layer in BackgroundLayer)
{
if (layer is IDisposable)
{
((IDisposable)layer).Dispose();
}
}
}
if (VariableLayers != null)
{
foreach (ILayer layer in VariableLayers)
{
if (layer is IDisposable)
{
((IDisposable)layer).Dispose();
}
}
}
}
if (Layers != null)
{
Layers.Clear();
}
if (BackgroundLayer != null)
{
BackgroundLayer.Clear();
}
if (VariableLayers != null)
{
VariableLayers.Clear();
}
}
/// <summary>
/// Clears all layers and sets all outputs to 0 (off).
/// </summary>
public override void Reset()
{
Layers.Clear();
if (_OutputRed != null)
{
_OutputRed.Value = 0;
}
if (_OutputGreen != null)
{
_OutputGreen.Value = 0;
}
if (_OutputBlue != null)
{
_OutputBlue.Value = 0;
}
}
void DisposeRenderTarget()
{
using (var l = _lock.TryLock())
{
if (l == null)
{
// We are still trying to render on the render thread, try again a bit later
DispatcherTimer.RunOnce(DisposeRenderTarget, TimeSpan.FromMilliseconds(50),
DispatcherPriority.Background);
return;
}
Layers.Clear();
RenderTarget?.Dispose();
RenderTarget = null;
}
}
private void RefreshLayerCollection()
{
Layers.Clear();
if (_activeMap == null)
{
return;
}
var layers = _activeMap.GetLayersAsFlattenedList().OfType <BasicFeatureLayer>();
lock (_lock)
{
foreach (var layer in layers)
{
Layers.Add(layer);
}
}
}
public void Open(string path)
{
using (Stream stream = new FileStream(path, FileMode.Open))
{
BinaryReader reader = new BinaryReader(stream);
int version = reader.ReadInt32();
string guid = reader.ReadString();
RegisteredTemplates.Template template = RegisteredTemplates.Instance.FindTemplate(guid);
if (template == null)
{
MessageBox.Info(string.Format("Template {0} is not registered.", guid));
return;
}
if (template.Path.IsNullOrEmpty())
{
using (Stream templateStream = ContentLoader.Current.Open("Templates/SampleTemplate.zip"))
{
CurrentTemplate.Instance.Load(templateStream);
}
}
else
{
using (Stream templateStream = new FileStream(template.Path, FileMode.Open))
{
CurrentTemplate.Instance.Load(templateStream);
}
}
New();
Layers.Clear();
ReadVersion1(reader);
_layerIndex = Layers.Count + 1;
Layers[Layers.Count - 1].Selected.Value = true;
}
FilePath = path;
FileName = Path.GetFileNameWithoutExtension(path);
}
private void EditorStateHandler(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName != "SelectedProfile")
{
return;
}
// Update editor enabled state
NotifyOfPropertyChange(() => EditorEnabled);
// Update interface
Layers.Clear();
if (SelectedProfile != null)
{
Layers.AddRange(SelectedProfile.Layers);
}
NotifyOfPropertyChange(() => ProfileSelected);
}
private UIElement CreateRadioButton(ISample sample)
{
var radioButton = new RadioButton
{
FontSize = 16,
Content = sample.Name,
Margin = new Thickness(4)
};
radioButton.Click += (s, a) => {
MapControl.Map !.Layers.Clear();
MapControl.Info -= MapOnInfo;
sample.Setup(MapControl);
MapControl.Info += MapOnInfo;
MapControl.Refresh();
};
return(radioButton);
}
private async Task AggiungiLayers(params UserControl[] layers)
{
layers = layers ?? new UserControl[] { };
Layers.Clear();
foreach (var layer in layers)
{
Layers.Add(layer);
}
//var delay = layers.OfType<ICanvasView>().DefaultIfEmpty().Max(c => c.Delay);
var delay = TimeSpan.Zero;
if (delay < TimeSpan.FromMilliseconds(500))
{
delay = TimeSpan.FromMilliseconds(500);
}
await Task.Delay(delay);
}
public ArcImsDataFrame(ArcImsService service, DataFrameInfo dataFrameInfo)
{
_dataFrameInfo = dataFrameInfo;
Service = service;
Dpi = service.ServiceInfo.Environment.Screen.Dpi;
Name = dataFrameInfo.Name;
IsDefault = dataFrameInfo.Default;
foreach (LayerInfo layerInfo in dataFrameInfo.LayerInfos.Reverse <LayerInfo>())
{
Layers.Add(new ArcImsLayer(this, layerInfo));
}
CreateLayerHierarchy();
List <CommonLayer> topLayers = TopLevelLayers;
Layers.Clear();
AddLayersFromHierarchy(topLayers);
}
public static void Compile(List <Protocol> protocols)
{
Layers.Clear();
ProgramSet.RuleProgram.Clear();
var rootLayer = new ProgramLayer();
rootLayer.AddProtocol(ProtocolLibrary.GetRoot());
Layers.Add(rootLayer);
foreach (var p in protocols)
{
AddProtocol(p);
}
Validate();
//generate the program set beased on statically available Layers var
ProgramSet.Generate();
}
private void UpdateLayerList(LayerModel selectModel)
{
// Update the UI
Layers.Clear();
if (SelectedProfile != null)
{
Layers.AddRange(SelectedProfile.Layers);
}
if (selectModel == null)
{
return;
}
// A small delay to allow the profile list to rebuild
Task.Factory.StartNew(() =>
{
Thread.Sleep(20);
ProfileViewModel.SelectedLayer = selectModel;
});
}
public void UpdateMap() // newly 20140624
{
Layers.Clear();
Children.Clear();
TempLayers.ForEach(x => x.Children.Clear());
LabelLayers.ForEach(x => x.Children.Clear());
foreach (VectorLayer layer in Map.Layers)
{
var mLayer = new DrawingMapLayer(); // mod 20130302
//MapLayer mLayer = new MapLayer();
mLayer.SetData(layer);
mLayer.AppendProperties(); // newly 20120319
Layers.Add(mLayer);
Children.Add(mLayer);
}
TempLayers.ForEach(x => this.Children.Add(x));
LabelLayers.ForEach(x => this.Children.Add(x));
RenderLayers();
}
/// <summary>
/// Unloads local content then calls <see cref="OnUnloadContent()"/> for inheriting controls.
/// </summary>
protected void UnloadContent()
{
_brushes.Cleanup();
_brushes = null;
_fonts.Cleanup();
_fonts = null;
foreach (var layer in Layers)
{
layer.UnloadContent();
var disposableLayer = layer as IDisposable;
if (disposableLayer != null)
{
disposableLayer.Dispose();
}
}
Layers.Clear();
OnUnloadContent();
}
private void ButtonRestoreNetworkParams_OnClick(object sender, RoutedEventArgs e)
{
Layers.Clear();
UpDownInputLayerSize.Value = Defaults.Default.InputLayerSize;
UpDownOutputLayerSize.Value = Defaults.Default.OutputLayerSize;
for (var i = 0; i < Defaults.Default.HiddenLayers.Length; i++)
{
Layers.Add(new LayerModel {
LayerNo = i + 1, Size = Defaults.Default.HiddenLayers[i]
});
}
RangeSliderWeight.LowerValue = Defaults.Default.MinWeight;
RangeSliderWeight.UpperValue = Defaults.Default.MaxWeight;
UpDownBias.Value = Defaults.Default.Bias;
ComboBoxActivationFunction.SelectedItem = Defaults.Default.ActivationFunction;
UpDownT.Value = Defaults.Default.T;
}
private void GetLayers()
{
Layers.Clear();
if (_activeMap == null)
{
return;
}
ReportName = $"Report_{_activeMap.Name}";
var layers = _activeMap.GetLayersAsFlattenedList().OfType <FeatureLayer>();
//if (layers.Count == 0)
// return;
lock (_lock)
{
foreach (var layer in layers)
{
lock (_lock)
Layers.Add(layer);
}
}
SelectedLayer = Layers.Count > 0 ? Layers[0] : null;
}
private void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
foreach (Entity e in Entities)
{
e.Dispose();
}
if (Tileset != null)
{
Tileset.Dispose();
}
Layers.Clear();
}
Layers = null;
Tileset = null;
Entities = null;
}
_disposed = true;
}
private void InitializeNeuralNetworkSettings()
{
Layers.Clear();
UpDownInputLayerSize.Value = Settings.Default.InputLayerSize;
UpDownOutputLayerSize.Value = Settings.Default.OutputLayerSize;
for (var i = 0; i < Settings.Default.HiddenLayers.Length; i++)
{
Layers.Add(new LayerModel {
LayerNo = i + 1, Size = Settings.Default.HiddenLayers[i]
});
}
RangeSliderWeight.LowerValue = Settings.Default.MinWeight;
RangeSliderWeight.UpperValue = Settings.Default.MaxWeight;
UpDownBias.Value = Settings.Default.Bias;
ComboBoxActivationFunction.SelectedItem = Settings.Default.ActivationFunction;
UpDownT.Value = Settings.Default.T;
}
public void New()
{
new Tools.Select();
_nextIndex++;
FileName = string.Format("New {0}", _nextIndex);
FilePath = null;
Layers.Clear();
foreach (var layer in CurrentTemplate.Instance.Layers)
{
DocLayer generated = layer.Generate();
Layers.Add(generated);
if (layer.Selected)
{
Select(generated);
}
}
_layerIndex = Layers.Count + 1;
IsModified = false;
}
/// <summary>
/// Handles refreshing the layer preview
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void PropertyChangeHandler(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "KeyboardPreview")
{
return;
}
if (e.PropertyName == "SelectedLayer")
{
NotifyOfPropertyChange(() => LayerSelected);
return;
}
if (SelectedProfile != null)
{
ProfileProvider.AddOrUpdate(SelectedProfile);
}
if (e.PropertyName != "SelectedProfile")
{
return;
}
// Update editor enabled state
NotifyOfPropertyChange(() => EditorEnabled);
// Update ProfileViewModel
ProfileViewModel.SelectedProfile = SelectedProfile;
// Update interface
Layers.Clear();
if (SelectedProfile != null)
{
Layers.AddRange(SelectedProfile.Layers);
}
NotifyOfPropertyChange(() => ProfileSelected);
}
public void InitializeMap(Map map)
{
Map = map;
Layers.Clear();
Children.Clear();
TempLayers.ForEach(x => x.Children.Clear());
LabelLayers.ForEach(x => x.Children.Clear());
foreach (VectorLayer layer in map.Layers)
{
var mLayer = new DrawingMapLayer(); // mod 20130302
//MapLayer mLayer = new MapLayer();
mLayer.SetData(layer);
mLayer.AppendProperties(); // newly 20120319
Layers.Add(mLayer);
Children.Add(mLayer);
}
TempLayers.ForEach(x => this.Children.Add(x));
LabelLayers.ForEach(x => this.Children.Add(x));
this.ZoomExtents();
InitialScale = Scale;
OnLayersChanged();
}
public static void Clear()
{
Layers.Clear();
ProgramSet = new ProgramSet();
}
public void Reset()
{
Layers.Clear();
SelectedLayer = null;
}
/// <summary>
/// Clear out the configuration
/// </summary>
/// <param name="args"></param>
private void OnProjectOpened(ProjectEventArgs args)
{
Maps.Clear();
Layers.Clear();
}
///////////////////////////////////////////////////////////////////////////
/// <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)
{
Debug.WriteLine("LoadLayers started at " + reader.BaseStream.Position.ToString(CultureInfo.InvariantCulture));
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);
}
Layers.Clear();
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;
var positionOffset = reader.BaseStream.Position - endPosition;
Debug.Assert(positionOffset > -4,
"LoadLayers did not read the full length of the Layers Info section.");
Debug.Assert(positionOffset <= 0,
"LoadLayers read past the end of the Layers Info section.");
if (reader.BaseStream.Position < endPosition)
{
reader.BaseStream.Position = endPosition;
}
}
}
/// <summary> /// Clears all layers in this cell /// </summary> public void ClearLayers() => Layers.Clear();
protected override void Generate()
{
var planet = this;
var sun = StellarBody;
var mass = GasMass + DustMass;
planet.OrbitZone = Science.Astronomy.GetOrbitalZone(sun.Luminosity, SemiMajorAxis);
planet.OrbitalPeriod = Science.Astronomy.GetPeriod(SemiMajorAxis, mass, sun.Mass);
planet.AxialTilt = GetRandomInclination(SemiMajorAxis);
planet.ExosphereTemperature = Science.Thermodynamics.GetEstimatedExosphereTemperature(SemiMajorAxis, sun.EcosphereRadius, sun.Temperature);
planet.RMSVelocity = Science.Physics.GetRMSVelocity(Mass.FromGrams(GlobalConstants.MOL_NITROGEN), ExosphereTemperature);
planet.CoreRadius = Science.Planetology.GetCoreRadius(DustMass, OrbitZone, false);
// Calculate the radius as a gas giant, to verify it will retain gas.
// Then if mass > Earth, it's at least 5% gas and retains He, it's
// some flavor of gas giant.
planet.Density = Science.Physics.GetDensityFromStar(mass, SemiMajorAxis, sun.EcosphereRadius, true);
planet.Radius = Mathematics.GetRadiusFromVolume(mass, Density);
planet.SurfaceAcceleration = GetAcceleration(mass, Radius);
//planet.SurfaceGravityG = Environment.Gravity(planet.SurfaceAcceleration);
planet.MolecularWeightRetained = Science.Physics.GetMolecularWeightRetained(SurfaceAcceleration, mass, Radius, ExosphereTemperature, sun.Age);
// Is the planet a gas giant?
if (Science.Planetology.TestIsGasGiant(mass, GasMass, MolecularWeightRetained))
{
//Type = GetGasGiantType(MassSM, GasMassSM);
AdjustPropertiesForGasBody();
SurfacePressure = Pressure.Zero;
Layers.Clear();
Layers.Add(new BasicGiantGaseousLayer(Radius).Generate(this, GasMass, new Chemical[0], Layers));
}
else // If not, it's rocky.
{
Radius = Science.Planetology.GetCoreRadius(mass, OrbitZone, false);
Density = Science.Physics.GetDensityFromBody(mass, Radius);
// Radius has changed, we need to adjust Surfa
SurfaceAcceleration = GetAcceleration(mass, Radius);
//SurfaceGravityG = Environment.Gravity(SurfaceAcceleration);
AdjustPropertiesForRockyBody();
MolecularWeightRetained = Science.Physics.GetMolecularWeightRetained(SurfaceAcceleration, mass, Radius, ExosphereTemperature, sun.Age);
}
planet.AngularVelocity = Science.Dynamics.GetAngularVelocity(mass,
Radius,
Density,
SemiMajorAxis,
Science.Planetology.TestIsGasGiant(Mass, GasMass, MolecularWeightRetained),
sun.Mass,
sun.Age);
planet.DayLength = Science.Astronomy.GetDayLength(planet.AngularVelocity, planet.OrbitalPeriod, planet.Eccentricity);
planet.HasResonantPeriod = Science.Planetology.TestHasResonantPeriod(planet.AngularVelocity, planet.DayLength, planet.OrbitalPeriod, planet.Eccentricity);
planet.EscapeVelocity = Science.Dynamics.GetEscapeVelocity(mass, planet.Radius);
planet.VolatileGasInventory = Science.Physics.GetVolatileGasInventory(mass,
EscapeVelocity,
RMSVelocity,
sun.Mass,
GasMass,
OrbitZone,
HasGreenhouseEffect);
planet.HillSphere = Science.Astronomy.GetHillSphere(sun.Mass, mass, planet.SemiMajorAxis);
if (!Science.Planetology.TestIsGasGiant(mass, GasMass, MolecularWeightRetained))
{
Pressure surfpres = Science.Physics.GetSurfacePressure(planet.VolatileGasInventory, planet.Radius, planet.SurfaceAcceleration);
// Calculate all atmosphere layers total mass.
if (GasMass == Mass.Zero)
{
Area surf = Area.FromSquareKilometers(4.0 * Math.PI * Math.Pow(planet.Radius.Kilometers, 2.0));
GasMass = Mass.FromKilograms(surf.SquareMeters * surfpres.NewtonsPerSquareMeter / planet.SurfaceAcceleration.MetersPerSecondSquared);
}
planet.BoilingPointWater = Science.Thermodynamics.GetBoilingPointWater(surfpres);
// Sets: planet.surf_temp, planet.greenhs_rise, planet.albedo, planet.hydrosphere,
// planet.cloud_cover, planet.ice_cover
AdjustSurfaceTemperatures(surfpres);
planet.IsTidallyLocked = Science.Planetology.TestIsTidallyLocked(DayLength, OrbitalPeriod);
// Add basic Burrows layer.
Layers.Add(new BasicSolidLayer(CoreRadius).Generate(this, DustMass, new Chemical[0], new Layer[0]));
// Generate complete atmosphere.
if (surfpres.Millibars > 0.0 && GasMass.SolarMasses > 0.0)
{
Layers.Add(new BasicGaseousLayer(Radius - CoreRadius, surfpres).Generate(this, GasMass, Chemical.All.Values.ToArray(), Layers));
}
SurfacePressure = surfpres;
HasGreenhouseEffect = Science.Planetology.TestHasGreenhouseEffect(sun.EcosphereRadius, SemiMajorAxis) & SurfacePressure > Pressure.Zero;
}
Type = Science.Planetology.GetBodyType(Mass,
GasMass,
MolecularWeightRetained,
SurfacePressure,
WaterCoverFraction,
IceCoverFraction,
MaxTemperature,
BoilingPointWater,
Temperature);
IsForming = false;
}
/// <summary>
/// Resets this viewmodel to its default values.
/// </summary>
public void Reset()
{
Layers.Clear();
AddRgb = false;
RgbContrastEnhancement = false;
}
public void Clear()
{
Layers.Clear();
Sources.Clear();
}
//清除所有图层
public void ClearLayers()
{
Layers.Clear();
SelectedLayer = -1;
}
