Exemple #1
0
        public override async Task <FaceDto> GetAsync(EntityDto <long> input)
        {
            Face face = await _faceRepository.GetAllIncluding(t => t.SubImageInfos)
                        .SingleOrDefaultAsync(f => f.Id == input.Id).ConfigureAwait(false);

            if (face?.SubImageInfos != null)
            {
                foreach (var subImageInfo in face.SubImageInfos)
                {
                    if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
                        string.IsNullOrEmpty(subImageInfo.NodeId))
                    {
                        continue;
                    }

                    GetImageRequest request = new GetImageRequest()
                    {
                        BucketName = subImageInfo.NodeId,
                        ImageName  = subImageInfo.ImageKey
                    };

                    GetImageWithBytesResponse response = await _imageAppService.GetImageWithBytesAsync(request).ConfigureAwait(false);

                    subImageInfo.Data = Convert.ToBase64String(response.ImageData);
                }
            }

            var faceDto = MapToEntityDto(face);

            //faceDto.SubImageList = new SubImageInfoDtoList();
            //faceDto.SubImageList.SubImageInfoObject = faceDto.SubImageInfos;
            //faceDto.SubImageInfos = null;

            return(faceDto);
        }
        public override async Task <MotorDto> GetAsync(EntityDto <long> input)
        {
            var entity = await _motorVehicleRepository.GetAllIncluding(t => t.SubImageInfos)
                         .SingleOrDefaultAsync(f => f.Id == input.Id).ConfigureAwait(false);

            if (entity?.SubImageInfos != null)
            {
                foreach (var subImageInfo in entity.SubImageInfos)
                {
                    if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
                        string.IsNullOrEmpty(subImageInfo.NodeId))
                    {
                        continue;
                    }

                    GetImageRequest request = new GetImageRequest()
                    {
                        BucketName = subImageInfo.NodeId,
                        ImageName  = subImageInfo.ImageKey
                    };

                    GetImageWithBytesResponse response = await _imageAppService.GetImageWithBytesAsync(request);

                    subImageInfo.Data = Convert.ToBase64String(response.ImageData);
                }
            }
            var dto = MapToEntityDto(entity);

            return(dto);
        }
        public async Task GetSubImageInfoDtoList(List <SubImageInfoDto> subImageInfoDtos)
        {
            try
            {
                foreach (var subImageInfo in subImageInfoDtos)
                {
                    if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
                        string.IsNullOrEmpty(subImageInfo.NodeId))
                    {
                        continue;
                    }

                    GetImageRequest request = new GetImageRequest()
                    {
                        BucketName = subImageInfo.NodeId,
                        ImageName  = subImageInfo.ImageKey
                    };

                    GetImageWithBytesResponse response = await GetImageWithBytesAsync(request).ConfigureAwait(false);

                    subImageInfo.Data = Convert.ToBase64String(response.ImageData);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        public async Task GetImageWithBytesAsync_Test()
        {
            SaveImageByUrlRequest saveRequest = new SaveImageByUrlRequest()
            {
                ImageUrl = "https://www.baidu.com/img/bd_logo1.png?where=super"
            };

            SaveImageResponse saveResponse = await _imageAppService.SaveImageByUrlAsync(saveRequest);

            GetImageRequest getRequest = new GetImageRequest()
            {
                BucketName = saveResponse.BucketName,
                ImageName  = saveResponse.ImageName
            };

            GetImageWithBytesResponse getResponse = await _imageAppService.GetImageWithBytesAsync(getRequest);

            using (MD5 md5Hash = MD5.Create())
            {
                byte[] md5Bytes = md5Hash.ComputeHash(getResponse.ImageData);

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < md5Bytes.Length; i++)
                {
                    sb.Append(md5Bytes[i].ToString("X2"));
                }

                sb.ToString().ShouldBe("B15C113AEDDBEB606D938010B88CF8E6");
            }
        }
Exemple #5
0
        public override async Task <GetImageWithBytesRpcResponse> GetImageWithBytesRpc(
            GetImageRpcRequest request, ServerCallContext context)
        {
            GetImageWithBytesResponse result = await _imageAppService.GetImageWithBytesAsync(new GetImageRequest()
            {
                BucketName = request.Bucketname,
                ImageName  = request.ImageName
            }).ConfigureAwait(false);

            return(new GetImageWithBytesRpcResponse()
            {
                ImageData = ByteString.CopyFrom(result.ImageData)
            });
        }
Exemple #6
0
        public async Task <PagedResultDto <ClusteringFaceDto> > QueryClusteringFaceByParams(PagedAndSortedRequestDto input)
        {
            var query = _faceRepository.GetAllIncluding(p => p.SubImageInfos);

            query = await _faceRepository.QueryByParams(input.Parameters, query).ConfigureAwait(false);

            //var faces = await GetAllAsync(input).ConfigureAwait(false);
            var faces = PagingAndSorting(input, query);

            if (input.ImageRequred == 1)
            {
                foreach (var face in faces.Items)
                {
                    var imageToQuery = face.SubImageList.SubImageInfoObject;
                    //imageType
                    if (input.ImageType == "11" || input.ImageType == "14")
                    {
                        imageToQuery = imageToQuery.Where(p => p.Type == input.ImageType).ToList();
                    }
                    foreach (var subImageInfo in imageToQuery)
                    {
                        if (string.IsNullOrEmpty(subImageInfo.ImageKey) ||
                            string.IsNullOrEmpty(subImageInfo.NodeId))
                        {
                            continue;
                        }

                        GetImageRequest request = new GetImageRequest()
                        {
                            BucketName = subImageInfo.NodeId,
                            ImageName  = subImageInfo.ImageKey
                        };

                        GetImageWithBytesResponse response = await _imageAppService.GetImageWithBytesAsync(request).ConfigureAwait(false);

                        subImageInfo.Data = Convert.ToBase64String(response.ImageData);
                    }
                }
            }

            return(new PagedResultDto <ClusteringFaceDto>(faces.TotalCount, ObjectMapper.Map <List <ClusteringFaceDto> >(faces.Items)));
        }