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