Example #1
0
        /// <summary>
        /// This is meant to be a generic prune method.  It returns the top weights, and normalizes them so the sum of the smaller
        /// set is the same as the sum of the larger set
        /// </summary>
        private static Tuple<int, double>[] Prune(double[] weights, int count)
        {
            // Convert the weights into a list with the original index
            Tuple<int, double>[] weightsIndexed = new Tuple<int, double>[weights.Length];
            for (int cntr = 0; cntr < weights.Length; cntr++)
            {
                weightsIndexed[cntr] = new Tuple<int, double>(cntr, weights[cntr]);
            }

            if (count > weights.Length)
            {
                // This method shouldn't have been called, there is nothing to do
                return weightsIndexed;
            }

            Tuple<int, double>[] topWeights = weightsIndexed.OrderByDescending(o => Math.Abs(o.Item2)).Take(count).ToArray();

            double sumWeights = weights.Sum(o => Math.Abs(o));
            double sumTop = topWeights.Sum(o => Math.Abs(o.Item2));

            double ratio = sumWeights / sumTop;
            if (double.IsNaN(ratio))
            {
                ratio = 1d;		// probably divide by zero
            }

            // Normalize the top weights
            return topWeights.Select(o => new Tuple<int, double>(o.Item1, o.Item2 * ratio)).ToArray();
        }
Example #2
0
    private Tuple<Point, List<Point>>[] unique(Tuple<Point, List<Point>>[] killPoints)
    {
        var uniqueEffects = new List<Tuple<Point, List<Point>>>();
        foreach (var killPoint in killPoints.OrderByDescending(t=>t.Item2.Count))
        {
            var isCoveredByExistingPoint =
                uniqueEffects.Any(existingKillPoint =>
                    killPoint.Item2.All(p=> existingKillPoint.Item2.Contains(p))
                );

            if (!isCoveredByExistingPoint)
            {
                //Console.Error.WriteLine("    + Adding test of {0}", killPoint.Item1);
                uniqueEffects.Add(killPoint);
            }
            else
            {
                //Console.Error.WriteLine("    - Skipping test of {0}", killPoint.Item1);
            }
        }
        return uniqueEffects.ToArray();
    }
Example #3
0
 public static string sanitizeVars(this string inputCode)
 {
     replacementVars = memory.getVariableNames().Select((m, i) => new Tuple<string, string>(m, createHash(i))).ToArray();
     replacementVars = replacementVars.OrderByDescending(n => n.Item1.Length).ToArray();
     for (int i = 0; i < replacementVars.Length; i++)
     {
         inputCode = inputCode.Replace(replacementVars[i].Item1, "(" + replacementVars[i].Item2 + ")");
     }
     Array.Reverse(replacementVars);
     return inputCode;
 }
Example #4
0
        private static void Main()
        {
            var img = new Bitmap(Image.FromFile(".\\Fingerprints\\102_5.tif"));
            var imgBytes = new int[img.Size.Width, img.Size.Height];
            for (var x = 0; x < img.Size.Width; x++)
                for (var y = 0; y < img.Size.Height; y++)
                {
                    var color = img.GetPixel(x, y);
                    imgBytes[x, y] = (int)(.299 * color.R + .587 * color.G + .114 * color.B);
                }

            var orfield = OrientationFieldGenerator.GenerateOrientationField(imgBytes);
            //VSCOMEdetector(orfield);
            int nFilters = 7;
            int nBands = 3;
            int bandRadius = 24;
            int holeRadius = 14;
            int nSectors = 9;


           
            var filterbank = new List<List<Tuple<int, int, double>>>();

            int[,] filtersInt = new int[32,nFilters*32];

            for (int i = 0; i < nFilters; i++)
            {
                filterbank.Add(CreateGaborFilter((1.0/10), Math.PI/nFilters*i));
            }

            // this code was used to test the similarity of the fingerprints
            //var min = filterbank.SelectMany(x=>x).Select(x=>x.Item3).Min();
            //var max = filterbank.SelectMany(x=>x).Select(x=>x.Item3).Max();

            //for (int i = 0; i < nFilters; i++)
            //{
            //    var filter = filterbank[i];
            //    foreach (var tuple in filter)
            //    {
            //        filtersInt[tuple.Item1, tuple.Item2 + i*32] = (int) ((tuple.Item3 - min)/(max - min)*255);
            //    }
            //}

            //Common.SaveAndShowImage(filtersInt);

            int size = nBands * nSectors*nFilters;

            int num = 60000;

            List<double>[] dbase = new List<double>[num];
            var rand = new Random();
            for (int w = 0; w < num; w++)
            {
                var lst = new List<double>();
                for(int s=0;s<size;s++)
                {
                    lst.Add(rand.NextDouble() * 128.0f);
                }
                dbase[w] = lst;
            }

            using (FileStream fs = new FileStream("C:\\temp\\fusrodah_cpu_results.csv", FileMode.Create))
            {
                using (StreamWriter streamWriter = new StreamWriter(fs))
                {
                    streamWriter.WriteLine("Find;Create;Match;Top");
                    for (int n = 0; n < 20; n++)
                    {
                        int radius = nBands*bandRadius + holeRadius + 16; //mask size

                        var sw = new Stopwatch();
                        sw.Start();
                        PerformNewDetectionAlgorithmTestfire(imgBytes);
                        streamWriter.Write(sw.ElapsedMilliseconds + ";");
                        sw.Stop();


                        sw.Restart();
                        var normalizedImage =
                            NormalizeImage(imgBytes, nBands, holeRadius, bandRadius,
                                           265, 292);
                        //Common.SaveAndShowImage(normalizedImage);
                        var filteredImages = new List<int[,]>();
                        for (int i = 0; i < nFilters; i++) filteredImages.Add(null);
                        Parallel.ForEach(filterbank, new ParallelOptions() {MaxDegreeOfParallelism = 4},
                                         filter =>
                                             {

                                                 var filtered = FilterWithGaborFilter(normalizedImage,
                                                                                      filter, nBands, holeRadius,
                                                                                      bandRadius,
                                                                                      265, 292);
                                                 //Common.SaveAndShowImage(filtered);
                                                 filteredImages[filterbank.IndexOf(filter)] = filtered;
                                             }

                            );
                        var fingercode = new List<double>();
                        for (int i = 0; i < nFilters*nBands*nSectors; i++)
                        {
                            fingercode.Add(0);
                        }
                        Parallel.ForEach(filteredImages,
                                         new ParallelOptions {MaxDegreeOfParallelism = 4},
                                         filteredImgBytes =>
                                             {
                                                 var fingercodePart = FormFingerCode(filteredImgBytes, nSectors, nBands,
                                                                                     holeRadius,
                                                                                     bandRadius);
                                                 int startIndex = filteredImages.IndexOf(filteredImgBytes)*
                                                                  nBands*nSectors;
                                                 foreach (var d in fingercodePart)
                                                 {
                                                     fingercode[startIndex++] = d;
                                                 }
                                             });
                        sw.Stop();
                        streamWriter.Write(sw.ElapsedMilliseconds + ";");
                        //Common.SaveFingerCode(fingercode, nBands, nSectors, nFilters, bandRadius, holeRadius);
                        sw.Restart();
                        Tuple<int, double>[] result = new Tuple<int, double>[num];

                        Parallel.ForEach(new[] {0, 1, 2, 3}, new ParallelOptions() {MaxDegreeOfParallelism = 4},
                                         (offset) =>
                                             {
                                                 for (int i = 0; i < num/4; i++)
                                                 {
                                                     var index = i*4 + offset;
                                                     result[index] = Tuple.Create(index,
                                                                                  CalculateDistance(fingercode,
                                                                                                    dbase[index]));
                                                 }
                                             });
                        sw.Stop();
                        streamWriter.Write(sw.ElapsedMilliseconds + ";");
                        sw.Restart();
                        result = result.OrderByDescending(x => x.Item2).ToArray();
                        sw.Stop();
                        streamWriter.WriteLine(sw.ElapsedMilliseconds);
                    }
                }
            }
        }
Example #5
0
        public static Tuple<int[], int, int[], int, int> BeamSerach(int[] board)
        {
            var results = new Tuple<int[], int, int[], int, int>[30];//board, score, route, startRow, startColumn;
            Parallel.For(0, 6 * 5, idx =>
            {
                var route = new int[50];
                int tmpScore = 0;

                fixed (int* b = board, r = route)
                {
                    tmpScore = BeamSearch(b, 1, 42, 400, idx / 6, idx % 6, r);
                }

                results[idx] = Tuple.Create(route, tmpScore, route, idx / 6, idx % 6);
            });
            return results.OrderByDescending(x => x.Item2).First();
        }
Example #6
0
        private static Tuple<Point3D, Point3D, double>[] Prune_Pre(Tuple<Point3D, Point3D, double>[] existing, int count)
        {
            // Sort it so the smaller links have a higher chance of being removed
            var retVal = existing.
                OrderByDescending(o => Math.Abs(o.Item3)).      // the weights could be negative, so sort on distance from zero
                ToList();

            Random rand = StaticRandom.GetRandomForThread();

            while (retVal.Count > count)
            {
                // Choose a random item to remove - favor the end of the list (where the smallest links are)
                double percent = rand.NextPow(10);
                int index = UtilityCore.GetIndexIntoList(percent, retVal.Count);

                retVal.RemoveAt(index);
            }

            return retVal.ToArray();
        }