vx_tutorial_image_histogram.c

Go to the documentation of this file.

/*
*
* Copyright (c) 2017 Texas Instruments Incorporated
*
* All rights reserved not granted herein.
*
* Limited License.
*
* Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
* license under copyrights and patents it now or hereafter owns or controls to make,
* have made, use, import, offer to sell and sell ("Utilize") this software subject to the
* terms herein.  With respect to the foregoing patent license, such license is granted
* solely to the extent that any such patent is necessary to Utilize the software alone.
* The patent license shall not apply to any combinations which include this software,
* other than combinations with devices manufactured by or for TI ("TI Devices").
* No hardware patent is licensed hereunder.
*
* Redistributions must preserve existing copyright notices and reproduce this license
* (including the above copyright notice and the disclaimer and (if applicable) source
* code license limitations below) in the documentation and/or other materials provided
* with the distribution
*
* Redistribution and use in binary form, without modification, are permitted provided
* that the following conditions are met:
*
* *       No reverse engineering, decompilation, or disassembly of this software is
* permitted with respect to any software provided in binary form.
*
* *       any redistribution and use are licensed by TI for use only with TI Devices.
*
* *       Nothing shall obligate TI to provide you with source code for the software
* licensed and provided to you in object code.
*
* If software source code is provided to you, modification and redistribution of the
* source code are permitted provided that the following conditions are met:
*
* *       any redistribution and use of the source code, including any resulting derivative
* works, are licensed by TI for use only with TI Devices.
*
* *       any redistribution and use of any object code compiled from the source code
* and any resulting derivative works, are licensed by TI for use only with TI Devices.
*
* Neither the name of Texas Instruments Incorporated nor the names of its suppliers
*
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* DISCLAIMER.
*
* THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL TI AND TI'S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/



#include <stdio.h>
#include <VX/vx.h>
#include <TI/tivx.h>
#include <utility.h>

#define IN_FILE_NAME       "${VX_TEST_DATA_PATH}/colors.bmp"

#define OUT_FILE_NAME      "${VX_TEST_DATA_PATH}/vx_tutorial_image_histogram_out.bmp"


vx_image convert_distribution_to_image(vx_distribution distribution,
            uint32_t width, uint32_t height);

void vx_tutorial_image_histogram()
{
    vx_context context;
    vx_image in_image = NULL, out_image = NULL;
    vx_distribution histogram = NULL;
    uint32_t num_bins = 256;
    uint32_t histogram_image_width  = 256;
    uint32_t histogram_image_height = 128;
    vx_node node0 = NULL;
    vx_graph graph = NULL;
    vx_status status;

    printf(" vx_tutorial_image_histogram: Tutorial Started !!! \n");

    context = vxCreateContext();
    printf(" Loading file %s ...\n", IN_FILE_NAME);

    graph = vxCreateGraph(context);
    vxSetReferenceName((vx_reference)graph, "MY_GRAPH");

    in_image = tivx_utils_create_vximage_from_bmpfile(context, IN_FILE_NAME, (vx_bool)vx_true_e);
    vxSetReferenceName((vx_reference)in_image, "INPUT");
    show_image_attributes(in_image);
    histogram = vxCreateDistribution(context, num_bins, 0, 256);
    vxSetReferenceName((vx_reference)histogram, "HISTOGRAM");

    {
        vx_reference refs[] = {(vx_reference)in_image, (vx_reference)histogram};

        node0 = tivxCreateNodeByKernelEnum(graph,
                    (vx_enum)VX_KERNEL_HISTOGRAM,
                    refs, sizeof(refs)/sizeof(refs[0])
                    );
        vxSetReferenceName((vx_reference)node0, "HISTOGRAM");
    }

    status = vxVerifyGraph(graph);
    tivxExportGraphToDot(graph, ".", "vx_tutorial_image_histogram");
    show_graph_attributes(graph);
    show_node_attributes(node0);
    if(status==(vx_status)VX_SUCCESS)
    {
        printf(" Executing graph ...\n");

        vxScheduleGraph(graph);
        vxWaitGraph(graph);
        printf(" Executing graph ... Done !!!\n");

        show_graph_attributes(graph);
        show_node_attributes(node0);
        out_image = convert_distribution_to_image(histogram,
                        histogram_image_width,
                        histogram_image_height);

        vxSetReferenceName((vx_reference)out_image, "HISTOGRAM_IMAGE");
        show_image_attributes(out_image);
        printf(" Saving to file %s ...\n", OUT_FILE_NAME);
        tivx_utils_save_vximage_to_bmpfile(OUT_FILE_NAME, out_image);
        vxReleaseImage(&out_image);
    }

    vxReleaseImage(&in_image);
    vxReleaseDistribution(&histogram);
    vxReleaseNode(&node0);
    vxReleaseGraph(&graph);
    vxReleaseContext(&context);
    printf(" vx_tutorial_image_histogram: Tutorial Done !!! \n");
    printf(" \n");
}

#define MAX_BINS    (256u)

vx_image convert_distribution_to_image(vx_distribution distribution,
            uint32_t width, uint32_t height)
{
    vx_image image;
    vx_context context;
    vx_status status;

    context = vxGetContext((vx_reference)distribution);

    image = vxCreateImage(context, width, height, (vx_df_image)VX_DF_IMAGE_U8);
    if(vxGetStatus((vx_reference)image)==(vx_status)VX_SUCCESS)
    {
        vx_size num_bins;

        status = vxQueryDistribution(distribution, (vx_enum)VX_DISTRIBUTION_BINS, &num_bins, sizeof(vx_size));
        if(status == (vx_status)VX_SUCCESS && num_bins <=  MAX_BINS)
        {
            uint32_t histogram_data[MAX_BINS] = {0};
            uint32_t i, max;

            vxCopyDistribution(distribution,
                (void**)&histogram_data[0],
                (vx_enum)VX_READ_ONLY,
                (vx_enum)VX_MEMORY_TYPE_HOST);
            /* normalize bins */
            max = 0;
            for(i=0; i<num_bins; i++)
            {
                if(histogram_data[i] > max )
                    max = histogram_data[i];
            }
            /* scale to image height */
            for(i=0; i<num_bins; i++)
            {
                histogram_data[i] = (uint32_t)(((float)histogram_data[i]/max)*height + 0.5);
                if(histogram_data[i]>height)
                    histogram_data[i] = height;
            }

            {
                uint8_t *data_ptr = NULL;
                vx_rectangle_t rect = { 0, 0, width, height};
                vx_map_id map_id;
                vx_imagepatch_addressing_t image_addr;

                status = vxMapImagePatch(image,
                            &rect,
                            0,
                            &map_id,
                            &image_addr,
                            (void**)&data_ptr,
                            (vx_enum)VX_WRITE_ONLY, (vx_enum)VX_MEMORY_TYPE_HOST, (vx_enum)VX_NOGAP_X);
                if(status==(vx_status)VX_SUCCESS && data_ptr!=NULL)
                {
                    uint32_t i, j, k, bin_width;
                    uint8_t *addr0 = NULL, *addr1 = NULL;

                    bin_width = width/num_bins;

                    for(i=0; i<num_bins; i++)
                    {
                        addr0 = data_ptr + i*bin_width;

                        for(j=0; j<height-histogram_data[i]; j++)
                        {
                            addr1 = addr0 + j*image_addr.stride_y;
                            for(k=0; k<bin_width; k++)
                            {
                                addr1[k] = 0xFF;
                            }
                        }

                        addr0 = data_ptr + j*image_addr.stride_y + i*bin_width;

                        for(j=0; j<histogram_data[i]; j++)
                        {
                            addr1 = addr0 + j*image_addr.stride_y;
                            for(k=0; k<bin_width; k++)
                            {
                                addr1[k] = 0x0;
                            }
                        }
                    }
                    vxUnmapImagePatch(image, map_id);
                }
            }
        }
        else
        {
            /* more bins than allocated memory */
            vxReleaseImage(&image);
        }
    }

    return image;
}