static void Main(string[] args)
        {
            CultureInfo customCulture = (CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone();

            customCulture.NumberFormat.NumberDecimalSeparator    = ".";
            System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;


            string descriptorFile = args[0];
            string outputFile     = args[1];
            double seedPercentage = double.Parse(args[2]);

            int seed       = 5334;
            int windowSize = 720;

            int nClusters      = 64;// 128;
            int iterationCount = 1;


            ClusteringSimple clustering = new ClusteringSimple(LoadArrayDescriptors(descriptorFile));

            clustering.Clusterize(nClusters, iterationCount, seed);

            HelperTestClass.VisualizeClustering(clustering.Descriptors, clustering.Centroids, windowSize, windowSize);
        }
        public void TestContinueWith()
        {
            var param = new HelperTestClass()
            {
                result = 0
            };
            var t = new Task <bool>((r) =>
            {
                Task.Delay(1000);
                System.Diagnostics.Debug.WriteLine("First Task Called");
                ((HelperTestClass)r).result = 1;
                return(true);
            }, param);

            var t2 = t.ContinueWith((antecedent, r) =>
            {
                System.Diagnostics.Debug.WriteLine("Second Task Called. First task returned {0}", antecedent.Result);
                ((HelperTestClass)r).result = 2;
            }, param);

            t.Start();

            // Start cannot be called on a continuation task
            //t2.Start();
            // Doesn't work if the task isn't started
            Task.WaitAll(t, t2);

            Assert.IsTrue(param.result == 2);
        }
        private static int HelperTestClassUpdate(HelperTestClass tp)
        {
            Random r = new Random((int)DateTime.Now.Ticks);

            Task.Delay(r.Next(2000));
            System.Diagnostics.Debug.WriteLine("Task Called {0}", tp.result);
            tp.result++;
            return(tp.result);
        }
Exemple #4
0
        static void Main(string[] args)
        {
            int seed       = 5334;
            int windowSize = 720;

            int nDescriptors        = 1000;
            int descriptorDimension = 2;
            int nClusters           = 100;
            int iterationCount      = 10;

            //int nDescriptors = 350000;
            //int descriptorDimension = 4096;
            //int nClusters = 25;// 128;
            //int iterationCount = 10;

            int nDescriptorsDiv5 = nDescriptors / 5;

            Descriptor[] descriptors = HelperTestClass.GenerateHierarchicalDescriptors(seed, nDescriptorsDiv5, descriptorDimension);

            //ClusteringSimple clustering = new ClusteringSimple(descriptors);
            //clustering.Clusterize(nClusters, iterationCount, seed);

            ClusteringAgglomerative clustering = new ClusteringAgglomerative(descriptors);

            //clustering.Clusterize(new List<int> { 0, 1, 3, 7, 15, 31, 63, 127, 255, 511 });
            clustering.Clusterize();

            //HelperTestClass.VisualizeClustering(clustering.Descriptors, clustering.Centroids[0], windowSize, windowSize);

            //for (int i = clustering.Centroids.Length - 1; i > 0; i--)
            //{
            //    HelperTestClass.VisualizeClustering(clustering.Descriptors, clustering.Centroids[i], windowSize, windowSize);
            //}

            HelperTestClass.SaveClustering(clustering.Descriptors, clustering.Centroids, windowSize, windowSize, "clustering");

            //int resolution = 20;
            //for (int i = clustering.Centroids.Length - 1; i > 0; i -= clustering.Centroids.Length / resolution)
            //{
            //    HelperTestClass.VisualizeClustering(clustering.Descriptors, clustering.Centroids[i], windowSize, windowSize);
            //}
        }
        public void TestParameterPassingToTask()
        {
            var param = new HelperTestClass()
            {
                result = 0
            };
            var t = new Task <bool>((r) =>
            {
                Task.Delay(5000);
                System.Diagnostics.Debug.WriteLine("Task Called");
                ((HelperTestClass)r).result = 1;
                return(true);
            }, param);

            var taskList = new List <Task>();

            taskList.Add(t);
            t.Start();
            // Doesn't work if the task isn't started
            Task.WaitAll(taskList.ToArray());

            Assert.IsTrue(param.result == 1);
        }
        public void TestWaitAllOneByOnePattern()
        {
            var param = new HelperTestClass()
            {
                result = 0
            };
            var t1 = new Task <int>((r) =>
            {
                return(HelperTestClassUpdate((HelperTestClass)r));
            }, param);

            var t2 = new Task <int>((r) =>
            {
                return(HelperTestClassUpdate((HelperTestClass)r));
            }, param);

            var t3 = new Task <int>((r) =>
            {
                return(HelperTestClassUpdate((HelperTestClass)r));
            }, param);

            var taskList = new List <Task <int> >();

            taskList.Add(t1);
            taskList.Add(t2);
            taskList.Add(t3);
            taskList.ForEach(t => t.Start());
            while (taskList.Count > 0)
            {
                int index = Task.WaitAny(taskList.ToArray());
                Assert.IsTrue(taskList[index].Exception == null);
                Assert.IsTrue(taskList[index].Result > 0);
                taskList.RemoveAt(index);
            }

            Assert.IsTrue(param.result > 0);
        }