Beispiel #1
0
        public static void Calculate(string[] ids, DataSetLoader offlineLoader, DataSetLoader onlineLoader)
        {
            var offlineSigners = offlineLoader.EnumerateSigners(signer => ids.Contains(signer.ID)).ToList();
            var onlineSigners  = onlineLoader.EnumerateSigners(signer => ids.Contains(signer.ID)).ToList();

            var offlinePipeline = FusionPipelines.GetOfflinePipeline();
            var onlinePipeline  = FusionPipelines.GetOnlinePipeline();
            var fusionPipeline  = FusionPipelines.GetFusionPipeline(onlineSigners, false, 0);

            foreach (var offSigner in offlineSigners)
            {
                Console.WriteLine(offSigner.ID + " started at " + DateTime.Now.ToString("h:mm:ss tt"));
                var onSigner = onlineSigners.Find(signer => signer.ID == offSigner.ID);
                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    offlinePipeline.Transform(offSig);
                    var onSig          = onSigner.Signatures.Find(sig => sig.ID == offSig.ID);
                    var onToOnPipeline = FusionPipelines.GetHackedOnToOnPipeline(offSig.GetFeature(FusionFeatures.Bounds));
                    onToOnPipeline.Transform(onSig);
                    onlinePipeline.Transform(onSig);
                }
                                 );

                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    fusionPipeline.Transform(offSig);
                    onlinePipeline.Transform(offSig);
                }
                                 );

                var distViewer = FusionPipelines.GetDistanceMatrixViewer(onSigner.Signatures, offSigner.Signatures);
                TxtHelper.Save(TxtHelper.ArrayToLines(distViewer.Calculate()), "distancematrix" + offSigner.ID);
            }
        }
Beispiel #2
0
        public static BenchmarkResults BenchmarkingWithAllSigners(bool isoptimal, DataSetLoader offlineLoader)
        {
            var offlineSigners = offlineLoader.EnumerateSigners().ToList();

            var benchmark = FusionPipelines.GetBenchmark(offlineSigners, isoptimal);

            var marosPipeline  = FusionPipelines.GetMarosPipeline();
            var onlinePipeline = FusionPipelines.GetOnlinePipeline();

            foreach (var offSigner in offlineSigners)
            {
                try
                {
                    Console.WriteLine(offSigner.ID + " started at " + DateTime.Now.ToString("h:mm:ss tt"));
                    Parallel.ForEach(offSigner.Signatures, offSig =>
                    {
                        marosPipeline.Transform(offSig);
                        onlinePipeline.Transform(offSig);
                    }
                                     );
                    Console.WriteLine(offSigner.ID + " finished at " + DateTime.Now.ToString("h:mm:ss tt"));
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
            return(benchmark.Execute());
        }
Beispiel #3
0
        public static BenchmarkResults BenchMarkWithAllSigners(bool isoptimal, DataSetLoader onlineLoader)
        {
            Console.WriteLine("Online - online benchmark started");

            var onlineSigners = onlineLoader.EnumerateSigners().ToList();

            var onlinePipeline = FusionPipelines.GetOnlinePipeline();

            var benchmark = FusionPipelines.GetBenchmark(onlineSigners, isoptimal);

            foreach (var onSigner in onlineSigners)
            {
                try
                {
                    Parallel.ForEach(onSigner.Signatures, onSig =>
                    {
                        onlinePipeline.Transform(onSig);
                    }
                                     );
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
            return(benchmark.Execute());
        }
 public DatasetsViewModel()
 {
     _dataSetLoader              = DataSetLoader.Instance;
     _dataSetLoader.ModelLoaded += DataSetLoaderOnModelLoaded;
     Title           = "data sets";
     PendingDataSets = new ObservableCollection <PendingDataSet>();
 }
Beispiel #5
0
        public ILoader GetLoader(Type type)
        {
            lock (_loaders)
            {
                if (_loaders.ContainsKey(type))
                {
                    return(_loaders[type]);
                }
                ILoader loader;
                switch (_mode)
                {
                case PsMode.DataSet:
                    loader = new DataSetLoader(this, type, _dataSet);
                    break;

                case PsMode.MsSql:
                    loader = new Sql.MsSqlDataLoader(this, _connectionString, type);
                    break;

                case PsMode.Xml:
                    loader = new Xml.XmlDataLoader(_fileName, _entitiesTagPath, this, type);
                    break;

                default:
                    throw new Exception("Undefined mode");
                }
                _loaders.Add(type, loader);
                return(loader);
            }
        }
Beispiel #6
0
        public static void Calculate(string[] ids, DataSetLoader offlineLoader, DataSetLoader onlineLoader)
        {
            var offlineSigners = offlineLoader.EnumerateSigners(signer => ids.Contains(signer.ID)).ToList();
            var onlineSigners  = onlineLoader.EnumerateSigners(signer => ids.Contains(signer.ID)).ToList();


            var offlinePipeline = FusionPipelines.GetOfflinePipeline();

            foreach (var offSigner in offlineSigners)
            {
                Console.WriteLine(offSigner.ID + " started at " + DateTime.Now.ToString("h:mm:ss tt"));
                var onSigner = onlineSigners.Find(signer => signer.ID == offSigner.ID);
                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    Console.WriteLine("Preprocess - " + offSig.Signer.ID + "_" + offSig.ID + "started at " + DateTime.Now.ToString("h:mm:ss tt"));
                    offlinePipeline.Transform(offSig);
                    var onSig          = onSigner.Signatures.Find(sig => sig.ID == offSig.ID);
                    var onToOnPipeline = FusionPipelines.GetHackedOnToOnPipeline(offSig.GetFeature(FusionFeatures.Bounds));
                    onToOnPipeline.Transform(onSig);
                }
                                 );

                int numOfRef   = 10;
                int numOfGen   = 20;
                var references = onSigner.Signatures.FindAll(sig => sig.Origin == Origin.Genuine).Take(numOfRef).ToList();
                var genuines   = offSigner.Signatures.FindAll(sig => sig.Origin == Origin.Genuine).Take(numOfGen).ToList();

                double[,] results = new double[references.Count, genuines.Count];

                for (int i = 0; i < references.Count; i++)
                {
                    var fusionPipeline = FusionPipelines.GetFusionPipeline(onlineSigners, false, i);
                    Parallel.For(0, genuines.Count, j =>
                    {
                        Console.WriteLine("ref: {0}, sig: {1}", i, j);
                        fusionPipeline.Transform(genuines[j]);
                    }
                                 );
                    var pairingDists = new StrokePairingDistances
                    {
                        InputOfflineTrajectory = FusionFeatures.Trajectory,
                        InputOnlineTrajectory  = FusionFeatures.Trajectory,
                        OnlineSignatures       = onSigner.Signatures,
                        OfflineSignatures      = genuines
                    };
                    var newDists = pairingDists.Calculate();
                    if (newDists.Count != results.GetLength(1))
                    {
                        throw new Exception();
                    }
                    for (int j = 0; j < newDists.Count; j++)
                    {
                        results[i, j] = newDists[j].Item3;
                        Console.WriteLine(results[i, j]);
                    }
                }
                TxtHelper.Save(TxtHelper.ArrayToLines(results), "pairingmatrix" + offSigner.ID);
            }
        }
Beispiel #7
0
        public void QuadTreeIntersectionProcessorShallReturnExpectedIntersection()
        {
            // Arrange
            List <DataPoint> testDataSet    = DataSetLoader.ReadDataPoints("InputDataSet.json");
            List <DataPoint> expectedResult = DataSetLoader.ReadDataPoints("ExpectedDataSet.json");
            Rectangle        rect           = new Rectangle(-0.1m, -0.1m, 0.1m, 0.1m);

            // Act
            List <DataPoint> actualResult = GetIntersectedSetUsingQuadTree(testDataSet, rect);

            // Assert
            Assert.True(actualResult.Identical(expectedResult));
        }
        public static Tuple <List <double>, List <List <double> > > Calculate(DataSetLoader loader)
        {
            var signers   = loader.EnumerateSigners().ToList();
            var resampler = new ReSamplingFeatureExtraction()
            {
                InputButton = FusionFeatures.Button,
                InputX      = FusionFeatures.X,
                InputY      = FusionFeatures.Y
            };
            var results = resampler.Calculate(signers);

            TxtHelper.Save(TxtHelper.ReSamplingResultsToLines(results), "resamplingdataset");
            return(results);
        }
Beispiel #9
0
        public static void CalculateForID(string[] ids, DataSetLoader offlineLoader, DataSetLoader onlineLoader)
        {
            var offlineSigners = offlineLoader.EnumerateSigners(signer => ids.Contains(signer.ID)).ToList();
            var onlineSigners  = onlineLoader.EnumerateSigners(signer => ids.Contains(signer.ID)).ToList();


            var offlinePipeline = FusionPipelines.GetOfflinePipeline();
            var fusionPipeline  = FusionPipelines.GetFusionPipeline(onlineSigners, false, 0);

            foreach (var offSigner in offlineSigners)
            {
                Console.WriteLine(offSigner.ID + " started at " + DateTime.Now.ToString("h:mm:ss tt"));
                var onSigner = onlineSigners.Find(signer => signer.ID == offSigner.ID);
                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    Console.WriteLine("Preprocess - " + offSig.Signer.ID + "_" + offSig.ID + "started at " + DateTime.Now.ToString("h:mm:ss tt"));
                    offlinePipeline.Transform(offSig);
                    var onSig           = onSigner.Signatures.Find(sig => sig.ID == offSig.ID);
                    var onToOffPipeline = FusionPipelines.GetOnlineToOfflinePipeline(offSig.GetFeature(FusionFeatures.Bounds));
                    onToOffPipeline.Transform(onSig);
                }
                                 );

                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    Console.WriteLine("Process - " + offSig.Signer.ID + "_" + offSig.ID + "started at " + DateTime.Now.ToString("h:mm:ss tt"));
                    fusionPipeline.Transform(offSig);
                }
                                 );
            }

            foreach (var offSigner in offlineSigners)
            {
                var onSigner     = onlineSigners.Find(signer => signer.ID == offSigner.ID);
                var pairingDists = new StrokePairingDistances
                {
                    InputOfflineTrajectory = FusionFeatures.Trajectory,
                    InputOnlineTrajectory  = FusionFeatures.BaseTrajectory,
                    OfflineSignatures      = offSigner.Signatures,
                    OnlineSignatures       = onSigner.Signatures
                };
                pairingDists.Calculate();
            }
        }
        public static BenchmarkResults BenchMarkingWithAllSigners(bool isoptimal, DataSetLoader offlineLoader, DataSetLoader onlineLoader)
        {
            var offlineSigners = offlineLoader.EnumerateSigners().ToList();
            var onlineSigners  = onlineLoader.EnumerateSigners().ToList();

            var benchmark = FusionPipelines.GetBenchmark(offlineSigners, isoptimal);

            var offlinePipeline = FusionPipelines.GetOfflinePipeline();
            var onlinePipeline  = FusionPipelines.GetOnlinePipeline();
            var fusionPipeline  = FusionPipelines.GetFusionPipeline(onlineSigners, false, 0);


            foreach (var offSigner in offlineSigners)
            {
                Console.WriteLine(offSigner.ID + " started at " + DateTime.Now.ToString("h:mm:ss tt"));
                var onSigner = onlineSigners.Find(signer => signer.ID == offSigner.ID);
                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    offlinePipeline.Transform(offSig);
                    var onSig          = onSigner.Signatures.Find(sig => sig.ID == offSig.ID);
                    var onToOnPipeline = FusionPipelines.GetHackedOnToOnPipeline(offSig.GetFeature(FusionFeatures.Bounds));
                    onToOnPipeline.Transform(onSig);
                    onlinePipeline.Transform(onSig);
                }
                                 );
                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    fusionPipeline.Transform(offSig);
                    onlinePipeline.Transform(offSig);
                }
                                 );


                var listWithOnlySigner = new List <Signer>()
                {
                    offSigner
                };
                var onlySigBenchmark = FusionPipelines.GetBenchmark(listWithOnlySigner, true);
                var onlyRes          = onlySigBenchmark.Execute();
                TxtHelper.Save(TxtHelper.BenchmarkResToLines(onlyRes), "offoff" + offSigner.ID);
            }
            return(benchmark.Execute());
        }
Beispiel #11
0
        public static BenchmarkResults BenchmarkWithAllSigners(bool isOptimal, DataSetLoader offlineLoader, DataSetLoader onlineLoader)
        {
            Console.WriteLine("Hacked online - online benchmark started");

            var onlineSigners  = onlineLoader.EnumerateSigners().ToList();
            var offlineSigners = offlineLoader.EnumerateSigners().ToList();

            var offlinePipeline = FusionPipelines.GetHackedOfflinePipeline();

            var benchmark = FusionPipelines.GetBenchmark(onlineSigners, isOptimal);

            foreach (var offSigner in offlineSigners)
            {
                Console.WriteLine(offSigner.ID + " started at " + DateTime.Now.ToString("h:mm:ss tt"));
                var onSigner = onlineSigners.Find(signer => signer.ID == offSigner.ID);
                Parallel.ForEach(offSigner.Signatures, offSig =>
                {
                    offlinePipeline.Transform(offSig);
                    var onSig          = onSigner.Signatures.Find(sig => sig.ID == offSig.ID);
                    var onToOnPipeline = FusionPipelines.GetHackedOnToOnPipeline(offSig.GetFeature(FusionFeatures.Bounds));
                    onToOnPipeline.Transform(onSig);
                }
                                 );
            }

            var onlinePipeline = FusionPipelines.GetOnlinePipeline();

            foreach (var onSigner in onlineSigners)
            {
                Parallel.ForEach(onSigner.Signatures, onSig =>
                {
                    onlinePipeline.Transform(onSig);
                }
                                 );
            }
            return(benchmark.Execute());
        }
Beispiel #12
0
        public static FusionBenchmarkResults BenchMarkingWithAllSigners(bool isoptimal, DataSetLoader offlineLoader, DataSetLoader onlineLoader)
        {
            var offlineSigners = offlineLoader.EnumerateSigners().ToList();
            var onlineSigners  = onlineLoader.EnumerateSigners().ToList();


            var offlinePipeline = FusionPipelines.GetOfflinePipeline();
            var onlinePipeline  = FusionPipelines.GetOnlinePipeline();
            var fusionPipeline  = FusionPipelines.GetFusionPipeline(onlineSigners, false, 0);

            var offOnSigners = new List <Signer>();
            var onOffSigners = new List <Signer>();

            Parallel.ForEach(offlineSigners, offSigner =>
            {
                try
                {
                    Console.WriteLine(offSigner.ID + " started at " + DateTime.Now.ToString("h:mm:ss tt"));
                    var onSigner = onlineSigners.Find(signer => signer.ID == offSigner.ID);
                    Parallel.ForEach(offSigner.Signatures, offSig =>
                    {
                        offlinePipeline.Transform(offSig);
                        var onSig = onSigner.Signatures.Find(sig => sig.ID == offSig.ID);
                        onSig.SetFeature <Image <Rgba32> >(FusionFeatures.Image, offSig.GetFeature(FusionFeatures.Image));
                        var onToOnPipeline = FusionPipelines.GetHackedOnToOnPipeline(offSig.GetFeature(FusionFeatures.Bounds));
                        onToOnPipeline.Transform(onSig);
                        onlinePipeline.Transform(onSig);
                    }
                                     );
                    Parallel.ForEach(offSigner.Signatures, offSig =>
                    {
                        fusionPipeline.Transform(offSig);
                        onlinePipeline.Transform(offSig);
                    }
                                     );

                    var offonSigner = FusionPipelines.GetMixedSigner(offSigner, onSigner);
                    var onoffSigner = FusionPipelines.GetMixedSigner(onSigner, offSigner);
                    offOnSigners.Add(offonSigner);
                    onOffSigners.Add(onoffSigner);
                    Console.WriteLine(offSigner.ID + " finished at " + DateTime.Now.ToString("h:mm:ss tt"));
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
                             );


            var offoffBenchmark = FusionPipelines.GetBenchmark(offlineSigners, isoptimal);
            var offonBenchmark  = FusionPipelines.GetBenchmark(offOnSigners, isoptimal);
            var onoffBenchamrk  = FusionPipelines.GetBenchmark(onOffSigners, isoptimal);
            var ononBenchmark   = FusionPipelines.GetBenchmark(onlineSigners, isoptimal);


            return(new FusionBenchmarkResults
            {
                OffOffResults = offoffBenchmark.Execute(),
                OffOnResults = offonBenchmark.Execute(),
                OnOffResults = onoffBenchamrk.Execute(),
                OnOnResults = ononBenchmark.Execute()
            });
        }
Beispiel #13
0
 public static BenchmarkResults BenchmarkingWithAllSigners(bool isoptimal, DataSetLoader offlineLoader, DataSetLoader onlineLoader)
 {
     throw new NotImplementedException();
 }
 /// <summary>
 /// Get payload used in this controller.
 /// </summary>
 private static List <string[]> GetPayload()
 {
     return(DataSetLoader.Load("userItem"));
 }