Пример #1
0
        ExtractFeatureAsync(IntPtr engine, Image image) =>
        await Task.Run(async() =>
        {
            ImageInfo imageInfo = null;
            var pSingleFaceInfo = IntPtr.Zero;
            var pFaceFeature    = IntPtr.Zero;
            try
            {
                var asfFaces = await DetectFaceAsync(engine, image);
                if (asfFaces.Code != 0)
                {
                    return(new OperationResult <IEnumerable <byte[]> >(asfFaces.Code));
                }

                var faces = asfFaces.Data.Cast();
                if (faces.FaceNum <= 0)
                {
                    return(new OperationResult <IEnumerable <byte[]> >(null));
                }

                var features = new byte[faces.FaceNum][];
                for (var i = 0; i < faces.FaceNum; i++)
                {
                    var singleFaceInfo = faces.Faces[i];
                    pSingleFaceInfo    = Marshal.AllocHGlobal(Marshal.SizeOf <SingleFaceInfo>());
                    Marshal.StructureToPtr(singleFaceInfo, pSingleFaceInfo, false);

                    imageInfo    = ImageHelper.ReadBmp(image);
                    pFaceFeature = Marshal.AllocHGlobal(Marshal.SizeOf <AsfFaceFeature>());
                    var code     = AsfHelper.ASFFaceFeatureExtract(engine, imageInfo.Width, imageInfo.Height,
                                                                   imageInfo.Format, imageInfo.ImgData, pSingleFaceInfo, pFaceFeature);
                    if (code != 0)
                    {
                        return(new OperationResult <IEnumerable <byte[]> >(code));
                    }

                    var faceFeature = Marshal.PtrToStructure <AsfFaceFeature>(pFaceFeature);
                    var feature     = new byte[faceFeature.FeatureSize];
                    Marshal.Copy(faceFeature.Feature, feature, 0, faceFeature.FeatureSize);
                    features[i] = feature;
                }

                return(new OperationResult <IEnumerable <byte[]> >(features));
            }
            finally
            {
                if (imageInfo != null)
                {
                    Marshal.FreeHGlobal(imageInfo.ImgData);
                }
                if (pSingleFaceInfo != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(pSingleFaceInfo);
                }
                if (pFaceFeature != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(pFaceFeature);
                }
            }
        });
Пример #2
0
        /// <summary>
        /// 提取最大人脸特征
        /// </summary>
        /// <param name="engine">引擎Handle</param>
        /// <param name="image"></param>
        /// <returns>保存人脸特征结构体指针</returns>
        public static async Task <OperationResult <byte[]> > ExtractSingleFeatureAsync(IntPtr engine, Image image) =>
        await Task.Run(async() =>
        {
            ImageInfo imageInfo = null;
            var pSingleFaceInfo = IntPtr.Zero;
            var pFaceFeature    = IntPtr.Zero;
            try
            {
                var asfFaces = await DetectFaceAsync(engine, image);
                if (asfFaces.Code != 0)
                {
                    return(new OperationResult <byte[]>(asfFaces.Code));
                }

                var faces = asfFaces.Data.Cast();
                if (faces.FaceNum <= 0)
                {
                    return(new OperationResult <byte[]>(null));
                }

                var singleFaceInfo = await GetBiggestFaceAsync(faces);
                pSingleFaceInfo    = Marshal.AllocHGlobal(Marshal.SizeOf <SingleFaceInfo>());
                Marshal.StructureToPtr(singleFaceInfo, pSingleFaceInfo, false);

                imageInfo    = ImageHelper.ReadBmp(image);
                pFaceFeature = Marshal.AllocHGlobal(Marshal.SizeOf <AsfFaceFeature>());
                var code     = AsfHelper.ASFFaceFeatureExtract(engine, imageInfo.Width, imageInfo.Height,
                                                               imageInfo.Format, imageInfo.ImgData, pSingleFaceInfo, pFaceFeature);
                if (code != 0)
                {
                    return(new OperationResult <byte[]>(code));
                }

                var faceFeature = Marshal.PtrToStructure <AsfFaceFeature>(pFaceFeature);
                var feature     = new byte[faceFeature.FeatureSize];
                Marshal.Copy(faceFeature.Feature, feature, 0, faceFeature.FeatureSize);
                return(new OperationResult <byte[]>(feature));

                /*使用同一个引擎时,每次特征提取后的临时内存存储地址相同,后面的特征提取会覆盖之前的结果。
                 * 如要保存每次提取的特征,需要拷贝保存到单独的内存
                 */

                /*
                 * var localFeature = new AsfFaceFeature {Feature = Marshal.AllocHGlobal(feature.Length)};
                 * Marshal.Copy(feature, 0, localFeature.Feature, feature.Length);
                 * localFeature.FeatureSize = feature.Length;
                 *
                 * var pLocalFeature = Marshal.AllocHGlobal(Marshal.SizeOf<AsfFaceFeature>());
                 * Marshal.StructureToPtr(localFeature, pLocalFeature, false);
                 * return new OperationResult<IntPtr>(pLocalFeature);*/
            }
            finally
            {
                if (imageInfo != null)
                {
                    Marshal.FreeHGlobal(imageInfo.ImgData);
                }
                if (pSingleFaceInfo != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(pSingleFaceInfo);
                }
                if (pFaceFeature != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(pFaceFeature);
                }
            }
        });