├── .gitignore
├── tests
    └── XSolve
    │   └── FaceValidatorBundle
    │       ├── images
    │           ├── 1x1
    │           └── 100x100
    │       ├── Integration
    │           ├── config_test.yml
    │           ├── AzureClientMock.php
    │           ├── TestKernel.php
    │           ├── KernelTestCase.php
    │           ├── responses
    │           │   ├── glasses.json
    │           │   ├── sunglasses.json
    │           │   ├── small_face.json
    │           │   ├── medium_blur.json
    │           │   └── medium_noise.json
    │           └── FaceValidatorIntegrationTest.php
    │       ├── Calculator
    │           └── FaceToImageRatioCalculatorTest.php
    │       ├── Detector
    │           └── AzureAPIFaceDetectorTest.php
    │       ├── Result
    │           ├── BlurLevelTest.php
    │           └── NoiseLevelTest.php
    │       └── Validator
    │           └── Constraints
    │               └── FaceValidatorTest.php
├── src
    ├── .htaccess
    └── XSolve
    │   └── FaceValidatorBundle
    │       ├── Exception
    │           └── NoFaceDetectedException.php
    │       ├── Result
    │           ├── Gender.php
    │           ├── Accessory.php
    │           ├── ExposureLevel.php
    │           ├── Glasses.php
    │           ├── Makeup.php
    │           ├── Blur.php
    │           ├── Noise.php
    │           ├── Exposure.php
    │           ├── BlurLevel.php
    │           ├── NoiseLevel.php
    │           ├── Rotation.php
    │           └── FaceDetectionResult.php
    │       ├── Client
    │           ├── AzureFaceAPIClient.php
    │           └── GuzzleWrapper.php
    │       ├── XSolveFaceValidatorBundle.php
    │       ├── Detector
    │           ├── FaceDetector.php
    │           └── AzureAPIFaceDetector.php
    │       ├── Validator
    │           ├── Specification
    │           │   ├── FaceValidationSpecification.php
    │           │   ├── HairIsVisible.php
    │           │   ├── FaceIsOfSufficientSize.php
    │           │   ├── NoMakeup.php
    │           │   ├── Evaluation.php
    │           │   ├── IsNotWearingGlasses.php
    │           │   ├── IsNotWearingSunglasses.php
    │           │   ├── FaceIsNotCovered.php
    │           │   ├── BlurIsAcceptable.php
    │           │   ├── NoiseIsAcceptable.php
    │           │   └── FaceIsOfAcceptableAngle.php
    │           └── Constraints
    │           │   ├── FaceValidator.php
    │           │   └── Face.php
    │       ├── Calculator
    │           └── FaceToImageRatioCalculator.php
    │       ├── DependencyInjection
    │           ├── AllowedRegions.php
    │           ├── Configuration.php
    │           └── XSolveFaceValidatorExtension.php
    │       ├── Factory
    │           └── FaceDetectionResultFactory.php
    │       └── Resources
    │           └── config
    │               └── services.yml
├── .travis.yml
├── .php_cs
├── phpunit.xml.dist
├── LICENSE
├── composer.json
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | composer.lock
2 | /phpunit.xml
3 | /vendor/
4 | /.php_cs.cache
5 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/images/1x1:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boldare/xsolve-face-validator-bundle/HEAD/tests/XSolve/FaceValidatorBundle/images/1x1


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/images/100x100:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boldare/xsolve-face-validator-bundle/HEAD/tests/XSolve/FaceValidatorBundle/images/100x100


--------------------------------------------------------------------------------
/src/.htaccess:
--------------------------------------------------------------------------------
1 | <IfModule mod_authz_core.c>
2 |     Require all denied
3 | </IfModule>
4 | <IfModule !mod_authz_core.c>
5 |     Order deny,allow
6 |     Deny from all
7 | </IfModule>
8 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Exception/NoFaceDetectedException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace XSolve\FaceValidatorBundle\Exception;
4 | 
5 | class NoFaceDetectedException extends \Exception
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Gender.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use MyCLabs\Enum\Enum;
 6 | 
 7 | /**
 8 |  * @method static MALE()
 9 |  * @method static FEMALE()
10 |  */
11 | class Gender extends Enum
12 | {
13 |     const MALE = 'male';
14 | 
15 |     const FEMALE = 'female';
16 | }
17 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Client/AzureFaceAPIClient.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Client;
 4 | 
 5 | interface AzureFaceAPIClient
 6 | {
 7 |     public function detect(
 8 |         string $filePath,
 9 |         bool $returnFaceId = false,
10 |         bool $returnFaceLandmarks = true,
11 |         array $returnFaceAttributes = null
12 |     ): array;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/XSolveFaceValidatorBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle;
 4 | 
 5 | use Symfony\Component\HttpKernel\Bundle\Bundle;
 6 | 
 7 | class XSolveFaceValidatorBundle extends Bundle
 8 | {
 9 |     public function getContainerExtension()
10 |     {
11 |         return new DependencyInjection\XSolveFaceValidatorExtension();
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Accessory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use MyCLabs\Enum\Enum;
 6 | 
 7 | /**
 8 |  * @method static HEADWEAR()
 9 |  * @method static GLASSES()
10 |  * @method static MASK()
11 |  */
12 | class Accessory extends Enum
13 | {
14 |     const HEADWEAR = 'headwear';
15 | 
16 |     const GLASSES = 'glasses';
17 | 
18 |     const MASK = 'mask';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/ExposureLevel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use MyCLabs\Enum\Enum;
 6 | 
 7 | /**
 8 |  * @method static GOOD()
 9 |  * @method static OVER()
10 |  * @method static UNDER()
11 |  */
12 | class ExposureLevel extends Enum
13 | {
14 |     const GOOD = 'goodExposure';
15 | 
16 |     const OVER = 'overExposure';
17 | 
18 |     const UNDER = 'underExposure';
19 | }
20 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Detector/FaceDetector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Detector;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Exception\NoFaceDetectedException;
 6 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 7 | 
 8 | interface FaceDetector
 9 | {
10 |     /**
11 |      * @throws NoFaceDetectedException
12 |      */
13 |     public function detect(string $filePath): FaceDetectionResult;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/FaceValidationSpecification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 7 | 
 8 | interface FaceValidationSpecification
 9 | {
10 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Calculator/FaceToImageRatioCalculator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Calculator;
 4 | 
 5 | class FaceToImageRatioCalculator
 6 | {
 7 |     public function calculate(string $filePath, int $faceWidth, int $faceHeight): float
 8 |     {
 9 |         list($imageWidth, $imageHeight) = getimagesize($filePath);
10 | 
11 |         return ($faceWidth * $faceHeight) / ($imageWidth * $imageHeight);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/config_test.yml:
--------------------------------------------------------------------------------
 1 | xsolve_face_validator:
 2 |     azure_subscription_key: dummy_azure_subscription_key
 3 |     region: westeurope
 4 | 
 5 | framework:
 6 |     test: ~
 7 |     validation: ~
 8 | 
 9 | services:
10 |     xsolve_face_validator.client.azure:
11 |         class: Tests\XSolve\FaceValidatorBundle\Integration\AzureClientMock
12 |         public: true
13 | 
14 | parameters:
15 |     kernel.secret: dummy_kernel_secret
16 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Glasses.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use MyCLabs\Enum\Enum;
 6 | 
 7 | /**
 8 |  * @method static NONE()
 9 |  * @method static READING()
10 |  * @method static SUN()
11 |  * @method static SWIMMING()
12 |  */
13 | class Glasses extends Enum
14 | {
15 |     const NONE = 'NoGlasses';
16 | 
17 |     const READING = 'ReadingGlasses';
18 | 
19 |     const SUN = 'Sunglasses';
20 | 
21 |     const SWIMMING = 'SwimmingGoggles';
22 | }
23 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | sudo: false
 4 | 
 5 | cache:
 6 |   directories:
 7 |     - $HOME/.composer/cache/files
 8 | 
 9 | php:
10 |   - '7.0'
11 |   - '7.1'
12 |   - '7.2'
13 | 
14 | env:
15 |   - SYMFONY_VERSION="3.3.*"
16 |   - SYMFONY_VERSION="3.4.*"
17 | 
18 | install:
19 |     - composer install
20 | 
21 | script:
22 |   - vendor/bin/phpunit
23 |   - vendor/bin/php-cs-fixer fix -vvv --using-cache=no --diff --config=.php_cs --dry-run --path-mode=intersection `git diff --name-only --diff-filter=ACMRTUXB $TRAVIS_COMMIT_RANGE`


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/DependencyInjection/AllowedRegions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\DependencyInjection;
 4 | 
 5 | class AllowedRegions
 6 | {
 7 |     const NAMES = [
 8 |         'westus',
 9 |         'westus2',
10 |         'eastus',
11 |         'eastus2',
12 |         'westcentralus',
13 |         'southcentralus',
14 |         'westeurope',
15 |         'northeurope',
16 |         'southeastasia',
17 |         'eastasia',
18 |         'australiaeast',
19 |         'brazilsouth',
20 |     ];
21 | }
22 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Makeup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | class Makeup
 6 | {
 7 |     /**
 8 |      * @var bool
 9 |      */
10 |     private $onFace;
11 | 
12 |     /**
13 |      * @var bool
14 |      */
15 |     private $onLips;
16 | 
17 |     public function __construct(bool $onFace, bool $onLips)
18 |     {
19 |         $this->onFace = $onFace;
20 |         $this->onLips = $onLips;
21 |     }
22 | 
23 |     public function isOnFace(): bool
24 |     {
25 |         return $this->onFace;
26 |     }
27 | 
28 |     public function isOnLips(): bool
29 |     {
30 |         return $this->onLips;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Blur.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | class Blur
 6 | {
 7 |     /**
 8 |      * @var BlurLevel
 9 |      */
10 |     private $level;
11 | 
12 |     /**
13 |      * @var float
14 |      */
15 |     private $value;
16 | 
17 |     public function __construct(BlurLevel $level, float $value)
18 |     {
19 |         $this->level = $level;
20 |         $this->value = $value;
21 |     }
22 | 
23 |     public function getLevel(): BlurLevel
24 |     {
25 |         return $this->level;
26 |     }
27 | 
28 |     public function getValue(): float
29 |     {
30 |         return $this->value;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Noise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | class Noise
 6 | {
 7 |     /**
 8 |      * @var NoiseLevel
 9 |      */
10 |     private $level;
11 | 
12 |     /**
13 |      * @var float
14 |      */
15 |     private $value;
16 | 
17 |     public function __construct(NoiseLevel $level, float $value)
18 |     {
19 |         $this->level = $level;
20 |         $this->value = $value;
21 |     }
22 | 
23 |     public function getLevel(): NoiseLevel
24 |     {
25 |         return $this->level;
26 |     }
27 | 
28 |     public function getValue(): float
29 |     {
30 |         return $this->value;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/HairIsVisible.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 7 | 
 8 | class HairIsVisible implements FaceValidationSpecification
 9 | {
10 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
11 |     {
12 |         if ($constraint->allowNoHair || $result->isHairVisible()) {
13 |             return new Evaluation(true);
14 |         }
15 | 
16 |         return new Evaluation(false, $constraint->hairCoveredMessage);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Exposure.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | class Exposure
 6 | {
 7 |     /**
 8 |      * @var ExposureLevel
 9 |      */
10 |     private $level;
11 | 
12 |     /**
13 |      * @var float
14 |      */
15 |     private $value;
16 | 
17 |     public function __construct(ExposureLevel $level, float $value)
18 |     {
19 |         $this->level = $level;
20 |         $this->value = $value;
21 |     }
22 | 
23 |     public function getLevel(): ExposureLevel
24 |     {
25 |         return $this->level;
26 |     }
27 | 
28 |     public function getValue(): float
29 |     {
30 |         return $this->value;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/FaceIsOfSufficientSize.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 7 | 
 8 | class FaceIsOfSufficientSize implements FaceValidationSpecification
 9 | {
10 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
11 |     {
12 |         if ($result->getFaceToImageRatio() >= $constraint->minFaceRatio) {
13 |             return new Evaluation(true);
14 |         }
15 | 
16 |         return new Evaluation(false, $constraint->faceTooSmallMessage);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/NoMakeup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 7 | 
 8 | class NoMakeup implements FaceValidationSpecification
 9 | {
10 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
11 |     {
12 |         $makeup = $result->getMakeup();
13 | 
14 |         if ($constraint->allowMakeup || ($makeup->isOnFace() && !$makeup->isOnLips())) {
15 |             return new Evaluation(true);
16 |         }
17 | 
18 |         return new Evaluation(false, $constraint->makeupMessage);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/BlurLevel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use MyCLabs\Enum\Enum;
 6 | 
 7 | /**
 8 |  * @method static LOW()
 9 |  * @method static MEDIUM()
10 |  * @method static HIGH()
11 |  */
12 | class BlurLevel extends Enum
13 | {
14 |     const LOW = 'low';
15 | 
16 |     const MEDIUM = 'medium';
17 | 
18 |     const HIGH = 'high';
19 | 
20 |     public function isLowerOrEqual(self $other): bool
21 |     {
22 |         if (self::HIGH() == $other) {
23 |             return true;
24 |         }
25 | 
26 |         if (self::MEDIUM() == $other) {
27 |             return in_array($this, [self::MEDIUM(), self::LOW()]);
28 |         }
29 | 
30 |         return self::LOW() == $this;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/NoiseLevel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use MyCLabs\Enum\Enum;
 6 | 
 7 | /**
 8 |  * @method static LOW()
 9 |  * @method static MEDIUM()
10 |  * @method static HIGH()
11 |  */
12 | class NoiseLevel extends Enum
13 | {
14 |     const LOW = 'low';
15 | 
16 |     const MEDIUM = 'medium';
17 | 
18 |     const HIGH = 'high';
19 | 
20 |     public function isLowerOrEqual(self $other): bool
21 |     {
22 |         if (self::HIGH() == $other) {
23 |             return true;
24 |         }
25 | 
26 |         if (self::MEDIUM() == $other) {
27 |             return in_array($this, [self::MEDIUM(), self::LOW()]);
28 |         }
29 | 
30 |         return self::LOW() == $this;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/Evaluation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | final class Evaluation
 6 | {
 7 |     /**
 8 |      * @var bool
 9 |      */
10 |     private $successful;
11 | 
12 |     /**
13 |      * @var string
14 |      */
15 |     private $message = '';
16 | 
17 |     public function __construct(bool $successful, string $message = '')
18 |     {
19 |         $this->successful = $successful;
20 |         $this->message = $message;
21 |     }
22 | 
23 |     public function isSuccessful(): bool
24 |     {
25 |         return $this->successful;
26 |     }
27 | 
28 |     public function getMessage(): string
29 |     {
30 |         return $this->message;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/IsNotWearingGlasses.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Result\Glasses;
 7 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 8 | 
 9 | class IsNotWearingGlasses implements FaceValidationSpecification
10 | {
11 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
12 |     {
13 |         if ($constraint->allowGlasses || Glasses::NONE() == $result->getGlasses()) {
14 |             return new Evaluation(true);
15 |         }
16 | 
17 |         return new Evaluation(false, $constraint->glassesMessage);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/IsNotWearingSunglasses.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Result\Glasses;
 7 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 8 | 
 9 | class IsNotWearingSunglasses implements FaceValidationSpecification
10 | {
11 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
12 |     {
13 |         if ($constraint->allowSunglasses || Glasses::SUN() != $result->getGlasses()) {
14 |             return new Evaluation(true);
15 |         }
16 | 
17 |         return new Evaluation(false, $constraint->sunglassesMessage);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/FaceIsNotCovered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\Accessory;
 6 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 7 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 8 | 
 9 | class FaceIsNotCovered implements FaceValidationSpecification
10 | {
11 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
12 |     {
13 |         if ($constraint->allowCoveringFace || !in_array(Accessory::MASK(), $result->getAccessories())) {
14 |             return new Evaluation(true);
15 |         }
16 | 
17 |         return new Evaluation(false, $constraint->faceCoveredMessage);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/.php_cs:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return PhpCsFixer\Config::create()
 4 |     ->setRules([
 5 |         '@Symfony'                            => true,
 6 |         'array_syntax'                        => ['syntax' => 'short'],
 7 |         'phpdoc_add_missing_param_annotation' => true,
 8 |         'linebreak_after_opening_tag'         => true,
 9 |         'phpdoc_annotation_without_dot'       => false,
10 |         'phpdoc_summary'                      => false,
11 |         'phpdoc_no_package'                   => false,
12 |         'phpdoc_order'                        => true,
13 |         'pre_increment'                       => false,
14 |         'phpdoc_align'                        => false,
15 |     ])
16 |     ->setFinder(
17 |         PhpCsFixer\Finder::create()
18 |             ->in('./src')
19 |     );
20 | 
21 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/AzureClientMock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\XSolve\FaceValidatorBundle\Integration;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Client\AzureFaceAPIClient;
 6 | 
 7 | class AzureClientMock implements AzureFaceAPIClient
 8 | {
 9 |     /**
10 |      * @var array
11 |      */
12 |     private $responseData = [];
13 | 
14 |     /**
15 |      * {@inheritdoc}
16 |      */
17 |     public function detect(
18 |         string $filePath,
19 |         bool $returnFaceId = false,
20 |         bool $returnFaceLandmarks = true,
21 |        array $returnFaceAttributes = null
22 |     ): array {
23 |         return $this->responseData;
24 |     }
25 | 
26 |     public function setResponseData(array $responseData)
27 |     {
28 |         $this->responseData = $responseData;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/Rotation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | class Rotation
 6 | {
 7 |     /**
 8 |      * @var float
 9 |      */
10 |     private $x;
11 | 
12 |     /**
13 |      * @var float
14 |      */
15 |     private $y;
16 | 
17 |     /**
18 |      * @var float
19 |      */
20 |     private $z;
21 | 
22 |     public function __construct(float $x, float $y, float $z)
23 |     {
24 |         $this->x = $x;
25 |         $this->y = $y;
26 |         $this->z = $z;
27 |     }
28 | 
29 |     public function getX(): float
30 |     {
31 |         return $this->x;
32 |     }
33 | 
34 |     public function getY(): float
35 |     {
36 |         return $this->y;
37 |     }
38 | 
39 |     public function getZ(): float
40 |     {
41 |         return $this->z;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/BlurIsAcceptable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\BlurLevel;
 6 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 7 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 8 | 
 9 | class BlurIsAcceptable implements FaceValidationSpecification
10 | {
11 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
12 |     {
13 |         $acceptableLevel = new BlurLevel($constraint->maxBlurLevel);
14 | 
15 |         if ($result->getBlur()->getLevel()->isLowerOrEqual($acceptableLevel)) {
16 |             return new Evaluation(true);
17 |         }
18 | 
19 |         return new Evaluation(false, $constraint->blurredMessage);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/NoiseIsAcceptable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Result\NoiseLevel;
 7 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 8 | 
 9 | class NoiseIsAcceptable implements FaceValidationSpecification
10 | {
11 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
12 |     {
13 |         $acceptableLevel = new NoiseLevel($constraint->maxNoiseLevel);
14 |         $actualLevel = $result->getNoise()->getLevel();
15 | 
16 |         if ($actualLevel->isLowerOrEqual($acceptableLevel)) {
17 |             return new Evaluation(true);
18 |         }
19 | 
20 |         return new Evaluation(false, $constraint->noiseMessage);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Specification/FaceIsOfAcceptableAngle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Specification;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 6 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 7 | 
 8 | class FaceIsOfAcceptableAngle implements FaceValidationSpecification
 9 | {
10 |     public function evaluate(FaceDetectionResult $result, Face $constraint): Evaluation
11 |     {
12 |         $rotation = $result->getRotation();
13 | 
14 |         foreach ([$rotation->getX(), $rotation->getY(), $rotation->getZ()] as $rotationValue) {
15 |             if ($rotationValue > $constraint->maxFaceRotation) {
16 |                 return new Evaluation(false, $constraint->tooMuchRotatedMessage);
17 |             }
18 |         }
19 | 
20 |         return new Evaluation(true);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/TestKernel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\XSolve\FaceValidatorBundle\Integration;
 4 | 
 5 | use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
 6 | use Symfony\Component\Config\Loader\LoaderInterface;
 7 | use Symfony\Component\HttpKernel\Kernel;
 8 | use XSolve\FaceValidatorBundle\XSolveFaceValidatorBundle;
 9 | 
10 | class TestKernel extends Kernel
11 | {
12 |     /**
13 |      * {@inheritdoc}
14 |      */
15 |     public function registerBundles(): array
16 |     {
17 |         return [
18 |             new FrameworkBundle(),
19 |             new XSolveFaceValidatorBundle(),
20 |         ];
21 |     }
22 | 
23 |     /**
24 |      * {@inheritdoc}
25 |      */
26 |     public function registerContainerConfiguration(LoaderInterface $loader)
27 |     {
28 |         $loader->load(__DIR__.'/config_test.yml');
29 |     }
30 | 
31 |     /**
32 |      * {@inheritdoc}
33 |      */
34 |     public function getCacheDir()
35 |     {
36 |         return $this->rootDir.'/cache';
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/DependencyInjection/Configuration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\DependencyInjection;
 4 | 
 5 | use Symfony\Component\Config\Definition\Builder\TreeBuilder;
 6 | use Symfony\Component\Config\Definition\ConfigurationInterface;
 7 | 
 8 | class Configuration implements ConfigurationInterface
 9 | {
10 |     /**
11 |      * {@inheritdoc}
12 |      */
13 |     public function getConfigTreeBuilder()
14 |     {
15 |         $treeBuilder = new TreeBuilder();
16 |         $rootNode = $treeBuilder->root('xsolve_face_validator');
17 | 
18 |         $rootNode
19 |             ->children()
20 |                 ->scalarNode('azure_subscription_key')
21 |                     ->isRequired()
22 |                     ->cannotBeEmpty()
23 |                 ->end()
24 |                 ->enumNode('region')
25 |                     ->isRequired()
26 |                     ->values(AllowedRegions::NAMES)
27 |                 ->end()
28 |             ->end();
29 | 
30 |         return $treeBuilder;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <!-- https://phpunit.de/manual/current/en/appendixes.configuration.html -->
 4 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 |          xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.8/phpunit.xsd"
 6 |          backupGlobals="false"
 7 |          colors="true"
 8 |          bootstrap="vendor/autoload.php"
 9 | >
10 |     <php>
11 |         <server name="KERNEL_CLASS" value="Tests\XSolve\FaceValidatorBundle\Integration\TestKernel" />
12 |     </php>
13 | 
14 |     <testsuites>
15 |         <testsuite name="Project Test Suite">
16 |             <directory>tests</directory>
17 |         </testsuite>
18 |     </testsuites>
19 | 
20 |     <filter>
21 |         <whitelist>
22 |             <directory>src</directory>
23 |             <exclude>
24 |                 <directory>src/XSolve/FaceValidatorBundle/DependencyInjection</directory>
25 |                 <directory>src/XSolve/FaceValidatorBundle/Resources</directory>
26 |             </exclude>
27 |         </whitelist>
28 |     </filter>
29 | </phpunit>
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 XSolve Sp. z o.o.
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Detector/AzureAPIFaceDetector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Detector;
 4 | 
 5 | use XSolve\FaceValidatorBundle\Client\AzureFaceAPIClient;
 6 | use XSolve\FaceValidatorBundle\Exception\NoFaceDetectedException;
 7 | use XSolve\FaceValidatorBundle\Factory\FaceDetectionResultFactory;
 8 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 9 | 
10 | class AzureAPIFaceDetector implements FaceDetector
11 | {
12 |     /**
13 |      * @var AzureFaceAPIClient
14 |      */
15 |     private $client;
16 | 
17 |     /**
18 |      * @var FaceDetectionResultFactory
19 |      */
20 |     private $resultFactory;
21 | 
22 |     public function __construct(AzureFaceAPIClient $client, FaceDetectionResultFactory $resultFactory)
23 |     {
24 |         $this->client = $client;
25 |         $this->resultFactory = $resultFactory;
26 |     }
27 | 
28 |     public function detect(string $filePath): FaceDetectionResult
29 |     {
30 |         $data = $this->client->detect($filePath);
31 | 
32 |         if (empty($data)) {
33 |             throw new NoFaceDetectedException();
34 |         }
35 | 
36 |         return $this->resultFactory->create($filePath, $data);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/KernelTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\XSolve\FaceValidatorBundle\Integration;
 4 | 
 5 | use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase as BaseKernelTestCase;
 6 | use Symfony\Component\Filesystem\Filesystem;
 7 | 
 8 | class KernelTestCase extends BaseKernelTestCase
 9 | {
10 |     /**
11 |      * {@inheritdoc}
12 |      */
13 |     public static function setUpBeforeClass()
14 |     {
15 |         static::bootKernel(['environment' => 'test', 'debug' => true]);
16 |     }
17 | 
18 |     /**
19 |      * {@inheritdoc}
20 |      */
21 |     public static function tearDownAfterClass()
22 |     {
23 |         static::ensureKernelShutdown();
24 |         static::removeDirWithFiles(static::$kernel->getCacheDir());
25 |         static::removeDirWithFiles(static::$kernel->getLogDir());
26 |     }
27 | 
28 |     /**
29 |      * {@inheritdoc}
30 |      */
31 |     protected function tearDown()
32 |     {
33 |         // shutting down the kernel after each test (which is done in parent class) is not really efficient
34 |     }
35 | 
36 |     private static function removeDirWithFiles(string $path)
37 |     {
38 |         (new Filesystem())->remove($path);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/DependencyInjection/XSolveFaceValidatorExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\DependencyInjection;
 4 | 
 5 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 6 | use Symfony\Component\Config\FileLocator;
 7 | use Symfony\Component\HttpKernel\DependencyInjection\Extension;
 8 | use Symfony\Component\DependencyInjection\Loader;
 9 | 
10 | class XSolveFaceValidatorExtension extends Extension
11 | {
12 |     /**
13 |      * {@inheritdoc}
14 |      */
15 |     public function load(array $configs, ContainerBuilder $container)
16 |     {
17 |         $configuration = new Configuration();
18 |         $config = $this->processConfiguration($configuration, $configs);
19 | 
20 |         $container->setParameter('xsolve_face_validator.client.azure.subscription_key', $config['azure_subscription_key']);
21 |         $container->setParameter(
22 |             'xsolve_face_validator.client.azure.base_uri',
23 |             sprintf('https://%s.api.cognitive.microsoft.com/face/v1.0/', $config['region'])
24 |         );
25 | 
26 |         $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
27 |         $loader->load('services.yml');
28 |     }
29 | 
30 |     /**
31 |      * {@inheritdoc}
32 |      */
33 |     public function getAlias()
34 |     {
35 |         return 'xsolve_face_validator';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "xsolve-pl/face-validator-bundle",
 3 |     "description": "Symfony3 bundle for validating face on picture using MS Azure Face API",
 4 |     "license": "MIT",
 5 |     "homepage": "https://xsolve.software",
 6 |     "type": "symfony-bundle",
 7 |     "keywords": ["face", "validator", "detect", "recognition", "machine learning", "azure"],
 8 |     "authors": [
 9 |         {
10 |             "name": "Pawel Krynicki",
11 |             "email": "pawel.krynicki@xsolve.software"
12 |         },
13 |         {
14 |             "name": "Michal Nicinski",
15 |             "email": "michal.nicinski@xsolve.software"
16 |         }
17 |     ],
18 |     "require": {
19 |         "php": ">=7.0.0",
20 |         "guzzlehttp/guzzle": "~6.3",
21 |         "myclabs/php-enum": "~1.5",
22 |         "symfony/http-kernel": "3.3.*",
23 |         "symfony/config": "3.3.*",
24 |         "symfony/dependency-injection": "3.3.*",
25 |         "symfony/validator": "3.3.*",
26 |         "symfony/property-access": "3.3.*"
27 |     },
28 |     "require-dev": {
29 |         "phpunit/phpunit": "^6.2",
30 |         "symfony/framework-bundle": "3.3.*",
31 |         "symfony/yaml": "3.3.*",
32 |         "friendsofphp/php-cs-fixer": "^2.7"
33 |     },
34 |     "autoload": {
35 |         "psr-4": {
36 |             "XSolve\\": "src/XSolve"
37 |         }
38 |     },
39 |     "autoload-dev": {
40 |         "psr-4": {
41 |             "Tests\\": "tests/"
42 |         }
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Calculator/FaceToImageRatioCalculatorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\XSolve\FaceValidatorBundle\Calculator;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use XSolve\FaceValidatorBundle\Calculator\FaceToImageRatioCalculator;
 7 | 
 8 | class FaceToImageRatioCalculatorTest extends TestCase
 9 | {
10 |     const IMAGES_DIRECTORY = __DIR__.'/../images';
11 | 
12 |     /**
13 |      * @var FaceToImageRatioCalculator
14 |      */
15 |     private $calculator;
16 | 
17 |     /**
18 |      * {@inheritdoc}
19 |      */
20 |     protected function setUp()
21 |     {
22 |         $this->calculator = new FaceToImageRatioCalculator();
23 |     }
24 | 
25 |     /**
26 |      * @group integration
27 |      * @requires extension gd
28 |      * @dataProvider calculateProvider
29 |      */
30 |     public function testCalculate(string $path, int $faceWidth, int $faceHeight, float $expectedResult)
31 |     {
32 |         $this->assertSame($expectedResult, $this->calculator->calculate($path, $faceWidth, $faceHeight));
33 |     }
34 | 
35 |     public function calculateProvider(): array
36 |     {
37 |         return [
38 |             [$this->generateImagePath('100x100'), 0, 0, 0.0],
39 |             [$this->generateImagePath('100x100'), 100, 100, 1.0],
40 |             [$this->generateImagePath('100x100'), 100, 50, 0.5],
41 |             [$this->generateImagePath('100x100'), 50, 50, 0.25],
42 |         ];
43 |     }
44 | 
45 |     private function generateImagePath(string $imageName): string
46 |     {
47 |         return sprintf('%s/%s', self::IMAGES_DIRECTORY, $imageName);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Detector/AzureAPIFaceDetectorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\XSolve\FaceValidatorBundle\Detector;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use Prophecy\Prophecy\ObjectProphecy;
 7 | use XSolve\FaceValidatorBundle\Client\AzureFaceAPIClient;
 8 | use XSolve\FaceValidatorBundle\Detector\AzureAPIFaceDetector;
 9 | use XSolve\FaceValidatorBundle\Factory\FaceDetectionResultFactory;
10 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
11 | 
12 | class AzureAPIFaceDetectorTest extends TestCase
13 | {
14 |     /**
15 |      * @var AzureAPIFaceDetector
16 |      */
17 |     private $detector;
18 | 
19 |     /**
20 |      * @var ObjectProphecy|AzureFaceAPIClient
21 |      */
22 |     private $client;
23 | 
24 |     /**
25 |      * @var ObjectProphecy|FaceDetectionResultFactory
26 |      */
27 |     private $resultFactory;
28 | 
29 |     /**
30 |      * {@inheritdoc}
31 |      */
32 |     protected function setUp()
33 |     {
34 |         $this->client = $this->prophesize(AzureFaceAPIClient::class);
35 |         $this->resultFactory = $this->prophesize(FaceDetectionResultFactory::class);
36 |         $this->detector = new AzureAPIFaceDetector($this->client->reveal(), $this->resultFactory->reveal());
37 |     }
38 | 
39 |     public function testDetect()
40 |     {
41 |         $result = $this->prophesize(FaceDetectionResult::class)->reveal();
42 |         $this->client->detect('test file path')->willReturn(['data']);
43 |         $this->resultFactory->create('test file path', ['data'])->willReturn($result);
44 | 
45 |         $this->assertSame($result, $this->detector->detect('test file path'));
46 |     }
47 | 
48 |     /**
49 |      * @expectedException \XSolve\FaceValidatorBundle\Exception\NoFaceDetectedException
50 |      */
51 |     public function testDetectNoResult()
52 |     {
53 |         $this->client->detect('test file path')->willReturn([]);
54 | 
55 |         $this->detector->detect('test file path');
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Client/GuzzleWrapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Client;
 4 | 
 5 | use GuzzleHttp\ClientInterface;
 6 | 
 7 | class GuzzleWrapper implements AzureFaceAPIClient
 8 | {
 9 |     /**
10 |      * @var ClientInterface
11 |      */
12 |     private $client;
13 |     /**
14 |      * @var string
15 |      */
16 |     private $subscriptionKey;
17 | 
18 |     /**
19 |      * @var string[]
20 |      */
21 |     private static $faceAttributes = [
22 |         'age', 'gender', 'headPose', 'smile', 'facialHair',
23 |         'glasses', 'emotion', 'hair', 'makeup', 'occlusion',
24 |         'accessories', 'blur', 'exposure', 'noise',
25 |     ];
26 | 
27 |     public function __construct(ClientInterface $client, string $subscriptionKey)
28 |     {
29 |         $this->client = $client;
30 |         $this->subscriptionKey = $subscriptionKey;
31 |     }
32 | 
33 |     public function detect(
34 |         string $filePath,
35 |         bool $returnFaceId = false,
36 |         bool $returnFaceLandmarks = true,
37 |         array $returnFaceAttributes = null
38 |     ): array {
39 |         $fs = fopen($filePath, 'r');
40 | 
41 |         if (null === $returnFaceAttributes) {
42 |             $returnFaceAttributes = self::$faceAttributes;
43 |         }
44 | 
45 |         $response = $this->client->request('POST', 'detect', [
46 |             'headers' => [
47 |                 'Content-Type' => 'application/octet-stream',
48 |                 'Ocp-Apim-Subscription-Key' => $this->subscriptionKey,
49 |             ],
50 |             'query' => [
51 |                 'returnFaceId' => $returnFaceId,
52 |                 'returnFaceLandmarks' => $returnFaceLandmarks,
53 |                 'returnFaceAttributes' => implode(',', $returnFaceAttributes),
54 |             ],
55 |             'body' => $fs,
56 |         ]);
57 |         $data = json_decode($response->getBody()->getContents(), true);
58 | 
59 |         return $data ? current($data) : [];
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Result/BlurLevelTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use XSolve\FaceValidatorBundle\Result\BlurLevel;
 7 | 
 8 | class BlurLevelTest extends TestCase
 9 | {
10 |     /**
11 |      * @var BlurLevel
12 |      */
13 |     private $testedBlurLevel;
14 | 
15 |     public function testIsLowerOrEqualToLowBlurLvl()
16 |     {
17 |         $lowBlurLevel = BlurLevel::LOW();
18 | 
19 |         $this->testedBlurLevel = BlurLevel::LOW();
20 |         $this->assertTrue($this->testedBlurLevel->isLowerOrEqual($lowBlurLevel));
21 | 
22 |         $this->testedBlurLevel = BlurLevel::MEDIUM();
23 |         $this->assertNotTrue($this->testedBlurLevel->isLowerOrEqual($lowBlurLevel));
24 | 
25 |         $this->testedBlurLevel = BlurLevel::HIGH();
26 |         $this->assertNotTrue($this->testedBlurLevel->isLowerOrEqual($lowBlurLevel));
27 |     }
28 | 
29 |     public function testIsLowerOrEqualToMediumBlurLvl()
30 |     {
31 |         $mediumBlurLevel = BlurLevel::MEDIUM();
32 | 
33 |         $this->testedBlurLevel = BlurLevel::LOW();
34 |         $this->assertTrue($this->testedBlurLevel->isLowerOrEqual($mediumBlurLevel));
35 | 
36 |         $this->testedBlurLevel = BlurLevel::MEDIUM();
37 |         $this->assertTrue($this->testedBlurLevel->isLowerOrEqual($mediumBlurLevel));
38 | 
39 |         $this->testedBlurLevel = BlurLevel::HIGH();
40 |         $this->assertNotTrue($this->testedBlurLevel->isLowerOrEqual($mediumBlurLevel));
41 |     }
42 | 
43 |     public function testIsLowerOrEqualToHighBlurLvl()
44 |     {
45 |         $highBlurLevel = BlurLevel::HIGH();
46 | 
47 |         $this->testedBlurLevel = BlurLevel::LOW();
48 |         $this->assertTrue($this->testedBlurLevel->isLowerOrEqual($highBlurLevel));
49 | 
50 |         $this->testedBlurLevel = BlurLevel::MEDIUM();
51 |         $this->assertTrue($this->testedBlurLevel->isLowerOrEqual($highBlurLevel));
52 | 
53 |         $this->testedBlurLevel = BlurLevel::HIGH();
54 |         $this->assertTrue($this->testedBlurLevel->isLowerOrEqual($highBlurLevel));
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Result/NoiseLevelTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Tests\XSolve\FaceValidatorBundle\Result;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use XSolve\FaceValidatorBundle\Result\NoiseLevel;
 7 | 
 8 | class NoiseLevelTest extends TestCase
 9 | {
10 |     /**
11 |      * @var NoiseLevel
12 |      */
13 |     private $testedNoiseLevel;
14 | 
15 |     public function testIsLowerOrEqualToLowNoiseLvl()
16 |     {
17 |         $lowNoiseLevel = NoiseLevel::LOW();
18 | 
19 |         $this->testedNoiseLevel = NoiseLevel::LOW();
20 |         $this->assertTrue($this->testedNoiseLevel->isLowerOrEqual($lowNoiseLevel));
21 | 
22 |         $this->testedNoiseLevel = NoiseLevel::MEDIUM();
23 |         $this->assertNotTrue($this->testedNoiseLevel->isLowerOrEqual($lowNoiseLevel));
24 | 
25 |         $this->testedNoiseLevel = NoiseLevel::HIGH();
26 |         $this->assertNotTrue($this->testedNoiseLevel->isLowerOrEqual($lowNoiseLevel));
27 |     }
28 | 
29 |     public function testIsLowerOrEqualToMediumNoiseLvl()
30 |     {
31 |         $mediumNoiseLevel = NoiseLevel::MEDIUM();
32 | 
33 |         $this->testedNoiseLevel = NoiseLevel::LOW();
34 |         $this->assertTrue($this->testedNoiseLevel->isLowerOrEqual($mediumNoiseLevel));
35 | 
36 |         $this->testedNoiseLevel = NoiseLevel::MEDIUM();
37 |         $this->assertTrue($this->testedNoiseLevel->isLowerOrEqual($mediumNoiseLevel));
38 | 
39 |         $this->testedNoiseLevel = NoiseLevel::HIGH();
40 |         $this->assertNotTrue($this->testedNoiseLevel->isLowerOrEqual($mediumNoiseLevel));
41 |     }
42 | 
43 |     public function testIsLowerOrEqualToHighNoiseLvl()
44 |     {
45 |         $highNoiseLevel = NoiseLevel::HIGH();
46 | 
47 |         $this->testedNoiseLevel = NoiseLevel::LOW();
48 |         $this->assertTrue($this->testedNoiseLevel->isLowerOrEqual($highNoiseLevel));
49 | 
50 |         $this->testedNoiseLevel = NoiseLevel::MEDIUM();
51 |         $this->assertTrue($this->testedNoiseLevel->isLowerOrEqual($highNoiseLevel));
52 | 
53 |         $this->testedNoiseLevel = NoiseLevel::HIGH();
54 |         $this->assertTrue($this->testedNoiseLevel->isLowerOrEqual($highNoiseLevel));
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/responses/glasses.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "faceId": "glasses",
 3 |     "faceRectangle": {
 4 |         "top": 83,
 5 |         "left": 76,
 6 |         "width": 97,
 7 |         "height": 97
 8 |     },
 9 |     "faceAttributes": {
10 |         "smile": 0.112,
11 |         "headPose": {
12 |             "pitch": 0,
13 |             "roll": -4,
14 |             "yaw": 0.3
15 |         },
16 |         "gender": "male",
17 |         "age": 68.9,
18 |         "facialHair": {
19 |             "moustache": 0,
20 |             "beard": 0,
21 |             "sideburns": 0
22 |         },
23 |         "glasses": "ReadingGlasses",
24 |         "emotion": {
25 |             "anger": 0,
26 |             "contempt": 0,
27 |             "disgust": 0,
28 |             "fear": 0,
29 |             "happiness": 0.112,
30 |             "neutral": 0.857,
31 |             "sadness": 0.03,
32 |             "surprise": 0
33 |         },
34 |         "blur": {
35 |             "blurLevel": "low",
36 |             "value": 0.19
37 |         },
38 |         "exposure": {
39 |             "exposureLevel": "goodExposure",
40 |             "value": 0.68
41 |         },
42 |         "noise": {
43 |             "noiseLevel": "low",
44 |             "value": 0.21
45 |         },
46 |         "makeup": {
47 |             "eyeMakeup": false,
48 |             "lipMakeup": false
49 |         },
50 |         "accessories": [{
51 |                 "type": "glasses",
52 |                 "confidence": 0.99
53 |             }],
54 |         "occlusion": {
55 |             "foreheadOccluded": false,
56 |             "eyeOccluded": false,
57 |             "mouthOccluded": false
58 |         },
59 |         "hair": {
60 |             "bald": 0.02,
61 |             "invisible": false,
62 |             "hairColor": [{
63 |                     "color": "brown",
64 |                     "confidence": 0.99
65 |                 }, {
66 |                     "color": "blond",
67 |                     "confidence": 0.59
68 |                 }, {
69 |                     "color": "gray",
70 |                     "confidence": 0.59
71 |                 }, {
72 |                     "color": "red",
73 |                     "confidence": 0.2
74 |                 }, {
75 |                     "color": "black",
76 |                     "confidence": 0.19
77 |                 }, {
78 |                     "color": "other",
79 |                     "confidence": 0.11
80 |                 }]
81 |         }
82 |     }
83 | }


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/responses/sunglasses.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "faceId": "sunglasses",
 3 |     "faceRectangle": {
 4 |         "top": 83,
 5 |         "left": 76,
 6 |         "width": 97,
 7 |         "height": 97
 8 |     },
 9 |     "faceAttributes": {
10 |         "smile": 0.112,
11 |         "headPose": {
12 |             "pitch": 0,
13 |             "roll": -4,
14 |             "yaw": 0.3
15 |         },
16 |         "gender": "male",
17 |         "age": 68.9,
18 |         "facialHair": {
19 |             "moustache": 0,
20 |             "beard": 0,
21 |             "sideburns": 0
22 |         },
23 |         "glasses": "Sunglasses",
24 |         "emotion": {
25 |             "anger": 0,
26 |             "contempt": 0,
27 |             "disgust": 0,
28 |             "fear": 0,
29 |             "happiness": 0.112,
30 |             "neutral": 0.857,
31 |             "sadness": 0.03,
32 |             "surprise": 0
33 |         },
34 |         "blur": {
35 |             "blurLevel": "low",
36 |             "value": 0.19
37 |         },
38 |         "exposure": {
39 |             "exposureLevel": "goodExposure",
40 |             "value": 0.68
41 |         },
42 |         "noise": {
43 |             "noiseLevel": "low",
44 |             "value": 0.21
45 |         },
46 |         "makeup": {
47 |             "eyeMakeup": false,
48 |             "lipMakeup": false
49 |         },
50 |         "accessories": [{
51 |                 "type": "glasses",
52 |                 "confidence": 0.99
53 |             }],
54 |         "occlusion": {
55 |             "foreheadOccluded": false,
56 |             "eyeOccluded": false,
57 |             "mouthOccluded": false
58 |         },
59 |         "hair": {
60 |             "bald": 0.02,
61 |             "invisible": false,
62 |             "hairColor": [{
63 |                     "color": "brown",
64 |                     "confidence": 0.99
65 |                 }, {
66 |                     "color": "blond",
67 |                     "confidence": 0.59
68 |                 }, {
69 |                     "color": "gray",
70 |                     "confidence": 0.59
71 |                 }, {
72 |                     "color": "red",
73 |                     "confidence": 0.2
74 |                 }, {
75 |                     "color": "black",
76 |                     "confidence": 0.19
77 |                 }, {
78 |                     "color": "other",
79 |                     "confidence": 0.11
80 |                 }]
81 |         }
82 |     }
83 | }


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/responses/small_face.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "faceId": "small_face",
 3 |     "faceRectangle": {
 4 |         "top": 25,
 5 |         "left": 25,
 6 |         "width": 10,
 7 |         "height": 10
 8 |     },
 9 |     "faceAttributes": {
10 |         "smile": 0.112,
11 |         "headPose": {
12 |             "pitch": 0,
13 |             "roll": -4,
14 |             "yaw": 0.3
15 |         },
16 |         "gender": "male",
17 |         "age": 68.9,
18 |         "facialHair": {
19 |             "moustache": 0,
20 |             "beard": 0,
21 |             "sideburns": 0
22 |         },
23 |         "glasses": "ReadingGlasses",
24 |         "emotion": {
25 |             "anger": 0,
26 |             "contempt": 0,
27 |             "disgust": 0,
28 |             "fear": 0,
29 |             "happiness": 0.112,
30 |             "neutral": 0.857,
31 |             "sadness": 0.03,
32 |             "surprise": 0
33 |         },
34 |         "blur": {
35 |             "blurLevel": "low",
36 |             "value": 0.19
37 |         },
38 |         "exposure": {
39 |             "exposureLevel": "goodExposure",
40 |             "value": 0.68
41 |         },
42 |         "noise": {
43 |             "noiseLevel": "low",
44 |             "value": 0.21
45 |         },
46 |         "makeup": {
47 |             "eyeMakeup": false,
48 |             "lipMakeup": false
49 |         },
50 |         "accessories": [{
51 |                 "type": "glasses",
52 |                 "confidence": 0.99
53 |             }],
54 |         "occlusion": {
55 |             "foreheadOccluded": false,
56 |             "eyeOccluded": false,
57 |             "mouthOccluded": false
58 |         },
59 |         "hair": {
60 |             "bald": 0.02,
61 |             "invisible": false,
62 |             "hairColor": [{
63 |                     "color": "brown",
64 |                     "confidence": 0.99
65 |                 }, {
66 |                     "color": "blond",
67 |                     "confidence": 0.59
68 |                 }, {
69 |                     "color": "gray",
70 |                     "confidence": 0.59
71 |                 }, {
72 |                     "color": "red",
73 |                     "confidence": 0.2
74 |                 }, {
75 |                     "color": "black",
76 |                     "confidence": 0.19
77 |                 }, {
78 |                     "color": "other",
79 |                     "confidence": 0.11
80 |                 }]
81 |         }
82 |     }
83 | }


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/responses/medium_blur.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "faceId": "medium_blur",
 3 |     "faceRectangle": {
 4 |         "top": 83,
 5 |         "left": 76,
 6 |         "width": 97,
 7 |         "height": 97
 8 |     },
 9 |     "faceAttributes": {
10 |         "smile": 0.112,
11 |         "headPose": {
12 |             "pitch": 0,
13 |             "roll": -4,
14 |             "yaw": 0.3
15 |         },
16 |         "gender": "male",
17 |         "age": 68.9,
18 |         "facialHair": {
19 |             "moustache": 0,
20 |             "beard": 0,
21 |             "sideburns": 0
22 |         },
23 |         "glasses": "ReadingGlasses",
24 |         "emotion": {
25 |             "anger": 0,
26 |             "contempt": 0,
27 |             "disgust": 0,
28 |             "fear": 0,
29 |             "happiness": 0.112,
30 |             "neutral": 0.857,
31 |             "sadness": 0.03,
32 |             "surprise": 0
33 |         },
34 |         "blur": {
35 |             "blurLevel": "medium",
36 |             "value": 0.38
37 |         },
38 |         "exposure": {
39 |             "exposureLevel": "goodExposure",
40 |             "value": 0.68
41 |         },
42 |         "noise": {
43 |             "noiseLevel": "low",
44 |             "value": 0.21
45 |         },
46 |         "makeup": {
47 |             "eyeMakeup": false,
48 |             "lipMakeup": false
49 |         },
50 |         "accessories": [{
51 |                 "type": "glasses",
52 |                 "confidence": 0.99
53 |             }],
54 |         "occlusion": {
55 |             "foreheadOccluded": false,
56 |             "eyeOccluded": false,
57 |             "mouthOccluded": false
58 |         },
59 |         "hair": {
60 |             "bald": 0.02,
61 |             "invisible": false,
62 |             "hairColor": [{
63 |                     "color": "brown",
64 |                     "confidence": 0.99
65 |                 }, {
66 |                     "color": "blond",
67 |                     "confidence": 0.59
68 |                 }, {
69 |                     "color": "gray",
70 |                     "confidence": 0.59
71 |                 }, {
72 |                     "color": "red",
73 |                     "confidence": 0.2
74 |                 }, {
75 |                     "color": "black",
76 |                     "confidence": 0.19
77 |                 }, {
78 |                     "color": "other",
79 |                     "confidence": 0.11
80 |                 }]
81 |         }
82 |     }
83 | }


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/responses/medium_noise.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "faceId": "medium_noise",
 3 |     "faceRectangle": {
 4 |         "top": 83,
 5 |         "left": 76,
 6 |         "width": 97,
 7 |         "height": 97
 8 |     },
 9 |     "faceAttributes": {
10 |         "smile": 0.112,
11 |         "headPose": {
12 |             "pitch": 0,
13 |             "roll": -4,
14 |             "yaw": 0.3
15 |         },
16 |         "gender": "male",
17 |         "age": 68.9,
18 |         "facialHair": {
19 |             "moustache": 0,
20 |             "beard": 0,
21 |             "sideburns": 0
22 |         },
23 |         "glasses": "ReadingGlasses",
24 |         "emotion": {
25 |             "anger": 0,
26 |             "contempt": 0,
27 |             "disgust": 0,
28 |             "fear": 0,
29 |             "happiness": 0.112,
30 |             "neutral": 0.857,
31 |             "sadness": 0.03,
32 |             "surprise": 0
33 |         },
34 |         "blur": {
35 |             "blurLevel": "low",
36 |             "value": 0.19
37 |         },
38 |         "exposure": {
39 |             "exposureLevel": "goodExposure",
40 |             "value": 0.68
41 |         },
42 |         "noise": {
43 |             "noiseLevel": "medium",
44 |             "value": 0.51
45 |         },
46 |         "makeup": {
47 |             "eyeMakeup": false,
48 |             "lipMakeup": false
49 |         },
50 |         "accessories": [{
51 |                 "type": "glasses",
52 |                 "confidence": 0.99
53 |             }],
54 |         "occlusion": {
55 |             "foreheadOccluded": false,
56 |             "eyeOccluded": false,
57 |             "mouthOccluded": false
58 |         },
59 |         "hair": {
60 |             "bald": 0.02,
61 |             "invisible": false,
62 |             "hairColor": [{
63 |                     "color": "brown",
64 |                     "confidence": 0.99
65 |                 }, {
66 |                     "color": "blond",
67 |                     "confidence": 0.59
68 |                 }, {
69 |                     "color": "gray",
70 |                     "confidence": 0.59
71 |                 }, {
72 |                     "color": "red",
73 |                     "confidence": 0.2
74 |                 }, {
75 |                     "color": "black",
76 |                     "confidence": 0.19
77 |                 }, {
78 |                     "color": "other",
79 |                     "confidence": 0.11
80 |                 }]
81 |         }
82 |     }
83 | }


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Constraints/FaceValidator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Validator\Constraints;
 4 | 
 5 | use Symfony\Component\Validator\Constraint;
 6 | use Symfony\Component\Validator\ConstraintValidator;
 7 | use Symfony\Component\Validator\Exception\UnexpectedTypeException;
 8 | use XSolve\FaceValidatorBundle\Detector\FaceDetector;
 9 | use XSolve\FaceValidatorBundle\Exception\NoFaceDetectedException;
10 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
11 | use XSolve\FaceValidatorBundle\Validator\Specification\FaceValidationSpecification;
12 | 
13 | class FaceValidator extends ConstraintValidator
14 | {
15 |     /**
16 |      * @var FaceDetector
17 |      */
18 |     private $faceDetector;
19 | 
20 |     /**
21 |      * @var FaceValidationSpecification[]
22 |      */
23 |     private $conditions;
24 | 
25 |     public function __construct(FaceDetector $faceDetector, array $conditions)
26 |     {
27 |         $this->faceDetector = $faceDetector;
28 |         $this->conditions = $conditions;
29 |     }
30 | 
31 |     public function validate($value, Constraint $constraint)
32 |     {
33 |         if (!$constraint instanceof Face) {
34 |             throw new UnexpectedTypeException($constraint, Face::class);
35 |         }
36 | 
37 |         $path = $this->extractPath($value);
38 | 
39 |         if (null === $path) {
40 |             return;
41 |         }
42 | 
43 |         try {
44 |             $detectionResult = $this->faceDetector->detect($path);
45 |         } catch (NoFaceDetectedException $e) {
46 |             $this->context->addViolation($constraint->noFaceMessage);
47 | 
48 |             return;
49 |         }
50 | 
51 |         $this->evaluateConditions($detectionResult, $constraint);
52 |     }
53 | 
54 |     private function extractPath($value)
55 |     {
56 |         if (is_string($value)) {
57 |             return $value;
58 |         }
59 | 
60 |         if ($value instanceof \SplFileInfo && $value->isFile()) {
61 |             return $value->getRealPath();
62 |         }
63 | 
64 |         return null;
65 |     }
66 | 
67 |     private function evaluateConditions(FaceDetectionResult $result, Face $constraint)
68 |     {
69 |         foreach ($this->conditions as $condition) {
70 |             $evaluation = $condition->evaluate($result, $constraint);
71 | 
72 |             if (!$evaluation->isSuccessful()) {
73 |                 $this->context->addViolation($evaluation->getMessage());
74 |             }
75 |         }
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Validator/Constraints/Face.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace XSolve\FaceValidatorBundle\Validator\Constraints;
  4 | 
  5 | use Symfony\Component\Validator\Constraint;
  6 | 
  7 | /**
  8 |  * @Annotation
  9 |  */
 10 | class Face extends Constraint
 11 | {
 12 |     const LEVEL_LOW = 'low';
 13 |     const LEVEL_MEDIUM = 'medium';
 14 |     const LEVEL_HIGH = 'high';
 15 | 
 16 |     /**
 17 |      * @var string
 18 |      */
 19 |     public $noFaceMessage = 'Face is not visible.';
 20 | 
 21 |     /**
 22 |      * @var string
 23 |      */
 24 |     public $faceTooSmallMessage = 'Face is too small.';
 25 | 
 26 |     /**
 27 |      * @var string
 28 |      */
 29 |     public $faceCoveredMessage = 'Face cannot be covered.';
 30 | 
 31 |     /**
 32 |      * @var string
 33 |      */
 34 |     public $hairCoveredMessage = 'Hair cannot be covered.';
 35 | 
 36 |     /**
 37 |      * @var string
 38 |      */
 39 |     public $tooMuchRotatedMessage = 'Face is too much rotated.';
 40 | 
 41 |     /**
 42 |      * @var string
 43 |      */
 44 |     public $glassesMessage = 'There should be no glasses in the picture.';
 45 | 
 46 |     /**
 47 |      * @var string
 48 |      */
 49 |     public $sunglassesMessage = 'There should be no sunglasses in the picture.';
 50 | 
 51 |     /**
 52 |      * @var string
 53 |      */
 54 |     public $makeupMessage = 'The person should not be wearing any makeup.';
 55 | 
 56 |     /**
 57 |      * @var string
 58 |      */
 59 |     public $blurredMessage = 'The picture is too blurred.';
 60 | 
 61 |     /**
 62 |      * @var string
 63 |      */
 64 |     public $noiseMessage = 'The picture is too noisy.';
 65 | 
 66 |     /**
 67 |      * @var float
 68 |      */
 69 |     public $minFaceRatio = 0.15;
 70 | 
 71 |     /**
 72 |      * @var bool
 73 |      */
 74 |     public $allowCoveringFace = true;
 75 | 
 76 |     /**
 77 |      * @var float
 78 |      */
 79 |     public $maxFaceRotation = 20.0;
 80 | 
 81 |     /**
 82 |      * @var bool
 83 |      */
 84 |     public $allowGlasses = true;
 85 | 
 86 |     /**
 87 |      * @var bool
 88 |      */
 89 |     public $allowSunglasses = true;
 90 | 
 91 |     /**
 92 |      * @var bool
 93 |      */
 94 |     public $allowMakeup = true;
 95 | 
 96 |     /**
 97 |      * @var bool
 98 |      */
 99 |     public $allowNoHair = true;
100 | 
101 |     /**
102 |      * @var string
103 |      */
104 |     public $maxBlurLevel = self::LEVEL_HIGH;
105 | 
106 |     /**
107 |      * @var string
108 |      */
109 |     public $maxNoiseLevel = self::LEVEL_HIGH;
110 | }
111 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Result/FaceDetectionResult.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace XSolve\FaceValidatorBundle\Result;
  4 | 
  5 | class FaceDetectionResult
  6 | {
  7 |     /**
  8 |      * @var float
  9 |      */
 10 |     private $faceToImageRatio;
 11 | 
 12 |     /**
 13 |      * @var Rotation
 14 |      */
 15 |     private $rotation;
 16 | 
 17 |     /**
 18 |      * @var Glasses
 19 |      */
 20 |     private $glasses;
 21 | 
 22 |     /**
 23 |      * @var Blur
 24 |      */
 25 |     private $blur;
 26 | 
 27 |     /**
 28 |      * @var Exposure
 29 |      */
 30 |     private $exposure;
 31 | 
 32 |     /**
 33 |      * @var Noise
 34 |      */
 35 |     private $noise;
 36 | 
 37 |     /**
 38 |      * @var Makeup
 39 |      */
 40 |     private $makeup;
 41 | 
 42 |     /**
 43 |      * @var Accessory[]
 44 |      */
 45 |     private $accessories;
 46 | 
 47 |     /**
 48 |      * @var bool
 49 |      */
 50 |     private $hairVisible;
 51 | 
 52 |     public function __construct(
 53 |         float $faceToImageRatio,
 54 |         Rotation $rotation,
 55 |         Glasses $glasses,
 56 |         Blur $blur,
 57 |         Exposure $exposure,
 58 |         Noise $noise,
 59 |         Makeup $makeup,
 60 |         array $accessories,
 61 |         bool $hairVisible
 62 |     ) {
 63 |         $this->faceToImageRatio = $faceToImageRatio;
 64 |         $this->rotation = $rotation;
 65 |         $this->glasses = $glasses;
 66 |         $this->blur = $blur;
 67 |         $this->exposure = $exposure;
 68 |         $this->noise = $noise;
 69 |         $this->makeup = $makeup;
 70 |         $this->accessories = $accessories;
 71 |         $this->hairVisible = $hairVisible;
 72 |     }
 73 | 
 74 |     public function getFaceToImageRatio(): float
 75 |     {
 76 |         return $this->faceToImageRatio;
 77 |     }
 78 | 
 79 |     public function getRotation(): Rotation
 80 |     {
 81 |         return $this->rotation;
 82 |     }
 83 | 
 84 |     public function getGlasses(): Glasses
 85 |     {
 86 |         return $this->glasses;
 87 |     }
 88 | 
 89 |     public function getBlur(): Blur
 90 |     {
 91 |         return $this->blur;
 92 |     }
 93 | 
 94 |     public function getExposure(): Exposure
 95 |     {
 96 |         return $this->exposure;
 97 |     }
 98 | 
 99 |     public function getNoise(): Noise
100 |     {
101 |         return $this->noise;
102 |     }
103 | 
104 |     public function getMakeup(): Makeup
105 |     {
106 |         return $this->makeup;
107 |     }
108 | 
109 |     public function getAccessories(): array
110 |     {
111 |         return $this->accessories;
112 |     }
113 | 
114 |     public function isHairVisible(): bool
115 |     {
116 |         return $this->hairVisible;
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Factory/FaceDetectionResultFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace XSolve\FaceValidatorBundle\Factory;
 4 | 
 5 | use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
 6 | use XSolve\FaceValidatorBundle\Calculator\FaceToImageRatioCalculator;
 7 | use XSolve\FaceValidatorBundle\Result\Accessory;
 8 | use XSolve\FaceValidatorBundle\Result\Blur;
 9 | use XSolve\FaceValidatorBundle\Result\BlurLevel;
10 | use XSolve\FaceValidatorBundle\Result\Exposure;
11 | use XSolve\FaceValidatorBundle\Result\ExposureLevel;
12 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
13 | use XSolve\FaceValidatorBundle\Result\Glasses;
14 | use XSolve\FaceValidatorBundle\Result\Makeup;
15 | use XSolve\FaceValidatorBundle\Result\Noise;
16 | use XSolve\FaceValidatorBundle\Result\NoiseLevel;
17 | use XSolve\FaceValidatorBundle\Result\Rotation;
18 | 
19 | class FaceDetectionResultFactory
20 | {
21 |     /**
22 |      * @var PropertyAccessorInterface
23 |      */
24 |     private $propertyAccessor;
25 | 
26 |     /**
27 |      * @var FaceToImageRatioCalculator
28 |      */
29 |     private $faceToImageRatioCalculator;
30 | 
31 |     public function __construct(PropertyAccessorInterface $propertyAccessor, FaceToImageRatioCalculator $faceToImageRatioCalculator)
32 |     {
33 |         $this->propertyAccessor = $propertyAccessor;
34 |         $this->faceToImageRatioCalculator = $faceToImageRatioCalculator;
35 |     }
36 | 
37 |     public function create(string $imagePath, array $data): FaceDetectionResult
38 |     {
39 |         return new FaceDetectionResult(
40 |             $this->faceToImageRatioCalculator->calculate(
41 |                 $imagePath,
42 |                 $this->propertyAccessor->getValue($data, '[faceRectangle][width]'),
43 |                 $this->propertyAccessor->getValue($data, '[faceRectangle][height]')
44 |             ),
45 |             new Rotation(
46 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][headPose][pitch]'),
47 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][headPose][roll]'),
48 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][headPose][yaw]')
49 |             ),
50 |             new Glasses(
51 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][glasses]')
52 |             ),
53 |             new Blur(
54 |                 new BlurLevel(
55 |                     $this->propertyAccessor->getValue($data, '[faceAttributes][blur][blurLevel]')
56 |                 ),
57 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][blur][value]')
58 |             ),
59 |             new Exposure(
60 |                 new ExposureLevel(
61 |                     $this->propertyAccessor->getValue($data, '[faceAttributes][exposure][exposureLevel]')
62 |                 ),
63 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][exposure][value]')
64 |             ),
65 |             new Noise(
66 |                 new NoiseLevel(
67 |                     $this->propertyAccessor->getValue($data, '[faceAttributes][noise][noiseLevel]')
68 |                 ),
69 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][noise][value]')
70 |             ),
71 |             new Makeup(
72 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][makeup][eyeMakeup]'),
73 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][makeup][lipMakeup]')
74 |             ),
75 |             array_map(
76 |                 function (array $accessoryData) {
77 |                     return new Accessory($accessoryData['type']);
78 |                 },
79 |                 $this->propertyAccessor->getValue($data, '[faceAttributes][accessories]')
80 |             ),
81 |             !$this->propertyAccessor->getValue($data, '[faceAttributes][hair][invisible]')
82 |         );
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/src/XSolve/FaceValidatorBundle/Resources/config/services.yml:
--------------------------------------------------------------------------------
 1 | parameters:
 2 |     xsolve_face_validator.client.azure.class: XSolve\FaceValidatorBundle\Client\GuzzleWrapper
 3 |     xsolve_face_validator.detector.face.class: XSolve\FaceValidatorBundle\Detector\AzureAPIFaceDetector
 4 | 
 5 | services:
 6 |     _defaults:
 7 |         autowire: false
 8 |         autoconfigure: false
 9 |         public: false
10 |     xsolve_face_validator.guzzle_client:
11 |         class: GuzzleHttp\Client
12 |         public: false
13 |         arguments:
14 |             - { base_uri: "%xsolve_face_validator.client.azure.base_uri%" }
15 |     xsolve_face_validator.client.azure:
16 |         class: "%xsolve_face_validator.client.azure.class%"
17 |         arguments:
18 |             - "@xsolve_face_validator.guzzle_client"
19 |             - "%xsolve_face_validator.client.azure.subscription_key%"
20 |     xsolve_face_validator.detector.face:
21 |         class: "%xsolve_face_validator.detector.face.class%"
22 |         arguments:
23 |             - "@xsolve_face_validator.client.azure"
24 |             - "@xsolve_face_validator.factory.face_detection_result"
25 |     xsolve_face_validator.factory.face_to_image_ratio_calculator:
26 |         class: XSolve\FaceValidatorBundle\Calculator\FaceToImageRatioCalculator
27 |     xsolve_face_validator.factory.face_detection_result:
28 |         class: XSolve\FaceValidatorBundle\Factory\FaceDetectionResultFactory
29 |         arguments:
30 |             - "@property_accessor"
31 |             - "@xsolve_face_validator.factory.face_to_image_ratio_calculator"
32 |     xsolve_face_validator.validator.specification.blur_is_acceptable:
33 |         class: XSolve\FaceValidatorBundle\Validator\Specification\BlurIsAcceptable
34 |     xsolve_face_validator.validator.specification.face_is_not_covered:
35 |         class: XSolve\FaceValidatorBundle\Validator\Specification\FaceIsNotCovered
36 |     xsolve_face_validator.validator.specification.face_is_of_acceptable_angle:
37 |         class: XSolve\FaceValidatorBundle\Validator\Specification\FaceIsOfAcceptableAngle
38 |     xsolve_face_validator.validator.specification.face_is_of_sufficient_size:
39 |         class: XSolve\FaceValidatorBundle\Validator\Specification\FaceIsOfSufficientSize
40 |     xsolve_face_validator.validator.specification.hair_is_visible:
41 |         class: XSolve\FaceValidatorBundle\Validator\Specification\HairIsVisible
42 |     xsolve_face_validator.validator.specification.is_not_wearing_glasses:
43 |         class: XSolve\FaceValidatorBundle\Validator\Specification\IsNotWearingGlasses
44 |     xsolve_face_validator.validator.specification.is_not_wearing_sunglasses:
45 |         class: XSolve\FaceValidatorBundle\Validator\Specification\IsNotWearingSunglasses
46 |     xsolve_face_validator.validator.specification.no_makeup:
47 |         class: XSolve\FaceValidatorBundle\Validator\Specification\NoMakeup
48 |     xsolve_face_validator.validator.specification.noise_is_acceptable:
49 |         class: XSolve\FaceValidatorBundle\Validator\Specification\NoiseIsAcceptable
50 | 
51 |     xsolve_face_validator.validator.validator.face:
52 |         class: XSolve\FaceValidatorBundle\Validator\Constraints\FaceValidator
53 |         public: true
54 |         tags:
55 |             - { name: validator.constraint_validator }
56 |         arguments:
57 |             - "@xsolve_face_validator.detector.face"
58 |             -
59 |                 - "@xsolve_face_validator.validator.specification.blur_is_acceptable"
60 |                 - "@xsolve_face_validator.validator.specification.face_is_not_covered"
61 |                 - "@xsolve_face_validator.validator.specification.face_is_of_acceptable_angle"
62 |                 - "@xsolve_face_validator.validator.specification.face_is_of_sufficient_size"
63 |                 - "@xsolve_face_validator.validator.specification.hair_is_visible"
64 |                 - "@xsolve_face_validator.validator.specification.is_not_wearing_glasses"
65 |                 - "@xsolve_face_validator.validator.specification.is_not_wearing_sunglasses"
66 |                 - "@xsolve_face_validator.validator.specification.no_makeup"
67 |                 - "@xsolve_face_validator.validator.specification.noise_is_acceptable"
68 | 
69 | 
70 | 
71 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Validator/Constraints/FaceValidatorTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Tests\XSolve\FaceValidatorBundle\Validator\Constraints;
  4 | 
  5 | use PHPUnit\Framework\TestCase;
  6 | use Prophecy\Argument;
  7 | use Prophecy\Prophecy\ObjectProphecy;
  8 | use Symfony\Component\Validator\Constraint;
  9 | use Symfony\Component\Validator\Context\ExecutionContextInterface;
 10 | use XSolve\FaceValidatorBundle\Detector\FaceDetector;
 11 | use XSolve\FaceValidatorBundle\Exception\NoFaceDetectedException;
 12 | use XSolve\FaceValidatorBundle\Result\FaceDetectionResult;
 13 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
 14 | use XSolve\FaceValidatorBundle\Validator\Constraints\FaceValidator;
 15 | use XSolve\FaceValidatorBundle\Validator\Specification\Evaluation;
 16 | use XSolve\FaceValidatorBundle\Validator\Specification\FaceValidationSpecification;
 17 | 
 18 | class FaceValidatorTest extends TestCase
 19 | {
 20 |     /**
 21 |      * @var FaceValidator
 22 |      */
 23 |     private $validator;
 24 | 
 25 |     /**
 26 |      * @var ObjectProphecy|ExecutionContextInterface
 27 |      */
 28 |     private $executionContext;
 29 | 
 30 |     /**
 31 |      * @var ObjectProphecy|FaceDetector
 32 |      */
 33 |     private $faceDetector;
 34 | 
 35 |     /**
 36 |      * @var ObjectProphecy|FaceValidationSpecification
 37 |      */
 38 |     private $firstCondition;
 39 | 
 40 |     /**
 41 |      * @var ObjectProphecy|FaceValidationSpecification
 42 |      */
 43 |     private $secondCondition;
 44 | 
 45 |     /**
 46 |      * {@inheritdoc}
 47 |      */
 48 |     protected function setUp()
 49 |     {
 50 |         $this->executionContext = $this->prophesize(ExecutionContextInterface::class);
 51 |         $this->faceDetector = $this->prophesize(FaceDetector::class);
 52 |         $this->firstCondition = $this->prophesize(FaceValidationSpecification::class);
 53 |         $this->secondCondition = $this->prophesize(FaceValidationSpecification::class);
 54 |         $this->validator = new FaceValidator($this->faceDetector->reveal(), [
 55 |             $this->firstCondition->reveal(),
 56 |             $this->secondCondition->reveal(),
 57 |         ]);
 58 |         $this->validator->initialize($this->executionContext->reveal());
 59 |     }
 60 | 
 61 |     /**
 62 |      * @expectedException \Symfony\Component\Validator\Exception\UnexpectedTypeException
 63 |      */
 64 |     public function testValidateInvalidConstraint()
 65 |     {
 66 |         $constraint = $this->prophesize(Constraint::class);
 67 | 
 68 |         $this->validator->validate('test file', $constraint->reveal());
 69 |     }
 70 | 
 71 |     /**
 72 |      * @param mixed $invalidValue
 73 |      *
 74 |      * @dataProvider invalidValuesProvider
 75 |      */
 76 |     public function testValidateInvalidValue($invalidValue)
 77 |     {
 78 |         $this->faceDetector->detect(Argument::any())->shouldNotBeCalled();
 79 |         $this->executionContext->addViolation(Argument::any())->shouldNotBeCalled();
 80 | 
 81 |         $this->validator->validate($invalidValue, new Face());
 82 |     }
 83 | 
 84 |     public function testValidateNoFace()
 85 |     {
 86 |         $constraint = new Face();
 87 |         $this->faceDetector->detect('test file')->willThrow(NoFaceDetectedException::class);
 88 |         $this->executionContext->addViolation($constraint->noFaceMessage)->shouldBeCalled();
 89 | 
 90 |         $this->validator->validate('test file', $constraint);
 91 |     }
 92 | 
 93 |     public function testValidate()
 94 |     {
 95 |         $constraint = new Face();
 96 |         $result = $this->prophesize(FaceDetectionResult::class);
 97 |         $this->faceDetector->detect('test file')->willReturn($result->reveal());
 98 |         $this->firstCondition->evaluate($result->reveal(), $constraint)->willReturn(new Evaluation(true));
 99 |         $this->secondCondition->evaluate($result->reveal(), $constraint)->willReturn(new Evaluation(false, 'test message'));
100 |         $this->executionContext->addViolation('test message')->shouldBeCalled();
101 | 
102 |         $this->validator->validate('test file', $constraint);
103 |     }
104 | 
105 |     public function invalidValuesProvider(): array
106 |     {
107 |         return [
108 |             [null],
109 |             [new \stdClass()],
110 |             [new \SplFileInfo('dummy')],
111 |         ];
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/tests/XSolve/FaceValidatorBundle/Integration/FaceValidatorIntegrationTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Tests\XSolve\FaceValidatorBundle\Integration;
  4 | 
  5 | use Symfony\Component\Validator\ConstraintViolationInterface;
  6 | use Symfony\Component\Validator\Validator\ValidatorInterface;
  7 | use XSolve\FaceValidatorBundle\Validator\Constraints\Face;
  8 | 
  9 | class FaceValidatorIntegrationTest extends KernelTestCase
 10 | {
 11 |     const IMAGES_DIRECTORY = __DIR__.'/../images';
 12 |     const RESPONSES_DIRECTORY = __DIR__.'/responses';
 13 | 
 14 |     /**
 15 |      * @var ValidatorInterface
 16 |      */
 17 |     private $validator;
 18 | 
 19 |     /**
 20 |      * @var AzureClientMock
 21 |      */
 22 |     private $client;
 23 | 
 24 |     /**
 25 |      * {@inheritdoc}
 26 |      */
 27 |     protected function setUp()
 28 |     {
 29 |         $this->validator = static::$kernel->getContainer()->get('validator');
 30 |         $this->client = static::$kernel->getContainer()->get('xsolve_face_validator.client.azure');
 31 |     }
 32 | 
 33 |     /**
 34 |      * @dataProvider validateProvider
 35 |      */
 36 |     public function testValidate(Face $constraint, string $imagePath, array $apiResponse, array $expectedViolations)
 37 |     {
 38 |         $this->client->setResponseData($apiResponse);
 39 |         $constraintViolations = $this->validator->validate(new \SplFileInfo($imagePath), [$constraint]);
 40 |         $this->assertCount(count($expectedViolations), $constraintViolations);
 41 |         $violationMessages = array_map(
 42 |             function (ConstraintViolationInterface $violation) {
 43 |                 return $violation->getMessage();
 44 |             },
 45 |             iterator_to_array($constraintViolations)
 46 |         );
 47 | 
 48 |         foreach ($expectedViolations as $expectedViolationMessage) {
 49 |             $this->assertContains($expectedViolationMessage, $violationMessages);
 50 |         }
 51 |     }
 52 | 
 53 |     /**
 54 |      * @todo add missing cases
 55 |      */
 56 |     public function validateProvider(): array
 57 |     {
 58 |         return [
 59 |             [
 60 |                 new Face(),
 61 |                 $this->generateImagePath('1x1'),
 62 |                 [],
 63 |                 [
 64 |                     'Face is not visible.',
 65 |                 ],
 66 |             ],
 67 |             [
 68 |                 new Face(),
 69 |                 $this->generateImagePath('100x100'),
 70 |                 $this->loadResponseFromFile('glasses.json'),
 71 |                 [],
 72 |             ],
 73 |             [
 74 |                 new Face(['allowGlasses' => false]),
 75 |                 $this->generateImagePath('100x100'),
 76 |                 $this->loadResponseFromFile('glasses.json'),
 77 |                 [
 78 |                     'There should be no glasses in the picture.',
 79 |                 ],
 80 |             ],
 81 |             [
 82 |                 new Face(['maxBlurLevel' => Face::LEVEL_MEDIUM]),
 83 |                 $this->generateImagePath('100x100'),
 84 |                 $this->loadResponseFromFile('medium_blur.json'),
 85 |                 [],
 86 |             ],
 87 |             [
 88 |                 new Face(['maxBlurLevel' => Face::LEVEL_LOW]),
 89 |                 $this->generateImagePath('100x100'),
 90 |                 $this->loadResponseFromFile('medium_blur.json'),
 91 |                 [
 92 |                     'The picture is too blurred.',
 93 |                 ],
 94 |             ],
 95 |             [
 96 |                 new Face(['maxNoiseLevel' => Face::LEVEL_LOW]),
 97 |                 $this->generateImagePath('100x100'),
 98 |                 $this->loadResponseFromFile('medium_noise.json'),
 99 |                 [
100 |                     'The picture is too noisy.',
101 |                 ],
102 |             ],
103 |             [
104 |                 new Face(),
105 |                 $this->generateImagePath('100x100'),
106 |                 $this->loadResponseFromFile('small_face.json'),
107 |                 [
108 |                     'Face is too small.',
109 |                 ],
110 |             ],
111 |             [
112 |                 new Face(['allowSunglasses' => false]),
113 |                 $this->generateImagePath('100x100'),
114 |                 $this->loadResponseFromFile('sunglasses.json'),
115 |                 [
116 |                     'There should be no sunglasses in the picture.',
117 |                 ],
118 |             ],
119 |         ];
120 |     }
121 | 
122 |     private function loadResponseFromFile(string $name): array
123 |     {
124 |         $path = sprintf('%s/%s', self::RESPONSES_DIRECTORY, $name);
125 |         $this->assertFileExists($path);
126 | 
127 |         return json_decode(file_get_contents($path), true);
128 |     }
129 | 
130 |     private function generateImagePath(string $imageName): string
131 |     {
132 |         return sprintf('%s/%s', self::IMAGES_DIRECTORY, $imageName);
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ----------
  2 | # XSolve Face Validator Bundle
  3 | 
  4 | [![Build Status](https://travis-ci.org/xsolve-pl/xsolve-face-validator-bundle.svg?branch=master)](https://travis-ci.org/xsolve-pl/xsolve-face-validator-bundle)
  5 | [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/xsolve-pl/xsolve-face-validator-bundle/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/xsolve-pl/xsolve-face-validator-bundle/?branch=master)
  6 | 
  7 | ============================
  8 | 
  9 | Table of contents
 10 | =================
 11 | 
 12 |   * [Introduction](#introduction)
 13 |   * [License](#license)
 14 |   * [Getting started](#getting-started)
 15 |   * [Usage](#usage)
 16 | 
 17 | Introduction
 18 | =================
 19 | This Symfony3 bundle allows to validate whether an image (for instance uploaded by a user of your app) contains person's face.
 20 | Internally it uses MS Azure Face API so in order to use it you need an account in MS Azure. In free plan the API allows
 21 | to make 30 000 requests per month and 20 per minute so it should be enough to be useful for low traffic apps.
 22 | 
 23 | All the following features are configurable on the constraint level and can be easily enabled/disabled:
 24 |   * requiring certain face size (ratio to the image size)
 25 |   * disallowing an image when the face is covered
 26 |   * requiring the hair to be visible (the image must not be cut)
 27 |   * allowing the face to be rotated in any of the 3 axes to given level
 28 |   * disallowing to wear glasses
 29 |   * disallowing to wear sunglasses
 30 |   * disallowing any makeup
 31 |   * requiring an image not to be blurred over given level (low/medium/high)
 32 |   * requiring an image not to contain noises over given level (low/medium/high)
 33 | 
 34 | Licence
 35 | =================
 36 | This library is under the MIT license. See the complete license in [LICENSE](LICENSE) file.
 37 | 
 38 | Getting started
 39 | =================
 40 | Add the bundle to your Symfony3 project using [Composer](https://getcomposer.org/):
 41 | ```bash
 42 | $ composer require xsolve-pl/face-validator-bundle
 43 | ```
 44 | 
 45 | You'll need also to register the bundle in your kernel:
 46 | ```php
 47 | <?php
 48 | // app/AppKernel.php
 49 | 
 50 | class AppKernel extends Kernel
 51 | {
 52 |     public function registerBundles()
 53 |     {
 54 |         $bundles = [
 55 |             // ...
 56 |             new XSolve\FaceValidatorBundle\XSolveFaceValidatorBundle(),
 57 |         ];
 58 |     }
 59 | }
 60 | ```
 61 | 
 62 | In the configuration file you must provide your [MS Azure subscription key for Face API](https://azure.microsoft.com/en-us/try/cognitive-services/?api=face-api)
 63 | and the region name (can be taken from the `Endpoint` section in MS Azure portal). Available regions can be previewed by running:
 64 | 
 65 | ```bash
 66 | $ bin/console config:dump-reference xsolve_face_validator
 67 | ```
 68 | 
 69 | Example configuration:
 70 | 
 71 | ```yml
 72 | # app/config/config.yml
 73 | 
 74 | xsolve_face_validator:
 75 |     azure_subscription_key: your-subscription-key
 76 |     region: westeurope
 77 | ```
 78 | 
 79 | Usage
 80 | =================
 81 | Check [this documentation](https://symfony.com/doc/current/controller/upload_file.html) if you'd like to know
 82 | how to allow users to upload files using Symfony forms and validation.
 83 | Assuming in your application you already have some model representing a user (for instance Doctrine entity) and it's
 84 | used in a form to gather the data from users and perform validation, it already contains a profile picture:
 85 | 
 86 | ```php
 87 | // src/AppBundle/Entity/User.php
 88 | 
 89 | use Symfony\Component\HttpFoundation\File\UploadedFile;
 90 | use Symfony\Component\Validator\Constraints as Assert;
 91 | use XSolve\FaceValidatorBundle\Validator\Constraints as XSolveAssert;
 92 | 
 93 | class User
 94 | {
 95 |     /**
 96 |      * @var UploadedFile
 97 |      *
 98 |      * @Assert\Image()
 99 |      * @XSolveAssert\Face()
100 |      */
101 |     public $profilePicture;
102 | }
103 | ```
104 | 
105 | or with YML:
106 | ```yml
107 | # src/AppBundle/Resources/config/validation.yml
108 | AppBundle\Entity\User:
109 |     properties:
110 |         profilePicture:
111 |             - Image
112 |             - XSolve\FaceValidatorBundle\Validator\Constraints\Face
113 | ```
114 | 
115 | For other validation config formats please check [dedicated documentation section](http://symfony.com/doc/current/validation.html#constraint-configuration)
116 | 
117 | Now when executing regular validation, for instance in your controller:
118 | ```php
119 | // src/AppBundle/Controller/UserController.php
120 | 
121 | namespace AppBundle\Controller;
122 | 
123 | use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
124 | use Symfony\Bundle\FrameworkBundle\Controller\Controller;
125 | use Symfony\Component\Form\Extension\Core\Type\FileType;
126 | use Symfony\Component\HttpFoundation\Request;
127 | use AppBundle\Entity\User;
128 | 
129 | class UserController extends Controller
130 | {
131 |     /**
132 |      * @Route("/user/new", name="app_user_new")
133 |      */
134 |     public function newAction(Request $request)
135 |     {
136 |         $user = new User();
137 |         $form = $this->createFormBuilder($user)
138 |             ->add('profilePicture', FileType::class)
139 |             ->getForm();
140 |         $form->handleRequest($request);
141 | 
142 |         if ($form->isSubmitted() && $form->isValid()) {
143 |             // ...
144 |         }
145 | 
146 |         // ...
147 |     }
148 | }
149 | ```
150 | 
151 | the image will be validated whether it contains a face. The way the face is being validated is customizable, all the possible
152 | options with their default values are shown on the example below:
153 | 
154 | ```php
155 | // src/AppBundle/Entity/User.php
156 | 
157 | use Symfony\Component\Validator\Constraints as Assert;
158 | use XSolve\FaceValidatorBundle\Validator\Constraints as XSolveAssert;
159 | 
160 | class User
161 | {
162 |     /**
163 |      * @var Symfony\Component\HttpFoundation\File\UploadedFile
164 | 
165 |      * @Assert\Image()
166 |      * @XSolveAssert\Face(
167 |      *     minFaceRatio = 0.15,
168 |      *     allowCoveringFace = true,
169 |      *     maxFaceRotation = 20.0,
170 |      *     allowGlasses = true,
171 |      *     allowSunglasses = true,
172 |      *     allowMakeup = true,
173 |      *     allowNoHair = true,
174 |      *     maxBlurLevel = high,
175 |      *     maxNoiseLevel = high,
176 |      *     noFaceMessage = 'Face is not visible.',
177 |      *     faceTooSmallMessage = 'Face is too small.',
178 |      *     faceCoveredMessage = 'Face cannot be covered.',
179 |      *     hairCoveredMessage = 'Hair cannot be covered.',
180 |      *     tooMuchRotatedMessage = 'Face is too much rotated.',
181 |      *     glassesMessage = 'There should be no glasses in the picture.',
182 |      *     sunglassesMessage = 'There should be no sunglasses in the picture.',
183 |      *     makeupMessage = 'The person should not be wearing any makeup.',
184 |      *     blurredMessage = 'The picture is too blurred.',
185 |      *     noiseMessage = 'The picture is too noisy.'
186 |      * )
187 |      */
188 |     public $profilePicture;
189 | }
190 | ```
191 | 
192 | Note that you can omit any (or even all) of the options listed above, then the defaults will be used.
193 | 
194 | For blur and noise levels the possible options are:
195 |   * low
196 |   * medium
197 |   * high
198 | 
199 | It's also possible, just like with any other Symfony validator, to use it directly against given value (either file path or an instance of \SplFileInfo).
200 | 
201 | ```php
202 | // src/AppBundle/Controller/ImageController.php
203 | 
204 | namespace AppBundle\Controller;
205 | 
206 | use Symfony\Bundle\FrameworkBundle\Controller\Controller;
207 | use Symfony\Component\Validator\Validator\ValidatorInterface;
208 | 
209 | class ImageController extends Controller
210 | {
211 |     public function validateAction(Request $request)
212 |     {
213 |         /* @var $validator ValidatorInterface */
214 |         $validator = $this->get('validator');
215 |         $constraintViolations = $validator->validate(
216 |             '/path/to/your/image/file.png',
217 |             new Face([
218 |                 // you can pass the options mentioned before to the validation constraint
219 |             ])
220 |         );
221 |     }
222 | }
223 | ```
224 | 


--------------------------------------------------------------------------------