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
