Face Detection Tutorial

View on GitHub

var client = ImageAnnotatorClient.Create();

Node.js

View on GitHub

// By default, the client will authenticate using the service account file
// specified by the GOOGLE_APPLICATION_CREDENTIALS environment variable and use
// the project specified by the GCLOUD_PROJECT environment variable. See
// https://googlecloudplatform.github.io/gcloud-node/#/docs/google-cloud/latest/guides/authentication
var Vision = require('@google-cloud/vision');

// Instantiate a vision client
var vision = Vision();

PHP

vision/api/src/snippets/detect_face.php

View on GitHub

use Google\Cloud\Vision\VisionClient;

// $projectId = 'YOUR_PROJECT_ID';
// $path = 'path/to/your/image.jpg'

$vision = new VisionClient([
    'projectId' => $projectId,
]);

Python

View on GitHub

image = vision.Client().image(content=content)

Ruby

View on GitHub

require "google/cloud/vision"

...

vision = Google::Cloud::Vision.new project: project_id

Send a face detection request

To construct a request to the Vision API, first consult the API documentation. In this case, you'll be asking the images resource to annotate your image. A request to this API takes the form of an object with a requests list. Each item in this list contains two bits of information:

The base64-encoded image data
A list of features you'd like annotated about that image.

For this example, you'll simply request FACE_DETECTION annotation on one image, and return the relevant portion of the response:

C#

View on GitHub

var response = client.DetectFaces(Image.FromFile(args[0]));

Node.js

View on GitHub

function detectFaces (inputFile, callback) {
  // Make a call to the Vision API to detect the faces
  vision.detectFaces(inputFile, function (err, faces) {
    if (err) {
      return callback(err);
    }
    var numFaces = faces.length;
    console.log('Found ' + numFaces + (numFaces === 1 ? ' face' : ' faces'));
    callback(null, faces);
  });
}

PHP

vision/api/src/snippets/detect_face.php

View on GitHub

$image = $vision->image(file_get_contents($path), ['FACE_DETECTION']);
$result = $vision->annotate($image);

Python

View on GitHub

def detect_face(face_file, max_results=4):
    """Uses the Vision API to detect faces in the given file.

    Args:
        face_file: A file-like object containing an image with faces.

    Returns:
        An array of Face objects with information about the picture.
    """
    content = face_file.read()
    image = vision.Client().image(content=content)

    return image.detect_faces()

Ruby

View on GitHub

image = vision.image path_to_image_file
faces = image.faces

Process the response

Congratulations - you've detected the faces in your image! The response to our face annotation request includes a bunch of metadata about the detected faces, which include coordinates of a polygon encompassing the face. At this point, though, this is only a list of numbers. Let's use them to confirm that you have, in fact, found the faces in your image. We'll draw polygons onto a copy of the image, using the coordinates returned by the Vision API:

C#

View on GitHub

using (var image = System.Drawing.Image.FromFile(args[0]))
using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(image))
{
    var cyanPen = new System.Drawing.Pen(System.Drawing.Color.
        FromKnownColor(System.Drawing.KnownColor.Cyan), 3);
    foreach (var annotation in response)
    {
        g.DrawPolygon(cyanPen, annotation.BoundingPoly.Vertices.Select(
            (vertex) => new System.Drawing.Point(vertex.X, vertex.Y)).ToArray());
    }

Node.js

We use the node-canvas library to draw onto images.

View on GitHub

function highlightFaces (inputFile, faces, outputFile, Canvas, callback) {
  fs.readFile(inputFile, function (err, image) {
    if (err) {
      return callback(err);
    }

    var Image = Canvas.Image;
    // Open the original image into a canvas
    var img = new Image();
    img.src = image;
    var canvas = new Canvas(img.width, img.height);
    var context = canvas.getContext('2d');
    context.drawImage(img, 0, 0, img.width, img.height);

    // Now draw boxes around all the faces
    context.strokeStyle = 'rgba(0,255,0,0.8)';
    context.lineWidth = '5';

    faces.forEach(function (face) {
      context.beginPath();
      face.bounds.face.forEach(function (bounds) {
        context.lineTo(bounds.x, bounds.y);
      });
      context.lineTo(face.bounds.face[0].x, face.bounds.face[0].y);
      context.stroke();
    });

    // Write the result to a file
    console.log('Writing to file ' + outputFile);
    var writeStream = fs.createWriteStream(outputFile);
    var pngStream = canvas.pngStream();

    pngStream.on('data', function (chunk) {
      writeStream.write(chunk);
    });
    pngStream.on('error', console.log);
    pngStream.on('end', callback);
  });
}

PHP

We use the GD extension to draw onto images.

vision/api/src/DetectFaceCommand.php

View on GitHub

foreach ($result->info()['faceAnnotations'] as $annotation) {
    if (isset($annotation['boundingPoly'])) {
        $verticies = $annotation['boundingPoly']['vertices'];
        $x1 = isset($verticies[0]['x']) ? $verticies[0]['x'] : 0;
        $y1 = isset($verticies[0]['y']) ? $verticies[0]['y'] : 0;
        $x2 = isset($verticies[2]['x']) ? $verticies[2]['x'] : 0;
        $y2 = isset($verticies[2]['y']) ? $verticies[2]['y'] : 0;
        imagerectangle($outputImage, $x1, $y1, $x2, $y2, 0x00ff00);
    }
}

Python

View on GitHub

def highlight_faces(image, faces, output_filename):
    """Draws a polygon around the faces, then saves to output_filename.

    Args:
      image: a file containing the image with the faces.
      faces: a list of faces found in the file. This should be in the format
          returned by the Vision API.
      output_filename: the name of the image file to be created, where the
          faces have polygons drawn around them.
    """
    im = Image.open(image)
    draw = ImageDraw.Draw(im)

    for face in faces:
        box = [(bound.x_coordinate, bound.y_coordinate)
               for bound in face.bounds.vertices]
        draw.line(box + [box[0]], width=5, fill='#00ff00')

    im.save(output_filename)

Ruby

We use the rmagick gem to draw onto images.

View on GitHub

require "rmagick"

...

image = Magick::Image.read(path_to_image_file).first

faces.each do |face|
  puts "Face bounds:"
  face.bounds.face.each do |vector|
    puts "(#{vector.x}, #{vector.y})"
  end

  draw = Magick::Draw.new
  draw.stroke = "green"
  draw.stroke_width 5
  draw.fill_opacity 0

  x1 = face.bounds.face[0].x.to_i
  y1 = face.bounds.face[0].y.to_i
  x2 = face.bounds.face[2].x.to_i
  y2 = face.bounds.face[2].y.to_i

  draw.rectangle x1, y1, x2, y2
  draw.draw image
end

image.write path_to_output_file

puts "Output file: #{path_to_output_file}"

Put it all together

C#

View on GitHub

static readonly string s_usage = @"DetectFaces image-file

Use the Google Cloud Vision API to detect faces in the image.
Writes an output file called image-file.faces.
";
public static void Main(string[] args)
{
    if (args.Length < 1)
    {
        Console.WriteLine(s_usage);
        return;
    }

To build the sample, open the Solution file dotnet-doc-samples/vision/api/Vision.sln in Visual Studio and build the solution.

To run the sample:

C:\...\> cd dotnet-docs-samples\vision\api\DetectFaces\bin\Debug
C:\...\bin\Debug> DetectFaces ..\..\..\VisionTest\data\face.png

Node.js

View on GitHub

function main (inputFile, outputFile, Canvas, callback) {
  outputFile = outputFile || 'out.png';
  detectFaces(inputFile, function (err, faces) {
    if (err) {
      return callback(err);
    }

    console.log('Highlighting...');
    highlightFaces(inputFile, faces, outputFile, Canvas, function (err) {
      if (err) {
        return callback(err);
      }
      console.log('Finished!');
      callback(null, faces);
    });
  });
}

To run the sample, run the following command from the sample code directory:

node faceDetection face.png

PHP

To run the sample, run the following command from the sample code directory:

composer install
php vision.php face images/face.png output-image.png

Python

View on GitHub

def main(input_filename, output_filename, max_results):
    with open(input_filename, 'rb') as image:
        faces = detect_face(image, max_results)
        print('Found {} face{}'.format(
            len(faces), '' if len(faces) == 1 else 's'))

        print('Writing to file {}'.format(output_filename))
        # Reset the file pointer, so we can read the file again
        image.seek(0)
        highlight_faces(image, faces, output_filename)

Ruby