コード例 #1
0
        public IEnumerable <RenderElement> Build(Position nodePosition, GraphConfig config)
        {
            var padding             = new Position(config.ContentPadding.Left, config.ContentPadding.Top);
            var nextLinePosition    = nodePosition + padding;
            var currentLinePosition = nextLinePosition;

            foreach (var nodeElement in config.Elements)
            {
                if (nodeElement.NextLine)
                {
                    nextLinePosition   += nodeElement.Offset;
                    currentLinePosition = nextLinePosition;
                    nextLinePosition    = new Position(nextLinePosition.X,
                                                       nextLinePosition.Y + nodeElement.Dimensions.Height);
                }
                else
                {
                    currentLinePosition += nodeElement.Offset;
                }

                var dimensions = nodeElement.Dimensions;
                if (nodeElement.StretchHorizontal)
                {
                    var offsetFromLeft = currentLinePosition.X - nodePosition.X;
                    var availableWidth = config.Dimensions.Width - config.ContentPadding.Right;
                    dimensions = new Dimensions(availableWidth - offsetFromLeft, dimensions.Height);
                }

                yield return(new RenderElement(currentLinePosition, dimensions));

                currentLinePosition = new Position(currentLinePosition.X + dimensions.Width, currentLinePosition.Y);
            }
        }
コード例 #2
0
        public Graph RenderGraph(GraphConfig config)
        {
            _config = config;
            _graph  = new Graph();
            _edges.Clear();
            _nodes.Clear();
            foreach (var nodeFamily in _config.Nodes)
            {
                void NodeAddition(GraphElementFamily <INodeProperty> family, Identifier identifier) =>
                AddNode(identifier);

                ProcessGraphElementFamily(nodeFamily, NodeAddition, ApplyNodeProperty);
            }

            foreach (var edgeFamily in _config.Edges)
            {
                void EdgeAddition(GraphElementFamily <IEdgeProperty> family, Identifier identifier) =>
                AddEdge(family as EdgeFamily, identifier);

                ProcessGraphElementFamily(edgeFamily, EdgeAddition, ApplyEdgeProperty);
            }

            _debuggerOperations.WriteDebugOutput();
            _debuggerOperations.Reset();

            return(_graph);
        }
コード例 #3
0
        private void CreateConfig()
        {
            NodeFamily nodes = new NodeFamily(
                new List <IdentifierPartTemplate>()
            {
                new IdentifierPartTemplate("v", "0", "n")
            }
                );
            EdgeFamily edges = new EdgeFamily(
                new List <IdentifierPartTemplate>
            {
                new IdentifierPartTemplate("a", "0", "n"),
                new IdentifierPartTemplate("b", "0", "n"),
                new IdentifierPartTemplate("x", "0", "n")
            }, new EdgeFamily.EdgeEnd(nodes, new List <string> {
                "__a__"
            }),
                new EdgeFamily.EdgeEnd(nodes, new List <string> {
                "__b__"
            })
                )
            {
                ValidationTemplate = "g[__a__][__x__] == __b__", IsDirected = true
            };

            _config = new GraphConfig
            {
                Edges = new HashSet <EdgeFamily> {
                    edges
                },
                Nodes = new HashSet <NodeFamily> {
                    nodes
                }
            };
        }
コード例 #4
0
 public GraphRenderer(GraphConfig config, Debugger debugger)
 {
     _config   = config;
     _debugger = debugger;
     _graph    = new Graph();
     _edges    = new Dictionary <string, Edge>();
 }
コード例 #5
0
        public Task <RenderGraph> Analyze(PlacementGraph graph, GraphConfig config)
        {
            _config = config ?? throw new ArgumentNullException(nameof(config));
            var nodes = graph.Nodes.Select(CreateNode);
            var edges = CreateEdges(graph.Edges);

            return(Task.FromResult(new RenderGraph(nodes.ToList(), edges.ToList())));
        }
コード例 #6
0
        public void DetermineNewFrequencyRange(int x, ref Int64 Low, ref Int64 High, ref int SampleCount)
        {
            Int64 nCentralFrequency;
            Int64 nPreviousBW;
            Int64 nNewStartFrequency;
            Int64 nNewEndFrequency;


            nCentralFrequency = GraphConfig.GetFrequencyFromXDisplay(x);
            nPreviousBW       = GraphConfig.nLastDrawingHighFrequency - GraphConfig.nLastDrawingLowFrequency;


            if (nPreviousBW < 100)
            {
                return;
            }

            nNewStartFrequency = nCentralFrequency - (Int64)(nPreviousBW * fZoomInRatio * 0.5f);
            nNewEndFrequency   = nCentralFrequency + (Int64)(nPreviousBW * fZoomInRatio * 0.5f);


            // now we correct the zoom to take acount of discrete frequency step
            SampleCount = Owner.GetSampleCount();


            Int64 nBW = (nNewEndFrequency - nNewStartFrequency);

            Int64 nRealStep;

            if (SampleCount > nBW)
            {
                SampleCount = (int)nBW;
                nRealStep   = 1;
            }
            else
            {
                nRealStep = ((nNewEndFrequency - nNewStartFrequency) + SampleCount / 2) / SampleCount;
            }

            nNewStartFrequency = nCentralFrequency - nRealStep * SampleCount / 2;
            nNewEndFrequency   = nNewStartFrequency + nRealStep * SampleCount;


            if (nNewEndFrequency > Owner.DeviceInterface.MaxFrequency)
            {
                nNewEndFrequency = Owner.DeviceInterface.MaxFrequency;
            }

            if (nNewStartFrequency < Owner.DeviceInterface.MinFrequency)
            {
                nNewStartFrequency = Owner.DeviceInterface.MinFrequency;
            }

            Low  = nNewStartFrequency;
            High = nNewEndFrequency;
        }
コード例 #7
0
        private async Task AnalyzeGraph()
        {
            _showingTypesSelector.BitMask = _analyzeTypesSelector.BitMask;
            var tasks = await TaskManager.GetAll();

            var config = new GraphConfig
            {
                ReferenceTypes = _analyzeTypesSelector.BitMask
            };

            _graph = await Analyzer.Analyze(tasks, config);
            await RenderGraph();
        }
コード例 #8
0
        public void DisplayFrequencyAndLevelOnCorners(int nXMouse)
        {
            Int64 nFrequency = GraphConfig.GetFrequencyFromXDisplay(nXMouse);


            double dBLevel;

            String LevelText = null;

            if (CurvesList.Count > 0 && ActiveCurve != null && ActiveCurve.Visible == CCurve.YesNo.Yes)
            {
                dBLevel = Math.Round(ActiveCurve.GeDBLevelFromFrequency(nFrequency), 2);
                LevelDisplayLabel.ForeColor = ActiveCurve.Color_;
                LevelText = ActiveCurve.Name + " : ";
            }
            else
            {
                dBLevel = 0.0f;
                LevelDisplayLabel.ForeColor = Color.Black;
                LevelText = "Level : ";
            }


            double ImpedanceNorm = (100.0f / ((float)Math.Pow(10.0f, dBLevel / 20.0f)) - 100.0f) / 1.0f;

            FreqDisplayLabel.Text = "Frequency : " + Utility.GetStringWithSeparators(nFrequency, " ") + "Hz";


            if (GraphConfig.outputMode == OutputMode.dB)
            {
                if (ImpedanceNorm >= 0)
                {
                    LevelDisplayLabel.Text = LevelText + dBLevel.ToString() + "dB " + " |Z|=" + Math.Round(ImpedanceNorm, 0) + " Ohms";
                }
                else
                {
                    LevelDisplayLabel.Text = LevelText + dBLevel.ToString() + "dB ";
                }
            }
            else
            {
                LevelDisplayLabel.Text = LevelText + dBLevel.ToString();
            }

            GraphConfig.DrawTopBox(CurvesList, nFrequency);
        }
コード例 #9
0
        static void Main(string[] args)
        {
            IConfiguration config     = new ConfigurationBuilder().AddJsonFile("appsettings.json", true, true).Build();
            var            endpoint   = config["GraphConnectionEndPoint"];
            var            primaryKey = config["GraphConnectionPrimaryKey"];
            var            database   = config["GraphConnectionDatabase"];
            var            collection = config["GraphConnectionCollection"];

            GraphConfig.SetGraphDataBaseConnection(endpoint, primaryKey, database, collection);
            CVGenerator generator = new CVGenerator();

            generator.ProcessCV(args[0]);


            Console.WriteLine("Convertion finalisée");
            Console.WriteLine("Appuyer sur un bouton pour sortir");
            Console.ReadKey();
        }
コード例 #10
0
        public void Instantiate_GraphConnectionString_GraphExecutionEngine()
        {
            var config          = new GraphConfig();
            var clientProvider  = new ClientProvider(config);
            var commandProvider = new CommandProvider(config);
            var factory         = new ExecutionEngineFactory(clientProvider, commandProvider, config);

            var query = Mock.Of <IQuery>
                        (
                x => x.ConnectionString == $"Endpoint=https://xyz.documents.azure.com:443;AuthKey={base64AuthKey};database=db;graph=FoF" &&
                x.Statement == "g.V().Count()"
                        );

            var engine = factory.Instantiate(query);

            Assert.That(engine, Is.Not.Null);
            Assert.That(engine, Is.TypeOf <GraphExecutionEngine>());
        }
コード例 #11
0
ファイル: Startup.cs プロジェクト: gsantana/LGCV
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext <ApplicationDbContext>(options =>
                                                         options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

            endpoint   = Configuration.GetSection("GraphConnectionEndPoint").Value;
            primaryKey = Configuration.GetSection("GraphConnectionPrimaryKey").Value;
            database   = Configuration.GetSection("GraphConnectionDatabase").Value;
            collection = Configuration.GetSection("GraphConnectionCollection").Value;

            GraphConfig.SetGraphDataBaseConnection(endpoint, primaryKey, database, collection);

            services = TokenConfigurations(services);

            services.AddIdentity <ApplicationUser, ApplicationRole>()
            .AddEntityFrameworkStores <ApplicationDbContext>()
            .AddDefaultTokenProviders();

            services.ConfigureApplicationCookie(options =>
            {
                options.Cookie.HttpOnly   = true;
                options.ExpireTimeSpan    = TimeSpan.FromMinutes(30);
                options.LoginPath         = "/Account/Login";
                options.AccessDeniedPath  = "/Account/AccessDenied";
                options.SlidingExpiration = true;
            });

            services.AddCors();

            services.AddMvc();
            services.AddTransient <IEmailSender, EmailSender>();
            services.AddSingleton(Configuration);
            services.AddSingleton <IEmailSender, EmailSender>();
            services.Configure <AuthMessageSenderOptions>(Configuration);

            services.AddDistributedMemoryCache();

            services.AddSession(options =>
            {
                // Set a short timeout for easy testing.
                options.IdleTimeout     = TimeSpan.FromSeconds(10);
                options.Cookie.HttpOnly = true;
            });
        }
コード例 #12
0
        public Task <AbstractGraph> Analyze(IEnumerable <Todo> tasks, GraphConfig config)
        {
            _tasks  = tasks ?? throw new ArgumentNullException(nameof(tasks));
            _config = config ?? throw new ArgumentNullException(nameof(config));

            var notVisited = tasks.ToHashSet();

            if (!notVisited.Any())
            {
                return(Task.FromResult(new AbstractGraph()));
            }

            _nodes = new HashSet <AbstractNode>();
            _roots = new HashSet <AbstractNode>();

            AnalyzeUnvisited(notVisited);
            RemoveOneNodeGraphs();
            return(Task.FromResult(new AbstractGraph(_roots.ToList())));
        }
コード例 #13
0
        public void CreateGraphConfigForDfs()
        {
            NodeFamily nodes = new NodeFamily(
                new List <IdentifierPartTemplate>
            {
                new IdentifierPartTemplate("v", "0", "n")
            });
            var dfsNode = System.Tuple.Create(
                new Condition("\"__CURRENT_FUNCTION__\" == \"dfs\" && __ARG1__ == __v__"),
                (INodeProperty) new FillColorNodeProperty(Color.Red));

            nodes.Properties.Add(dfsNode);
            EdgeFamily edges = new EdgeFamily(
                new List <IdentifierPartTemplate>
            {
                new IdentifierPartTemplate("a", "0", "n"),
                new IdentifierPartTemplate("b", "0", "n"),
                new IdentifierPartTemplate("x", "0", "g[__a__].size()")
            }, new EdgeFamily.EdgeEnd(nodes, new List <string> {
                "__a__"
            }),
                new EdgeFamily.EdgeEnd(nodes, new List <string> {
                "__b__"
            }))
            {
                ValidationTemplate = "__a__ < __b__ && g[__a__][__x__] == __b__"
            };


            var dfsEdges = Tuple.Create(new Condition("p[__a__] == __b__ || p[__b__] == __a__"),
                                        (IEdgeProperty) new LineColorEdgeProperty(Color.Red));


            edges.Properties.Add(dfsEdges);
            GraphConfig config = new GraphConfig
            {
                Edges = new HashSet <EdgeFamily> {
                    edges
                }, Nodes = new HashSet <NodeFamily> {
                    nodes
                }
            };
        }
コード例 #14
0
        public void FromConfig(GraphConfig config)
        {
            var nodeWindows = config.Nodes.Select(n =>
            {
                var w = new NodeFamilyWindow();
                w.FromNodeFamily(n);
                return((Window)w);
            }).ToList();

            Nodes.SetNewWindows(nodeWindows);
            var edgeWindows = config.Edges.Select(e =>
            {
                var w = new EdgeFamilyWindow(Nodes.Windows.Cast <NodeFamilyWindow>().ToList());
                w.FromEdgeFamily(e);
                return((Window)w);
            }).ToList();

            Edges.SetNewWindows(edgeWindows);
        }
コード例 #15
0
        public ActionResult CreateCohortGraph(CohortGraphRequestModel userRequest)
        {
            var subForm = userRequest.SubForm;

            var graphConfig = new GraphConfig()
                                  {
                                      GraphName = userRequest.Title,
                                      SafeMode = userRequest.SafeMode,
                                      Type = GraphType.Cohort,
                                      Prefix = userRequest.Prefix,
                                      Subform = System.Web.Helpers.Json.Encode(userRequest.SubForm),
                                      MaxYAxis = userRequest.MaxYAxis,
                                      CohortConfig = new CohortConfig()
                                                         {
                                                             IntervalList = CohortHelper.GetCohortPreviousMagnitudeList(subForm.Previous, subForm.CustomDay),
                                                             IntervalUnitName = IntervalHelper.GetIntervalUnitFromString(subForm.Show).ToString(),
                                                             MinutesInUnit = CohortHelper.GetMinutesInIntervalUnit(IntervalHelper.GetIntervalUnitFromString(subForm.Show))
                                                         }
                                  };

            var dataSources = this.GetDataSources(userRequest);

            foreach (var source in dataSources)
            {
                graphConfig.DataSets.Add(new DataSetConfig()
                                             {
                                                 Data = source,
                                                 Resolution =
                                                     (int)
                                                     IntervalHelper.GetResolutionFromString(
                                                         (subForm.DataInterval)),
                                                 Offset = 0,
                                                 IntervalLength =
                                                     CohortHelper.GetCohortIntervalLengthInMinutes(
                                                         subForm.Previous, userRequest.SubForm.Show,
                                                         subForm.CustomDay),
                                             });
            }

            return Json(graphConfig,JsonRequestBehavior.AllowGet);
        }
コード例 #16
0
        void DisplayZoomBox(int nX)
        {
            Int64 Low         = -1;
            Int64 High        = -1;
            int   SampleCount = -1;

            DetermineNewFrequencyRange(nX, ref Low, ref High, ref SampleCount);

            int X1 = GraphConfig.GetXFromFrequency(Low);
            int X2 = GraphConfig.GetXFromFrequency(High);

            if (X1 < GraphConfig.LeftBorder)
            {
                X1 = GraphConfig.LeftBorder;
            }

            if (X2 > Size.Width - GraphConfig.RightBorder)
            {
                X2 = Size.Width - GraphConfig.RightBorder;
            }


            int nWidh = X2 - X1;



            HUDGraphics.Clear(Color.Transparent);
            Brush brush = new SolidBrush(Color.FromArgb(10, 255, 0, 0));

            //Brush brushText = new SolidBrush(Color.FromArgb(10, 255, 0, 0));

            HUDGraphics.FillRectangle(brush, X1, GraphConfig.UpBorder, nWidh, Size.Height - GraphConfig.LowBorder - GraphConfig.UpBorder);
            Pen RecPen = new Pen(Color.FromArgb(100, 255, 0, 0), 2);

            HUDGraphics.DrawRectangle(RecPen, X1, GraphConfig.UpBorder, nWidh, Size.Height - GraphConfig.LowBorder - GraphConfig.UpBorder);

            //HUDGraphics.DrawString("F1 & F2 to ajust size", new Font(FontFamily.GenericMonospace, 10), brushText, new PointF(X1, Size.Height - GraphConfig.LowBorder-20));
            //ForeGroundImageGraphics.
            this.Invalidate();
            //ImageUpdate();
        }
コード例 #17
0
        public GraphConfig ProcessGraph(bool withCriticalPath, Schedule upperResult, Schedule lowerResult)
        {
            GraphConfig   upwardGraph   = null;
            GraphConfig   downwardGraph = null;
            List <Series> allSeries     = new List <Series>();

            if (upperResult != null)
            {
                upwardGraph = BuildConfig().AddActivities(upperResult.Activities);
                if (withCriticalPath)
                {
                    upwardGraph.AddCriticalPath(upperResult.CriticalPath.ActivityDirections)
                    .AddProjectBuff(upperResult.CriticalPath.ProjectBuffer)
                    .AddFeedingBuffers(upperResult.FeedingBuffers);
                }
                allSeries = upwardGraph.series.ToList();
            }

            if (lowerResult != null)
            {
                downwardGraph = BuildConfig().AddActivities(lowerResult.Activities);
                if (withCriticalPath)
                {
                    downwardGraph.AddCriticalPath(lowerResult.CriticalPath.ActivityDirections)
                    .AddProjectBuff(lowerResult.CriticalPath.ProjectBuffer)
                    .AddFeedingBuffers(lowerResult.FeedingBuffers);
                }

                foreach (var serie in downwardGraph.series)
                {
                    serie.data.ToList().ForEach(d => d[1] = d[1] * -1);
                    allSeries.Add(serie);
                }
            }

            if (upwardGraph != null)
            {
                upwardGraph.series = allSeries.ToArray();
            }
            return(upwardGraph);
        }
コード例 #18
0
        public Task <PlacementGraph> Analyze(AbstractGraph abstractGraph, GraphConfig config)
        {
            _abstractGraph = abstractGraph ?? throw new ArgumentNullException(nameof(abstractGraph));
            _config        = config ?? throw new ArgumentNullException(nameof(config));

            if (abstractGraph.Roots.Count == 0)
            {
                return(Task.FromResult(new PlacementGraph()));
            }

            _nextGraphRow = 0;
            _graph        = new PlacementGraph();
            _placedTasks  = new HashSet <Todo>();

            foreach (var root in _abstractGraph.Roots)
            {
                AddGraph(root);
            }

            return(Task.FromResult(_graph));
        }
コード例 #19
0
        void DisplayZoomBox(int nX)
        {
            Int64 Low         = -1;
            Int64 High        = -1;
            int   SampleCount = -1;

            DetermineNewFrequencyRange(nX, ref Low, ref High, ref SampleCount);

            int X1 = GraphConfig.GetXFromFrequency(Low);
            int X2 = GraphConfig.GetXFromFrequency(High);

            if (X1 < GraphConfig.LeftBorder)
            {
                X1 = GraphConfig.LeftBorder;
            }

            if (X2 > Size.Width - GraphConfig.RightBorder)
            {
                X2 = Size.Width - GraphConfig.RightBorder;
            }


            int nWidh = X2 - X1;



            ForeGroundImageGraphics.Clear(Color.Transparent);
            Brush brush = new SolidBrush(Color.FromArgb(50, 255, 0, 0));

            //Brush brushText = new SolidBrush(Color.FromArgb(50, 255, 0, 0));

            ForeGroundImageGraphics.FillRectangle(brush, X1, GraphConfig.UpBorder, nWidh, Size.Height - GraphConfig.LowBorder - GraphConfig.UpBorder);
            //ForeGroundImageGraphics.DrawString("F1 & F2 to ajust size", new Font("Arial", 10), brushText, new PointF(X1, Size.Height - GraphConfig.LowBorder));
            //ForeGroundImageGraphics.
            Image = ForeGroundImageBitmap;
        }
コード例 #20
0
        public void DrawCurveCollection(ArrayList Curves, bool bLoopMode = false)
        {
            CurvesList = Curves;
            int nUpperScale = 10;
            int nLowerScale = -90;

            GraphConfig.outputMode = OutputMode.dB;


            if (HUDBitmap == null)
            {
                BitmapUpdate(this.Size);
                ImageUpdate();
            }



            if (CurvesList.Count > 0 && Owner != null && Owner.GetOutputMode() == OutputMode.dB)
            {
                float fMax = CurvesRetrieveMaximumScale();


                if (fMax != Single.MinValue)
                {
                    nUpperScale  = (int)(fMax + 10.0f);
                    nUpperScale /= 10;
                    nUpperScale *= 10;
                }

                float fMin = CurvesRetrieveMinimumScale();

                if (fMin != Single.MaxValue)
                {
                    nLowerScale  = (int)(fMin - 10.0f);
                    nLowerScale /= 10;
                    nLowerScale *= 10;
                }


                if (bLoopMode)
                {
                    if (GraphConfig.fLastDrawingLevelHigh - nUpperScale <= 20 &&
                        GraphConfig.fLastDrawingLevelHigh - nUpperScale > 0)
                    {
                        nUpperScale = (int)GraphConfig.fLastDrawingLevelHigh;
                    }

                    if (nLowerScale - GraphConfig.fLastDrawingLevelLow <= 20 &&
                        nLowerScale - GraphConfig.fLastDrawingLevelLow > 0)
                    {
                        nLowerScale = (int)GraphConfig.fLastDrawingLevelLow;
                    }
                }
            }
            else
            {
                if (Owner != null)
                {
                    GraphConfig.outputMode = Owner.GetOutputMode();

                    switch (GraphConfig.outputMode)
                    {
                    case OutputMode.SWR_3:
                        nUpperScale = 3;
                        break;

                    case OutputMode.SWR_6:
                        nUpperScale = 6;
                        break;

                    case OutputMode.SWR_10:
                        nUpperScale = 10;
                        break;
                    }
                    nLowerScale = 1;
                }
            }


            GraphConfig.fLastDrawingLevelLow  = nLowerScale;
            GraphConfig.fLastDrawingLevelHigh = nUpperScale;

            GraphConfig.GraphicDisplay(Curves, ActiveCurve, GraphicAndCurvesBitmap);
            ImageUpdate();
        }
コード例 #21
0
 public void SpectrumPictureBox_MouseLeave(object sender, EventArgs e)
 {
     GraphConfig.DrawTopBox(CurvesList); // to redraw only curve names
     HUDGraphics.Clear(Color.Transparent);
     ImageUpdate();
 }
コード例 #22
0
 public MessagesController(GraphConfig config)
 {
     this.config = config;
 }
コード例 #23
0
        private void SpectrumPictureBoxClass_MouseClick(object sender, MouseEventArgs e)
        {
            if (Owner.DeviceInterface.GetDevice() == null)
            {
                return; // no device
            }
            MouseEventArgs Event = (MouseEventArgs)e;
            {
                Int64 nCentralFrequency;
                Int64 nPreviousBW;
                Int64 nNewStartFrequency;
                Int64 nNewEndFrequency;


                nCentralFrequency = GraphConfig.GetFrequencyFromXDisplay(Event.X);
                nPreviousBW       = GraphConfig.nLastDrawingHighFrequency - GraphConfig.nLastDrawingLowFrequency;


                if (Event.Button == MouseButtons.Left)
                {
                    if (nPreviousBW < 100)
                    {
                        return;
                    }

                    nNewStartFrequency = nCentralFrequency - (Int64)(nPreviousBW * fZoomInRatio * 0.5f);
                    nNewEndFrequency   = nCentralFrequency + (Int64)(nPreviousBW * fZoomInRatio * 0.5f);
                }
                else
                {
                    nNewStartFrequency = nCentralFrequency - nPreviousBW;
                    nNewEndFrequency   = nCentralFrequency + nPreviousBW;
                }

                // now we correct the zoom to take acount of discrete frequency step
                int nSampleCount = Owner.GetSampleCount();


                Int64 nBW = (nNewEndFrequency - nNewStartFrequency);

                Int64 nRealStep;
                if (nSampleCount > nBW)
                {
                    nSampleCount = (int)nBW;
                    Owner.SetSampleCount(nSampleCount);
                    nRealStep = 1;
                }
                else
                {
                    nRealStep = ((nNewEndFrequency - nNewStartFrequency) + nSampleCount / 2) / nSampleCount;
                }

                nNewStartFrequency = nCentralFrequency - nRealStep * nSampleCount / 2;
                nNewEndFrequency   = nNewStartFrequency + nRealStep * nSampleCount;


                if (nNewEndFrequency > Owner.DeviceInterface.MaxFrequency)
                {
                    nNewEndFrequency = Owner.DeviceInterface.MaxFrequency;
                }

                if (nNewStartFrequency < Owner.DeviceInterface.MinFrequency)
                {
                    nNewStartFrequency = Owner.DeviceInterface.MinFrequency;
                }


                GraphConfig.nLastDrawingLowFrequency  = nNewStartFrequency;
                GraphConfig.nLastDrawingHighFrequency = nNewEndFrequency;

                DrawCurveCollection(CurvesList);
                Owner.SetSweepStartFrequency(nNewStartFrequency);
                Owner.SetSweepEndFrequency(nNewEndFrequency);
            }
        }
コード例 #24
0
        public ActionResult CreateLineGraph(LineGraphRequestModel userRequest)
        {
            var graphConfig = new GraphConfig()
                                  {
                                      GraphName = userRequest.Title,
                                      SafeMode = userRequest.SafeMode,
                                      Type = GraphType.Line,
                                      Prefix = userRequest.Prefix,
                                      Subform = System.Web.Helpers.Json.Encode(userRequest.SubForm),
                                      MaxYAxis = userRequest.MaxYAxis
                                  };

            var dataSources = this.GetDataSources(userRequest);

            foreach (var source in dataSources)
            {
                graphConfig.DataSets.Add(new DataSetConfig()
                                             {
                                                 Data = source,
                                                 Offset = 0,
                                                 Resolution =
                                                     (int)
                                                     IntervalHelper.GetResolutionFromString(
                                                         userRequest.SubForm.DataInterval),
                                                 IntervalLength =
                                                     IntervalHelper.GetLineInterval(userRequest.SubForm.HistoricalRange)
                                             });
            }

            return Json(graphConfig, JsonRequestBehavior.AllowGet);
        }
コード例 #25
0
        public ActionResult CreateRatioGraph(RatioGraphRequestModel userRequest)
        {
            var graphConfig = new GraphConfig()
                                  {
                                      GraphName = userRequest.Title,
                                      SafeMode = userRequest.SafeMode,
                                      Type = GraphType.Ratio,
                                      Prefix = userRequest.Prefix,
                                      Subform = System.Web.Helpers.Json.Encode(userRequest.SubForm),
                                      RatioConfig =
                                          new RatioConfig()
                                              {
                                                  CompareNumber = userRequest.SubForm.CompareNumber,
                                                  CompareUnit = userRequest.SubForm.CompareUnit,
                                                  CustomDay = userRequest.SubForm.CustomDay,
                                                  HistoricalRange = userRequest.SubForm.HistoricalRange
                                              }
                                  };
            var subForm = userRequest.SubForm;

            var dataSources = this.GetDataSources(userRequest);

            foreach (var source in dataSources)
            {
                graphConfig.DataSets.AddRange(RatioHelper.GetRatioDataSets(source, subForm.HistoricalRange,
                                                                           subForm.CompareNumber, subForm.CompareUnit,
                                                                           subForm.CustomDay));
            }
            return Json(graphConfig, JsonRequestBehavior.AllowGet);
        }