static vx_status vxHistogramOutputValidator(vx_node node, vx_uint32 index, vx_meta_format_t *ptr)
{
vx_status status = VX_ERROR_INVALID_PARAMETERS;
if (index == 1)
{
vx_image src = 0;
vx_parameter src_param = vxGetParameterByIndex(node, 0);
vx_parameter dst_param = vxGetParameterByIndex(node, 1);
vx_distribution dist;
vxQueryParameter(src_param, VX_PARAMETER_ATTRIBUTE_REF, &src, sizeof(src));
vxQueryParameter(dst_param, VX_PARAMETER_ATTRIBUTE_REF, &dist, sizeof(dist));
if ((src) && (dist))
{
vx_uint32 width = 0, height = 0;
vx_df_image format;
vx_size numBins = 0;
vxQueryDistribution(dist, VX_DISTRIBUTION_ATTRIBUTE_BINS, &numBins, sizeof(numBins));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_WIDTH, &width, sizeof(height));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_HEIGHT, &height, sizeof(height));
vxQueryImage(src, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
/* fill in the meta data with the attributes so that the checker will pass */
ptr->type = VX_TYPE_DISTRIBUTION;
status = VX_SUCCESS;
vxReleaseDistribution(&dist);
vxReleaseImage(&src);
}
vxReleaseParameter(&dst_param);
vxReleaseParameter(&src_param);
}
return status;
}
int CVxParamDistribution::InitializeIO(vx_context context, vx_graph graph, vx_reference ref, const char * io_params)
{
// save reference object and get object attributes
m_vxObjRef = ref;
m_distribution = (vx_distribution)m_vxObjRef;
ERROR_CHECK(vxQueryDistribution(m_distribution, VX_DISTRIBUTION_ATTRIBUTE_BINS, &m_numBins, sizeof(m_numBins)));
ERROR_CHECK(vxQueryDistribution(m_distribution, VX_DISTRIBUTION_ATTRIBUTE_OFFSET, &m_offset, sizeof(m_offset)));
ERROR_CHECK(vxQueryDistribution(m_distribution, VX_DISTRIBUTION_ATTRIBUTE_RANGE, &m_range, sizeof(m_range)));
// process I/O parameters
if (*io_params == ':') io_params++;
while (*io_params) {
char ioType[64], fileName[256];
io_params = ScanParameters(io_params, "<io-operation>,<parameter>", "s,S", ioType, fileName);
if (!_stricmp(ioType, "read"))
{ // read request syntax: read,<fileName>[,ascii|binary]
m_fileNameRead.assign(RootDirUpdated(fileName));
m_fileNameForReadHasIndex = (m_fileNameRead.find("%") != m_fileNameRead.npos) ? true : false;
m_readFileIsBinary = (m_fileNameRead.find(".txt") != m_fileNameRead.npos) ? false : true;
while (*io_params == ',') {
char option[64];
io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
if (!_stricmp(option, "ascii")) {
m_readFileIsBinary = false;
}
else if (!_stricmp(option, "binary")) {
m_readFileIsBinary = true;
}
else ReportError("ERROR: invalid distribution read option: %s\n", option);
}
}
else if (!_stricmp(ioType, "write"))
{ // write request syntax: write,<fileName>[,ascii|binary]
m_fileNameWrite.assign(RootDirUpdated(fileName));
m_writeFileIsBinary = (m_fileNameWrite.find(".txt") != m_fileNameWrite.npos) ? false : true;
while (*io_params == ',') {
char option[64];
io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
if (!_stricmp(option, "ascii")) {
m_writeFileIsBinary = false;
}
else if (!_stricmp(option, "binary")) {
m_writeFileIsBinary = true;
}
else ReportError("ERROR: invalid distribution write option: %s\n", option);
}
}
else if (!_stricmp(ioType, "compare"))
{ // compare syntax: compare,fileName[,ascii|binary]
m_fileNameCompare.assign(RootDirUpdated(fileName));
m_compareFileIsBinary = (m_fileNameCompare.find(".txt") != m_fileNameCompare.npos) ? false : true;
while (*io_params == ',') {
char option[64];
io_params = ScanParameters(io_params, ",ascii|binary", ",s", option);
if (!_stricmp(option, "ascii")) {
m_compareFileIsBinary = false;
}
else if (!_stricmp(option, "binary")) {
m_compareFileIsBinary = true;
}
else ReportError("ERROR: invalid distribution compare option: %s\n", option);
}
}
else if (!_stricmp(ioType, "view")) {
m_displayName.assign(fileName);
m_paramList.push_back(this);
}
else ReportError("ERROR: invalid distribution operation: %s\n", ioType);
if (*io_params == ':') io_params++;
else if (*io_params) ReportError("ERROR: unexpected character sequence in parameter specification: %s\n", io_params);
}
return 0;
}
static vx_status vxHistogramKernel(vx_node node, vx_reference *parameters, vx_uint32 num)
{
vx_status status = VX_FAILURE;
if (num == 2)
{
vx_image src_image = (vx_image)parameters[0];
vx_distribution dist = (vx_scalar)parameters[1];
vx_rectangle src_rect;
vx_imagepatch_addressing_t src_addr;
void *src_base = NULL, *dist_ptr = NULL;
vx_fourcc format = 0;
vx_uint32 y = 0, x = 0;
vx_uint32 offset = 0, range = 0, numBins = 0, window_size = 0;
vxQueryImage(src_image, VX_IMAGE_ATTRIBUTE_FORMAT, &format, sizeof(format));
vxQueryDistribution(dist, VX_DISTRIBUTION_ATTRIBUTE_BINS, &numBins, sizeof(numBins));
vxQueryDistribution(dist, VX_DISTRIBUTION_ATTRIBUTE_RANGE, &range, sizeof(range));
vxQueryDistribution(dist, VX_DISTRIBUTION_ATTRIBUTE_OFFSET, &offset, sizeof(offset));
vxQueryDistribution(dist, VX_DISTRIBUTION_ATTRIBUTE_WINDOW, &window_size, sizeof(window_size));
src_rect = vxGetValidRegionImage(src_image);
status = VX_SUCCESS;
status |= vxAccessImagePatch(src_image, src_rect, 0, &src_addr, &src_base);
status |= vxAccessDistribution(dist, &dist_ptr);
printf("distribution:%p bins:%u off:%u ws:%u range:%u\n", dist_ptr, numBins, offset, window_size, range);
if (status == VX_SUCCESS)
{
vx_int32 *dist_tmp = dist_ptr;
/* clear the distribution */
for (x = 0; x < numBins; x++)
{
dist_tmp[x] = 0;
}
for (y = 0; y < src_addr.dim_y; y++)
{
for (x = 0; x < src_addr.dim_x; x++)
{
if (format == FOURCC_U8)
{
vx_uint8 *src_ptr = vxFormatImagePatchAddress2d(src_base, x, y, &src_addr);
vx_uint8 pixel = *src_ptr;
if ((offset <= (vx_size)pixel) && ((vx_size)pixel < (offset+range)))
{
vx_size index = (pixel - (vx_uint16)offset) / window_size;
dist_tmp[index]++;
}
}
else if (format == FOURCC_U16)
{
vx_uint16 *src_ptr = vxFormatImagePatchAddress2d(src_base, x, y, &src_addr);
vx_uint16 pixel = *src_ptr;
if ((offset <= (vx_size)pixel) && ((vx_size)pixel < (offset+range)))
{
vx_size index = (pixel - (vx_uint16)offset) / window_size;
dist_tmp[index]++;
}
}
}
}
}
status |= vxCommitDistribution(dist, dist_ptr);
status |= vxCommitImagePatch(src_image, 0, 0, &src_addr, src_base);
vxReleaseParameter(&src_rect);
}
return status;
}
