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 vxCreateImageFromROI_int(img, rect): logger = logging.getLogger(__name__) ret0 = defn.verifyImage(img) ret1 = defn.verifyRect(rect) if (ret0 & ret1) is not True: logger.error('vxCreateImageFromROI : verification fails') raise AttributeError ROIimg = defn.create_dict(defn.VX_VIRT, img['VX_PARENT']) if ((rect['VX_DATA'].start_x < 0) or (rect['VX_DATA'].end_x > img['VX_DATA'].width)): logger.error('vxCreateImageFromROI : rect width params fails') raise ValueError if ((rect['VX_DATA'].start_y < 0) or (rect['VX_DATA'].end_y > img['VX_DATA'].height)): logger.error('vxCreateImageFromROI : rect height params fails') raise ValueError width = rect['VX_DATA'].end_x - rect['VX_DATA'].start_x + 1 height = rect['VX_DATA'].end_y - rect['VX_DATA'].start_y + 1 step = img['VX_DATA'].step startX = rect['VX_DATA'].start_x startY = rect['VX_DATA'].start_y offset = (startY * step) + (startX) ROIimg['VX_DATA'] = VXImage( img['VX_PARENT'], width, height, img['VX_DATA'].type, context.VXStorage(0, 0, offset, img['VX_DATA'].storage)) ROIimg['VX_DATA'].step = img['VX_DATA'].step img['VX_PARENT']['VX_VIRT'].append(ROIimg) return ROIimg
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 vxCreateThreshold_int(context, thresholdType, dataType): logger = logging.getLogger(__name__) ret0 = defn.verifyContext(context) ret1 = isinstance(thresholdType, numbers.Number) ret2 = isinstance(dataType, numbers.Number) if ((ret0 != True) or (ret1 != True) or (ret2 != True)): logger.error('vxCreateThreshold: one or all parameters are wrong') raise Exception thresh = defn.create_dict(defn.VX_THRESHOLD,context) thresh['VX_DATA'] = Threshold(thresholdType, dataType) context['VX_THRESHOLD'].append(thresh) return thresh
def DilateErode3x3Node(graph, input, output, tmpImg, type, iterations): logger = logging.getLogger(__name__) node = defn.create_dict(defn.VX_NODE, graph) if tmpImg is not None: newTmpImg = tmpImg['VX_DATA'] else: newTmpImg = None node['VX_DATA'] = VXMorph(input['VX_DATA'], output['VX_DATA'], newTmpImg, type, iterations) graph['VX_DATA'].node.append(node) return node
def vxCreateScalar_int(context, data_type, initial_value): logger = logging.getLogger(__name__) ret = defn.verifyContext(context) if ret is not True: logger.error('vxCreateScalar: context cannot be verified') raise AttributeError if (isinstance(initial_value,numbers.Number) == False): logger.error('vxCreateScalar: initial_value is not a number') raise TypeError sclr = defn.create_dict(defn.VX_SCALAR,context) sclr['VX_DATA'] = VXScalar(context['VX_DATA'],data_type,initial_value,len(context['VX_SCALAR'])) context['VX_SCALAR'].append(sclr) return sclr
def vxCreateContext_int(): ctxt = defn.create_dict(defn.VX_CONTEXT, None) ctxt['VX_DATA'] = VXContext() ctxt['VX_GRAPH'] = [] ctxt['VX_IMAGE'] = [] ctxt['VX_PYRAMID'] = [] ctxt['VX_THRESHOLD'] = [] ctxt['VX_DISTRIBUTION'] = [] ctxt['VX_SCALAR'] = [] ctxt['VX_ARRAY'] = [] ctxt['VX_VIRT'] = [] ctxt['VX_RECT'] = [] return ctxt
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 vxGetPyramidLevel_int(pyramid, idx): logger = logging.getLogger(__name__) ret = defn.verifyPyramid(pyramid) if ret is not True: logger.error('vxGetPyramidLevel: pyramid cannot be verified') raise AttributeError if idx > (pyramid['VX_DATA'].levels - 1): logger.error('vxGetPyramidLevel: level doesnt exist') raise AttributeError image = defn.create_dict(defn.VX_IMAGE, pyramid) image['VX_DATA'] = pyramid['VX_DATA'].images[idx] pyramid['VX_PARENT']['VX_IMAGE'].append(image) return image
def vxCreateGraph_int(context): logger = logging.getLogger(__name__) ret = defn.verifyContext(context) if ret is not True: logger.error('vxCreateGraph: verifyContext failed') return None grph = defn.create_dict(defn.VX_GRAPH, context) grph['VX_DATA'] = VXGraph() grph['VX_IMAGE'] = [] grph['VX_SCALAR'] = [] grph['VX_ARRAY'] = [] grph['VX_VIRT'] = [] context['VX_GRAPH'].append(grph) return grph
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 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 vxCreateImage_int(context, width, height, type): logger = logging.getLogger(__name__) ret = defn.verifyContext(context) if ret is not True: logger.error('vxCreateImage: cannot verify context') raise AttributeError if ((isinstance(width, numbers.Number) == False) or (isinstance(height, numbers.Number) == False)): logger.error('vxCreateImage: width and height are not valid') raise TypeError img = defn.create_dict(defn.VX_IMAGE, context) img['VX_DATA'] = VXImage(context['VX_DATA'], width, height, type, None) context['VX_IMAGE'].append(img) return img
def vxCreateRectangle_int(context, start_x, start_y, end_x, end_y): logger = logging.getLogger(__name__) ret = defn.verifyContext(context) if ret is not True: logger.error('vxCreateRectangle: Context cannot be verified') raise AttributeError if ((isinstance(start_x, numbers.Number) == False) or (isinstance(start_y, numbers.Number) == False) or (isinstance(end_x, numbers.Number) == False) or (isinstance(end_y, numbers.Number) == False)): logger.error('vxCreateRectangle: rect values are not int') raise TypeError rect = defn.create_dict(defn.VX_RECT, context) rect['VX_DATA'] = VXRectangle(start_x, start_y, end_x, end_y) context['VX_RECT'].append(rect) return rect
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 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 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 vxCreateDistribution_int(context, numBins, offset, range): logger = logging.getLogger('__name__') ret = defn.verifyContext(context) if ret is not True: logger.error('vxCreateDistribution: Cannot verify context') raise AttributeError if ((isinstance(numBins, numbers.Number) == False) or (isinstance(range, numbers.Number) == False) or (isinstance(offset, numbers.Number) == False)): logger.error('vxCreateDistribution: bins/offset/range not numbers') raise TypeError if numBins != 256: logger.error('vxCreateDistribution: numBins not in range') raise ValueError distribution = defn.create_dict(defn.VX_DISTRIBUTION, context) distribution['VX_DATA'] = VXDistribution(context, numBins, offset, range) context['VX_DISTRIBUTION'].append(distribution) return distribution
def vxCreateArray_int(context, item_type, capacity): logger = logging.getLogger(__name__) ret = defn.verifyContext(context) if ret is not True: logger.error('vxCreateArray: Context cannot be verified') raise AttributeError if ((isinstance(item_type, numbers.Number) == False) or (isinstance(capacity, numbers.Number) == False)): logger.error('vxCreateArray: item type/capacity is not integer type') raise TypeError lArray = VXArray(context['VX_DATA'], item_type, capacity) if lArray.verify() is not True: logger.error('vxCreateArray: VXArray cannot be created') raise AttributeError arr = defn.create_dict(defn.VX_ARRAY, context) arr['VX_DATA'] = lArray context['VX_ARRAY'].append(arr) return arr
def vxArithScalarExtNode(graph, in1, scalarObj, out, opcode,extParam): logger = logging.getLogger(__name__) node = defn.create_dict(defn.VX_NODE,graph) if isinstance(scalarObj,dict): ret = False if (in1['VX_DATA'].type == brcm_openvx.VX_DF_IMAGE_U8): ret = (scalarObj['VX_DATA'].type == brcm_openvx.VX_TYPE_UINT8 - brcm_openvx.VX_TYPE_START) elif (in1['VX_DATA'].type == brcm_openvx.VX_DF_IMAGE_S16): ret = (scalarObj['VX_DATA'].type == brcm_openvx.VX_TYPE_INT16 - brcm_openvx.VX_TYPE_START) if ret is not True: logger.error('%s: input and output type constraints are not met'%(OPCODE_ARITH[opcode])) raise TypeError scalarValue = scalarObj['VX_DATA'] else: scalarValue = scalarObj node['VX_DATA'] = VXArithS(in1['VX_DATA'],None,out['VX_DATA'],opcode,extParam,scalarValue) 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 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 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 vxCreatePyramid_int(context, levels, scale, width, height, type): logger = logging.getLogger(__name__) ret = defn.verifyContext(context) if ret is not True: logger.error('vxCreatePyramid: Context cannot be verified') raise AttributeError if ((isinstance(levels, numbers.Number) == False) or (isinstance(scale, numbers.Number) == False)): logger.error('vxCreatePyramid: levels/scale are not numbers') raise TypeError if ((isinstance(width, numbers.Number) == False) or (isinstance(height, numbers.Number) == False) or (isinstance(type, numbers.Number) == False)): logger.error('vxCreatePyramid: levels/scale are not numbers') raise TypeError pyrd = defn.create_dict(defn.VX_PYRAMID, context) pyrd['VX_DATA'] = VXPyramid(context['VX_DATA'], levels, scale, width, height, type) context['VX_PYRAMID'].append(pyrd) return pyrd
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