def vxVerifyGraph_int(graph):
logger = logging.getLogger(__name__)
ret = defn.verifyGraph(graph)
if ret is not True:
logger.error('vxVerifyGraph: Cannot be verified')
raise AttributeError
return brcm_openvx.VX_SUCCESS
def vxHalfScaleGaussianNode_int(graph, input, output, kernel_size):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
ret3 = isinstance(kernel_size, numbers.Number)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error(
'vxHalfScaleGaussianNode: one or all parameters are wrong')
raise AttributeError
tmpImg = image.vxCreateVirtualImage_int(graph, input['VX_DATA'].width,
input['VX_DATA'].height,
input['VX_DATA'].type)
for imag in tmpImg:
if imag is None:
logger.error(
'vxHalfScaleGaussianNode: vxCreateVirtualImage cannot be created '
)
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
hlfSclGaussNode = VXHalfScaleGaussianNode(input['VX_DATA'],
output['VX_DATA'],
tmpImg['VX_DATA'], kernel_size)
if kernel_size is 3:
hlfSclGaussNode.scaleNode[0].compute(graph['VX_DATA'])
node['VX_DATA'] = hlfSclGaussNode
graph['VX_DATA'].node.append(node)
return node
def vxCreateVirtualImage_int(graph, width, height, type):
ret = defn.verifyGraph(graph)
if ret is not True:
logger.error('vxCreateVirtualImage: cannot verify graph')
raise AttributeError
vert = defn.create_dict(defn.VX_TEMP, graph)
vert['VX_DATA'] = VXImage(graph['VX_DATA'], width, height, type, None)
graph['VX_IMAGE'].append(vert)
return vert
def vxCopyExtNode_int(graph,input,output):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxCopyExtNode: one or all parameters are wrong')
raise AttributeError
return vxArithScalarExtNode(graph, input, 0, output, OPCODE_ARITH_COPY, 0)
def vxSetExtNode_int(graph, inout, value):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(inout)
ret2 = defn.verifyScalar(value)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxSetExtNode: parameters are wrong ret0 = %s, ret1= %s, ret2 = %s' %(ret0,ret1, ret2))
raise AttributeError
return vxArithScalarExtNode(graph, inout, value, inout, OPCODE_ARITH_SET, 0)
def vxMaxScalarExtNode_int(graph, in1, scalarObj, out):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(in1)
ret2 = defn.verifyScalar(scalarObj)
ret3 = defn.verifyImage(out)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxMaxScalarExtNode: one or all parameters are wrong')
raise AttributeError
return vxArithScalarExtNode(graph, in1, scalarObj, out, OPCODE_ARITH_MAX, 0)
def vxXorNode_int(graph, in1, in2, out):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(in1)
ret2 = defn.verifyImage(in2)
ret3 = defn.verifyImage(out)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxXorNode: one or all parameters are wrong')
raise AttributeError
return vxArithNode(graph, in1, in2, out, OPCODE_ARITH_XOR, 0)
def vxAddScalarExtNode_int(graph, in1, scalarObj, policy, out):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(in1)
ret2 = defn.verifyScalar(scalarObj)
ret3 = defn.verifyImage(out)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxAddScalarExtNode: one or all parameters are wrong')
raise AttributeError
logger.info('vxAddScalarExtNode always uses VX_CONVERT_POLICY_SATURATE policy')
return vxArithScalarExtNode(graph, in1, scalarObj, out, OPCODE_ARITH_ADD, 0)
def vxErode3x3Node_int(graph, input, output):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxErode3x3Node: one or all parameters are wrong')
raise AttributeError
return DilateErode3x3Node(graph, input, output, None, VX_ERODE, 1)
def vxColorConvertNode_int(graph, input, output):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
if (ret0 & ret1 & ret2) is False:
logger.error('vxColorConvertNode: One or all parameters are wrong')
raise AttributeError
clrConvNode = VXColorConvertNode(input['VX_DATA'],output['VX_DATA'])
node = defn.create_dict(defn.VX_NODE,graph)
node['VX_DATA'] = clrConvNode
graph['VX_DATA'].node.append(node)
return node
def vxHistogramNode_int(graph, input, distribution):
logger = logging.getLogger('__name__')
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyDistribution(distribution)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxHistogramNode: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
node['VX_DATA'] = Histogram(input['VX_DATA'], distribution['VX_DATA'],
graph)
graph['VX_DATA'].node.append(node)
return node
def vxMultiplyNode_int(graph, in1, in2, scale, overflow_policy, rounding_policy, out):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(in1)
ret2 = defn.verifyImage(in2)
ret3 = defn.verifyImage(out)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxMultiplyNode: one or all parameters are wrong')
raise AttributeError
logger.info('vxMultiplyNode always uses VX_CONVERT_POLICY_SATURATE policy')
logger.info('vxMultiplyNode does not support any rounding policy')
logger.info('vxMultiplyNode does not support any scale factor')
return vxArithNode(graph, in1, in2, out, OPCODE_ARITH_MUL, scale)
def vxThresholdNode_int(graph, input, thresh, output):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyThreshold(thresh)
ret3 = defn.verifyImage(output)
ret = ret0 & ret1 & ret2 & ret3
if ret is False:
logger.warning('VXThresholdNode: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE,graph)
node['VX_DATA'] = VXThresholdNode(input['VX_DATA'],output['VX_DATA'],thresh['VX_DATA'])
graph['VX_DATA'].node.append(node)
return node
def vxNotNode_int(graph, input, output):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxNotNode: one or all parameters are wrong')
raise AttributeError
if (input['VX_DATA'].type == brcm_openvx.VX_DF_IMAGE_S16) is True:
scalarObj = 0xFFFF
else:
scalarObj = 0xFF
return vxArithScalarExtNode(graph, input, scalarObj, output, OPCODE_ARITH_XOR, 0)
def vxScaleAddExtNode_int(graph, in1, in2, scale, out):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(in1)
ret2 = defn.verifyImage(in2)
ret3 = defn.verifyImage(out)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxScaleAddExtNode: one or all parameters are wrong')
raise AttributeError
if (isinstance(scale, numbers.Number)==False):
logger.error('vxScaleAddExtNode: scale is not a number')
raise TypeError
scalefactor = int(scale)
return vxArithNode(graph, in1, in2, out, OPCODE_ARITH_SCALEADD, scalefactor)
def vxUpSampleBy2x2Node_int(graph, input, output):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxUpSampleBy2x2Node: one or all parameters are wrong')
raise AttributeError
upsampleNode = VXUpSampleBy2x2Node(input['VX_DATA'], output['VX_DATA'])
node = defn.create_dict(defn.VX_NODE, graph)
node['VX_DATA'] = upsampleNode
graph['VX_DATA'].node.append(node)
return node
def vxSubtractScalarExtNode_int(graph, in1, scalarObj, policy, out, reverse):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(in1)
ret2 = defn.verifyScalar(scalarObj)
ret3 = defn.verifyImage(out)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxSubtractScalarExtNode: one or all parameters are wrong')
raise AttributeError
if ((reverse != 0) and (reverse != 1)):
logger.error('vxSubtractScalarExtNode: reverse should be a bool value 1 or 0')
raise ValueError
logger.info('vxSubtractScalarExtNode: bool argument is %s'%(reverse))
logger.info('vxSubtractScalarExtNode always uses VX_CONVERT_POLICY_SATURATE policy')
return vxArithScalarExtNode(graph, in1, scalarObj, out, OPCODE_ARITH_SUB, reverse)
def vxOpticalFlowPyrLKNode_int(graph, old_images, new_images, old_points,
new_points_estimates, new_points, termination,
epsilon, num_iterations, use_initial_estimate,
window_dimension):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyPyramid(old_images)
ret2 = defn.verifyPyramid(new_images)
ret3 = defn.verifyArray(old_points)
ret4 = defn.verifyArray(new_points)
ret5 = len(window_dimension) == 2
ret6 = defn.verifyArray(new_points_estimates)
ret7 = window_dimension[0] == window_dimension[1]
ret8 = (window_dimension[0] == 11) | (window_dimension[0] == 13)
ret = ret0 & ret1 & ret2 & ret3 & ret4 & ret5 & ret6 & ret7 & ret8
if ret is not True:
logger.error('vxOpticalFlowPyrLKNode: one or all parameters are wrong')
raise AttributeError
max_count = 30
final_epsilon = 0.01
if ((termination < brcm_openvx.VX_TERM_CRITERIA_ITERATIONS)
or (termination > brcm_openvx.VX_TERM_CRITERIA_BOTH)):
logger.error('vxOpticalFlowPyrLKNode: termination not supported')
raise ValueError
if ((isinstance(epsilon, numbers.Number) == False)
or (isinstance(num_iterations, numbers.Number) == False)):
logger.error('vxOpticalFlowPyrLKNode: epsilon is not a valid number')
raise TypeError
if termination is brcm_openvx.VX_TERM_CRITERIA_ITERATIONS or termination is brcm_openvx.VX_TERM_CRITERIA_BOTH:
max_count = min(max(num_iterations, 0), 100)
if termination is brcm_openvx.VX_TERM_CRITERIA_EPSILON or termination is brcm_openvx.VX_TERM_CRITERIA_BOTH:
final_epsilon = min(max(epsilon, 0.), 10.)
final_epsilon = final_epsilon * final_epsilon
logger.info(
'vxOpticalFlowPyrLKNode:use_initial_estimate is not used currently')
final_epsilon = int(final_epsilon * (1 << 28))
node = defn.create_dict(defn.VX_NODE, graph)
node['VX_DATA'] = OpticalFlowPyrLKNode(
graph['VX_DATA'], old_images['VX_DATA'], new_images['VX_DATA'],
old_points['VX_DATA'], new_points_estimates['VX_DATA'],
new_points['VX_DATA'], max_count, final_epsilon, window_dimension[0])
graph['VX_DATA'].node.append(node)
return node
def vxGaussian5x5ExtNode_int(graph, input, output):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error(
'vxGaussian5x5ExtNode: one or all parameters have gone wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
node['VX_DATA'] = VXGaussian5x5(input['VX_DATA'], output['VX_DATA'])
graph['VX_DATA'].node.append(node)
return node
def vxCompareScalarExtNode_int(graph, in1, scalarObj, compare_operation, out):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(in1)
ret2 = defn.verifyScalar(scalarObj)
ret3 = defn.verifyImage(out)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxCompareScalarExtNode: one or all parameters are wrong')
raise AttributeError
if (isinstance(compare_operation,numbers.Number) == False):
logger.error('vxCompareScalarExtNode: compare_operation is not a number')
raise TypeError
if ((compare_operation < brcm_openvx.VX_CMP_EQ) or (compare_operation > brcm_openvx.VX_CMP_NE)):
logger.error('vxCompareScalarExtNode: compare operator is wrong')
raise ValueError
compare_operation = compare_operation - brcm_openvx.VX_CMP_EQ
return vxArithScalarExtNode(graph, in1, scalarObj, out, OPCODE_ARITH_CMP, compare_operation)
def vxMeanStdDevNode_int(graph, input, mean, stddev):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyScalar(mean)
ret3 = defn.verifyScalar(stddev)
ret = ret0 & ret1 & ret2 & ret3
if ret is False:
logger.error('vxMeanStdDevNode: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE,graph)
node['VX_DATA'] = VXMeanStdDev(input['VX_DATA'],mean['VX_DATA'],stddev['VX_DATA'],graph['VX_DATA'])
if node['VX_DATA'] is None:
logger.error('vxMeanStdDevNode: Parameter constraints are not met')
raise AttributeError
graph['VX_DATA'].node.append(node)
return node
def vxCannyEdgeDetectorNode_int(graph, input, hyst, gradient_size, norm_type,
output):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyThreshold(hyst)
ret3 = defn.verifyImage(output)
ret4 = isinstance(gradient_size, numbers.Number)
ret = ret0 & ret1 & ret2 & ret3 & ret4
if ret is not True:
logger.error(
'vxCannyEdgeDetectorNode: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
node['VX_DATA'] = VXCanny(input['VX_DATA'], hyst['VX_DATA'], gradient_size,
norm_type, output['VX_DATA'])
graph['VX_DATA'].node.append(node)
return node
def vxLaplacianPyramidNode_int(graph, input, laplacian, output):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyPyramid(laplacian)
ret3 = defn.verifyImage(output)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxLaplacianPyramidNode: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
laplacianNode = VXLaplacianPyramidNode(graph['VX_DATA'], input['VX_DATA'],
laplacian['VX_DATA'],
output['VX_DATA'])
node['VX_DATA'] = laplacianNode
graph['VX_DATA'].node.append(node)
return node
def vxGaussianPyramidNode_int(graph, input, pyramiid):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyPyramid(pyramiid)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxGaussianPyramidNode: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
gaussPyrNode = VXGaussianPyramidNode(graph['VX_DATA'], input['VX_DATA'],
pyramiid['VX_DATA'])
if (pyramiid['VX_DATA'].scale is brcm_openvx.VX_SCALE_PYRAMID_ORB):
for i in range(pyramiid['VX_DATA'].levels - 1):
gaussPyrNode.scaleNode[i].compute(graph['VX_DATA'])
node['VX_DATA'] = gaussPyrNode
graph['VX_DATA'].node.append(node)
return node
def vxSobel3x3Node_int(graph, input, output_x, output_y):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output_x)
ret3 = defn.verifyImage(output_y)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxSobel3x3Node: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
mask_x = [-1, 0, 1, -2, 0, 2, -1, 0, 1, 1]
mask_y = [-1, -2, -1, 0, 0, 0, 1, 2, 1, 1]
node['VX_DATA'] = VXSobel(input['VX_DATA'], output_x['VX_DATA'],
output_y['VX_DATA'], mask_x, mask_y,
utils.VENDOR_SOBEL_NORMAL)
graph['VX_DATA'].node.append(node)
return node
def vxPedestrianDetectNode_int(graph, image, rectangles, num_rect, scale,
levels, quality):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(image)
ret2 = defn.verifyArray(rectangles)
ret3 = defn.verifyScalar(num_rect)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxPedestrianDetect: one or all parameters are wrong')
raise AttributeError
ped_detect = VXPedestrianDetect(graph['VX_DATA'], image['VX_DATA'],
rectangles['VX_DATA'], num_rect['VX_DATA'],
scale, levels, quality)
ped_detect.compute(graph['VX_DATA'])
node = defn.create_dict(defn.VX_NODE, graph)
node['VX_DATA'] = ped_detect
graph['VX_DATA'].node.append(node)
return node
def vxFaceDetectNode_int(graph, image, rectangles, num_rect, scale, minSize):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(image)
ret2 = defn.verifyArray(rectangles)
ret3 = defn.verifyScalar(num_rect)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxFaceDetect: one or all parameters are wrong')
raise AttributeError
faceDetect = VXFaceDetect(graph['VX_DATA'], image['VX_DATA'], rectangles['VX_DATA'], num_rect['VX_DATA'], scale, minSize)
if faceDetect.compute() == False:
logger.error('vxFaceDetect: compute failed')
raise ValueError
for i in range (faceDetect.resizeCntr):
faceDetect.scaleNode[i].compute(graph['VX_DATA'])
node = defn.create_dict(defn.VX_NODE,graph)
node['VX_DATA'] = faceDetect
graph['VX_DATA'].node.append(node)
return node
def vxAccumulateImageNode_int(graph, input, accum):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(accum)
if (ret0 & ret1 & ret2) is False:
logger.error(
'vxAccumulateImageNode:one or all parameters are wrong ret0 = %s, ret1= %s,ret2 = %s'
% (ret0, ret1, ret2))
raise AttributeError
tmpImg = image.vxCreateVirtualImage_int(graph, accum['VX_DATA'].width,
accum['VX_DATA'].height,
accum['VX_DATA'].type)
for img in tmpImg:
if img is None:
logger.error('vxAccumulateImageNode:tmpImg fails')
raise AttributeError
accumNode = VXAccumulate(input['VX_DATA'], tmpImg['VX_DATA'],
accum['VX_DATA'])
node = defn.create_dict(defn.VX_NODE, graph)
node['VX_DATA'] = accumNode
graph['VX_DATA'].node.append(node)
return node
def vxScaleImageNode_int(graph, src, dst, type):
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(src)
ret2 = defn.verifyImage(dst)
ret = ret0 & ret1 & ret2
if ret is not True:
logger.error('vxScaleImageNode: one or all parameters are wrong')
raise AttributeError
node = defn.create_dict(defn.VX_NODE, graph)
if (type != brcm_openvx.VX_INTERPOLATION_BILINEAR):
logger.error('VXScaleNode: interpolation type = %s is not supported' %
(type))
raise ValueError
logger.info(
'VXScaleNode: Allows downscaling and upscaling upto a factor of 2: 0.5 <= x <= 2'
)
if ((dst['VX_DATA'].width > src['VX_DATA'].width)
and (dst['VX_DATA'].height > src['VX_DATA'].height)):
if ((src['VX_DATA'].width > OPENVX_RESIZE_MAX_WIDTH / 2)
or (src['VX_DATA'].height > OPENVX_RESIZE_MAX_WIDTH / 2)):
logger.error(
'VXScaleNode: verify: max input resolution constraints are not met inW = %s inH = %s'
% (src['VX_DATA'].width, src['VX_DATA'].height))
raise ValueError
if ((dst['VX_DATA'].width > 2 * src['VX_DATA'].width)
or (dst['VX_DATA'].height > 2 * src['VX_DATA'].height)):
logger.error(
'VXScaleNode: input-output img upscaling ratio is more than allowed outW = %s outH = %s'
% (dst['VX_DATA'].width, dst['VX_DATA'].height))
raise ValueError
tmpImg = image.vxCreateVirtualImage_int(graph,
src['VX_DATA'].width * 2,
src['VX_DATA'].height * 2,
src['VX_DATA'].type)
upsampleNode = pyramid.VXUpSampleBy2x2Node(src['VX_DATA'],
tmpImg['VX_DATA'])
node['VX_DATA'] = upsampleNode
graph['VX_DATA'].node.append(node)
if ((dst['VX_DATA'].width < tmpImg['VX_DATA'].width)
and (dst['VX_DATA'].height < tmpImg['VX_DATA'].height)):
node = defn.create_dict(defn.VX_NODE, graph)
scaleNode = VXScaleNode(tmpImg['VX_DATA'], dst['VX_DATA'], type)
scaleNode.compute(graph['VX_DATA'])
node['VX_DATA'] = scaleNode
graph['VX_DATA'].node.append(node)
if ((dst['VX_DATA'].width == tmpImg['VX_DATA'].width)
and (dst['VX_DATA'].height == tmpImg['VX_DATA'].height)):
node = defn.create_dict(defn.VX_NODE, graph)
copyNode = arith.VXArithS(tmpImg['VX_DATA'], None, dst['VX_DATA'],
arith.OPCODE_ARITH_COPY, 0, 0)
node['VX_DATA'] = copyNode
graph['VX_DATA'].node.append(node)
elif ((dst['VX_DATA'].width == src['VX_DATA'].width)
and (dst['VX_DATA'].height == src['VX_DATA'].height)):
node = defn.create_dict(defn.VX_NODE, graph)
copyNode = arith.VXArithS(src['VX_DATA'], None, dst['VX_DATA'],
arith.OPCODE_ARITH_COPY, 0, 0)
node['VX_DATA'] = copyNode
graph['VX_DATA'].node.append(node)
else:
scaleNode = VXScaleNode(src['VX_DATA'], dst['VX_DATA'], type)
scaleNode.compute(graph['VX_DATA'])
node['VX_DATA'] = scaleNode
graph['VX_DATA'].node.append(node)
return node
def vxMorphologyExtNode_int(graph, input, output, operation, iterations):
#validate parameters
logger = logging.getLogger(__name__)
ret0 = defn.verifyGraph(graph)
ret1 = defn.verifyImage(input)
ret2 = defn.verifyImage(output)
ret3 = isinstance(iterations, numbers.Number)
ret = ret0 & ret1 & ret2 & ret3
if ret is not True:
logger.error('vxMorphologyExtNode: one or all parameters are wrong')
raise AttributeError
if ((operation < brcm_openvx.VX_MORPH_ERODE_EXT)
or (operation > brcm_openvx.VX_MORPH_BLACKHAT_EXT)):
logger.error('VXMorph: this operation is not supported')
raise ValueError
if (input['VX_DATA'].type == brcm_openvx.VX_DF_IMAGE_S32):
logger.error('vxMorphologyExtNode: type constraints are not met')
raise TypeError
tmpImg = [
image.vxCreateVirtualImage_int(graph, input['VX_DATA'].width,
input['VX_DATA'].height,
input['VX_DATA'].type),
image.vxCreateVirtualImage_int(graph, input['VX_DATA'].width,
input['VX_DATA'].height,
input['VX_DATA'].type)
]
for img in tmpImg:
if img is None:
logger.error('vxMorphologyExtNode: virtual imgs cannot be created')
raise AttributeError
if (operation == brcm_openvx.VX_MORPH_ERODE_EXT):
return DilateErode3x3Node(graph, input, output, tmpImg[0], VX_ERODE,
iterations)
elif (operation == brcm_openvx.VX_MORPH_DILATE_EXT):
return DilateErode3x3Node(graph, input, output, tmpImg[0], VX_DILATE,
iterations)
elif (operation == brcm_openvx.VX_MORPH_OPEN_EXT):
DilateErode3x3Node(
graph, input, tmpImg[0], output, VX_ERODE, iterations
) #can create one more temp image instead of reusin output as tmp
return DilateErode3x3Node(graph, tmpImg[0], output, tmpImg[1],
VX_DILATE, iterations)
elif (operation == brcm_openvx.VX_MORPH_CLOSE_EXT):
DilateErode3x3Node(graph, input, tmpImg[0], output, VX_DILATE,
iterations)
return DilateErode3x3Node(graph, tmpImg[0], output, tmpImg[1],
VX_ERODE, iterations)
elif (operation == brcm_openvx.VX_MORPH_GRADIENT_EXT):
DilateErode3x3Node(graph, input, tmpImg[0], output, VX_DILATE,
iterations)
DilateErode3x3Node(graph, input, tmpImg[1], output, VX_ERODE,
iterations)
return arith.vxSubtractNode_int(graph, tmpImg[0], tmpImg[1], 0,
output) #subtract u16 s not supported
elif (operation == brcm_openvx.VX_MORPH_TOPHAT_EXT):
DilateErode3x3Node(graph, input, tmpImg[0], output, VX_ERODE,
iterations)
DilateErode3x3Node(graph, tmpImg[0], tmpImg[1], output, VX_DILATE,
iterations)
return arith.vxSubtractNode_int(graph, input, tmpImg[1], 0,
output) #subtract u16 s not supported
elif (operation == brcm_openvx.VX_MORPH_BLACKHAT_EXT):
DilateErode3x3Node(graph, input, tmpImg[0], output, VX_DILATE,
iterations)
DilateErode3x3Node(graph, tmpImg[0], tmpImg[1], output, VX_ERODE,
iterations)
return arith.vxSubtractNode_int(graph, tmpImg[1], input, 0,
output) #subtract u16 s not supported
