Ejemplo n.º 1
0
        /// <summary>
        /// Gets a video frame and processes it.
        /// </summary>
        /// <param name="Sender"></param>
        /// <param name="e"></param>
        void GetAndProcessFrame(object Sender, EventArgs e)
        {
            // Get the next image from the camera
            var mat = capture.QueryFrame();

            if (null == mat)
            {
                return;
            }

            // It is not clear if the whole image frame should be applied to
            // the image processing stage, or if the image should be broken up
            // into fixed sized regions.  Or if the regions should overlap.
            // Or if it is intended to be applied to just the center of the
            // image.
            //
            // Experiments will need to be done.

            // First, get the subframe that matches what I think the mobilenet aspect ratio is (1:1)
            var nWidth   = mat.Width - mat.Height;
            var tmpi     = new Mat(mat, new Rectangle((int)(nWidth / 2), 0, mat.Height, mat.Height));
            var subImage = new Mat();

            CvInvoke.Resize(
                src: tmpi,
                dst: subImage,
                dsize: tmpi.Size);

            // This holds the image in the various sizes and formats.
            // It seems likely that stages will reuse the sizing/format so this
            // reduces the work to set it up each time.
            using var ic = new ImageContainer(subImage);

            // This will hold the localization grid
            Classification[,] localizationGrid = null;

            // This will hold the set of labels that we wish to display
            var newLabels = new Dictionary <string, int>();

            // Process each of the select stages and make a note of teh labels
            foreach (var stage in imageProcessingSteps)
            {
                // Process the image to get the classifications or localizations
                var ret = stage.ProcessImage(ic);

                // What kind of processing stage is?
                if (stage.IsCategorization())
                {
                    // This is a label, add the items to the list of labels to
                    // update on the display
                    if (ret.Length > 1)
                    {
                        foreach (var cat in ret)
                        {
                            if (cat.Probability >= 0.05)
                            {
                                newLabels[cat.Label] = -1;
                            }
                            else if (ret[0, 0].Probability >= 0.5)
                            {
                                newLabels[ret[0, 0].Label] = -1;
                            }
                        }
                    }
                }
                else
                {
                    localizationGrid = ret;
                }
            }

            // Update the labels displayed
            // First, retain the index of the previous labels
            var Used = new bool[textLabels.Length];

            foreach (var l in usedLabels)
            {
                if (!newLabels.TryGetValue(l.Key, out var oldIdx))
                {
                    continue;
                }
                newLabels[l.Key] = l.Value;
                Used[l.Value]    = true;
            }
            // Next, assign indices to the remaining labels.
            var tmp = new string[newLabels.Count];

            newLabels.Keys.CopyTo(tmp, 0);
            foreach (var l in tmp)
            {
                var lidx = newLabels[l];
                // Is it already assigned?
                if (lidx >= 0)
                {
                    continue;
                }
                // find a free label
                for (var idx2 = 0; idx2 < textLabels.Length; idx2++)
                {
                    if (!Used[idx2])
                    {
                        // Assign it this one
                        Used[idx2]   = true;
                        newLabels[l] = idx2;
                        break;
                    }
                }
            }

            // Now go thru and draw all of the labels on the screen
            foreach (var kv in newLabels)
            {
                if (kv.Value < 0)
                {
                    continue;
                }
                textLabels[kv.Value].Text = kv.Key;
            }
            // Blank out the text for the unused labels
            for (int lidx = 0; lidx < Used.Length; lidx++)
            {
                if (!Used[lidx])
                {
                    textLabels[lidx].Text = "";
                }
            }
            usedLabels = newLabels;

            // Draw the localization rectangles
            if (null != localizationGrid)
            {
                for (int x = 0; x < 6; x++)
                {
                    for (int y = 0; y < 6; y++)
                    {
                        if (localizationGrid[y, x].Probability >= 0.25)
                        {
                            CvInvoke.Rectangle(subImage,
                                               new Rectangle((x * subImage.Width) / 6, (y * subImage.Height) / 6, subImage.Width / 6, subImage.Height / 6),
                                               new Bgr(0, 255 * localizationGrid[y, x].Probability, 0).MCvScalar, 10);
                        }
                    }
                }
            }

            // Draw the images obtained from the camera
            imageBox1.Image = mat;
            imageBox2.Image = ic.Image(new Size(128, 128), Emgu.CV.CvEnum.DepthType.Cv8U, false);
        }