(Ruby) Google Cloud Vision Text Detection

Demonstrates calling the Google Cloud Vision for text detection (performs Optical Character Recognition). "Detects and extracts text within an image with support for a broad range of languages. It also features automatic language identification." See https://cloud.google.com/vision/docs/detecting-text

Chilkat Ruby Downloads install from rubygems.org gem install chilkat or download... Ruby Library for Windows, MacOS, Linux, Alpine Linux

require 'chilkat'

# This example requires the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

# Build the following request:

# {
#   "requests": [
#     {
#       "image": {
#         "content": "/9j/7QBEUGhvdG9zaG9...base64-encoded-image-content...fXNWzvDEeYxxxzj/Coa6Bax//Z"
#       },
#       "features": [
#         {
#           "type": "TEXT_DETECTION"
#         }
#       ]
#     }
#   ]
# }

# Use this online tool to generate the code from sample JSON: 
# Generate Code to Create JSON

# Load an image file.
imageData = Chilkat::CkBinData.new()
# This image file contains some text...
success = imageData.LoadFile("qa_data/jpg/text.jpg")
if (success != true)
    print "Failed to load image file." + "\n";
    exit
end

# Create the above JSON.
json = Chilkat::CkJsonObject.new()
json.UpdateBd("requests[0].image.content","base64",imageData)
json.UpdateString("requests[0].features[0].type","TEXT_DETECTION")

# Send the following POST with the HTTP request body containing the above JSON.
# POST https://vision.googleapis.com/v1/images:annotate?key=YOUR_API_KEY

http = Chilkat::CkHttp.new()
sb = Chilkat::CkStringBuilder.new()
url = "https://vision.googleapis.com/v1/images:annotate?key=YOUR_API_KEY"
# resp is a CkHttpResponse
resp = http.PostJson3(url,"application/json",json)
if (http.get_LastMethodSuccess() != true)
    print http.lastErrorText() + "\n";
    exit
end

print "status = " + resp.get_StatusCode().to_s() + "\n";

# A 200 response status indicate success.
if (resp.get_StatusCode() != 200)
    print resp.bodyStr() + "\n";
    print "Failed." + "\n";

    exit
end

sbResponseBody = Chilkat::CkStringBuilder.new()
resp.GetBodySb(sbResponseBody)
sbResponseBody.WriteFile("qa_output/textDetectResponse.json","utf-8",false)
json.LoadSb(sbResponseBody)

# The response is a JSON document like this:

# Use this online tool to generate parsing code from sample JSON: 
# Generate Parsing Code from JSON

# {
#   "responses": [
#     {
#       "textAnnotations": [
#         {
#           "locale": "en",
#           "description": "Chilkat is a cross-language, cross-platform\nAPl providing 90+ classes for many Internet\nprotocols, formats, and algorithms.\n",
#           "boundingPoly": {
#             "vertices": [
#               {
#                 "x": 17,
#                 "y": 14
#               },
# 	...
#             ]
#           }
#         ],
#         "text": "Chilkat is a cross-language, cross-platform\nAPl providing 90+ classes for many Internet\nprotocols, formats, and algorithms.\n"
#       }
#     }
#   ]
# }

# The parsing code generated from the online tool:

i = 0
count_i = json.SizeOfArray("responses")
while i < count_i
    json.put_I(i)
    fullTextAnnotationText = json.stringOf("responses[i].fullTextAnnotation.text")
    j = 0
    count_j = json.SizeOfArray("responses[i].textAnnotations")
    while j < count_j
        json.put_J(j)
        locale = json.stringOf("responses[i].textAnnotations[j].locale")
        description = json.stringOf("responses[i].textAnnotations[j].description")
        k = 0
        count_k = json.SizeOfArray("responses[i].textAnnotations[j].boundingPoly.vertices")
        while k < count_k
            json.put_K(k)
            x = json.IntOf("responses[i].textAnnotations[j].boundingPoly.vertices[k].x")
            y = json.IntOf("responses[i].textAnnotations[j].boundingPoly.vertices[k].y")
            k = k + 1
        end
        j = j + 1
    end
    j = 0
    count_j = json.SizeOfArray("responses[i].fullTextAnnotation.pages")
    while j < count_j
        json.put_J(j)
        width = json.IntOf("responses[i].fullTextAnnotation.pages[j].width")
        height = json.IntOf("responses[i].fullTextAnnotation.pages[j].height")
        k = 0
        count_k = json.SizeOfArray("responses[i].fullTextAnnotation.pages[j].property.detectedLanguages")
        while k < count_k
            json.put_K(k)
            languageCode = json.stringOf("responses[i].fullTextAnnotation.pages[j].property.detectedLanguages[k].languageCode")
            k = k + 1
        end
        k = 0
        count_k = json.SizeOfArray("responses[i].fullTextAnnotation.pages[j].blocks")
        while k < count_k
            json.put_K(k)
            blockType = json.stringOf("responses[i].fullTextAnnotation.pages[j].blocks[k].blockType")

            # json1 is a CkJsonObject
            json1 = json.ObjectOf("responses[i].fullTextAnnotation.pages[j].blocks[k]")
            i1 = 0
            count_i1 = json1.SizeOfArray("property.detectedLanguages")
            while i1 < count_i1
                json1.put_I(i1)
                languageCode = json1.stringOf("property.detectedLanguages[i].languageCode")
                i1 = i1 + 1
            end

            # json1 is a CkJsonObject
            json1 = json.ObjectOf("responses[i].fullTextAnnotation.pages[j].blocks[k]")
            i1 = 0
            count_i1 = json1.SizeOfArray("boundingBox.vertices")
            while i1 < count_i1
                json1.put_I(i1)
                x = json1.IntOf("boundingBox.vertices[i].x")
                y = json1.IntOf("boundingBox.vertices[i].y")
                i1 = i1 + 1
            end

            # json1 is a CkJsonObject
            json1 = json.ObjectOf("responses[i].fullTextAnnotation.pages[j].blocks[k]")
            i1 = 0
            count_i1 = json1.SizeOfArray("paragraphs")
            while i1 < count_i1
                json1.put_I(i1)
                j1 = 0
                count_j1 = json1.SizeOfArray("paragraphs[i].property.detectedLanguages")
                while j1 < count_j1
                    json1.put_J(j1)
                    languageCode = json1.stringOf("paragraphs[i].property.detectedLanguages[j].languageCode")
                    j1 = j1 + 1
                end
                j1 = 0
                count_j1 = json1.SizeOfArray("paragraphs[i].boundingBox.vertices")
                while j1 < count_j1
                    json1.put_J(j1)
                    x = json1.IntOf("paragraphs[i].boundingBox.vertices[j].x")
                    y = json1.IntOf("paragraphs[i].boundingBox.vertices[j].y")
                    j1 = j1 + 1
                end
                j1 = 0
                count_j1 = json1.SizeOfArray("paragraphs[i].words")
                while j1 < count_j1
                    json1.put_J(j1)
                    k1 = 0
                    count_k1 = json1.SizeOfArray("paragraphs[i].words[j].property.detectedLanguages")
                    while k1 < count_k1
                        json1.put_K(k1)
                        languageCode = json1.stringOf("paragraphs[i].words[j].property.detectedLanguages[k].languageCode")
                        k1 = k1 + 1
                    end
                    k1 = 0
                    count_k1 = json1.SizeOfArray("paragraphs[i].words[j].boundingBox.vertices")
                    while k1 < count_k1
                        json1.put_K(k1)
                        x = json1.IntOf("paragraphs[i].words[j].boundingBox.vertices[k].x")
                        y = json1.IntOf("paragraphs[i].words[j].boundingBox.vertices[k].y")
                        k1 = k1 + 1
                    end
                    k1 = 0
                    count_k1 = json1.SizeOfArray("paragraphs[i].words[j].symbols")
                    while k1 < count_k1
                        json1.put_K(k1)
                        text = json1.stringOf("paragraphs[i].words[j].symbols[k].text")
                        propertyDetectedBreakType = json1.stringOf("paragraphs[i].words[j].symbols[k].property.detectedBreak.type")

                        # json2 is a CkJsonObject
                        json2 = json1.ObjectOf("paragraphs[i].words[j].symbols[k]")
                        i2 = 0
                        count_i2 = json2.SizeOfArray("property.detectedLanguages")
                        while i2 < count_i2
                            json2.put_I(i2)
                            languageCode = json2.stringOf("property.detectedLanguages[i].languageCode")
                            i2 = i2 + 1
                        end

                        # json2 is a CkJsonObject
                        json2 = json1.ObjectOf("paragraphs[i].words[j].symbols[k]")
                        i2 = 0
                        count_i2 = json2.SizeOfArray("boundingBox.vertices")
                        while i2 < count_i2
                            json2.put_I(i2)
                            x = json2.IntOf("boundingBox.vertices[i].x")
                            y = json2.IntOf("boundingBox.vertices[i].y")
                            i2 = i2 + 1
                        end

                        k1 = k1 + 1
                    end
                    j1 = j1 + 1
                end
                i1 = i1 + 1
            end

            k = k + 1
        end
        j = j + 1
    end
    i = i + 1
end

print "Success." + "\n";