Ejemplo n.º 1
0
        /// <summary>
        ///   Creates a new object that is a copy of the current instance.
        /// </summary>
        ///
        /// <returns>
        ///   A new object that is a copy of this instance.
        /// </returns>
        ///
        public object Clone()
        {
            var clone = new SpeededUpRobustFeaturesDescriptor(_integral);

            clone._extended  = _extended;
            clone._invariant = _invariant;

            return(clone);
        }
        public SpeededUpRobustFeaturesDescriptor GetDescriptor()
        {
            if (_descriptor == null)
            {
                _descriptor           = new SpeededUpRobustFeaturesDescriptor(_integral);
                _descriptor.Extended  = _featureType == SpeededUpRobustFeatureDescriptorType.Extended;
                _descriptor.Invariant = _computeOrientation;
            }

            return(_descriptor);
        }
        public List <SpeededUpRobustFeaturePoint> ProcessImage(UnmanagedImage image)
        {
            // check image format
            if (
                (image.PixelFormat != PixelFormat.Format8bppIndexed) &&
                (image.PixelFormat != PixelFormat.Format24bppRgb) &&
                (image.PixelFormat != PixelFormat.Format32bppRgb) &&
                (image.PixelFormat != PixelFormat.Format32bppArgb)
                )
            {
                throw new UnsupportedImageFormatException("Unsupported pixel format of the source image.");
            }

            // make sure we have grayscale image
            UnmanagedImage grayImage = null;

            if (image.PixelFormat == PixelFormat.Format8bppIndexed)
            {
                grayImage = image;
            }
            else
            {
                // create temporary grayscale image
                grayImage = Grayscale.CommonAlgorithms.BT709.Apply(image);
            }


            // 1. Compute the integral for the given image
            _integral = IntegralImage.FromBitmap(grayImage);



            // 2. Create and compute interest point response map
            if (_responses == null)
            {
                // re-create only if really needed
                _responses = new ResponseLayerCollection(image.Width, image.Height, _octaves, _initial);
            }
            else
            {
                _responses.Update(image.Width, image.Height, _initial);
            }

            // Compute the response map
            _responses.Compute(_integral);


            // 3. Suppress non-maximum points
            List <SpeededUpRobustFeaturePoint> featureList =
                new List <SpeededUpRobustFeaturePoint>();

            // for each image pyramid in the response map
            foreach (ResponseLayer[] layers in _responses)
            {
                // Grab the three layers forming the pyramid
                ResponseLayer bot = layers[0]; // bottom layer
                ResponseLayer mid = layers[1]; // middle layer
                ResponseLayer top = layers[2]; // top layer

                int border = (top.Size + 1) / (2 * top.Step);

                int tstep = top.Step;
                int mstep = mid.Size - bot.Size;

                int mscale = mid.Width / top.Width;
                int bscale = bot.Width / top.Width;

                int r = 1;

                // for each row
                for (int y = border + 1; y < top.Height - border; y++)
                {
                    // for each pixel
                    for (int x = border + 1; x < top.Width - border; x++)
                    {
                        double currentValue = mid.Responses[y * mscale, x *mscale];

                        // for each windows' row
                        for (int i = -r; (currentValue >= _threshold) && (i <= r); i++)
                        {
                            // for each windows' pixel
                            for (int j = -r; j <= r; j++)
                            {
                                int yi = y + i;
                                int xj = x + j;

                                // for each response layer
                                if (top.Responses[yi, xj] >= currentValue ||
                                    bot.Responses[yi * bscale, xj *bscale] >= currentValue || ((i != 0 || j != 0) &&
                                                                                               mid.Responses[yi * mscale, xj *mscale] >= currentValue))
                                {
                                    currentValue = 0;
                                    break;
                                }
                            }
                        }

                        // check if this point is really interesting
                        if (currentValue >= _threshold)
                        {
                            // interpolate to sub-pixel precision
                            double[] offset = interpolate(y, x, top, mid, bot);

                            if (System.Math.Abs(offset[0]) < 0.5 &&
                                System.Math.Abs(offset[1]) < 0.5 &&
                                System.Math.Abs(offset[2]) < 0.5)
                            {
                                featureList.Add(new SpeededUpRobustFeaturePoint(
                                                    (x + offset[0]) * tstep,
                                                    (y + offset[1]) * tstep,
                                                    0.133333333 * (mid.Size + offset[2] * mstep),
                                                    mid.Laplacian[y * mscale, x * mscale]));
                            }
                        }
                    }
                }
            }

            _descriptor = null;

            if (_featureType != SpeededUpRobustFeatureDescriptorType.None)
            {
                _descriptor           = new SpeededUpRobustFeaturesDescriptor(_integral);
                _descriptor.Extended  = _featureType == SpeededUpRobustFeatureDescriptorType.Extended;
                _descriptor.Invariant = _computeOrientation;
                _descriptor.Compute(featureList);
            }
            else if (_computeOrientation)
            {
                _descriptor = new SpeededUpRobustFeaturesDescriptor(_integral);
                foreach (var p in featureList)
                {
                    p.Orientation = _descriptor.GetOrientation(p);
                }
            }

            return(featureList);
        }