source: gs3-installations/intermuse/trunk/sites/intermuse/collect/programmes/js/document_viewer.js@ 36997

function load_gv_dococr_json(json_file, callback) {

    var http_assocfilepath = gs.collectionMetadata["httpPath"]+"/index/assoc/"+gs.documentMetadata["assocfilepath"];
    var json_url = http_assocfilepath +"/"+json_file;

    $.ajax({
    method: "GET",
    url: json_url
    })
        .fail(function(jqXHR,textStatus) {
            console.error("load_gv_dococr_json(): failed to retrieve url '" + json_url +"'");
        console.error(textStatus);
        })
        .done(function(gv_ocr_json_result) {
        callback(gv_ocr_json_result);

        });
    
}

function display_gv_ocr_bounding_boxes(gv_ocr_json)
{
    console.log(gv_ocr_json);

    
    var full_text_annotation = gv_ocr_json.fullTextAnnotation;
    var pages = full_text_annotation.pages;
    var num_pages = pages.length;
    
    if (num_pages == 1) {
    var page = pages[0];

    var bounding_box_rects = [];
    var page_x_dim = page.width;
    var page_y_dim = page.height;

    var blocks = page.blocks;
    var num_blocks = blocks.length;

    for (b=0; b<num_blocks; b++) {
        var block = blocks[b];

        var boundingBox = block.boundingBox;

        var min_x = Number.MAX_SAFE_INTEGER;
        var min_y = Number.MAX_SAFE_INTEGER;
        var max_x = Number.MIN_SAFE_INTEGER;
        var max_y = Number.MIN_SAFE_INTEGER;

        var vertices = boundingBox.vertices;
        var num_vertices = vertices.length;

        for (v=0; v<num_vertices; v++) {
        var x = vertices[v].x;
        var y = vertices[v].y;
        
        min_x = Math.min(min_x,x);
        min_y = Math.min(min_y,y);
        max_x = Math.max(max_x,x);
        max_y = Math.max(max_y,y);
        }

        var x_org = min_x;
        var y_org = min_y;
        var x_dim = max_x - min_x +1;
        var y_dim = max_y - min_y +1;

        var rect = { "x_org": x_org, "y_org": y_org, "x_dim": x_dim, "y_dim": y_dim};
        bounding_box_rects.push(rect);
    }

        
    display_scaled_div_bounding_boxes(bounding_box_rects, page_x_dim,page_y_dim);
    
    }
    else {
    console.error("display_gv_ocr_bounding_boxes(): incorrect number of pages found.")
    console.error("  Expected 1 page, found " + num_pages +" page(s)");
    }

}


function display_scaled_div_bounding_boxes(bounding_box_rects,fullsize_x_dim,fullsize_y_dim)
{
    var screen_x_dim = gs.variables.screenImageWidth;
    var screen_y_dim = gs.variables.screenImageHeight;

    var scale_x = screen_x_dim / fullsize_x_dim;
    var scale_y = screen_y_dim / fullsize_y_dim;

    //console.log("scale x = " + scale_x);
    //console.log("scale y = " + scale_y);
    
    var docID = gs.variables.d;    
    var screen_image_id = "small"+docID;

    var $boundingbox_overlay = $("<div>")
    .attr("id","ocr-boundingbox-overlay-"+docID)
    .attr("class","ocr-boundingbox-overlay");

    var $screen_div = $('#'+screen_image_id);
    //var $screen_img = $screen_div.find("img");
    
    $screen_div.append($boundingbox_overlay);
    //$screen_img.append($boundingbox_overlay);

    
    var num_bb_rects = bounding_box_rects.length;

    console.log("Block bounding boxes:")

    for (r=0; r<num_bb_rects; r++) {
    var rect = bounding_box_rects[r];
        console.log("  " + JSON.stringify(rect));

    var scaled_x_org = rect.x_org * scale_x;
    var scaled_y_org = rect.y_org * scale_y;
    var scaled_x_dim = rect.x_dim * scale_x;
    var scaled_y_dim = rect.y_dim * scale_y;
        
    var $boundingbox_div = $("<div>")
        .attr("class","ocr-boundingbox")
        .css("left",  scaled_x_org)
        .css("top",   scaled_y_org)
        .css("width", scaled_x_dim)
        .css("height",scaled_y_dim);
    
    $boundingbox_overlay.append($boundingbox_div)
    }
}

/*

https://stackoverflow.com/questions/68395710/building-a-bounding-box-surrounding-text-in-google-vision-api-to-extract-the-tex

def get_text_within(document, x1, y1, x2, y2):
text = ""
for page in document.pages:
    for block in page.blocks:
        for paragraph in block.paragraphs:
            for word in paragraph.words:
                for symbol in word.symbols:
                    min_x = min(symbol.bounding_box.vertices[0].x, symbol.bounding_box.vertices[1].x,
                                symbol.bounding_box.vertices[2].x, symbol.bounding_box.vertices[3].x)
                    max_x = max(symbol.bounding_box.vertices[0].x, symbol.bounding_box.vertices[1].x,
                                symbol.bounding_box.vertices[2].x, symbol.bounding_box.vertices[3].x)
                    min_y = min(symbol.bounding_box.vertices[0].y, symbol.bounding_box.vertices[1].y,
                                symbol.bounding_box.vertices[2].y, symbol.bounding_box.vertices[3].y)
                    max_y = max(symbol.bounding_box.vertices[0].y, symbol.bounding_box.vertices[1].y,
                                symbol.bounding_box.vertices[2].y, symbol.bounding_box.vertices[3].y)
                    if (min_x >= x1 and max_x <= x2 and min_y >= y1 and max_y <= y2):
                        text += symbol.text
                    if (symbol.property.detected_break.type == 1 or
                            symbol.property.detected_break.type == 3):
                        text += ' '
                    if (symbol.property.detected_break.type == 2):
                        text += '\t'
                    if (symbol.property.detected_break.type == 5):
                        text += '\n'
return text

*/


/*

https://stackoverflow.com/questions/57071788/google-vision-api-text-detection-display-words-by-block


https://gist.github.com/UBISOFT-1/f00e4d22790f4af378d70b237fa56ca9

    response = client.text_detection(image=image)
    # The actual response for the first page of the input file.
    breaks = vision.enums.TextAnnotation.DetectedBreak.BreakType
    paragraphs = []
    lines = []
    # extract text by block of detection
    for page in response.full_text_annotation.pages:
        for block in page.blocks:
            for paragraph in block.paragraphs:
                para = ""
                line = ""
                suppose = str(paragraph.bounding_box)
                suppose = suppose.replace('vertices ','')
                print(suppose)
                for word in paragraph.words:
                    for symbol in word.symbols:
                        line += symbol.text
                        if symbol.property.detected_break.type == breaks.SPACE:
                            line += ' '
                        if symbol.property.detected_break.type == breaks.EOL_SURE_SPACE:
                            line += ' '
                            lines.append(line)
                            para += line
                            line = ''
                        if symbol.property.detected_break.type == breaks.LINE_BREAK:
                            lines.append(line)
                            para += line
                            line = ''
            paragraphs.append(para)


    return "\n".join(paragraphs)




https://blog.searce.com/tips-tricks-for-using-google-vision-api-for-text-detection-2d6d1e0c6361

def draw_boxes(image, bounds, color,width=5):
    draw = ImageDraw.Draw(image)
    for bound in bounds:
        draw.line([
            bound.vertices[0].x, bound.vertices[0].y,
            bound.vertices[1].x, bound.vertices[1].y,
            bound.vertices[2].x, bound.vertices[2].y,
            bound.vertices[3].x, bound.vertices[3].y,
            bound.vertices[0].x, bound.vertices[0].y],fill=color, width=width)
    return image
def get_document_bounds(response, feature):
    for i,page in enumerate(document.pages):
        for block in page.blocks:
            if feature==FeatureType.BLOCK:
                bounds.append(block.bounding_box)
            for paragraph in block.paragraphs:
                if feature==FeatureType.PARA:
                    bounds.append(paragraph.bounding_box)
                for word in paragraph.words:
                    for symbol in word.symbols:
                        if (feature == FeatureType.SYMBOL):
                            bounds.append(symbol.bounding_box)
                    if (feature == FeatureType.WORD):
                        bounds.append(word.bounding_box)
    return bounds
bounds=get_document_bounds(response, FeatureType.WORD)
draw_boxes(image,bounds, 'yellow')

*/