Exemplo n.º 1
0
        static void GenSIFT(string path, StreamWriter sw)
        {
            using (Mat input = new Mat(path, LoadMode.GrayScale)){
                if (input.Empty())
                {
                    return;
                }
                double h = input.Rows, w = input.Cols;
                double newh, neww;
                if (h > w)
                {
                    newh = maxSize;
                    neww = Math.Ceiling(w / h * maxSize);
                }
                else
                {
                    neww = maxSize;
                    newh = Math.Ceiling(h / w * maxSize);
                }
                Size newsize = new Size(neww, newh);
                using (Mat rinput = new Mat())
                {
                    Cv2.Resize(input, rinput, newsize);

                    using (MatOfFloat descriptors = new MatOfFloat())
                    {
                        sift.Run(rinput, null, out keypoint, descriptors);

                        var indexer = descriptors.GetIndexer();


                        int cnt = 0;
                        System.Console.Out.WriteLine(descriptors.Rows);
                        for (int i = 0; i < descriptors.Rows; i++)
                        {
                            String str = i.ToString();
                            //		System.Console.Out.WriteLine(cnt);
                            str = str + "\t0\t";
                            for (int j = 0; j < descriptors.Cols; j++)
                            {
                                str += indexer[i, j].ToString() + " ";
                            }
                            sw.Write(str + "\n");
                            cnt++;
                        }
                        input.Release();
                        rinput.Release();
                        descriptors.Release();
                    }
                }
            }
        }
Exemplo n.º 2
0
        public ConcurrentDictionary <string, MatOfFloat> CalcSiftHashes(IEnumerable <ImageInfo> infos, out Task result, int thumbSize = 100)
        {
            Trace.WriteLine("CalcSiftHashes started");

            EnablePublishingProgress();

            var hashesDict = new ConcurrentDictionary <string, MatOfFloat>();

            var tasks = new List <Task>();

            foreach (ImageInfo info in infos)
            {
                var task = new Task(() =>
                {
                    Thread.CurrentThread.Priority = ThreadPriority.Lowest;

                    //Thread.Sleep(1);

                    //var mem = new MemoryStream();

                    //// copy to byte array
                    //int stride = ((BitmapImage)info.Image).PixelWidth * 4;
                    //byte[] buffer = new byte[stride * ((BitmapImage)info.Image).PixelHeight];
                    //((BitmapImage)info.Image).CopyPixels(buffer, stride, 0);

                    //// create bitmap
                    //Bitmap bitmap = new Bitmap(((BitmapImage)info.Image).PixelWidth, ((BitmapImage)info.Image).PixelHeight, PixelFormat.Format32bppArgb);

                    //// lock bitmap data
                    //BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.WriteOnly, bitmap.PixelFormat);

                    //// copy byte array to bitmap data
                    //Marshal.Copy(buffer, 0, bitmapData.Scan0, buffer.Length);

                    //// unlock
                    //bitmap.UnlockBits(bitmapData);

                    //bitmap.Save(mem,ImageFormat.Bmp);


                    //Mat sourceMat = Cv2.ImDecode(mem.GetBuffer(), ImreadModes.Unchanged);

                    //var resizedMat = sourceMat.Resize(new OpenCvSharp.Size(thumbSize, thumbSize), 0, 0, InterpolationFlags.Nearest);

                    //var scale = (double)thumbSize / Max(sourceMat.Width, sourceMat.Height);
                    //var resizedMat = sourceMat.Resize(new OpenCvSharp.Size(0, 0), scale, scale, InterpolationFlags.Nearest);

                    //var grayScaledMat = new Mat();
                    //Cv2.CvtColor(resizedMat, grayScaledMat, ColorConversionCodes.BGR2GRAY);

                    //var siftPoints = SURF.Create(400);
                    SIFT siftPoints = SIFT.Create();

                    MatOfFloat descriptors = new MatOfFloat();

                    //var keypoints = siftPoints.Detect(info.StoredMat).ToArray();
                    //siftPoints.Compute(info.StoredMat, ref keypoints, descriptors);

                    double scale = Math.Min((float)thumbSize / info.StoredMat.Width, (float)thumbSize / info.StoredMat.Height);
                    Mat resized  = info.StoredMat.Resize(new OpenCvSharp.Size(0, 0), scale, scale, InterpolationFlags.Area);
                    siftPoints.DetectAndCompute(resized, null, out KeyPoint[] keypoints, descriptors);
                    resized.Release();

                    if (!ValidateDescriptor(descriptors))
                    {
                        descriptors.Release();
                        descriptors = new MatOfFloat(thumbSize, thumbSize);
                    }


                    hashesDict.TryAdd(info.FilePath, descriptors);

                    //resizedMat?.Dispose();
                    siftPoints.Dispose();
                    //grayScaledMat.Dispose();
                    //resizedMat.Release();
                    //sourceMat.Release();
                    UpdateIterationsCount();
                });

                tasks.Add(task);
            }

            SetProgressIterationsScope(tasks);

            foreach (var task in tasks)
            {
                task.Start();
            }

            result = Task.WhenAll(tasks.ToArray());
            result.ContinueWith(o => DisiblePublishingProgress());

            return(hashesDict);
        }
Exemplo n.º 3
0
        static void GenSIFT(string path, string filename)
        {
            try
            {
                using (Mat input = new Mat(path, LoadMode.GrayScale)){
                    if (input.Empty())
                    {
                        return;
                    }
                    double h = input.Rows, w = input.Cols;
                    double newh, neww;
                    if (h > w)
                    {
                        newh = maxSize;
                        neww = Math.Ceiling(w / h * maxSize);
                    }
                    else
                    {
                        neww = maxSize;
                        newh = Math.Ceiling(h / w * maxSize);
                    }
                    Size newsize = new Size(neww, newh);
                    using (Mat rinput = new Mat())
                    {
                        Cv2.Resize(input, rinput, newsize);

                        /*	using (new Window("image", rinput))
                         *      {
                         *              Cv2.WaitKey();
                         *      }*/

                        using (MatOfFloat descriptors = new MatOfFloat())
                        {
                            sift.Run(rinput, null, out keypoint, descriptors);

                            cnt += 1;
                            Console.Out.WriteLine(descriptors.Rows + " " + cnt);
                            var    indexer = descriptors.GetIndexer();
                            UInt64 v       = 0;
                            for (int i = 0; i < 16; i++)
                            {
                                v *= 16;
                                if (filename[i] >= '0' && filename[i] <= '9')
                                {
                                    v += (UInt64)filename[i] - '0';
                                }
                                else
                                {
                                    v += (UInt64)(filename[i] - 'a') + 10;
                                }
                            }

                            for (int i = 0; i < descriptors.Rows; i++)
                            {
                                bw.Write((UInt64)v);
                                for (int j = 0; j < descriptors.Cols; j++)
                                {
                                    Byte b = (Byte)indexer[i, j];
                                    bw.Write(b);
                                }
                            }

                            tot += descriptors.Rows;

                            input.Release();
                            rinput.Release();
                            descriptors.Release();
                        }
                    }
                }
            }
            catch
            {
                return;
            }
        }