Assessing image quality

To evaluate the quality of an image, use Image classification.

To do this, set the type property to Classification in the batchAnalyze method and specify the quality model in the configuration.

Examples

Getting started

To use the examples, install cURL.

Get your account data for authentication:

Apply the model to assess quality

1. Prepare an image file that meets the requirements:

   • The supported file formats are JPEG, PNG, and PDF. Specify the MIME type of the file in the mime_type property. The default value is image.
   • The maximum file size is 1 MB.
   • The image size should not exceed 20 MP (height × width).

   Note

   Need an image? Download a sample.

2. Encode the file into Base64:

   UNIX

   Windows

   PowerShell

   Python

   Node.js

   Java

   Go

   base64 -i input.jpg > output.txt
   

   C:> Base64.exe -e input.jpg > output.txt
   

   [Convert]::ToBase64String([IO.File]::ReadAllBytes("./input.jpg")) > output.txt
   

   # Import a library for encoding files in Base64.
   import base64
   
   # Create a function to encode a file and return the results.
   def encode_file(file_path):
     with open(file_path, "rb") as fid:
         file_content = fid.read()
     return base64.b64encode(file_content).decode("utf-8")
   

   // Read the file contents to memory.
   var fs = require('fs');
   var file = fs.readFileSync('/path/to/file');
   
   // Get the file contents in Base64 format.
   var encoded = Buffer.from(file).toString('base64');
   

   // Import a library for encoding files in Base64.
   import org.apache.commons.codec.binary.Base64;
   
   // Get the file contents in Base64 format.
   byte[] fileData = Base64.encodeBase64(yourFile.getBytes());
   

   import (
       "bufio"
       "encoding/base64"
       "io/ioutil"
       "os"
   )
   
   // Open the file.
   f, _ := os.Open("/path/to/file")
   
   // Read the file contents.
   reader := bufio.NewReader(f)
   content, _ := ioutil.ReadAll(reader)
   
   // Get the file contents in Base64 format.
   base64.StdEncoding.EncodeToString(content)
   

3. Create a file with the request body, e.g., body.json:

   body.json:

   {
     "folderId": "b1gvmob95yys********",
     "analyze_specs": [{
       "content": "iVBORw0KGgo...",
       "features": [{
         "type": "CLASSIFICATION",
         "classificationConfig": {
           "model": "quality"
         }
       }]
     }]
   }
   

   Where:

   • folderId: ID of any folder for which your account has the ai.vision.user role or higher.
   • analyze_specs: content: Base64-encoded image.

4. Send a request using the batchAnalyze method and save the response to a file, e.g., output.json:

   Bash

   CMD

   PowerShell

   export IAM_TOKEN=<IAM_token>
   curl \
     --request POST \
     --header "Content-Type: application/json" \
     --header "Authorization: Bearer ${IAM_TOKEN}" \
     --data '@body.json' \
     https://vision.api.cloud.yandex.net/vision/v1/batchAnalyze > output.json
   

   set IAM_TOKEN=<IAM_token>
   curl ^
     --request POST ^
     --header "Content-Type: application/json" ^
     --header "Authorization: Bearer %IAM_TOKEN%" ^
     --data "@body.json" ^
     https://vision.api.cloud.yandex.net/vision/v1/batchAnalyze > output.json
   

   $Env:IAM_TOKEN="<IAM_token>"
   curl `
     --request POST `
     --header "Content-Type: application/json" `
     --header "Authorization: Bearer $Env:IAM_TOKEN" `
     --data '@body.json' `
     https://vision.api.cloud.yandex.net/vision/v1/batchAnalyze > output.json
   

   Where IAM_TOKEN is the IAM token you got before you started.

   The response will contain the properties and the probability of matches. You can use these properties to moderate the image:

   {
     "results": [{
       "results": [{
         "faceDetection": {
           "properties": [{
               "name": "low",
               "probability": 0.001466292142868043
             },
             {
               "name": "medium",
               "probability": 0.003421348333358767
             },
             {
               "name": "high",
               "probability": 0.99511235952377319
             }
           ]
         }
       }]
     }]
   }
   

Ready-to-use function for sending requests in bash

The example below is intended to be run in MacOS and Linux. To run it in Windows, see how to work with Bash in Microsoft Windows.

1. If you do not have the Yandex Cloud (CLI) command line interface yet, install and initialize it.

2. Copy the function to the terminal:

    vision_quality() {
      curl --header "Authorization: Bearer `yc iam create-token`" \
      "https://vision.api.cloud.yandex.net/vision/v1/batchAnalyze" \
      -d @<(cat << EOF
        {
          "folderId": "`yc config get folder-id`",
          "analyze_specs": [{
            "content": "`base64 -i $1`",
            "features": [{
              "type": "CLASSIFICATION",
              "classificationConfig": {
                "model": "quality"
              }
            }]
          }]
        }
      EOF
      )
    }
   

   Explanations:

   • yc iam create-token: get an IAM token.
   • -d @<(cat EOF ... EOF): create a request body.
   • yc config get folder-id: get the ID of the default folder selected in the CLI.
   • base64 -i $1: Base64 encoding of the image passed in the function arguments.

3. Now you can call this function by passing the image path in the arguments:

   vision_quality path/to/image.jpg