Ejemplo n.º 1
0
        public IHttpActionResult PostLayoutSettings(LayoutSettings layoutSettings)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.LayoutSettings.Add(layoutSettings);

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateException)
            {
                if (LayoutSettingsExists(layoutSettings.Id))
                {
                    return(Conflict());
                }
                else
                {
                    throw;
                }
            }

            return(CreatedAtRoute("DefaultApi", new { id = layoutSettings.Id }, layoutSettings));
        }
Ejemplo n.º 2
0
 public void Assign(LayoutSettings settings)
 {
     TextColor = settings.TextColor;
     BackgroundColor = settings.BackgroundColor;
     BackgroundColor2 = settings.BackgroundColor2;
     ThinSeparatorsColor = settings.ThinSeparatorsColor;
     SeparatorsColor = settings.SeparatorsColor;
     PersonalBestColor = settings.PersonalBestColor;
     AheadGainingTimeColor = settings.AheadGainingTimeColor;
     AheadLosingTimeColor = settings.AheadLosingTimeColor;
     BehindGainingTimeColor = settings.BehindGainingTimeColor;
     BehindLosingTimeColor = settings.BehindLosingTimeColor;
     BestSegmentColor = settings.BestSegmentColor;
     NotRunningColor = settings.NotRunningColor;
     PausedColor = settings.PausedColor;
     ShadowsColor = settings.ShadowsColor;
     TimerFont = settings.TimerFont.Clone() as Font;
     TimesFont = settings.TimesFont.Clone() as Font;
     TextFont = settings.TextFont.Clone() as Font;
     ShowBestSegments = settings.ShowBestSegments;
     AlwaysOnTop = settings.AlwaysOnTop;
     AntiAliasing = settings.AntiAliasing;
     DropShadows = settings.DropShadows;
     Opacity = settings.Opacity;
     BackgroundGradient = settings.BackgroundGradient;
 }
Ejemplo n.º 3
0
        public ActionResult Settings(ViewLayoutSettings LayoutSetting)
        {
            if (LayoutSetting.LayoutSettingsList != null)
            {
                for (int i = 0; i < LayoutSetting.LayoutSettingsList.Count; i++)
                {
                    LayoutSettings data = db.LayoutSettings.Find(LayoutSetting.LayoutSettingsList[i].ltSId);
                    data.ltSContent = LayoutSetting.LayoutSettingsList[i].ltSContent;
                    db.SaveChanges();
                }
            }
            if (LayoutSetting.DeviceIO != null)
            {
                for (int i = 0; i < LayoutSetting.DeviceIO.Count; i++)
                {
                    DeviceIO data = db.DeviceIO.Find(LayoutSetting.DeviceIO[i].ioId);
                    data.ioName     = LayoutSetting.DeviceIO[i].ioName;
                    data.ioPortName = LayoutSetting.DeviceIO[i].ioPortName;
                    data.ioValType  = LayoutSetting.DeviceIO[i].ioValType;
                    db.SaveChanges();
                }
            }

            return(RedirectToAction("Index"));
        }
Ejemplo n.º 4
0
        public IHttpActionResult PutLayoutSettings([Bind(Include = "WidgetsColumnSide,WidgetList")] LayoutSettings layoutSettings)
        {
            layoutSettings.Id = CurrentUser.CurrentBlogId.Value;
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.Entry(layoutSettings).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!LayoutSettingsExists(layoutSettings.Id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Ejemplo n.º 5
0
        private static XmlElement ToElement(XmlDocument document, LayoutSettings settings)
        {
            var element = document.CreateElement("Settings");

            element.AppendChild(SettingsHelper.ToElement(document, settings.TextColor, "TextColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.BackgroundColor, "BackgroundColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.BackgroundColor2, "BackgroundColor2"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.ThinSeparatorsColor, "ThinSeparatorsColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.SeparatorsColor, "SeparatorsColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.PersonalBestColor, "PersonalBestColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.AheadGainingTimeColor, "AheadGainingTimeColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.AheadLosingTimeColor, "AheadLosingTimeColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.BehindGainingTimeColor, "BehindGainingTimeColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.BehindLosingTimeColor, "BehindLosingTimeColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.BestSegmentColor, "BestSegmentColor"));
            element.AppendChild(SettingsHelper.ToElement(document, "UseRainbowColor", settings.UseRainbowColor));
            element.AppendChild(SettingsHelper.ToElement(document, settings.NotRunningColor, "NotRunningColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.PausedColor, "PausedColor"));
            element.AppendChild(SettingsHelper.ToElement(document, settings.ShadowsColor, "ShadowsColor"));
            element.AppendChild(SettingsHelper.CreateFontElement(document, "TimesFont", settings.TimesFont));
            element.AppendChild(SettingsHelper.CreateFontElement(document, "TimerFont", settings.TimerFont));
            element.AppendChild(SettingsHelper.CreateFontElement(document, "TextFont", settings.TextFont));
            element.AppendChild(SettingsHelper.ToElement(document, "AlwaysOnTop", settings.AlwaysOnTop));
            element.AppendChild(SettingsHelper.ToElement(document, "ShowBestSegments", settings.ShowBestSegments));
            element.AppendChild(SettingsHelper.ToElement(document, "AntiAliasing", settings.AntiAliasing));
            element.AppendChild(SettingsHelper.ToElement(document, "DropShadows", settings.DropShadows));
            element.AppendChild(SettingsHelper.ToElement(document, "BackgroundType", settings.BackgroundType));
            element.AppendChild(SettingsHelper.ToElement(document, "BackgroundImagePath", settings.BackgroundImagePath));
            element.AppendChild(SettingsHelper.ToElement(document, "ImageOpacity", settings.ImageOpacity));
            element.AppendChild(SettingsHelper.ToElement(document, "ImageBlur", settings.ImageBlur));
            element.AppendChild(SettingsHelper.ToElement(document, "Opacity", settings.Opacity));
            return(element);
        }
Ejemplo n.º 6
0
        public Monitor(Rect workArea, Size monitorSize)
        {
            Window   = new LayoutOverlayWindow();
            Settings = new LayoutSettings();

            // provide a good default for vertical monitors
            if (monitorSize.Height > monitorSize.Width)
            {
                Settings.Type = LayoutType.Rows;
            }

            Device = new Device(workArea, monitorSize);

            if (App.DebugMode)
            {
                long           milliseconds = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
                PropertyInfo[] properties   = typeof(Brushes).GetProperties();
                Window.Opacity    = 0.5;
                Window.Background = (Brush)properties[milliseconds % properties.Length].GetValue(null, null);
            }

            Window.KeyUp   += ((App)Application.Current).App_KeyUp;
            Window.KeyDown += ((App)Application.Current).App_KeyDown;

            Window.Left   = workArea.X;
            Window.Top    = workArea.Y;
            Window.Width  = workArea.Width;
            Window.Height = workArea.Height;
        }
Ejemplo n.º 7
0
 public object Clone()
 {
     return(new LiveSplitState()
     {
         Run = Run.Clone() as IRun,
         Form = Form,
         Layout = Layout.Clone() as ILayout,
         Settings = Settings.Clone() as ISettings,
         LayoutSettings = LayoutSettings.Clone() as LayoutSettings,
         AdjustedStartTime = AdjustedStartTime,
         StartTimeWithOffset = StartTimeWithOffset,
         StartTime = StartTime,
         TimePausedAt = TimePausedAt,
         GameTimePauseTime = GameTimePauseTime,
         isGameTimePaused = isGameTimePaused,
         LoadingTimes = LoadingTimes,
         CurrentPhase = CurrentPhase,
         CurrentSplitIndex = CurrentSplitIndex,
         CurrentComparison = CurrentComparison,
         CurrentHotkeyProfile = CurrentHotkeyProfile,
         CurrentTimingMethod = CurrentTimingMethod,
         AttemptStarted = AttemptStarted,
         AttemptEnded = AttemptEnded
     });
 }
Ejemplo n.º 8
0
 private static int ToElement(XmlDocument document, XmlElement element, LayoutSettings settings)
 {
     return(SettingsHelper.CreateSetting(document, element, "TextColor", settings.TextColor) ^
            SettingsHelper.CreateSetting(document, element, "BackgroundColor", settings.BackgroundColor) ^
            SettingsHelper.CreateSetting(document, element, "BackgroundColor2", settings.BackgroundColor2) ^
            SettingsHelper.CreateSetting(document, element, "ThinSeparatorsColor", settings.ThinSeparatorsColor) ^
            SettingsHelper.CreateSetting(document, element, "SeparatorsColor", settings.SeparatorsColor) ^
            SettingsHelper.CreateSetting(document, element, "PersonalBestColor", settings.PersonalBestColor) ^
            SettingsHelper.CreateSetting(document, element, "AheadGainingTimeColor", settings.AheadGainingTimeColor) ^
            SettingsHelper.CreateSetting(document, element, "AheadLosingTimeColor", settings.AheadLosingTimeColor) ^
            SettingsHelper.CreateSetting(document, element, "BehindGainingTimeColor", settings.BehindGainingTimeColor) ^
            SettingsHelper.CreateSetting(document, element, "BehindLosingTimeColor", settings.BehindLosingTimeColor) ^
            SettingsHelper.CreateSetting(document, element, "BestSegmentColor", settings.BestSegmentColor) ^
            SettingsHelper.CreateSetting(document, element, "UseRainbowColor", settings.UseRainbowColor) ^
            SettingsHelper.CreateSetting(document, element, "NotRunningColor", settings.NotRunningColor) ^
            SettingsHelper.CreateSetting(document, element, "PausedColor", settings.PausedColor) ^
            SettingsHelper.CreateSetting(document, element, "ShadowsColor", settings.ShadowsColor) ^
            SettingsHelper.CreateSetting(document, element, "TimesFont", settings.TimesFont) ^
            SettingsHelper.CreateSetting(document, element, "TimerFont", settings.TimerFont) ^
            SettingsHelper.CreateSetting(document, element, "TextFont", settings.TextFont) ^
            SettingsHelper.CreateSetting(document, element, "AlwaysOnTop", settings.AlwaysOnTop) ^
            SettingsHelper.CreateSetting(document, element, "ShowBestSegments", settings.ShowBestSegments) ^
            SettingsHelper.CreateSetting(document, element, "AntiAliasing", settings.AntiAliasing) ^
            SettingsHelper.CreateSetting(document, element, "DropShadows", settings.DropShadows) ^
            SettingsHelper.CreateSetting(document, element, "BackgroundType", settings.BackgroundType) ^
            SettingsHelper.CreateSetting(document, element, "BackgroundImage", settings.BackgroundImage) ^
            SettingsHelper.CreateSetting(document, element, "ImageOpacity", settings.ImageOpacity) ^
            SettingsHelper.CreateSetting(document, element, "ImageBlur", settings.ImageBlur) ^
            SettingsHelper.CreateSetting(document, element, "Opacity", settings.Opacity));
 }
Ejemplo n.º 9
0
        private void LoadThingsPoBarcode(TblAssetsViewModel asset)
        {
            DisplayBarcodeUsercontrol = new ObservableCollection <DisplayingBarcodeToPrintUserControl>();

            var assetLayout = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 13);

            DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(asset.Code, assetLayout, LayoutSettings, null));
            var newcan = new Canvas();

            foreach (var barcodes in DisplayBarcodeUsercontrol)
            {
                if (PrintingFlag)
                {
                    newcan.Children.Add(barcodes);
                }
                if (!PrintingFlag)
                {
                    CanvasPreview.Children.Add(barcodes);
                }
            }

            if (PrintingFlag)
            {
                print(newcan);
                //     CanvasList.Add(Newcan);
            }
        }
Ejemplo n.º 10
0
        private XmlElement ToElement(XmlDocument document, LayoutSettings settings)
        {
            var element = document.CreateElement("Settings");

            element.AppendChild(ToElement(document, settings.TextColor, "TextColor"));
            element.AppendChild(ToElement(document, settings.BackgroundColor, "BackgroundColor"));
            element.AppendChild(ToElement(document, settings.BackgroundColor2, "BackgroundColor2"));
            element.AppendChild(ToElement(document, settings.ThinSeparatorsColor, "ThinSeparatorsColor"));
            element.AppendChild(ToElement(document, settings.SeparatorsColor, "SeparatorsColor"));
            element.AppendChild(ToElement(document, settings.PersonalBestColor, "PersonalBestColor"));
            element.AppendChild(ToElement(document, settings.AheadGainingTimeColor, "AheadGainingTimeColor"));
            element.AppendChild(ToElement(document, settings.AheadLosingTimeColor, "AheadLosingTimeColor"));
            element.AppendChild(ToElement(document, settings.BehindGainingTimeColor, "BehindGainingTimeColor"));
            element.AppendChild(ToElement(document, settings.BehindLosingTimeColor, "BehindLosingTimeColor"));
            element.AppendChild(ToElement(document, settings.BestSegmentColor, "BestSegmentColor"));
            element.AppendChild(ToElement(document, settings.NotRunningColor, "NotRunningColor"));
            element.AppendChild(ToElement(document, settings.PausedColor, "PausedColor"));
            element.AppendChild(ToElement(document, settings.ShadowsColor, "ShadowsColor"));

            element.AppendChild(CreateFontElement(document, "TimesFont", settings.TimesFont));
            element.AppendChild(CreateFontElement(document, "TimerFont", settings.TimerFont));
            element.AppendChild(CreateFontElement(document, "TextFont", settings.TextFont));

            element.AppendChild(ToElement(document, "AlwaysOnTop", settings.AlwaysOnTop));
            element.AppendChild(ToElement(document, "ShowBestSegments", settings.ShowBestSegments));
            element.AppendChild(ToElement(document, "AntiAliasing", settings.AntiAliasing));
            element.AppendChild(ToElement(document, "DropShadows", settings.DropShadows));
            element.AppendChild(ToElement(document, "BackgroundGradient", settings.BackgroundGradient));

            element.AppendChild(ToElement(document, "Opacity", settings.Opacity));

            return(element);
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Method to format PDF
        /// </summary>
        /// <param name="layoutSettings">the layoutsettings</param>
        /// <param name="data">data object</param>
        public async Task <LayoutSettings> FormatPdf(LayoutSettings layoutSettings, object data)
        {
            if (data is SvarPaaNabovarselType)
            {
                if (layoutSettings.Components == null || layoutSettings.Components.ExcludeFromPdf == null)
                {
                    layoutSettings.Components = new Components()
                    {
                        ExcludeFromPdf = new List <string>()
                    };
                }

                SvarPaaNabovarselType svar = data as SvarPaaNabovarselType;
                if (svar.eiendomByggested == null)
                {
                    layoutSettings.Components.ExcludeFromPdf.Add("a23234234");
                }
                else
                {
                    layoutSettings.Components.ExcludeFromPdf.Add("basdf23234234");
                }
            }

            return(await Task.FromResult(layoutSettings));
        }
Ejemplo n.º 12
0
 public GameSettings(LayoutSettings layoutSettings, VisualSettings visualSettings, GameplaySettings gameplaySettings, BuildingDescriptionDatabase buildingDescriptionDatabase, LanguageSettings languageSettings)
 {
     LayoutSettings              = layoutSettings;
     VisualSettings              = visualSettings;
     GameplaySettings            = gameplaySettings;
     BuildingDescriptionDatabase = buildingDescriptionDatabase;
     LanguageSettings            = languageSettings;
 }
Ejemplo n.º 13
0
        public void SerializeAppliedLayouts()
        {
            Logger.LogTrace();

            AppliedLayoutsListWrapper layouts = new AppliedLayoutsListWrapper {
            };

            layouts.AppliedLayouts = new List <AppliedLayoutWrapper>();

            // Serialize used layouts
            foreach (var monitor in App.Overlay.Monitors)
            {
                LayoutSettings zoneset = monitor.Settings;
                if (zoneset.ZonesetUuid.Length == 0)
                {
                    continue;
                }

                layouts.AppliedLayouts.Add(new AppliedLayoutWrapper
                {
                    Device = new AppliedLayoutWrapper.DeviceIdWrapper
                    {
                        Monitor         = monitor.Device.MonitorName,
                        MonitorInstance = monitor.Device.MonitorInstanceId,
                        MonitorNumber   = monitor.Device.MonitorNumber,
                        SerialNumber    = monitor.Device.MonitorSerialNumber,
                        VirtualDesktop  = monitor.Device.VirtualDesktopId,
                    },

                    AppliedLayout = new AppliedLayoutWrapper.LayoutWrapper
                    {
                        Uuid              = zoneset.ZonesetUuid,
                        Type              = LayoutTypeToJsonTag(zoneset.Type),
                        ShowSpacing       = zoneset.ShowSpacing,
                        Spacing           = zoneset.Spacing,
                        ZoneCount         = zoneset.ZoneCount,
                        SensitivityRadius = zoneset.SensitivityRadius,
                    },
                });
            }

            // Serialize unused layouts
            foreach (var device in _unusedLayouts)
            {
                layouts.AppliedLayouts.Add(device);
            }

            try
            {
                string jsonString = JsonSerializer.Serialize(layouts, _options);
                _fileSystem.File.WriteAllText(FancyZonesAppliedLayoutsFile, jsonString);
            }
            catch (Exception ex)
            {
                Logger.LogError("Serialize applied layouts error", ex);
                App.ShowExceptionMessageBox(Properties.Resources.Error_Applying_Layout, ex);
            }
        }
Ejemplo n.º 14
0
        private bool SetAppliedLayouts(List <AppliedLayoutWrapper> layouts)
        {
            Logger.LogTrace();

            if (layouts == null)
            {
                return(false);
            }

            bool result   = true;
            var  monitors = App.Overlay.Monitors;

            foreach (var layout in layouts)
            {
                if (layout.Device.Monitor == null ||
                    layout.Device.Monitor.Length == 0 ||
                    layout.Device.VirtualDesktop == null ||
                    layout.Device.VirtualDesktop.Length == 0 ||
                    layout.AppliedLayout.Uuid == null ||
                    layout.AppliedLayout.Uuid.Length == 0)
                {
                    result = false;
                    continue;
                }

                bool unused = true;
                foreach (Monitor monitor in monitors)
                {
                    if (monitor.Device.MonitorName == layout.Device.Monitor &&
                        monitor.Device.MonitorSerialNumber == layout.Device.SerialNumber &&
                        monitor.Device.MonitorNumber == layout.Device.MonitorNumber &&
                        (monitor.Device.VirtualDesktopId == layout.Device.VirtualDesktop ||
                         layout.Device.VirtualDesktop == DefaultVirtualDesktopGuid))
                    {
                        var settings = new LayoutSettings
                        {
                            ZonesetUuid       = layout.AppliedLayout.Uuid,
                            ShowSpacing       = layout.AppliedLayout.ShowSpacing,
                            Spacing           = layout.AppliedLayout.Spacing,
                            Type              = JsonTagToLayoutType(layout.AppliedLayout.Type),
                            ZoneCount         = layout.AppliedLayout.ZoneCount,
                            SensitivityRadius = layout.AppliedLayout.SensitivityRadius,
                        };

                        monitor.Settings = settings;
                        unused           = false;
                        break;
                    }
                }

                if (unused)
                {
                    _unusedLayouts.Add(layout);
                }
            }

            return(result);
        }
Ejemplo n.º 15
0
 public void SetFill(Control control, bool value)
 {
  LayoutSettings sets = null;
  if(_sets.TryGetValue(control, out sets) == false)
   _sets.Add(control, sets = new LayoutSettings());
  sets.Fill = value;
  if(sets.IsEmpty && _sets.ContainsKey(control))
   _sets.Remove(control); 
 } 
Ejemplo n.º 16
0
 public SplitterState(IRun run, ILayout layout, LayoutSettings layoutSettings, ISettings settings)
 {
     Run               = run;
     Layout            = layout;
     Settings          = settings;
     LayoutSettings    = layoutSettings;
     AdjustedStartTime = StartTimeWithOffset = StartTime = TimeStamp.Now;
     CurrentPhase      = TimerState.NotRunning;
     CurrentSplitIndex = -1;
 }
Ejemplo n.º 17
0
        private bool SetDevices(List <DeviceWrapper> devices)
        {
            Logger.LogTrace();

            if (devices == null)
            {
                return(false);
            }

            bool result   = true;
            var  monitors = App.Overlay.Monitors;

            foreach (var device in devices)
            {
                if (device.DeviceId == null || device.DeviceId.Length == 0 || device.ActiveZoneset.Uuid == null || device.ActiveZoneset.Uuid.Length == 0)
                {
                    result = false;
                    continue;
                }

                bool unused = true;
                foreach (Monitor monitor in monitors)
                {
                    string deviceIdSaved            = monitor.Device.Id.Substring(0, monitor.Device.Id.LastIndexOf("_"));
                    string deviceIdReadFromSettings = device.DeviceId.Substring(0, device.DeviceId.LastIndexOf("_"));

                    string virtualDesktopIdSaved            = monitor.Device.Id.Substring(monitor.Device.Id.LastIndexOf("_") + 1);
                    string virtualDesktopIdReadFromSettings = device.DeviceId.Substring(device.DeviceId.LastIndexOf("_") + 1);

                    if (deviceIdSaved == deviceIdReadFromSettings && (virtualDesktopIdSaved == virtualDesktopIdReadFromSettings || virtualDesktopIdReadFromSettings == DefaultVirtualDesktopGuid))
                    {
                        var settings = new LayoutSettings
                        {
                            ZonesetUuid       = device.ActiveZoneset.Uuid,
                            ShowSpacing       = device.EditorShowSpacing,
                            Spacing           = device.EditorSpacing,
                            Type              = JsonTagToLayoutType(device.ActiveZoneset.Type),
                            ZoneCount         = device.EditorZoneCount,
                            SensitivityRadius = device.EditorSensitivityRadius,
                        };

                        monitor.Settings = settings;
                        unused           = false;
                        break;
                    }
                }

                if (unused)
                {
                    _unusedDevices.Add(device);
                }
            }

            return(result);
        }
Ejemplo n.º 18
0
        private void LoadThings()
        {
            foreach (var item in PrintingList)
            {
                DisplayBarcodeUsercontrol = new ObservableCollection <DisplayingBarcodeToPrintUserControl>();
                foreach (var layoutItems in LayoutSettings.Where(x => x.printingPropertiesIserial == 0))
                {
                    DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl("", layoutItems, LayoutSettings, null));
                }

                var fabricCodeLayout       = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 1);
                var barCodeLayout          = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 2);
                var fabricDecriptionLayout = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 3);
                var rollQtyLayout          = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 5);
                var rollWmtLayout          = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 4);
                var degreeLayout           = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 7);
                var fabricColorLayout      = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 8);
                var batchLayout            = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 9); // For Dyeing Only
                var weightLayout           = LayoutSettings.SingleOrDefault(x => x.printingPropertiesIserial == 14);
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.Fabric_Code, fabricCodeLayout, LayoutSettings, null));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.FabricDecription, fabricDecriptionLayout, LayoutSettings, null));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.NetRollQty, rollQtyLayout, LayoutSettings, null));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.RollWMT.ToString(), rollWmtLayout, LayoutSettings, DefectsDataList.Where(x => x.Iserial == item.RecordNumber).ToList()));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.BarCode, barCodeLayout, LayoutSettings, null));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.M2WeightGm.ToString(), weightLayout, LayoutSettings, null));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.Degree.ToString(), degreeLayout, LayoutSettings, null));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.ColorCode, fabricColorLayout, LayoutSettings, null));
                DisplayBarcodeUsercontrol.Add(new DisplayingBarcodeToPrintUserControl(item.BatchNo, batchLayout, LayoutSettings, null));

                var newcan = new Canvas();
                foreach (var barcodes in DisplayBarcodeUsercontrol)
                {
                    if (PrintingFlag)
                    {
                        newcan.Children.Add(barcodes);
                    }
                    if (!PrintingFlag)
                    {
                        CanvasPreview.Children.Add(barcodes);
                    }
                }

                if (PrintingFlag)
                {
                    print(newcan);
                    //     CanvasList.Add(Newcan);
                }
            }

            if (PrintingFlag)
            {
                //   ListPrint.ItemsSource = DisplayBarcodeUsercontrol;
                //ListPrint.DataContext = 1;
            }
        }
Ejemplo n.º 19
0
        private bool SetAppliedLayouts(List <AppliedLayoutWrapper> layouts)
        {
            Logger.LogTrace();

            if (layouts == null)
            {
                return(false);
            }

            bool result   = true;
            var  monitors = App.Overlay.Monitors;

            foreach (var layout in layouts)
            {
                if (layout.DeviceId == null || layout.DeviceId.Length == 0 || layout.AppliedLayout.Uuid == null || layout.AppliedLayout.Uuid.Length == 0)
                {
                    result = false;
                    continue;
                }

                bool unused = true;
                foreach (Monitor monitor in monitors)
                {
                    string deviceIdSaved            = monitor.Device.Id.Substring(0, monitor.Device.Id.LastIndexOf("_", StringComparison.Ordinal));
                    string deviceIdReadFromSettings = layout.DeviceId.Substring(0, layout.DeviceId.LastIndexOf("_", StringComparison.Ordinal));

                    string virtualDesktopIdSaved            = monitor.Device.Id.Substring(monitor.Device.Id.LastIndexOf("_", StringComparison.Ordinal) + 1);
                    string virtualDesktopIdReadFromSettings = layout.DeviceId.Substring(layout.DeviceId.LastIndexOf("_", StringComparison.Ordinal) + 1);

                    if (deviceIdSaved == deviceIdReadFromSettings && (virtualDesktopIdSaved == virtualDesktopIdReadFromSettings || virtualDesktopIdReadFromSettings == DefaultVirtualDesktopGuid))
                    {
                        var settings = new LayoutSettings
                        {
                            ZonesetUuid       = layout.AppliedLayout.Uuid,
                            ShowSpacing       = layout.AppliedLayout.ShowSpacing,
                            Spacing           = layout.AppliedLayout.Spacing,
                            Type              = JsonTagToLayoutType(layout.AppliedLayout.Type),
                            ZoneCount         = layout.AppliedLayout.ZoneCount,
                            SensitivityRadius = layout.AppliedLayout.SensitivityRadius,
                        };

                        monitor.Settings = settings;
                        unused           = false;
                        break;
                    }
                }

                if (unused)
                {
                    _unusedLayouts.Add(layout);
                }
            }

            return(result);
        }
Ejemplo n.º 20
0
 public LiveSplitState(IRun run, Forms.Form form, ILayout layout, LayoutSettings layoutSettings, ISettings settings)
 {
     Run               = run;
     Form              = form;
     Layout            = layout;
     Settings          = settings;
     LayoutSettings    = layoutSettings;
     AdjustedStartTime = StartTimeWithOffset = StartTime = TimeStamp.Now;
     CurrentPhase      = TimerPhase.NotRunning;
     CurrentSplitIndex = -1;
 }
Ejemplo n.º 21
0
 /// <summary>
 /// Sets the layout settings.
 /// </summary>
 /// <param name="control">The control.</param>
 /// <param name="value">The value.</param>
 public static void SetLayoutSettings(this ToolStrip control, LayoutSettings value)
 {
     if (control.InvokeRequired)
     {
         control.BeginInvoke(new MethodInvoker(() => control.SetLayoutSettings(value)));
     }
     else
     {
         control.LayoutSettings = value;
         control.Refresh();
     }
 }
Ejemplo n.º 22
0
 public LiveSplitState(IRun run, Forms.Form form, ILayout layout, LayoutSettings layoutSettings, ISettings settings)
 {
     Run               = run;
     Form              = form;
     Layout            = layout;
     Settings          = settings;
     LayoutSettings    = layoutSettings;
     StartTime         = TripleDateTime.Now;
     CurrentPhase      = TimerPhase.NotRunning;
     CurrentSplitIndex = -1;
     //DrawLock = new ReaderWriterLockSlim();
 }
 public async Task <IActionResult> UpdateLayoutSettings(LayoutSettings settings)
 {
     if (ModelState.IsValid)
     {
         TempData.AddSuccess("Saved layout settings successfully!");
         await ConfigStore.ManipulateConfig(c => c.LayoutSettings = settings);
     }
     else
     {
         TempData.AddError("Unable to save layout settings.");
     }
     return(RedirectToAction("Layout"));
 }
Ejemplo n.º 24
0
        private LayoutSettings ParseSettings(XmlElement element, Version version)
        {
            var settings = new LayoutSettings();

            settings.TextColor              = SettingsHelper.ParseColor(element["TextColor"]);
            settings.BackgroundColor        = SettingsHelper.ParseColor(element["BackgroundColor"]);
            settings.ThinSeparatorsColor    = SettingsHelper.ParseColor(element["ThinSeparatorsColor"]);
            settings.SeparatorsColor        = SettingsHelper.ParseColor(element["SeparatorsColor"]);
            settings.PersonalBestColor      = SettingsHelper.ParseColor(element["PersonalBestColor"]);
            settings.AheadGainingTimeColor  = SettingsHelper.ParseColor(element["AheadGainingTimeColor"]);
            settings.AheadLosingTimeColor   = SettingsHelper.ParseColor(element["AheadLosingTimeColor"]);
            settings.BehindGainingTimeColor = SettingsHelper.ParseColor(element["BehindGainingTimeColor"]);
            settings.BehindLosingTimeColor  = SettingsHelper.ParseColor(element["BehindLosingTimeColor"]);
            settings.BestSegmentColor       = SettingsHelper.ParseColor(element["BestSegmentColor"]);
            settings.NotRunningColor        = SettingsHelper.ParseColor(element["NotRunningColor"]);
            settings.PausedColor            = SettingsHelper.ParseColor(element["PausedColor"], Color.FromArgb(122, 122, 122));
            settings.AntiAliasing           = SettingsHelper.ParseBool(element["AntiAliasing"], true);
            settings.DropShadows            = SettingsHelper.ParseBool(element["DropShadows"], true);
            settings.Opacity            = SettingsHelper.ParseFloat(element["Opacity"], 1);
            settings.BackgroundGradient = SettingsHelper.ParseEnum <GradientType>(element["BackgroundGradient"], GradientType.Plain);
            settings.ShadowsColor       = SettingsHelper.ParseColor(element["ShadowsColor"], Color.FromArgb(128, 0, 0, 0));
            settings.ShowBestSegments   = SettingsHelper.ParseBool(element["ShowBestSegments"]);
            settings.AlwaysOnTop        = SettingsHelper.ParseBool(element["AlwaysOnTop"]);
            settings.TimerFont          = SettingsHelper.GetFontFromElement(element["TimerFont"]);
            using (var timerFont = new Font(settings.TimerFont.FontFamily.Name, (settings.TimerFont.Size / 50f) * 18f, settings.TimerFont.Style, GraphicsUnit.Point))
            {
                settings.TimerFont = new Font(timerFont.FontFamily.Name, (timerFont.Size / 18f) * 50f, timerFont.Style, GraphicsUnit.Pixel);
            }

            if (version >= new Version(1, 3))
            {
                settings.BackgroundColor2 = SettingsHelper.ParseColor(element["BackgroundColor2"]);
                settings.TimesFont        = SettingsHelper.GetFontFromElement(element["TimesFont"]);
                settings.TextFont         = SettingsHelper.GetFontFromElement(element["TextFont"]);
            }
            else
            {
                if (settings.BackgroundColor == Color.Black)
                {
                    settings.BackgroundColor = settings.BackgroundColor2 = Color.Transparent;
                }
                else
                {
                    settings.BackgroundColor2 = settings.BackgroundColor;
                }
                settings.TimesFont = SettingsHelper.GetFontFromElement(element["MainFont"]);
                settings.TextFont  = SettingsHelper.GetFontFromElement(element["SplitNamesFont"]);
            }

            return(settings);
        }
Ejemplo n.º 25
0
        /// <inheritdoc />
        public LayoutSettings GetLayoutSettingsForSet(string layoutSetId)
        {
            string filename = Path.Join(_settings.AppBasePath, _settings.UiFolder, layoutSetId, _settings.FormLayoutSettingsFileName);
            string filedata = null;

            if (File.Exists(filename))
            {
                filedata = File.ReadAllText(filename, Encoding.UTF8);
            }

            LayoutSettings layoutSettings = JsonConvert.DeserializeObject <LayoutSettings>(filedata);

            return(layoutSettings);
        }
Ejemplo n.º 26
0
        public IHttpActionResult DeleteLayoutSettings(int id)
        {
            LayoutSettings layoutSettings = db.LayoutSettings.Find(id);

            if (layoutSettings == null)
            {
                return(NotFound());
            }

            db.LayoutSettings.Remove(layoutSettings);
            db.SaveChanges();

            return(Ok(layoutSettings));
        }
Ejemplo n.º 27
0
        /// <inheritdoc />
        public virtual async Task <List <string> > GetPageOrder(string org, string app, int instanceOwnerId, Guid instanceGuid, string layoutSetId, string currentPage, string dataTypeId, object formData)
        {
            LayoutSettings layoutSettings = null;

            if (string.IsNullOrEmpty(layoutSetId))
            {
                layoutSettings = _resourceService.GetLayoutSettings();
            }
            else
            {
                layoutSettings = _resourceService.GetLayoutSettingsForSet(layoutSetId);
            }

            return(await Task.FromResult(layoutSettings.Pages.Order));
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Save layout to XML.
        /// </summary>
        /// <param name="fileName">File name.</param>
        /// <param name="settings">Settings.</param>
        public static void SaveLayoutToXml(string fileName, LayoutSettings settings)
        {
            var wrapper = new LoaderRootWrapper <LayoutSettings> {
                Settings = settings
            };

            var serializer = new XmlSerializer(typeof(LoaderRootWrapper <LayoutSettings>));

            using (var stream = new FileStream(fileName, FileMode.Create))
            {
                using (var xmlWriter = XmlWriter.Create(stream, XmlUtils.GetXmlWriterSettings()))
                {
                    serializer.Serialize(xmlWriter, wrapper);
                }
            }
        }
Ejemplo n.º 29
0
        private bool SetDevices(List <DeviceWrapper> devices)
        {
            if (devices == null)
            {
                return(false);
            }

            bool result   = true;
            var  monitors = App.Overlay.Monitors;

            foreach (var device in devices)
            {
                if (device.DeviceId == null || device.DeviceId.Length == 0 || device.ActiveZoneset.Uuid == null || device.ActiveZoneset.Uuid.Length == 0)
                {
                    result = false;
                    continue;
                }

                bool unused = true;
                foreach (Monitor monitor in monitors)
                {
                    if (monitor.Device.Id == device.DeviceId)
                    {
                        var settings = new LayoutSettings
                        {
                            ZonesetUuid       = device.ActiveZoneset.Uuid,
                            ShowSpacing       = device.EditorShowSpacing,
                            Spacing           = device.EditorSpacing,
                            Type              = JsonTagToLayoutType(device.ActiveZoneset.Type),
                            ZoneCount         = device.EditorZoneCount,
                            SensitivityRadius = device.EditorSensitivityRadius,
                        };

                        monitor.Settings = settings;
                        unused           = false;
                        break;
                    }
                }

                if (unused)
                {
                    _unusedDevices.Add(device);
                }
            }

            return(result);
        }
Ejemplo n.º 30
0
        public ActionResult Settings(int id, ViewLayoutSettings LayoutSetting)
        {
            DevLayout getDevlayout = db.DevLayout.Find(id);

            getDevlayout.dvLtVersion = (Convert.ToInt32(getDevlayout.dvLtVersion) + 1).ToString();
            db.SaveChanges();
            if (LayoutSetting.LayoutSettingsList != null)
            {
                for (int i = 0; i < LayoutSetting.LayoutSettingsList.Count; i++)
                {
                    LayoutSettings data = db.LayoutSettings.Find(LayoutSetting.LayoutSettingsList[i].ltSId);
                    data.ltSContent = LayoutSetting.LayoutSettingsList[i].ltSContent;
                    db.SaveChanges();
                }
            }
            return(RedirectToAction("Index"));
        }
Ejemplo n.º 31
0
        public IHttpActionResult GetLayoutSettings(bool forCurrentUser)
        {
            var blogId = CurrentUser.CurrentBlogId;

            if (CurrentUser.CurrentBlogId == null)
            {
                return(NotFound());
            }

            LayoutSettings layoutSettings = db.LayoutSettings.Find(blogId);

            if (layoutSettings == null)
            {
                return(NotFound());
            }

            return(Ok(layoutSettings));
        }
Ejemplo n.º 32
0
        private void SetUpWithElements(double objectSpacing, params IMenuObject[] elements)
        {
            var profile = new LineProfile();

            profile.AddRange(elements.Select(e => new Mock <IObjectProfile>().Object));

            var menuHandlerMock = new Mock <IMenuHandler>();
            var layoutSettings  = new LayoutSettings()
            {
                lineSpacing = 5, objectSpacing = objectSpacing
            };

            menuHandlerMock.Setup(mh => mh.Layout).Returns(layoutSettings);
            menuHandlerMock.Setup(mh => mh.CreateRegion(It.IsAny <IObjectProfile>()))
            .Returns(new Func <IObjectProfile, IMenuRegion>(p => elements[profile.IndexOf(p)]));

            this.alignedBlockUnderTest.Prepare(profile, menuHandlerMock.Object);
        }
Ejemplo n.º 33
0
        static void Main(string[] args)
        {
            // load documents
            Utils.VerboseLine("Loading documents ...");
            string[] docs = File.ReadAllLines("C:\\newwork\\testclustering\\data\\yahoofinance.txt");
            BowSpace bowSpace = new BowSpace();
            bowSpace.StopWords = StopWords.EnglishStopWords;
            bowSpace.Stemmer = new PorterStemmer();
            bowSpace.WordWeightType = WordWeightType.TfIdf;
            RegexTokenizer tokenizer = new RegexTokenizer();
            tokenizer.IgnoreUnknownTokens = true;
            bowSpace.Tokenizer = tokenizer;
            bowSpace.Initialize(docs);
            // compute layout
            SemanticSpaceLayout semSpc = new SemanticSpaceLayout(bowSpace);
            Vector2D[] coords = semSpc.ComputeLayout();
            // build spatial index
            //Utils.VerboseLine("Building spatial index ...");
            //SpatialIndex2D spatIdx = new SpatialIndex2D();
            //spatIdx.BuildIndex(coords);
            //spatIdx.InsertPoint(9000, new Vector2D(1000, 1000));
            //ArrayList<IdxDat<Vector2D>> points = spatIdx.GetPoints(new Vector2D(0.5, 0.5), 0.1);
            //Utils.VerboseLine("Number of retrieved points: {0}.", points.Count);

            ArrayList<Vector2D> tmp = new ArrayList<Vector2D>(coords);
            tmp.Shuffle();
            //tmp.RemoveRange(1000, tmp.Count - 1000);

            // compute elevation
            StreamWriter writer = new StreamWriter("c:\\elev.txt");
            LayoutSettings ls = new LayoutSettings(800, 600);
            ls.AdjustmentType = LayoutAdjustmentType.Soft;
            ls.StdDevMult = 2;
            ls.FitToBounds = true;
            ls.MarginVert = 50;
            ls.MarginHoriz = 50;
            double[,] zMtx = VisualizationUtils.ComputeLayoutElevation(tmp, ls, 150, 200);
            VisualizationUtils.__DrawElevation__(tmp, ls, 300, 400).Save("c:\\elev.bmp");
            for (int row = 0; row < zMtx.GetLength(0); row++)
            {
                for (int col = 0; col < zMtx.GetLength(1); col++)
                {
                    writer.Write("{0}\t", zMtx[row, col]);
                }
                writer.WriteLine();
            }
            writer.Close();

            // output coordinates
            StreamWriter tsvWriter = new StreamWriter("c:\\layout.tsv");
            for (int i = 0; i < coords.Length; i++)
            {
                //if (i < points.Count)
                //{
                //    tsvWriter.WriteLine("{0}\t{1}\t{2}\t{3}", coords[i].X, coords[i].Y, points[i].Dat.X, points[i].Dat.Y);
                //}
                //else
                {
                    tsvWriter.WriteLine("{0}\t{1}", coords[i].X, coords[i].Y);
                }
            }
            tsvWriter.Close();
            //// get document names
            //int k = 0;
            //ArrayList<Pair<string, Vector2D>> layout = new ArrayList<Pair<string, Vector2D>>();
            //foreach (string doc in docs)
            //{
            //    string[] docInfo = doc.Split(' ');
            //    layout.Add(new Pair<string, Vector2D>(docInfo[0], coords[k++]));
            //}
            //Console.WriteLine(coords.Length);
            //Console.WriteLine(layout.Count);
            //StreamWriter writer = new StreamWriter("c:\\vidCoords.txt");
            //foreach (Pair<string, Vector2D> docPos in layout)
            //{
            //    writer.WriteLine("{0}\t{1}\t{2}", docPos.First, docPos.Second.X, docPos.Second.Y);
            //}
            //writer.Close();
        }
Ejemplo n.º 34
0
 public LiveSplitState(IRun run, Forms.Form form, ILayout layout, LayoutSettings layoutSettings, ISettings settings)
 {
     Run = run;
     Form = form;
     Layout = layout;
     Settings = settings;
     LayoutSettings = layoutSettings;
     StartTime = TimeStamp.Now;
     CurrentPhase = TimerPhase.NotRunning;
     CurrentSplitIndex = -1;
     //DrawLock = new ReaderWriterLockSlim();
 }
Ejemplo n.º 35
0
        public NodeTreeLayout(AdvTree treeControl, Rectangle clientArea, LayoutSettings layoutSettings)
            : base(treeControl, clientArea, layoutSettings)
		{
		}
Ejemplo n.º 36
0
 public static double[,] ComputeLayoutElevation(IEnumerable<Vector2D> layout, LayoutSettings layoutSettings, int matrixRows, int matrixCols)
 {
     return ComputeLayoutElevation(layout, layoutSettings, matrixRows, matrixCols, /*sigma=*/500, /*r=*/0.1, /*normalize=*/true, /*cut=*/false, 2);
 }
Ejemplo n.º 37
0
 // *** Layout utils ***
 // *** experimental
 public static Bitmap __DrawElevation__(IEnumerable<Vector2D> layout, LayoutSettings layoutSettings, int matrixRows, int matrixCols)
 {
     double[,] elevData = ComputeLayoutElevation(layout, layoutSettings, matrixRows, matrixCols);
     Bitmap bmp = new Bitmap((int)Math.Ceiling(layoutSettings.Width), (int)Math.Ceiling(layoutSettings.Height));
     Graphics gfx = Graphics.FromImage(bmp);
     Vector2D pixSz = new Vector2D(layoutSettings.Width / (double)matrixCols, layoutSettings.Height / (double)matrixRows);
     int row = 0;
     int oldY = 0;
     for (double y = pixSz.Y; row < elevData.GetLength(0); row++, y += pixSz.Y)
     {
         int _y = (int)Math.Round(y);
         int col = 0;
         int oldX = 0;
         for (double x = pixSz.X; col < elevData.GetLength(1); col++, x += pixSz.X)
         {
             int _x = (int)Math.Round(x);
             Brush brush = new SolidBrush(Color.FromArgb(255, 0, 0, (int)Math.Round(255.0 * elevData[row, col])));
             gfx.FillRectangle(brush, oldX, oldY, _x - oldX, _y - oldY);
             brush.Dispose();
             oldX = _x;
         }
         oldY = _y;
     }
     return bmp;
 }
 public Vector2D[] ComputeLayout(LayoutSettings settings, Vector2D[] initLayout)
 {
     if (settings == null) { settings = new LayoutSettings(); }
     if (mNumPoints == 1) { return settings.AdjustLayout(new Vector2D[] { new Vector2D() }); } // trivial case
     const double eps = 0.00001;
     Vector2D[] layout = new Vector2D[mNumPoints];
     // initialize layout
     if (initLayout != null)
     {
         int initLen = Math.Min(mNumPoints, initLayout.Length);
         Array.Copy(initLayout, layout, initLen);
         for (int i = initLayout.Length; i < mNumPoints; i++)
         {
             layout[i] = new Vector2D(mRnd.NextDouble(), mRnd.NextDouble());
         }
     }
     else
     {
         for (int i = 0; i < mNumPoints; i++)
         {
             layout[i] = new Vector2D(mRnd.NextDouble(), mRnd.NextDouble());
         }
     }
     // main optimization loop
     double globalStress = 0, stressDiff = 0;
     double oldGlobalStress = double.MaxValue;
     for (int step = 0; step < mMaxSteps; step++)
     {
         globalStress = 0;
         for (int i = 0; i < mNumPoints; i++)
         {
             double div = 0;
             Vector2D newPos = new Vector2D(0, 0);
             for (int j = 0; j < mNumPoints; j++)
             {
                 if (i != j)
                 {
                     double dIj = mDistFunc.GetDistance(i, j);
                     if (dIj < eps) { dIj = eps; }
                     double wIj = 1.0 / Math.Pow(dIj, 2);
                     double xIMinusXJ = layout[i].X - layout[j].X;
                     double yIMinusYJ = layout[i].Y - layout[j].Y;
                     double denom = Math.Sqrt(Math.Pow(xIMinusXJ, 2) + Math.Pow(yIMinusYJ, 2));
                     if (denom < eps) { denom = eps; } // avoid dividing by zero
                     div += wIj;
                     newPos.X += wIj * (layout[j].X + dIj * (xIMinusXJ / denom));
                     newPos.Y += wIj * (layout[j].Y + dIj * (yIMinusYJ / denom));
                     if (i < j)
                     {
                         Vector2D diff = layout[i] - layout[j];
                         globalStress += wIj * Math.Pow(diff.GetLength() - dIj, 2);
                     }
                 }
             }
             layout[i].X = newPos.X / div;
             layout[i].Y = newPos.Y / div;
         }
         stressDiff = oldGlobalStress - globalStress;
         if ((step - 1) % 100 == 0)
         {
             mLogger.Info("ComputeLayout", "Global stress: {0:0.00} Diff: {1:0.0000}", globalStress, stressDiff);
         }
         oldGlobalStress = globalStress;
         if (stressDiff <= mMinDiff) { break; }
     }
     mLogger.Info("ComputeLayout", "Final global stress: {0:0.00} Diff: {1:0.0000}", globalStress, stressDiff);
     return settings.AdjustLayout(layout);
 }
Ejemplo n.º 39
0
 public void LoadLayout()
 {
     var settings = new LayoutSettings(GetSettingsKey());
     if (!settings.IsDefault && !string.IsNullOrEmpty(settings.LayoutXml))
         SetLayout(settings.LayoutXml);
 }
Ejemplo n.º 40
0
 public static double[,] ComputeLayoutElevation(IEnumerable<Vector2D> layout, LayoutSettings layoutSettings, int matrixRows, int matrixCols,
     double sigma, double r, bool normalize, bool cut, double cutStdevMult)
 {
     Utils.ThrowException(layout == null ? new ArgumentNullException("layout") : null);
     Utils.ThrowException(layoutSettings == null ? new ArgumentNullException("layoutSettings") : null);
     Utils.ThrowException(matrixRows < 1 ? new ArgumentOutOfRangeException("matrixRows") : null);
     Utils.ThrowException(matrixCols < 1 ? new ArgumentOutOfRangeException("matrixCols") : null);
     Utils.ThrowException(sigma <= 0 ? new ArgumentOutOfRangeException("sigma") : null);
     LayoutSettings nrmLayoutSettings = layoutSettings.Clone();
     double fX = 1.0 / (layoutSettings.Width - 2.0 * layoutSettings.MarginHoriz);
     double fY = 1.0 / (layoutSettings.Height - 2.0 * layoutSettings.MarginVert);
     nrmLayoutSettings.Width *= fX;
     nrmLayoutSettings.MarginHoriz *= fX;
     nrmLayoutSettings.Height *= fY;
     nrmLayoutSettings.MarginVert *= fY;
     Vector2D[] nrmLayout = nrmLayoutSettings.AdjustLayout(layout);
     LayoutIndex layoutIndex = new LayoutIndex();
     layoutIndex.MaxPointsPerLeaf = 100; // *** hardcoded max points per leaf
     if (r > 0)
     {
         layoutIndex.BuildIndex(nrmLayout);
     }
     double[,] zMtx = new double[matrixRows, matrixCols];
     Vector2D pixSz = new Vector2D(nrmLayoutSettings.Width / (double)matrixCols, nrmLayoutSettings.Height / (double)matrixRows);
     double maxZ = 0;
     double avgZ = 0;
     int row = 0;
     for (double y = pixSz.Y / 2.0; y < nrmLayoutSettings.Height; y += pixSz.Y, row++)
     {
         int col = 0;
         for (double x = pixSz.X / 2.0; x < nrmLayoutSettings.Width; x += pixSz.X, col++)
         {
             Vector2D pt0 = new Vector2D(x, y);
             double z = 0;
             if (r <= 0)
             {
                 foreach (Vector2D pt in nrmLayout)
                 {
                     double dist = (pt - pt0).GetLength();
                     z += Math.Exp(-sigma * dist * dist);
                 }
             }
             else
             {
                 foreach (IdxDat<Vector2D> pt in layoutIndex.GetPoints(pt0, r))
                 {
                     double dist = (pt.Dat - pt0).GetLength();
                     z += Math.Exp(-sigma * dist * dist);
                 }
             }
             zMtx[row, col] = z;
             if (z > maxZ) { maxZ = z; }
             avgZ += z;
         }
     }
     avgZ /= (double)(matrixRows * matrixCols);
     if (avgZ > 0)
     {
         if (cut)
         {
             double stdev = 0;
             for (row = 0; row < zMtx.GetLength(0); row++)
             {
                 for (int col = 0; col < zMtx.GetLength(1); col++)
                 {
                     stdev += (zMtx[row, col] - avgZ) * (zMtx[row, col] - avgZ);
                 }
             }
             stdev = Math.Sqrt(stdev / (double)(matrixRows * matrixCols));
             maxZ = avgZ + stdev * cutStdevMult;
             for (row = 0; row < zMtx.GetLength(0); row++)
             {
                 for (int col = 0; col < zMtx.GetLength(1); col++)
                 {
                     if (zMtx[row, col] > maxZ) { zMtx[row, col] = maxZ; }
                 }
             }
         }
         if (normalize && maxZ > 0)
         {
             for (row = 0; row < zMtx.GetLength(0); row++)
             {
                 for (int col = 0; col < zMtx.GetLength(1); col++)
                 {
                     zMtx[row, col] /= maxZ;
                 }
             }
         }
     }
     return zMtx;
 }
 public Vector2D[] ComputeLayout(LayoutSettings settings)
 {
     return ComputeLayout(settings, /*initLayout=*/null);
 }
Ejemplo n.º 42
0
 public object Clone()
 {
     var settings = new LayoutSettings();
     settings.Assign(this);
     return settings;
 }