Emgu CV 3 findContours and hierarchy parameter of type Vec4i equivalent?

Question

I\'m attempting to translate the following OpenCV C++ code into Emgu CV 3:

std::vector > contours;
std::vector

        

Answer 1

EmguCV started using VectorOfVectorPoint for FindContours, but didn't really update their code to work correctly with it. See below for a working example:

    /// <summary>
    /// Find contours using the specific memory storage
    /// </summary>
    /// <param name="method">The type of approximation method</param>
    /// <param name="type">The retrieval type</param>
    /// <param name="stor">The storage used by the sequences</param>
    /// <returns>
    /// Contour if there is any;
    /// null if no contour is found
    /// </returns>
    public static VectorOfVectorOfPoint FindContours(this Image<Gray, byte> image, ChainApproxMethod method = ChainApproxMethod.ChainApproxSimple,
        Emgu.CV.CvEnum.RetrType type = RetrType.List) {
        //Check that all parameters are valid.
        VectorOfVectorOfPoint result = new VectorOfVectorOfPoint();

        if (method == Emgu.CV.CvEnum.ChainApproxMethod.ChainCode) {
            throw new ColsaNotImplementedException("Chain Code not implemented, sorry try again later");
        }

        CvInvoke.FindContours(image, result, null, type, method);
        return result;
    }

This returns a VectorOfVectorPoint, which implements IInputOutputArray, IOutputArray, IInputArrayOfArrays, and IInputArray. I'm not sure what you need to do with the contours, but here is an example of how to get the bounding boxes for each one. We do some other things, so let me know what you need and I can help you.

        VectorOfVectorOfPoint contours = canvass2.FindContours(ChainApproxMethod.ChainApproxSimple, RetrType.Tree);
        int contCount = contours.Size;
        for (int i = 0; i < contCount; i++) {
            using (VectorOfPoint contour = contours[i]) {
                segmentRectangles.Add(CvInvoke.BoundingRectangle(contour));
                if (debug) {
                    finalCopy.Draw(CvInvoke.BoundingRectangle(contour), new Rgb(255, 0, 0), 5);
                }
            }
        }

Answer 2

You can simply create a

Matrix

then copy you Mat object data into that Matrix. See Example below:

  Mat hierarchy = new Mat();
  CvInvoke.FindContours(imgThreshCopy, contours, hierarchy , RetrType.Tree,ChainApproxMethod.ChainApproxSimple);

  Matrix<int> matrix = new Matrix<int>(hierarchy.Rows, hierarchy.Cols,hierarchy.NumberOfChannels);
  hierarchy.CopyTo(matrix);

Data can be accessed in

matrix.Data

Good Luck. H

Answer 3

Pass a default-constructed Mat to get the hierarchy.

var VectorOfVectorOfPoint contours = new VectorOfVectorOfPoint();
var Mat hierarchy = new Mat();
CvInvoke.FindContours(
    image,
    contours,
    hierarchy,
    RetrType.Ccomp,
    ChainApproxMethod.ChainApproxSimple
    );

Console.WriteLine("contours.Size: " + contours.Size);
Console.WriteLine("hierarchy.Rows: " + hierarchy.Rows);
Console.WriteLine("hierarchy.Cols: " + hierarchy.Cols);
Console.WriteLine("hierarchy.Depth: " + hierarchy.Depth);
Console.WriteLine("hierarchy.NumberOfChannels: " + hierarchy.NumberOfChannels);

// Example Output:
// contours.Size: 4391
// hierarchy.Rows: 1
// hierarchy.Cols: 4391
// hierarchy.Depth: Cv32S
// hierarchy.NumberOfChannels: 4

You can access the hierarchy data using the Mat DataPointer:

    /// <summary>
    /// Get a neighbor index in the heirarchy tree.
    /// </summary>
    /// <returns>
    /// A neighbor index or -1 if the given neighbor does not exist.
    /// </returns>
    public int Get(HierarchyIndex component, int index)
    {
        if (Hierarchy.Depth != Emgu.CV.CvEnum.DepthType.Cv32S)
        {
            throw new ArgumentOutOfRangeException("ContourData must have Cv32S hierarchy element type.");
        }
        if (Hierarchy.Rows != 1)
        {
            throw new ArgumentOutOfRangeException("ContourData must have one hierarchy hierarchy row.");
        }
        if (Hierarchy.NumberOfChannels != 4)
        {
            throw new ArgumentOutOfRangeException("ContourData must have four hierarchy channels.");
        }
        if (Hierarchy.Dims != 2)
        {
            throw new ArgumentOutOfRangeException("ContourData must have two dimensional hierarchy.");
        }
        long elementStride = Hierarchy.ElementSize / sizeof(Int32);
        var offset = (long)component + index * elementStride;
        if (0 <= offset && offset < Hierarchy.Total.ToInt64() * elementStride)
        {
            unsafe
            {
                return *((Int32*)Hierarchy.DataPointer.ToPointer() + offset);
            }
        }
        else
        {
            return -1;
        }
    }

https://gist.github.com/joshuanapoli/8c3f282cece8340a1dd43aa5e80d170b