def get_texts_batch(rects, img, Y): texts = [] features = [ types.Feature(type=enums.Feature.Type.TEXT_DETECTION), ] requests = [] for i, rect in enumerate(rects): x, y, w, h = rect tag = img[int(y):int((y+h)), int(x):int((x+w))] cv2.imwrite('temp.png', tag) with open('temp.png', 'rb') as image_file: imageContext = types.ImageContext(language_hints=["en"]) image = types.Image(content = image_file.read()) request = types.AnnotateImageRequest(image=image, features=features, image_context=imageContext) requests.append(request) #print(labelSet[np.argmax(Y[i])]) #texts.append(detect_text('temp.png').strip()) client = vision.ImageAnnotatorClient() response = client.batch_annotate_images(requests) for response in response.responses: if len(response.full_text_annotation.text) > 0: texts.append(response.full_text_annotation.text.strip()) else: texts.append("none") os.remove('temp.png') return texts
def detect_crop_hints(path, frame_id, user_id): print "Detects crop hints in an image." + path client = vision.ImageAnnotatorClient() # [START migration_crop_hints] with io.open(path, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) # worth looking at this bullshit constant right here crop_hints_params = types.CropHintsParams(aspect_ratios=[1.77]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints cropHintsList = [] count = 0 for n, hint in enumerate(hints): print('\nCrop Hint: {}'.format(n)) crop_to_hint(path, hint.bounding_poly.vertices, count) count = count + 1 vertices = ([ '({},{})'.format(vertex.x, vertex.y) for vertex in hint.bounding_poly.vertices ]) print('bounds: {}'.format(','.join(vertices))) vertexes = [] for vertex in hint.bounding_poly.vertices: vertexes.append({"x": vertex.x, "y": vertex.y}) cropHintsList.append(vertexes) cropHintsJSON = {"crophints": cropHintsList} spitJSONAPIResulttoMDB(cropHintsJSON, "crophints_ocr_google", frame_id, user_id)
def cropImage(imagepath): client = vision.ImageAnnotatorClient() hints = None try: with io.open(imagepath, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) image_context = types.ImageContext() response = client.label_detection(image=image) labels = response.label_annotations hints = None for label in labels: if label.description == "Pizza": response2 = client.crop_hints(image=image, image_context=image_context) hints = response2.crop_hints_annotation.crop_hints except: print("Error opening file: " + str(imagepath)) return None if (hints is not None): print(hints) verticies = hints[0].bounding_poly.vertices else: verticies = None os.remove(imagepath) return verticies
def info(request): os.environ[ 'GOOGLE_APPLICATION_CREDENTIALS'] = 'kal-kal-1532846232334-738abd5f7e5a.json' image_context = types.ImageContext(language_hints=["iw"]) client = vision.ImageAnnotatorClient() myfile = request.FILES["pic"] print("myfile name data>>>>>>>>>>>>>>>>>>>>>>>>>", myfile) fs = FileSystemStorage() filename = fs.save(myfile.name, myfile) file_name = fs.url(filename) #image_file= r'C:\Users\mjha3\Desktop\Django_project\VisionAPI_Test\PDFtoTEXT\pdftotext\pdftotext\media\2020_07_30 00_23 Office Lens (3)3.jpg' print("Image file location>>>>>>>", image_file) with io.open(file_name, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) response = client.document_text_detection(image=image, image_context=image_context) document = response.full_text_annotation bounds = [] doctext = [] for page in response.full_text_annotation.pages: for block in page.blocks: block_words = [] for paragraph in block.paragraphs: block_words.extend(paragraph.words) #print(u'Paragraph Confidence: {}\n'.format(paragraph.confidence)) block_text = '' block_symbols = [] for word in block_words: block_symbols.extend(word.symbols) word_text = '' for symbol in word.symbols: word_text = word_text + symbol.text #print(u'\tSymbol text: {} (confidence: {})'.format(symbol.text, symbol.confidence)) #print(u'Word text: {} (confidence: {})\n'.format(word_text, word.confidence)) block_text += ' ' + word_text #print(u'Block Content: {}\n'.format(block_text)) #print(u'Block Confidence:\n {}\n'.format(block.confidence)) bounds.append(block.bounding_box) doctext.append(block_text + "\n") print("data value of doctext >>>>>>>>>>>>>>>..", doctext.append(block_text + "\n")) #return (bounds,doctext) return render(request, 'results.html', { "labels": doctext, 'image': image_file })
async def transcribe(self, document): """Detects document features in images and returns extracted text Input: -------- `document`: bytes - The file object to be sent to Google Vision API Output: -------- `transcribed_text`: str - Transcribed text from Google Vision API """ # read the file's content and cast into Image type # use async friendly await function to fetch read image = types.Image(content=document) # adding refined language specification to sort out Non-English # characters from transcription responses language = types.ImageContext(language_hints=["en-t-i0-handwrit"]) # Connect to Google API client with the file that is built above response = self.client.document_text_detection(image=image, image_context=language) # check if there are transcriptions from google if response.text_annotations: # store and process the response transcribed_text = response.text_annotations[0].description transcribed_text = transcribed_text.replace("\n", " ") else: # forward no text in image exception to caller raise NoTextFoundException("No Text Was Found In Image") flagged = False # List of confidence levels of each character symbol_confidences = [] for page in response.full_text_annotation.pages: for block in page.blocks: for paragraph in block.paragraphs: for word in paragraph.words: # check moderation status of word in paragraph if self.text_moderator.check_word(str(word).lower()): flagged = True for symbol in word.symbols: symbol_confidences.append(symbol.confidence) # Calculate the overall confidence for the page page_confidence = sum(symbol_confidences) / len(symbol_confidences) # return flag: True under 85% confident, False 85% confident or over # return text transcription return (page_confidence < 0.85), flagged, transcribed_text
def do_documnet_ocr(image_file, feature): image_context = types.ImageContext(language_hints=["dv"]) client = vision.ImageAnnotatorClient() with io.open(image_file, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) response = client.document_text_detection(image=image, image_context=image_context) document = response.full_text_annotation bounds = [] doctext = [] for page in response.full_text_annotation.pages: for block in page.blocks: block_words = [] for paragraph in block.paragraphs: block_words.extend(paragraph.words) print(u'Paragraph Confidence: {}\n'.format( paragraph.confidence)) block_text = '' block_symbols = [] for word in block_words: block_symbols.extend(word.symbols) word_text = '' for symbol in word.symbols: word_text = word_text + symbol.text print(u'\tSymbol text: {} (confidence: {})'.format( symbol.text, symbol.confidence)) print(u'Word text: {} (confidence: {})\n'.format( word_text, word.confidence)) block_text += ' ' + word_text print(u'Block Content: {}\n'.format(block_text)) print(u'Block Confidence:\n {}\n'.format(block.confidence)) bounds.append(block.bounding_box) doctext.append(block_text + "\n") return (bounds, doctext)
def get_crops(image_data, aspect_ratio, n_results=50): client = vision.ImageAnnotatorClient() response = client.crop_hints( image=types.Image(content=image_data), max_results=n_results, image_context=types.ImageContext( crop_hints_params={"aspect_ratios": [aspect_ratio]})) result = [] for crop_hint in response.crop_hints_annotation.crop_hints: entry = {} entry["score"] = crop_hint.confidence entry["crop"] = [(vertex.x, vertex.y) for vertex in crop_hint.bounding_poly.vertices] result.append(entry) return result
def get_crop_hint(path): """Detect crop hints on a single image and return the first result.""" client = vision.ImageAnnotatorClient() with io.open(path, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) crop_hints_params = types.CropHintsParams() image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints vertices = hints[0].bounding_poly.vertices return vertices
def detect_crop_hints_uri(uri): """Detects crop hints in the file located in Google Cloud Storage.""" client = vision.ImageAnnotatorClient() image = types.Image() image.source.image_uri = uri crop_hints_params = types.CropHintsParams(aspect_ratios=[1.77]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints for n, hint in enumerate(hints): print('\nCrop Hint: {}'.format(n)) vertices = (['({},{})'.format(vertex.x, vertex.y) for vertex in hint.bounding_poly.vertices]) print('bounds: {}'.format(','.join(vertices)))
def detect_crop_hints(latest_file, image_file): #Detect crop hints on a single image and return the first result. client = vision.ImageAnnotatorClient() with io.open(image_file, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) crop_hints_params = types.CropHintsParams(aspect_ratios=[1.77]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints # Get bounds for the first crop hint using an aspect ratio of 1.77. vertices = hints[0].bounding_poly.vertices return vertices
def get_crop_hints(path, ratios): """Detect crop hints on a single image and return the first result.""" client = vision.ImageAnnotatorClient() with io.open(path, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) crop_hints_params = types.CropHintsParams(aspect_ratios=ratios) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints # Get bounds for the first crop hint using an aspect ratio of 1.77. vertices = (a.bounding_poly.vertices for a in hints) return vertices
def get_ocr(temp_image_file, temp_source): client = vision.ImageAnnotatorClient() with io.open(temp_image_file, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) image_context = types.ImageContext(language_hints=[temp_source]) response = client.text_detection(image=image, image_context=image_context) texts = response.text_annotations source_text = [] for text in texts: text.description = text.description.strip() if text.description in source_text: pass else: source_text.append(text.description) source_text = ' '.join(source_text) return source_text
def detect_crop_hints_uri(self, uri): """ Description: Detects crop hints in an image. Args: uri: url to an image on the Internet Returns: crop hints json object """ image = types.Image() image.source.image_uri = uri crop_hints_params = types.CropHintsParams(aspect_ratios=[1.77]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = self.client.crop_hints(image=image, image_context=image_context) return response
def get_crop_hint(self, path): """Detect crop hints on a single image and return the first result.""" client = vision.ImageAnnotatorClient() with io.open(path, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) crop_hints_params = types.CropHintsParams(aspect_ratios=[0.3]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints try: vertices = hints[0].bounding_poly.vertices except: raise AssertionError("the image doesn't exist") return vertices
def get_crop_hint(image, aspect_ratios=''): """Detect crop hints on a single image and return the first result.""" try: aspect_ratios = [float(x) for x in aspect_ratios.split(',')] crop_hints_params = types.CropHintsParams(aspect_ratios=aspect_ratios) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image_properties.my_image(image), image_context=image_context) except ValueError: response = client.crop_hints(image=image_properties.my_image(image), ) hints = response.crop_hints_annotation.crop_hints # Get bounds for the first crop hint using an aspect ratio of 1.77. return { str(ratio): hint.bounding_poly.vertices for ratio, hint in zip(aspect_ratios, hints) }
def detect_crop_hints(self, path): """ Description: Detects crop hints in an image. Args: path: path to a local image Returns: crop hints json object """ with io.open(path, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) crop_hints_params = types.CropHintsParams(aspect_ratios=[1.77]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = self.client.crop_hints(image=image, image_context=image_context) return response
def detect_text(path, lang): """Detects text in the file.""" client = vision.ImageAnnotatorClient() with io.open(path, 'rb') as image_file: content = image_file.read() image = vision.types.Image(content=content) image_context = types.ImageContext(language_hints=[lang]) response = client.text_detection(image=image, image_context=image_context) texts = response.text_annotations output = [] for text in texts: if len(text.description.split(" ")) > 1: output.append(text.description) return output
def _detect_cropping(client, image): """ Get cropping hints for 1:1 ratio from vision api. :param client: :param image: :return: """ crop_hints_params = types.CropHintsParams(aspect_ratios=[1.0]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints vertices = [] for v in hints[0].bounding_poly.vertices: vertices.append({ "x": v.x, "y": v.y, }) return vertices
def detect_crop_hints(path): """Detects crop hints in an image.""" client = vision.ImageAnnotatorClient() # [START migration_crop_hints] with io.open(path, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) crop_hints_params = types.CropHintsParams(aspect_ratios=[1.77]) image_context = types.ImageContext(crop_hints_params=crop_hints_params) response = client.crop_hints(image=image, image_context=image_context) hints = response.crop_hints_annotation.crop_hints for n, hint in enumerate(hints): print('\nCrop Hint: {}'.format(n)) vertices = (['({},{})'.format(vertex.x, vertex.y) for vertex in hint.bounding_poly.vertices]) print('bounds: {}'.format(','.join(vertices)))
def detect_document_text(image_file, textfile, jsonfile): """Returns document text given an image.""" client = vision.ImageAnnotatorClient() with io.open(image_file, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) image_context = types.ImageContext(language_hints=['en']) response = client.document_text_detection(image=image, timeout=300, image_context=image_context) document = response.full_text_annotation if textfile is not 0: with io.open(textfile, 'wb') as f: f.write(document.text.encode('utf-8')) if jsonfile is not 0: with io.open(jsonfile, 'wb') as f: f.write(str(document)) return document
def annotate(basename): # The name of the image file to annotate file_name = os.path.join( os.path.dirname(__file__), 'resources/{}'.format(basename)) # Loads the image into memory with io.open(file_name, 'rb') as image_file: content = image_file.read() image = types.Image(content=content) # Specify language hints image_context = types.ImageContext(language_hints=['ja']) response = client.text_detection(image=image,image_context=image_context) # Write JSON File serialized = MessageToJson(response) data = json.loads(serialized) f = open('results/{}.json'.format(os.path.splitext(basename)[0]), 'w') f.write(json.dumps(data,ensure_ascii=False)) f.close()
def async_detect_document_text(bucket_name, image_file, textfile, jsonfile): # Supported mime_types are: 'application/pdf' and 'image/tiff' mime_type = 'image/tiff' tmp_dir = tempfile._get_default_tempdir() png_fn = os.path.basename(image_file) fn = os.path.splitext(png_fn)[0] tif_fn = fn + '.tif' prefix_fn = fn + '-' tif_path = os.path.join(tmp_dir, tif_fn) gcs_src_uri = 'gs://{}/{}'.format(bucket_name, tif_fn) gcs_dst_uri = 'gs://{}/{}'.format(bucket_name, prefix_fn) logging.info('Converting... {!s}'.format(png_fn)) with Image.open(image_file) as im: im.save(tif_path, compression='tiff_lzw', tiffinfo={317: 2, 278: 1}) logging.info('Uploading... {!s}'.format(tif_fn)) upload_blob(bucket_name, tif_path, tif_fn) os.unlink(tif_path) # How many pages should be grouped into each json output file. # With a file of 1 pages batch_size = 1 client = vision.ImageAnnotatorClient() feature = types.Feature( type=vision.enums.Feature.Type.DOCUMENT_TEXT_DETECTION) gcs_src = types.GcsSource(uri=gcs_src_uri) input_config = types.InputConfig(gcs_source=gcs_src, mime_type=mime_type) gcs_dst = types.GcsDestination(uri=gcs_dst_uri) output_config = types.OutputConfig(gcs_destination=gcs_dst, batch_size=batch_size) image_context = types.ImageContext(language_hints=['en']) async_request = types.AsyncAnnotateFileRequest(features=[feature], input_config=input_config, output_config=output_config, image_context=image_context) operation = client.async_batch_annotate_files(requests=[async_request]) logging.info('Waiting... {!s}'.format(gcs_src_uri)) result = operation.result(timeout=GOOGLE_OPERATION_TIMEOUT) logging.debug('{!s}'.format(result)) delete_blob(bucket_name, tif_fn) # Once the request has completed and the output has been # written to GCS, we can list all the output files. storage_client = storage.Client() match = re.match(r'gs://([^/]+)/(.+)', gcs_dst_uri) bucket_name = match.group(1) prefix = match.group(2) bucket = storage_client.get_bucket(bucket_name=bucket_name) # List objects with the given prefix. blob_list = list(bucket.list_blobs(prefix=prefix)) # Process the first output file from GCS. # Since we specified batch_size=1, the first response contains # the first page of the input file. output = blob_list[0] logging.info('Downloading... {!s}'.format(output.name)) json_string = output.download_as_string() logging.debug('JSON len={:d}'.format(len(json_string))) response = json_format.Parse(json_string, types.AnnotateFileResponse()) error = response.responses[0].error if error.code != 0: logging.error("Vision API code: {!s}, msg: {!s}".format( error.code, error.message)) return None # The actual response for the first page of the input file. document = response.responses[0].full_text_annotation if textfile is not 0: logging.info('Saving... {!s}'.format(textfile)) with io.open(textfile, 'wb') as f: f.write(document.text.encode('utf-8')) if jsonfile is not 0: logging.info('Saving... {!s}'.format(jsonfile)) with io.open(jsonfile, 'wb') as f: f.write(json_format.MessageToJson(document)) output.delete() return document